1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 /* Set the contents of the .interp section to the interpreter. */
1113 if (bfd_link_executable (info
) && !info
->nointerp
)
1115 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1118 s
->size
= htab
->dynamic_interpreter_size
;
1119 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1123 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1127 if (bfd_link_executable (info
))
1129 /* Always allow copy relocs for building executables. */
1130 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1133 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1134 s
= bfd_make_section_anyway_with_flags (dynobj
,
1136 (bed
->dynamic_sec_flags
1139 || ! bfd_set_section_alignment (dynobj
, s
,
1140 bed
->s
->log_file_align
))
1146 if (!info
->no_ld_generated_unwind_info
1147 && htab
->plt_eh_frame
== NULL
1148 && htab
->elf
.splt
!= NULL
)
1150 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1151 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1152 | SEC_LINKER_CREATED
);
1154 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1155 if (htab
->plt_eh_frame
== NULL
1156 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1162 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1165 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1166 struct elf_link_hash_entry
*dir
,
1167 struct elf_link_hash_entry
*ind
)
1169 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1171 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1172 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1174 if (!edir
->has_bnd_reloc
)
1175 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1177 if (!edir
->has_got_reloc
)
1178 edir
->has_got_reloc
= eind
->has_got_reloc
;
1180 if (!edir
->has_non_got_reloc
)
1181 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1183 if (eind
->dyn_relocs
!= NULL
)
1185 if (edir
->dyn_relocs
!= NULL
)
1187 struct elf_dyn_relocs
**pp
;
1188 struct elf_dyn_relocs
*p
;
1190 /* Add reloc counts against the indirect sym to the direct sym
1191 list. Merge any entries against the same section. */
1192 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1194 struct elf_dyn_relocs
*q
;
1196 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1197 if (q
->sec
== p
->sec
)
1199 q
->pc_count
+= p
->pc_count
;
1200 q
->count
+= p
->count
;
1207 *pp
= edir
->dyn_relocs
;
1210 edir
->dyn_relocs
= eind
->dyn_relocs
;
1211 eind
->dyn_relocs
= NULL
;
1214 if (ind
->root
.type
== bfd_link_hash_indirect
1215 && dir
->got
.refcount
<= 0)
1217 edir
->tls_type
= eind
->tls_type
;
1218 eind
->tls_type
= GOT_UNKNOWN
;
1221 if (ELIMINATE_COPY_RELOCS
1222 && ind
->root
.type
!= bfd_link_hash_indirect
1223 && dir
->dynamic_adjusted
)
1225 /* If called to transfer flags for a weakdef during processing
1226 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1227 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1228 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1229 dir
->ref_regular
|= ind
->ref_regular
;
1230 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1231 dir
->needs_plt
|= ind
->needs_plt
;
1232 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1236 if (eind
->func_pointer_refcount
> 0)
1238 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1239 eind
->func_pointer_refcount
= 0;
1242 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1247 elf64_x86_64_elf_object_p (bfd
*abfd
)
1249 /* Set the right machine number for an x86-64 elf64 file. */
1250 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1255 elf32_x86_64_elf_object_p (bfd
*abfd
)
1257 /* Set the right machine number for an x86-64 elf32 file. */
1258 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1262 /* Return TRUE if the TLS access code sequence support transition
1266 elf_x86_64_check_tls_transition (bfd
*abfd
,
1267 struct bfd_link_info
*info
,
1270 Elf_Internal_Shdr
*symtab_hdr
,
1271 struct elf_link_hash_entry
**sym_hashes
,
1272 unsigned int r_type
,
1273 const Elf_Internal_Rela
*rel
,
1274 const Elf_Internal_Rela
*relend
)
1277 unsigned long r_symndx
;
1278 bfd_boolean largepic
= FALSE
;
1279 struct elf_link_hash_entry
*h
;
1281 struct elf_x86_64_link_hash_table
*htab
;
1283 htab
= elf_x86_64_hash_table (info
);
1284 offset
= rel
->r_offset
;
1287 case R_X86_64_TLSGD
:
1288 case R_X86_64_TLSLD
:
1289 if ((rel
+ 1) >= relend
)
1292 if (r_type
== R_X86_64_TLSGD
)
1294 /* Check transition from GD access model. For 64bit, only
1295 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1296 .word 0x6666; rex64; call __tls_get_addr
1297 can transit to different access model. For 32bit, only
1298 leaq foo@tlsgd(%rip), %rdi
1299 .word 0x6666; rex64; call __tls_get_addr
1300 can transit to different access model. For largepic
1302 leaq foo@tlsgd(%rip), %rdi
1303 movabsq $__tls_get_addr@pltoff, %rax
1307 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1308 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1310 if ((offset
+ 12) > sec
->size
)
1313 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1315 if (!ABI_64_P (abfd
)
1316 || (offset
+ 19) > sec
->size
1318 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1319 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1320 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1325 else if (ABI_64_P (abfd
))
1328 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1334 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1340 /* Check transition from LD access model. Only
1341 leaq foo@tlsld(%rip), %rdi;
1343 can transit to different access model. For largepic
1345 leaq foo@tlsld(%rip), %rdi
1346 movabsq $__tls_get_addr@pltoff, %rax
1350 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1352 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1355 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1358 if (0xe8 != *(contents
+ offset
+ 4))
1360 if (!ABI_64_P (abfd
)
1361 || (offset
+ 19) > sec
->size
1362 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1363 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1370 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1371 if (r_symndx
< symtab_hdr
->sh_info
)
1374 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1375 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1376 may be versioned. */
1378 && h
->root
.root
.string
!= NULL
1380 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1381 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1382 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1383 && (strncmp (h
->root
.root
.string
,
1384 "__tls_get_addr", 14) == 0));
1386 case R_X86_64_GOTTPOFF
:
1387 /* Check transition from IE access model:
1388 mov foo@gottpoff(%rip), %reg
1389 add foo@gottpoff(%rip), %reg
1392 /* Check REX prefix first. */
1393 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1395 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1396 if (val
!= 0x48 && val
!= 0x4c)
1398 /* X32 may have 0x44 REX prefix or no REX prefix. */
1399 if (ABI_64_P (abfd
))
1405 /* X32 may not have any REX prefix. */
1406 if (ABI_64_P (abfd
))
1408 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1412 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1413 if (val
!= 0x8b && val
!= 0x03)
1416 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1417 return (val
& 0xc7) == 5;
1419 case R_X86_64_GOTPC32_TLSDESC
:
1420 /* Check transition from GDesc access model:
1421 leaq x@tlsdesc(%rip), %rax
1423 Make sure it's a leaq adding rip to a 32-bit offset
1424 into any register, although it's probably almost always
1427 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1430 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1431 if ((val
& 0xfb) != 0x48)
1434 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1437 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1438 return (val
& 0xc7) == 0x05;
1440 case R_X86_64_TLSDESC_CALL
:
1441 /* Check transition from GDesc access model:
1442 call *x@tlsdesc(%rax)
1444 if (offset
+ 2 <= sec
->size
)
1446 /* Make sure that it's a call *x@tlsdesc(%rax). */
1447 static const unsigned char call
[] = { 0xff, 0x10 };
1448 return memcmp (contents
+ offset
, call
, 2) == 0;
1458 /* Return TRUE if the TLS access transition is OK or no transition
1459 will be performed. Update R_TYPE if there is a transition. */
1462 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1463 asection
*sec
, bfd_byte
*contents
,
1464 Elf_Internal_Shdr
*symtab_hdr
,
1465 struct elf_link_hash_entry
**sym_hashes
,
1466 unsigned int *r_type
, int tls_type
,
1467 const Elf_Internal_Rela
*rel
,
1468 const Elf_Internal_Rela
*relend
,
1469 struct elf_link_hash_entry
*h
,
1470 unsigned long r_symndx
,
1471 bfd_boolean from_relocate_section
)
1473 unsigned int from_type
= *r_type
;
1474 unsigned int to_type
= from_type
;
1475 bfd_boolean check
= TRUE
;
1477 /* Skip TLS transition for functions. */
1479 && (h
->type
== STT_FUNC
1480 || h
->type
== STT_GNU_IFUNC
))
1485 case R_X86_64_TLSGD
:
1486 case R_X86_64_GOTPC32_TLSDESC
:
1487 case R_X86_64_TLSDESC_CALL
:
1488 case R_X86_64_GOTTPOFF
:
1489 if (bfd_link_executable (info
))
1492 to_type
= R_X86_64_TPOFF32
;
1494 to_type
= R_X86_64_GOTTPOFF
;
1497 /* When we are called from elf_x86_64_relocate_section, there may
1498 be additional transitions based on TLS_TYPE. */
1499 if (from_relocate_section
)
1501 unsigned int new_to_type
= to_type
;
1503 if (bfd_link_executable (info
)
1506 && tls_type
== GOT_TLS_IE
)
1507 new_to_type
= R_X86_64_TPOFF32
;
1509 if (to_type
== R_X86_64_TLSGD
1510 || to_type
== R_X86_64_GOTPC32_TLSDESC
1511 || to_type
== R_X86_64_TLSDESC_CALL
)
1513 if (tls_type
== GOT_TLS_IE
)
1514 new_to_type
= R_X86_64_GOTTPOFF
;
1517 /* We checked the transition before when we were called from
1518 elf_x86_64_check_relocs. We only want to check the new
1519 transition which hasn't been checked before. */
1520 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1521 to_type
= new_to_type
;
1526 case R_X86_64_TLSLD
:
1527 if (bfd_link_executable (info
))
1528 to_type
= R_X86_64_TPOFF32
;
1535 /* Return TRUE if there is no transition. */
1536 if (from_type
== to_type
)
1539 /* Check if the transition can be performed. */
1541 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1542 symtab_hdr
, sym_hashes
,
1543 from_type
, rel
, relend
))
1545 reloc_howto_type
*from
, *to
;
1548 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1549 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1552 name
= h
->root
.root
.string
;
1555 struct elf_x86_64_link_hash_table
*htab
;
1557 htab
= elf_x86_64_hash_table (info
);
1562 Elf_Internal_Sym
*isym
;
1564 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1566 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1570 (*_bfd_error_handler
)
1571 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1572 "in section `%A' failed"),
1573 abfd
, sec
, from
->name
, to
->name
, name
,
1574 (unsigned long) rel
->r_offset
);
1575 bfd_set_error (bfd_error_bad_value
);
1583 /* Rename some of the generic section flags to better document how they
1585 #define need_convert_load sec_flg0
1586 #define check_relocs_failed sec_flg1
1589 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1590 struct elf_link_hash_entry
*h
,
1591 Elf_Internal_Shdr
*symtab_hdr
,
1592 Elf_Internal_Sym
*isym
,
1593 reloc_howto_type
*howto
)
1596 const char *und
= "";
1597 const char *pic
= "";
1602 name
= h
->root
.root
.string
;
1603 switch (ELF_ST_VISIBILITY (h
->other
))
1606 v
= _("hidden symbol ");
1609 v
= _("internal symbol ");
1612 v
= _("protected symbol ");
1616 pic
= _("; recompile with -fPIC");
1620 if (!h
->def_regular
&& !h
->def_dynamic
)
1621 und
= _("undefined ");
1625 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1626 pic
= _("; recompile with -fPIC");
1629 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1630 "not be used when making a shared object%s"),
1631 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1632 bfd_set_error (bfd_error_bad_value
);
1633 sec
->check_relocs_failed
= 1;
1637 /* With the local symbol, foo, we convert
1638 mov foo@GOTPCREL(%rip), %reg
1642 call/jmp *foo@GOTPCREL(%rip)
1644 nop call foo/jmp foo nop
1645 When PIC is false, convert
1646 test %reg, foo@GOTPCREL(%rip)
1650 binop foo@GOTPCREL(%rip), %reg
1653 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1657 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1659 Elf_Internal_Rela
*irel
,
1660 struct elf_link_hash_entry
*h
,
1661 bfd_boolean
*converted
,
1662 struct bfd_link_info
*link_info
)
1664 struct elf_x86_64_link_hash_table
*htab
;
1666 bfd_boolean require_reloc_pc32
;
1668 bfd_boolean to_reloc_pc32
;
1671 bfd_signed_vma raddend
;
1672 unsigned int opcode
;
1674 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1675 unsigned int r_symndx
;
1677 bfd_vma roff
= irel
->r_offset
;
1679 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1682 raddend
= irel
->r_addend
;
1683 /* Addend for 32-bit PC-relative relocation must be -4. */
1687 htab
= elf_x86_64_hash_table (link_info
);
1688 is_pic
= bfd_link_pic (link_info
);
1690 relocx
= (r_type
== R_X86_64_GOTPCRELX
1691 || r_type
== R_X86_64_REX_GOTPCRELX
);
1693 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1696 = link_info
->disable_target_specific_optimizations
> 1;
1698 r_symndx
= htab
->r_sym (irel
->r_info
);
1700 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1702 /* Convert mov to lea since it has been done for a while. */
1705 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1706 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1707 test, xor instructions. */
1712 /* We convert only to R_X86_64_PC32:
1714 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1715 3. require_reloc_pc32 is true.
1718 to_reloc_pc32
= (opcode
== 0xff
1720 || require_reloc_pc32
1723 /* Get the symbol referred to by the reloc. */
1726 Elf_Internal_Sym
*isym
1727 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1729 /* Skip relocation against undefined symbols. */
1730 if (isym
->st_shndx
== SHN_UNDEF
)
1733 symtype
= ELF_ST_TYPE (isym
->st_info
);
1735 if (isym
->st_shndx
== SHN_ABS
)
1736 tsec
= bfd_abs_section_ptr
;
1737 else if (isym
->st_shndx
== SHN_COMMON
)
1738 tsec
= bfd_com_section_ptr
;
1739 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1740 tsec
= &_bfd_elf_large_com_section
;
1742 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1744 toff
= isym
->st_value
;
1748 /* Undefined weak symbol is only bound locally in executable
1749 and its reference is resolved as 0 without relocation
1750 overflow. We can only perform this optimization for
1751 GOTPCRELX relocations since we need to modify REX byte.
1752 It is OK convert mov with R_X86_64_GOTPCREL to
1754 if ((relocx
|| opcode
== 0x8b)
1755 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1757 elf_x86_64_hash_entry (h
)))
1761 /* Skip for branch instructions since R_X86_64_PC32
1763 if (require_reloc_pc32
)
1768 /* For non-branch instructions, we can convert to
1769 R_X86_64_32/R_X86_64_32S since we know if there
1771 to_reloc_pc32
= FALSE
;
1774 /* Since we don't know the current PC when PIC is true,
1775 we can't convert to R_X86_64_PC32. */
1776 if (to_reloc_pc32
&& is_pic
)
1781 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1782 ld.so may use its link-time address. */
1783 else if ((h
->def_regular
1784 || h
->root
.type
== bfd_link_hash_defined
1785 || h
->root
.type
== bfd_link_hash_defweak
)
1786 && h
!= htab
->elf
.hdynamic
1787 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1789 /* bfd_link_hash_new or bfd_link_hash_undefined is
1790 set by an assignment in a linker script in
1791 bfd_elf_record_link_assignment. */
1793 && (h
->root
.type
== bfd_link_hash_new
1794 || h
->root
.type
== bfd_link_hash_undefined
))
1796 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1797 if (require_reloc_pc32
)
1801 tsec
= h
->root
.u
.def
.section
;
1802 toff
= h
->root
.u
.def
.value
;
1809 /* Don't convert GOTPCREL relocation against large section. */
1810 if (elf_section_data (tsec
) != NULL
1811 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1814 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1818 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1820 /* At this stage in linking, no SEC_MERGE symbol has been
1821 adjusted, so all references to such symbols need to be
1822 passed through _bfd_merged_section_offset. (Later, in
1823 relocate_section, all SEC_MERGE symbols *except* for
1824 section symbols have been adjusted.)
1826 gas may reduce relocations against symbols in SEC_MERGE
1827 sections to a relocation against the section symbol when
1828 the original addend was zero. When the reloc is against
1829 a section symbol we should include the addend in the
1830 offset passed to _bfd_merged_section_offset, since the
1831 location of interest is the original symbol. On the
1832 other hand, an access to "sym+addend" where "sym" is not
1833 a section symbol should not include the addend; Such an
1834 access is presumed to be an offset from "sym"; The
1835 location of interest is just "sym". */
1836 if (symtype
== STT_SECTION
)
1839 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1840 elf_section_data (tsec
)->sec_info
,
1843 if (symtype
!= STT_SECTION
)
1849 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1850 if (tsec
->output_section
== sec
->output_section
)
1852 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1857 bfd_signed_vma distance
;
1859 /* At this point, we don't know the load addresses of TSEC
1860 section nor SEC section. We estimate the distrance between
1861 SEC and TSEC. We store the estimated distances in the
1862 compressed_size field of the output section, which is only
1863 used to decompress the compressed input section. */
1864 if (sec
->output_section
->compressed_size
== 0)
1867 bfd_size_type size
= 0;
1868 for (asect
= link_info
->output_bfd
->sections
;
1870 asect
= asect
->next
)
1871 /* Skip debug sections since compressed_size is used to
1872 compress debug sections. */
1873 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1876 for (i
= asect
->map_head
.s
;
1880 size
= align_power (size
, i
->alignment_power
);
1883 asect
->compressed_size
= size
;
1887 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1889 distance
= (tsec
->output_section
->compressed_size
1890 - sec
->output_section
->compressed_size
);
1894 /* Take PT_GNU_RELRO segment into account by adding
1896 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1897 - roff
+ 0x80000000) > 0xffffffff)
1904 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1909 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1911 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1914 /* Convert to "jmp foo nop". */
1917 nop_offset
= irel
->r_offset
+ 3;
1918 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1919 irel
->r_offset
-= 1;
1920 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1924 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1927 nop
= link_info
->call_nop_byte
;
1928 if (link_info
->call_nop_as_suffix
)
1930 nop_offset
= irel
->r_offset
+ 3;
1931 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1932 irel
->r_offset
-= 1;
1933 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1936 nop_offset
= irel
->r_offset
- 2;
1938 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1939 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1940 r_type
= R_X86_64_PC32
;
1945 unsigned int rex_mask
= REX_R
;
1947 if (r_type
== R_X86_64_REX_GOTPCRELX
)
1948 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
1956 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1957 "lea foo(%rip), %reg". */
1959 r_type
= R_X86_64_PC32
;
1963 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1964 "mov $foo, %reg". */
1966 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1967 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1968 if ((rex
& REX_W
) != 0
1969 && ABI_64_P (link_info
->output_bfd
))
1971 /* Keep the REX_W bit in REX byte for LP64. */
1972 r_type
= R_X86_64_32S
;
1973 goto rewrite_modrm_rex
;
1977 /* If the REX_W bit in REX byte isn't needed,
1978 use R_X86_64_32 and clear the W bit to avoid
1979 sign-extend imm32 to imm64. */
1980 r_type
= R_X86_64_32
;
1981 /* Clear the W bit in REX byte. */
1983 goto rewrite_modrm_rex
;
1989 /* R_X86_64_PC32 isn't supported. */
1993 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1996 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1997 "test $foo, %reg". */
1998 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2003 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2004 "binop $foo, %reg". */
2005 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2009 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2010 overflow when sign-extending imm32 to imm64. */
2011 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2014 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2018 /* Move the R bit to the B bit in REX byte. */
2019 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2020 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2023 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2027 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2030 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2037 /* Look through the relocs for a section during the first phase, and
2038 calculate needed space in the global offset table, procedure
2039 linkage table, and dynamic reloc sections. */
2042 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2044 const Elf_Internal_Rela
*relocs
)
2046 struct elf_x86_64_link_hash_table
*htab
;
2047 Elf_Internal_Shdr
*symtab_hdr
;
2048 struct elf_link_hash_entry
**sym_hashes
;
2049 const Elf_Internal_Rela
*rel
;
2050 const Elf_Internal_Rela
*rel_end
;
2053 bfd_boolean use_plt_got
;
2055 if (bfd_link_relocatable (info
))
2058 BFD_ASSERT (is_x86_64_elf (abfd
));
2060 htab
= elf_x86_64_hash_table (info
);
2063 sec
->check_relocs_failed
= 1;
2067 /* Get the section contents. */
2068 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2069 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2070 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2072 sec
->check_relocs_failed
= 1;
2076 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2078 symtab_hdr
= &elf_symtab_hdr (abfd
);
2079 sym_hashes
= elf_sym_hashes (abfd
);
2083 rel_end
= relocs
+ sec
->reloc_count
;
2084 for (rel
= relocs
; rel
< rel_end
; rel
++)
2086 unsigned int r_type
;
2087 unsigned long r_symndx
;
2088 struct elf_link_hash_entry
*h
;
2089 struct elf_x86_64_link_hash_entry
*eh
;
2090 Elf_Internal_Sym
*isym
;
2092 bfd_boolean size_reloc
;
2094 r_symndx
= htab
->r_sym (rel
->r_info
);
2095 r_type
= ELF32_R_TYPE (rel
->r_info
);
2097 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2099 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2104 if (r_symndx
< symtab_hdr
->sh_info
)
2106 /* A local symbol. */
2107 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2112 /* Check relocation against local STT_GNU_IFUNC symbol. */
2113 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2115 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2120 /* Fake a STT_GNU_IFUNC symbol. */
2121 h
->type
= STT_GNU_IFUNC
;
2124 h
->forced_local
= 1;
2125 h
->root
.type
= bfd_link_hash_defined
;
2133 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2134 while (h
->root
.type
== bfd_link_hash_indirect
2135 || h
->root
.type
== bfd_link_hash_warning
)
2136 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2139 /* Check invalid x32 relocations. */
2140 if (!ABI_64_P (abfd
))
2146 case R_X86_64_DTPOFF64
:
2147 case R_X86_64_TPOFF64
:
2149 case R_X86_64_GOTOFF64
:
2150 case R_X86_64_GOT64
:
2151 case R_X86_64_GOTPCREL64
:
2152 case R_X86_64_GOTPC64
:
2153 case R_X86_64_GOTPLT64
:
2154 case R_X86_64_PLTOFF64
:
2157 name
= h
->root
.root
.string
;
2159 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2161 (*_bfd_error_handler
)
2162 (_("%B: relocation %s against symbol `%s' isn't "
2163 "supported in x32 mode"), abfd
,
2164 x86_64_elf_howto_table
[r_type
].name
, name
);
2165 bfd_set_error (bfd_error_bad_value
);
2178 case R_X86_64_PC32_BND
:
2179 case R_X86_64_PLT32_BND
:
2181 case R_X86_64_PLT32
:
2184 /* MPX PLT is supported only if elf_x86_64_arch_bed
2185 is used in 64-bit mode. */
2188 && (get_elf_x86_64_backend_data (abfd
)
2189 == &elf_x86_64_arch_bed
))
2191 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2193 /* Create the second PLT for Intel MPX support. */
2194 if (htab
->plt_bnd
== NULL
)
2196 unsigned int plt_bnd_align
;
2197 const struct elf_backend_data
*bed
;
2199 bed
= get_elf_backend_data (info
->output_bfd
);
2200 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2201 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2202 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2205 if (htab
->elf
.dynobj
== NULL
)
2206 htab
->elf
.dynobj
= abfd
;
2208 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2210 (bed
->dynamic_sec_flags
2215 if (htab
->plt_bnd
== NULL
2216 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2225 case R_X86_64_GOTPCREL
:
2226 case R_X86_64_GOTPCRELX
:
2227 case R_X86_64_REX_GOTPCRELX
:
2228 case R_X86_64_GOTPCREL64
:
2229 if (htab
->elf
.dynobj
== NULL
)
2230 htab
->elf
.dynobj
= abfd
;
2231 /* Create the ifunc sections for static executables. */
2232 if (h
->type
== STT_GNU_IFUNC
2233 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2239 /* It is referenced by a non-shared object. */
2241 h
->root
.non_ir_ref
= 1;
2243 if (h
->type
== STT_GNU_IFUNC
)
2244 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2245 |= elf_gnu_symbol_ifunc
;
2248 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2249 symtab_hdr
, sym_hashes
,
2250 &r_type
, GOT_UNKNOWN
,
2251 rel
, rel_end
, h
, r_symndx
, FALSE
))
2254 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2257 case R_X86_64_TLSLD
:
2258 htab
->tls_ld_got
.refcount
+= 1;
2261 case R_X86_64_TPOFF32
:
2262 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2263 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2264 &x86_64_elf_howto_table
[r_type
]);
2266 eh
->has_got_reloc
= 1;
2269 case R_X86_64_GOTTPOFF
:
2270 if (!bfd_link_executable (info
))
2271 info
->flags
|= DF_STATIC_TLS
;
2274 case R_X86_64_GOT32
:
2275 case R_X86_64_GOTPCREL
:
2276 case R_X86_64_GOTPCRELX
:
2277 case R_X86_64_REX_GOTPCRELX
:
2278 case R_X86_64_TLSGD
:
2279 case R_X86_64_GOT64
:
2280 case R_X86_64_GOTPCREL64
:
2281 case R_X86_64_GOTPLT64
:
2282 case R_X86_64_GOTPC32_TLSDESC
:
2283 case R_X86_64_TLSDESC_CALL
:
2284 /* This symbol requires a global offset table entry. */
2286 int tls_type
, old_tls_type
;
2290 default: tls_type
= GOT_NORMAL
; break;
2291 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2292 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2293 case R_X86_64_GOTPC32_TLSDESC
:
2294 case R_X86_64_TLSDESC_CALL
:
2295 tls_type
= GOT_TLS_GDESC
; break;
2300 h
->got
.refcount
+= 1;
2301 old_tls_type
= eh
->tls_type
;
2305 bfd_signed_vma
*local_got_refcounts
;
2307 /* This is a global offset table entry for a local symbol. */
2308 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2309 if (local_got_refcounts
== NULL
)
2313 size
= symtab_hdr
->sh_info
;
2314 size
*= sizeof (bfd_signed_vma
)
2315 + sizeof (bfd_vma
) + sizeof (char);
2316 local_got_refcounts
= ((bfd_signed_vma
*)
2317 bfd_zalloc (abfd
, size
));
2318 if (local_got_refcounts
== NULL
)
2320 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2321 elf_x86_64_local_tlsdesc_gotent (abfd
)
2322 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2323 elf_x86_64_local_got_tls_type (abfd
)
2324 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2326 local_got_refcounts
[r_symndx
] += 1;
2328 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2331 /* If a TLS symbol is accessed using IE at least once,
2332 there is no point to use dynamic model for it. */
2333 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2334 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2335 || tls_type
!= GOT_TLS_IE
))
2337 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2338 tls_type
= old_tls_type
;
2339 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2340 && GOT_TLS_GD_ANY_P (tls_type
))
2341 tls_type
|= old_tls_type
;
2345 name
= h
->root
.root
.string
;
2347 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2349 (*_bfd_error_handler
)
2350 (_("%B: '%s' accessed both as normal and thread local symbol"),
2352 bfd_set_error (bfd_error_bad_value
);
2357 if (old_tls_type
!= tls_type
)
2360 eh
->tls_type
= tls_type
;
2362 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2367 case R_X86_64_GOTOFF64
:
2368 case R_X86_64_GOTPC32
:
2369 case R_X86_64_GOTPC64
:
2372 eh
->has_got_reloc
= 1;
2373 if (htab
->elf
.sgot
== NULL
)
2375 if (htab
->elf
.dynobj
== NULL
)
2376 htab
->elf
.dynobj
= abfd
;
2377 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2383 case R_X86_64_PLT32
:
2384 case R_X86_64_PLT32_BND
:
2385 /* This symbol requires a procedure linkage table entry. We
2386 actually build the entry in adjust_dynamic_symbol,
2387 because this might be a case of linking PIC code which is
2388 never referenced by a dynamic object, in which case we
2389 don't need to generate a procedure linkage table entry
2392 /* If this is a local symbol, we resolve it directly without
2393 creating a procedure linkage table entry. */
2397 eh
->has_got_reloc
= 1;
2399 h
->plt
.refcount
+= 1;
2402 case R_X86_64_PLTOFF64
:
2403 /* This tries to form the 'address' of a function relative
2404 to GOT. For global symbols we need a PLT entry. */
2408 h
->plt
.refcount
+= 1;
2412 case R_X86_64_SIZE32
:
2413 case R_X86_64_SIZE64
:
2418 if (!ABI_64_P (abfd
))
2423 /* Check relocation overflow as these relocs may lead to
2424 run-time relocation overflow. Don't error out for
2425 sections we don't care about, such as debug sections or
2426 when relocation overflow check is disabled. */
2427 if (!info
->no_reloc_overflow_check
2428 && (bfd_link_pic (info
)
2429 || (bfd_link_executable (info
)
2433 && (sec
->flags
& SEC_READONLY
) == 0))
2434 && (sec
->flags
& SEC_ALLOC
) != 0)
2435 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2436 &x86_64_elf_howto_table
[r_type
]);
2442 case R_X86_64_PC32_BND
:
2446 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2447 eh
->has_non_got_reloc
= 1;
2448 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2449 locally defined and undefined symbol may turn out to be
2450 a STT_GNU_IFUNC symbol later. */
2452 && (bfd_link_executable (info
)
2453 || ((h
->type
== STT_GNU_IFUNC
2454 || h
->root
.type
== bfd_link_hash_undefweak
2455 || h
->root
.type
== bfd_link_hash_undefined
)
2456 && SYMBOLIC_BIND (info
, h
))))
2458 /* If this reloc is in a read-only section, we might
2459 need a copy reloc. We can't check reliably at this
2460 stage whether the section is read-only, as input
2461 sections have not yet been mapped to output sections.
2462 Tentatively set the flag for now, and correct in
2463 adjust_dynamic_symbol. */
2466 /* We may need a .plt entry if the function this reloc
2467 refers to is in a shared lib. */
2468 h
->plt
.refcount
+= 1;
2469 if (r_type
== R_X86_64_PC32
)
2471 /* Since something like ".long foo - ." may be used
2472 as pointer, make sure that PLT is used if foo is
2473 a function defined in a shared library. */
2474 if ((sec
->flags
& SEC_CODE
) == 0)
2475 h
->pointer_equality_needed
= 1;
2477 else if (r_type
!= R_X86_64_PC32_BND
2478 && r_type
!= R_X86_64_PC64
)
2480 h
->pointer_equality_needed
= 1;
2481 /* At run-time, R_X86_64_64 can be resolved for both
2482 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2483 can only be resolved for x32. */
2484 if ((sec
->flags
& SEC_READONLY
) == 0
2485 && (r_type
== R_X86_64_64
2486 || (!ABI_64_P (abfd
)
2487 && (r_type
== R_X86_64_32
2488 || r_type
== R_X86_64_32S
))))
2489 eh
->func_pointer_refcount
+= 1;
2495 /* If we are creating a shared library, and this is a reloc
2496 against a global symbol, or a non PC relative reloc
2497 against a local symbol, then we need to copy the reloc
2498 into the shared library. However, if we are linking with
2499 -Bsymbolic, we do not need to copy a reloc against a
2500 global symbol which is defined in an object we are
2501 including in the link (i.e., DEF_REGULAR is set). At
2502 this point we have not seen all the input files, so it is
2503 possible that DEF_REGULAR is not set now but will be set
2504 later (it is never cleared). In case of a weak definition,
2505 DEF_REGULAR may be cleared later by a strong definition in
2506 a shared library. We account for that possibility below by
2507 storing information in the relocs_copied field of the hash
2508 table entry. A similar situation occurs when creating
2509 shared libraries and symbol visibility changes render the
2512 If on the other hand, we are creating an executable, we
2513 may need to keep relocations for symbols satisfied by a
2514 dynamic library if we manage to avoid copy relocs for the
2516 if ((bfd_link_pic (info
)
2517 && (sec
->flags
& SEC_ALLOC
) != 0
2518 && (! IS_X86_64_PCREL_TYPE (r_type
)
2520 && (! (bfd_link_pie (info
)
2521 || SYMBOLIC_BIND (info
, h
))
2522 || h
->root
.type
== bfd_link_hash_defweak
2523 || !h
->def_regular
))))
2524 || (ELIMINATE_COPY_RELOCS
2525 && !bfd_link_pic (info
)
2526 && (sec
->flags
& SEC_ALLOC
) != 0
2528 && (h
->root
.type
== bfd_link_hash_defweak
2529 || !h
->def_regular
)))
2531 struct elf_dyn_relocs
*p
;
2532 struct elf_dyn_relocs
**head
;
2534 /* We must copy these reloc types into the output file.
2535 Create a reloc section in dynobj and make room for
2539 if (htab
->elf
.dynobj
== NULL
)
2540 htab
->elf
.dynobj
= abfd
;
2542 sreloc
= _bfd_elf_make_dynamic_reloc_section
2543 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2544 abfd
, /*rela?*/ TRUE
);
2550 /* If this is a global symbol, we count the number of
2551 relocations we need for this symbol. */
2553 head
= &eh
->dyn_relocs
;
2556 /* Track dynamic relocs needed for local syms too.
2557 We really need local syms available to do this
2562 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2567 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2571 /* Beware of type punned pointers vs strict aliasing
2573 vpp
= &(elf_section_data (s
)->local_dynrel
);
2574 head
= (struct elf_dyn_relocs
**)vpp
;
2578 if (p
== NULL
|| p
->sec
!= sec
)
2580 bfd_size_type amt
= sizeof *p
;
2582 p
= ((struct elf_dyn_relocs
*)
2583 bfd_alloc (htab
->elf
.dynobj
, amt
));
2594 /* Count size relocation as PC-relative relocation. */
2595 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2600 /* This relocation describes the C++ object vtable hierarchy.
2601 Reconstruct it for later use during GC. */
2602 case R_X86_64_GNU_VTINHERIT
:
2603 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2607 /* This relocation describes which C++ vtable entries are actually
2608 used. Record for later use during GC. */
2609 case R_X86_64_GNU_VTENTRY
:
2610 BFD_ASSERT (h
!= NULL
);
2612 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2622 && h
->plt
.refcount
> 0
2623 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2624 || h
->got
.refcount
> 0)
2625 && htab
->plt_got
== NULL
)
2627 /* Create the GOT procedure linkage table. */
2628 unsigned int plt_got_align
;
2629 const struct elf_backend_data
*bed
;
2631 bed
= get_elf_backend_data (info
->output_bfd
);
2632 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2633 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2634 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2637 if (htab
->elf
.dynobj
== NULL
)
2638 htab
->elf
.dynobj
= abfd
;
2640 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2642 (bed
->dynamic_sec_flags
2647 if (htab
->plt_got
== NULL
2648 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2654 if ((r_type
== R_X86_64_GOTPCREL
2655 || r_type
== R_X86_64_GOTPCRELX
2656 || r_type
== R_X86_64_REX_GOTPCRELX
)
2657 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2658 sec
->need_convert_load
= 1;
2661 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2663 if (!info
->keep_memory
)
2667 /* Cache the section contents for elf_link_input_bfd. */
2668 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2675 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2677 sec
->check_relocs_failed
= 1;
2681 /* Return the section that should be marked against GC for a given
2685 elf_x86_64_gc_mark_hook (asection
*sec
,
2686 struct bfd_link_info
*info
,
2687 Elf_Internal_Rela
*rel
,
2688 struct elf_link_hash_entry
*h
,
2689 Elf_Internal_Sym
*sym
)
2692 switch (ELF32_R_TYPE (rel
->r_info
))
2694 case R_X86_64_GNU_VTINHERIT
:
2695 case R_X86_64_GNU_VTENTRY
:
2699 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2702 /* Remove undefined weak symbol from the dynamic symbol table if it
2703 is resolved to 0. */
2706 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2707 struct elf_link_hash_entry
*h
)
2709 if (h
->dynindx
!= -1
2710 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2711 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2712 elf_x86_64_hash_entry (h
)))
2715 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2721 /* Adjust a symbol defined by a dynamic object and referenced by a
2722 regular object. The current definition is in some section of the
2723 dynamic object, but we're not including those sections. We have to
2724 change the definition to something the rest of the link can
2728 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2729 struct elf_link_hash_entry
*h
)
2731 struct elf_x86_64_link_hash_table
*htab
;
2733 struct elf_x86_64_link_hash_entry
*eh
;
2734 struct elf_dyn_relocs
*p
;
2736 /* STT_GNU_IFUNC symbol must go through PLT. */
2737 if (h
->type
== STT_GNU_IFUNC
)
2739 /* All local STT_GNU_IFUNC references must be treate as local
2740 calls via local PLT. */
2742 && SYMBOL_CALLS_LOCAL (info
, h
))
2744 bfd_size_type pc_count
= 0, count
= 0;
2745 struct elf_dyn_relocs
**pp
;
2747 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2748 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2750 pc_count
+= p
->pc_count
;
2751 p
->count
-= p
->pc_count
;
2760 if (pc_count
|| count
)
2764 if (h
->plt
.refcount
<= 0)
2765 h
->plt
.refcount
= 1;
2767 h
->plt
.refcount
+= 1;
2771 if (h
->plt
.refcount
<= 0)
2773 h
->plt
.offset
= (bfd_vma
) -1;
2779 /* If this is a function, put it in the procedure linkage table. We
2780 will fill in the contents of the procedure linkage table later,
2781 when we know the address of the .got section. */
2782 if (h
->type
== STT_FUNC
2785 if (h
->plt
.refcount
<= 0
2786 || SYMBOL_CALLS_LOCAL (info
, h
)
2787 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2788 && h
->root
.type
== bfd_link_hash_undefweak
))
2790 /* This case can occur if we saw a PLT32 reloc in an input
2791 file, but the symbol was never referred to by a dynamic
2792 object, or if all references were garbage collected. In
2793 such a case, we don't actually need to build a procedure
2794 linkage table, and we can just do a PC32 reloc instead. */
2795 h
->plt
.offset
= (bfd_vma
) -1;
2802 /* It's possible that we incorrectly decided a .plt reloc was
2803 needed for an R_X86_64_PC32 reloc to a non-function sym in
2804 check_relocs. We can't decide accurately between function and
2805 non-function syms in check-relocs; Objects loaded later in
2806 the link may change h->type. So fix it now. */
2807 h
->plt
.offset
= (bfd_vma
) -1;
2809 /* If this is a weak symbol, and there is a real definition, the
2810 processor independent code will have arranged for us to see the
2811 real definition first, and we can just use the same value. */
2812 if (h
->u
.weakdef
!= NULL
)
2814 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2815 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2816 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2817 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2818 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2820 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2821 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2822 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2827 /* This is a reference to a symbol defined by a dynamic object which
2828 is not a function. */
2830 /* If we are creating a shared library, we must presume that the
2831 only references to the symbol are via the global offset table.
2832 For such cases we need not do anything here; the relocations will
2833 be handled correctly by relocate_section. */
2834 if (!bfd_link_executable (info
))
2837 /* If there are no references to this symbol that do not use the
2838 GOT, we don't need to generate a copy reloc. */
2839 if (!h
->non_got_ref
)
2842 /* If -z nocopyreloc was given, we won't generate them either. */
2843 if (info
->nocopyreloc
)
2849 if (ELIMINATE_COPY_RELOCS
)
2851 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2852 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2854 s
= p
->sec
->output_section
;
2855 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2859 /* If we didn't find any dynamic relocs in read-only sections, then
2860 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2868 /* We must allocate the symbol in our .dynbss section, which will
2869 become part of the .bss section of the executable. There will be
2870 an entry for this symbol in the .dynsym section. The dynamic
2871 object will contain position independent code, so all references
2872 from the dynamic object to this symbol will go through the global
2873 offset table. The dynamic linker will use the .dynsym entry to
2874 determine the address it must put in the global offset table, so
2875 both the dynamic object and the regular object will refer to the
2876 same memory location for the variable. */
2878 htab
= elf_x86_64_hash_table (info
);
2882 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2883 to copy the initial value out of the dynamic object and into the
2884 runtime process image. */
2885 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2887 const struct elf_backend_data
*bed
;
2888 bed
= get_elf_backend_data (info
->output_bfd
);
2889 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2895 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2898 /* Allocate space in .plt, .got and associated reloc sections for
2902 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2904 struct bfd_link_info
*info
;
2905 struct elf_x86_64_link_hash_table
*htab
;
2906 struct elf_x86_64_link_hash_entry
*eh
;
2907 struct elf_dyn_relocs
*p
;
2908 const struct elf_backend_data
*bed
;
2909 unsigned int plt_entry_size
;
2910 bfd_boolean resolved_to_zero
;
2912 if (h
->root
.type
== bfd_link_hash_indirect
)
2915 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2917 info
= (struct bfd_link_info
*) inf
;
2918 htab
= elf_x86_64_hash_table (info
);
2921 bed
= get_elf_backend_data (info
->output_bfd
);
2922 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2924 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2928 /* We can't use the GOT PLT if pointer equality is needed since
2929 finish_dynamic_symbol won't clear symbol value and the dynamic
2930 linker won't update the GOT slot. We will get into an infinite
2931 loop at run-time. */
2932 if (htab
->plt_got
!= NULL
2933 && h
->type
!= STT_GNU_IFUNC
2934 && !h
->pointer_equality_needed
2935 && h
->plt
.refcount
> 0
2936 && h
->got
.refcount
> 0)
2938 /* Don't use the regular PLT if there are both GOT and GOTPLT
2940 h
->plt
.offset
= (bfd_vma
) -1;
2942 /* Use the GOT PLT. */
2943 eh
->plt_got
.refcount
= 1;
2946 /* Clear the reference count of function pointer relocations if
2947 symbol isn't a normal function. */
2948 if (h
->type
!= STT_FUNC
)
2949 eh
->func_pointer_refcount
= 0;
2951 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2952 here if it is defined and referenced in a non-shared object. */
2953 if (h
->type
== STT_GNU_IFUNC
2956 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2958 &htab
->readonly_dynrelocs_against_ifunc
,
2963 asection
*s
= htab
->plt_bnd
;
2964 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2966 /* Use the .plt.bnd section if it is created. */
2967 eh
->plt_bnd
.offset
= s
->size
;
2969 /* Make room for this entry in the .plt.bnd section. */
2970 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2978 /* Don't create the PLT entry if there are only function pointer
2979 relocations which can be resolved at run-time. */
2980 else if (htab
->elf
.dynamic_sections_created
2981 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2982 || eh
->plt_got
.refcount
> 0))
2984 bfd_boolean use_plt_got
;
2986 /* Clear the reference count of function pointer relocations
2988 eh
->func_pointer_refcount
= 0;
2990 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2992 /* Don't use the regular PLT for DF_BIND_NOW. */
2993 h
->plt
.offset
= (bfd_vma
) -1;
2995 /* Use the GOT PLT. */
2996 h
->got
.refcount
= 1;
2997 eh
->plt_got
.refcount
= 1;
3000 use_plt_got
= eh
->plt_got
.refcount
> 0;
3002 /* Make sure this symbol is output as a dynamic symbol.
3003 Undefined weak syms won't yet be marked as dynamic. */
3004 if (h
->dynindx
== -1
3006 && !resolved_to_zero
)
3008 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3012 if (bfd_link_pic (info
)
3013 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3015 asection
*s
= htab
->elf
.splt
;
3016 asection
*bnd_s
= htab
->plt_bnd
;
3017 asection
*got_s
= htab
->plt_got
;
3019 /* If this is the first .plt entry, make room for the special
3020 first entry. The .plt section is used by prelink to undo
3021 prelinking for dynamic relocations. */
3023 s
->size
= plt_entry_size
;
3026 eh
->plt_got
.offset
= got_s
->size
;
3029 h
->plt
.offset
= s
->size
;
3031 eh
->plt_bnd
.offset
= bnd_s
->size
;
3034 /* If this symbol is not defined in a regular file, and we are
3035 not generating a shared library, then set the symbol to this
3036 location in the .plt. This is required to make function
3037 pointers compare as equal between the normal executable and
3038 the shared library. */
3039 if (! bfd_link_pic (info
)
3044 /* We need to make a call to the entry of the GOT PLT
3045 instead of regular PLT entry. */
3046 h
->root
.u
.def
.section
= got_s
;
3047 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3053 /* We need to make a call to the entry of the second
3054 PLT instead of regular PLT entry. */
3055 h
->root
.u
.def
.section
= bnd_s
;
3056 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3060 h
->root
.u
.def
.section
= s
;
3061 h
->root
.u
.def
.value
= h
->plt
.offset
;
3066 /* Make room for this entry. */
3068 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3071 s
->size
+= plt_entry_size
;
3073 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3075 /* We also need to make an entry in the .got.plt section,
3076 which will be placed in the .got section by the linker
3078 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3080 /* There should be no PLT relocation against resolved
3081 undefined weak symbol in executable. */
3082 if (!resolved_to_zero
)
3084 /* We also need to make an entry in the .rela.plt
3086 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3087 htab
->elf
.srelplt
->reloc_count
++;
3093 eh
->plt_got
.offset
= (bfd_vma
) -1;
3094 h
->plt
.offset
= (bfd_vma
) -1;
3100 eh
->plt_got
.offset
= (bfd_vma
) -1;
3101 h
->plt
.offset
= (bfd_vma
) -1;
3105 eh
->tlsdesc_got
= (bfd_vma
) -1;
3107 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3108 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3109 if (h
->got
.refcount
> 0
3110 && bfd_link_executable (info
)
3112 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3114 h
->got
.offset
= (bfd_vma
) -1;
3116 else if (h
->got
.refcount
> 0)
3120 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3122 /* Make sure this symbol is output as a dynamic symbol.
3123 Undefined weak syms won't yet be marked as dynamic. */
3124 if (h
->dynindx
== -1
3126 && !resolved_to_zero
)
3128 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3132 if (GOT_TLS_GDESC_P (tls_type
))
3134 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3135 - elf_x86_64_compute_jump_table_size (htab
);
3136 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3137 h
->got
.offset
= (bfd_vma
) -2;
3139 if (! GOT_TLS_GDESC_P (tls_type
)
3140 || GOT_TLS_GD_P (tls_type
))
3143 h
->got
.offset
= s
->size
;
3144 s
->size
+= GOT_ENTRY_SIZE
;
3145 if (GOT_TLS_GD_P (tls_type
))
3146 s
->size
+= GOT_ENTRY_SIZE
;
3148 dyn
= htab
->elf
.dynamic_sections_created
;
3149 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3150 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3151 relocation. No dynamic relocation against resolved undefined
3152 weak symbol in executable. */
3153 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3154 || tls_type
== GOT_TLS_IE
)
3155 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3156 else if (GOT_TLS_GD_P (tls_type
))
3157 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3158 else if (! GOT_TLS_GDESC_P (tls_type
)
3159 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3160 && !resolved_to_zero
)
3161 || h
->root
.type
!= bfd_link_hash_undefweak
)
3162 && (bfd_link_pic (info
)
3163 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3164 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3165 if (GOT_TLS_GDESC_P (tls_type
))
3167 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3168 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3172 h
->got
.offset
= (bfd_vma
) -1;
3174 if (eh
->dyn_relocs
== NULL
)
3177 /* In the shared -Bsymbolic case, discard space allocated for
3178 dynamic pc-relative relocs against symbols which turn out to be
3179 defined in regular objects. For the normal shared case, discard
3180 space for pc-relative relocs that have become local due to symbol
3181 visibility changes. */
3183 if (bfd_link_pic (info
))
3185 /* Relocs that use pc_count are those that appear on a call
3186 insn, or certain REL relocs that can generated via assembly.
3187 We want calls to protected symbols to resolve directly to the
3188 function rather than going via the plt. If people want
3189 function pointer comparisons to work as expected then they
3190 should avoid writing weird assembly. */
3191 if (SYMBOL_CALLS_LOCAL (info
, h
))
3193 struct elf_dyn_relocs
**pp
;
3195 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3197 p
->count
-= p
->pc_count
;
3206 /* Also discard relocs on undefined weak syms with non-default
3207 visibility or in PIE. */
3208 if (eh
->dyn_relocs
!= NULL
)
3210 if (h
->root
.type
== bfd_link_hash_undefweak
)
3212 /* Undefined weak symbol is never bound locally in shared
3214 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3215 || resolved_to_zero
)
3216 eh
->dyn_relocs
= NULL
;
3217 else if (h
->dynindx
== -1
3218 && ! h
->forced_local
3219 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3222 /* For PIE, discard space for pc-relative relocs against
3223 symbols which turn out to need copy relocs. */
3224 else if (bfd_link_executable (info
)
3225 && (h
->needs_copy
|| eh
->needs_copy
)
3229 struct elf_dyn_relocs
**pp
;
3231 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3233 if (p
->pc_count
!= 0)
3241 else if (ELIMINATE_COPY_RELOCS
)
3243 /* For the non-shared case, discard space for relocs against
3244 symbols which turn out to need copy relocs or are not
3245 dynamic. Keep dynamic relocations for run-time function
3246 pointer initialization. */
3248 if ((!h
->non_got_ref
3249 || eh
->func_pointer_refcount
> 0
3250 || (h
->root
.type
== bfd_link_hash_undefweak
3251 && !resolved_to_zero
))
3254 || (htab
->elf
.dynamic_sections_created
3255 && (h
->root
.type
== bfd_link_hash_undefweak
3256 || h
->root
.type
== bfd_link_hash_undefined
))))
3258 /* Make sure this symbol is output as a dynamic symbol.
3259 Undefined weak syms won't yet be marked as dynamic. */
3260 if (h
->dynindx
== -1
3261 && ! h
->forced_local
3262 && ! resolved_to_zero
3263 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3266 /* If that succeeded, we know we'll be keeping all the
3268 if (h
->dynindx
!= -1)
3272 eh
->dyn_relocs
= NULL
;
3273 eh
->func_pointer_refcount
= 0;
3278 /* Finally, allocate space. */
3279 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3283 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3285 BFD_ASSERT (sreloc
!= NULL
);
3287 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3293 /* Allocate space in .plt, .got and associated reloc sections for
3294 local dynamic relocs. */
3297 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3299 struct elf_link_hash_entry
*h
3300 = (struct elf_link_hash_entry
*) *slot
;
3302 if (h
->type
!= STT_GNU_IFUNC
3306 || h
->root
.type
!= bfd_link_hash_defined
)
3309 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3312 /* Find any dynamic relocs that apply to read-only sections. */
3315 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3318 struct elf_x86_64_link_hash_entry
*eh
;
3319 struct elf_dyn_relocs
*p
;
3321 /* Skip local IFUNC symbols. */
3322 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3325 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3326 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3328 asection
*s
= p
->sec
->output_section
;
3330 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3332 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3334 info
->flags
|= DF_TEXTREL
;
3336 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3337 || info
->error_textrel
)
3338 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3339 p
->sec
->owner
, h
->root
.root
.string
,
3342 /* Not an error, just cut short the traversal. */
3349 /* Convert load via the GOT slot to load immediate. */
3352 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3353 struct bfd_link_info
*link_info
)
3355 Elf_Internal_Shdr
*symtab_hdr
;
3356 Elf_Internal_Rela
*internal_relocs
;
3357 Elf_Internal_Rela
*irel
, *irelend
;
3359 struct elf_x86_64_link_hash_table
*htab
;
3360 bfd_boolean changed
;
3361 bfd_signed_vma
*local_got_refcounts
;
3363 /* Don't even try to convert non-ELF outputs. */
3364 if (!is_elf_hash_table (link_info
->hash
))
3367 /* Nothing to do if there is no need or no output. */
3368 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3369 || sec
->need_convert_load
== 0
3370 || bfd_is_abs_section (sec
->output_section
))
3373 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3375 /* Load the relocations for this section. */
3376 internal_relocs
= (_bfd_elf_link_read_relocs
3377 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3378 link_info
->keep_memory
));
3379 if (internal_relocs
== NULL
)
3383 htab
= elf_x86_64_hash_table (link_info
);
3384 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3386 /* Get the section contents. */
3387 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3388 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3391 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3395 irelend
= internal_relocs
+ sec
->reloc_count
;
3396 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3398 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3399 unsigned int r_symndx
;
3400 struct elf_link_hash_entry
*h
;
3401 bfd_boolean converted
;
3403 if (r_type
!= R_X86_64_GOTPCRELX
3404 && r_type
!= R_X86_64_REX_GOTPCRELX
3405 && r_type
!= R_X86_64_GOTPCREL
)
3408 r_symndx
= htab
->r_sym (irel
->r_info
);
3409 if (r_symndx
< symtab_hdr
->sh_info
)
3410 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3411 (const Elf_Internal_Rela
*) irel
,
3415 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3416 while (h
->root
.type
== bfd_link_hash_indirect
3417 || h
->root
.type
== bfd_link_hash_warning
)
3418 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3421 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3422 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3426 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3427 &converted
, link_info
))
3432 changed
= converted
;
3435 if (h
->got
.refcount
> 0)
3436 h
->got
.refcount
-= 1;
3440 if (local_got_refcounts
!= NULL
3441 && local_got_refcounts
[r_symndx
] > 0)
3442 local_got_refcounts
[r_symndx
] -= 1;
3447 if (contents
!= NULL
3448 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3450 if (!changed
&& !link_info
->keep_memory
)
3454 /* Cache the section contents for elf_link_input_bfd. */
3455 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3459 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3462 free (internal_relocs
);
3464 elf_section_data (sec
)->relocs
= internal_relocs
;
3470 if (contents
!= NULL
3471 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3473 if (internal_relocs
!= NULL
3474 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3475 free (internal_relocs
);
3479 /* Set the sizes of the dynamic sections. */
3482 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3483 struct bfd_link_info
*info
)
3485 struct elf_x86_64_link_hash_table
*htab
;
3490 const struct elf_backend_data
*bed
;
3492 htab
= elf_x86_64_hash_table (info
);
3495 bed
= get_elf_backend_data (output_bfd
);
3497 dynobj
= htab
->elf
.dynobj
;
3501 /* Set up .got offsets for local syms, and space for local dynamic
3503 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3505 bfd_signed_vma
*local_got
;
3506 bfd_signed_vma
*end_local_got
;
3507 char *local_tls_type
;
3508 bfd_vma
*local_tlsdesc_gotent
;
3509 bfd_size_type locsymcount
;
3510 Elf_Internal_Shdr
*symtab_hdr
;
3513 if (! is_x86_64_elf (ibfd
))
3516 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3518 struct elf_dyn_relocs
*p
;
3520 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3523 for (p
= (struct elf_dyn_relocs
*)
3524 (elf_section_data (s
)->local_dynrel
);
3528 if (!bfd_is_abs_section (p
->sec
)
3529 && bfd_is_abs_section (p
->sec
->output_section
))
3531 /* Input section has been discarded, either because
3532 it is a copy of a linkonce section or due to
3533 linker script /DISCARD/, so we'll be discarding
3536 else if (p
->count
!= 0)
3538 srel
= elf_section_data (p
->sec
)->sreloc
;
3539 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3540 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3541 && (info
->flags
& DF_TEXTREL
) == 0)
3543 info
->flags
|= DF_TEXTREL
;
3544 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3545 || info
->error_textrel
)
3546 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3547 p
->sec
->owner
, p
->sec
);
3553 local_got
= elf_local_got_refcounts (ibfd
);
3557 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3558 locsymcount
= symtab_hdr
->sh_info
;
3559 end_local_got
= local_got
+ locsymcount
;
3560 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3561 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3563 srel
= htab
->elf
.srelgot
;
3564 for (; local_got
< end_local_got
;
3565 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3567 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3570 if (GOT_TLS_GDESC_P (*local_tls_type
))
3572 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3573 - elf_x86_64_compute_jump_table_size (htab
);
3574 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3575 *local_got
= (bfd_vma
) -2;
3577 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3578 || GOT_TLS_GD_P (*local_tls_type
))
3580 *local_got
= s
->size
;
3581 s
->size
+= GOT_ENTRY_SIZE
;
3582 if (GOT_TLS_GD_P (*local_tls_type
))
3583 s
->size
+= GOT_ENTRY_SIZE
;
3585 if (bfd_link_pic (info
)
3586 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3587 || *local_tls_type
== GOT_TLS_IE
)
3589 if (GOT_TLS_GDESC_P (*local_tls_type
))
3591 htab
->elf
.srelplt
->size
3592 += bed
->s
->sizeof_rela
;
3593 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3595 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3596 || GOT_TLS_GD_P (*local_tls_type
))
3597 srel
->size
+= bed
->s
->sizeof_rela
;
3601 *local_got
= (bfd_vma
) -1;
3605 if (htab
->tls_ld_got
.refcount
> 0)
3607 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3609 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3610 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3611 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3614 htab
->tls_ld_got
.offset
= -1;
3616 /* Allocate global sym .plt and .got entries, and space for global
3617 sym dynamic relocs. */
3618 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3621 /* Allocate .plt and .got entries, and space for local symbols. */
3622 htab_traverse (htab
->loc_hash_table
,
3623 elf_x86_64_allocate_local_dynrelocs
,
3626 /* For every jump slot reserved in the sgotplt, reloc_count is
3627 incremented. However, when we reserve space for TLS descriptors,
3628 it's not incremented, so in order to compute the space reserved
3629 for them, it suffices to multiply the reloc count by the jump
3632 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3633 so that R_X86_64_IRELATIVE entries come last. */
3634 if (htab
->elf
.srelplt
)
3636 htab
->sgotplt_jump_table_size
3637 = elf_x86_64_compute_jump_table_size (htab
);
3638 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3640 else if (htab
->elf
.irelplt
)
3641 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3643 if (htab
->tlsdesc_plt
)
3645 /* If we're not using lazy TLS relocations, don't generate the
3646 PLT and GOT entries they require. */
3647 if ((info
->flags
& DF_BIND_NOW
))
3648 htab
->tlsdesc_plt
= 0;
3651 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3652 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3653 /* Reserve room for the initial entry.
3654 FIXME: we could probably do away with it in this case. */
3655 if (htab
->elf
.splt
->size
== 0)
3656 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3657 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3658 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3662 if (htab
->elf
.sgotplt
)
3664 /* Don't allocate .got.plt section if there are no GOT nor PLT
3665 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3666 if ((htab
->elf
.hgot
== NULL
3667 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3668 && (htab
->elf
.sgotplt
->size
3669 == get_elf_backend_data (output_bfd
)->got_header_size
)
3670 && (htab
->elf
.splt
== NULL
3671 || htab
->elf
.splt
->size
== 0)
3672 && (htab
->elf
.sgot
== NULL
3673 || htab
->elf
.sgot
->size
== 0)
3674 && (htab
->elf
.iplt
== NULL
3675 || htab
->elf
.iplt
->size
== 0)
3676 && (htab
->elf
.igotplt
== NULL
3677 || htab
->elf
.igotplt
->size
== 0))
3678 htab
->elf
.sgotplt
->size
= 0;
3681 if (htab
->plt_eh_frame
!= NULL
3682 && htab
->elf
.splt
!= NULL
3683 && htab
->elf
.splt
->size
!= 0
3684 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3685 && _bfd_elf_eh_frame_present (info
))
3687 const struct elf_x86_64_backend_data
*arch_data
3688 = get_elf_x86_64_arch_data (bed
);
3689 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3692 /* We now have determined the sizes of the various dynamic sections.
3693 Allocate memory for them. */
3695 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3697 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3700 if (s
== htab
->elf
.splt
3701 || s
== htab
->elf
.sgot
3702 || s
== htab
->elf
.sgotplt
3703 || s
== htab
->elf
.iplt
3704 || s
== htab
->elf
.igotplt
3705 || s
== htab
->plt_bnd
3706 || s
== htab
->plt_got
3707 || s
== htab
->plt_eh_frame
3708 || s
== htab
->sdynbss
)
3710 /* Strip this section if we don't need it; see the
3713 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3715 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3718 /* We use the reloc_count field as a counter if we need
3719 to copy relocs into the output file. */
3720 if (s
!= htab
->elf
.srelplt
)
3725 /* It's not one of our sections, so don't allocate space. */
3731 /* If we don't need this section, strip it from the
3732 output file. This is mostly to handle .rela.bss and
3733 .rela.plt. We must create both sections in
3734 create_dynamic_sections, because they must be created
3735 before the linker maps input sections to output
3736 sections. The linker does that before
3737 adjust_dynamic_symbol is called, and it is that
3738 function which decides whether anything needs to go
3739 into these sections. */
3741 s
->flags
|= SEC_EXCLUDE
;
3745 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3748 /* Allocate memory for the section contents. We use bfd_zalloc
3749 here in case unused entries are not reclaimed before the
3750 section's contents are written out. This should not happen,
3751 but this way if it does, we get a R_X86_64_NONE reloc instead
3753 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3754 if (s
->contents
== NULL
)
3758 if (htab
->plt_eh_frame
!= NULL
3759 && htab
->plt_eh_frame
->contents
!= NULL
)
3761 const struct elf_x86_64_backend_data
*arch_data
3762 = get_elf_x86_64_arch_data (bed
);
3764 memcpy (htab
->plt_eh_frame
->contents
,
3765 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3766 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3767 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3770 if (htab
->elf
.dynamic_sections_created
)
3772 /* Add some entries to the .dynamic section. We fill in the
3773 values later, in elf_x86_64_finish_dynamic_sections, but we
3774 must add the entries now so that we get the correct size for
3775 the .dynamic section. The DT_DEBUG entry is filled in by the
3776 dynamic linker and used by the debugger. */
3777 #define add_dynamic_entry(TAG, VAL) \
3778 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3780 if (bfd_link_executable (info
))
3782 if (!add_dynamic_entry (DT_DEBUG
, 0))
3786 if (htab
->elf
.splt
->size
!= 0)
3788 /* DT_PLTGOT is used by prelink even if there is no PLT
3790 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3793 if (htab
->elf
.srelplt
->size
!= 0)
3795 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3796 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3797 || !add_dynamic_entry (DT_JMPREL
, 0))
3801 if (htab
->tlsdesc_plt
3802 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3803 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3809 if (!add_dynamic_entry (DT_RELA
, 0)
3810 || !add_dynamic_entry (DT_RELASZ
, 0)
3811 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3814 /* If any dynamic relocs apply to a read-only section,
3815 then we need a DT_TEXTREL entry. */
3816 if ((info
->flags
& DF_TEXTREL
) == 0)
3817 elf_link_hash_traverse (&htab
->elf
,
3818 elf_x86_64_readonly_dynrelocs
,
3821 if ((info
->flags
& DF_TEXTREL
) != 0)
3823 if (htab
->readonly_dynrelocs_against_ifunc
)
3825 info
->callbacks
->einfo
3826 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3827 bfd_set_error (bfd_error_bad_value
);
3831 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3836 #undef add_dynamic_entry
3842 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3843 struct bfd_link_info
*info
)
3845 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3849 struct elf_link_hash_entry
*tlsbase
;
3851 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3852 "_TLS_MODULE_BASE_",
3853 FALSE
, FALSE
, FALSE
);
3855 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3857 struct elf_x86_64_link_hash_table
*htab
;
3858 struct bfd_link_hash_entry
*bh
= NULL
;
3859 const struct elf_backend_data
*bed
3860 = get_elf_backend_data (output_bfd
);
3862 htab
= elf_x86_64_hash_table (info
);
3866 if (!(_bfd_generic_link_add_one_symbol
3867 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3868 tls_sec
, 0, NULL
, FALSE
,
3869 bed
->collect
, &bh
)))
3872 htab
->tls_module_base
= bh
;
3874 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3875 tlsbase
->def_regular
= 1;
3876 tlsbase
->other
= STV_HIDDEN
;
3877 tlsbase
->root
.linker_def
= 1;
3878 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3885 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3886 executables. Rather than setting it to the beginning of the TLS
3887 section, we have to set it to the end. This function may be called
3888 multiple times, it is idempotent. */
3891 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3893 struct elf_x86_64_link_hash_table
*htab
;
3894 struct bfd_link_hash_entry
*base
;
3896 if (!bfd_link_executable (info
))
3899 htab
= elf_x86_64_hash_table (info
);
3903 base
= htab
->tls_module_base
;
3907 base
->u
.def
.value
= htab
->elf
.tls_size
;
3910 /* Return the base VMA address which should be subtracted from real addresses
3911 when resolving @dtpoff relocation.
3912 This is PT_TLS segment p_vaddr. */
3915 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3917 /* If tls_sec is NULL, we should have signalled an error already. */
3918 if (elf_hash_table (info
)->tls_sec
== NULL
)
3920 return elf_hash_table (info
)->tls_sec
->vma
;
3923 /* Return the relocation value for @tpoff relocation
3924 if STT_TLS virtual address is ADDRESS. */
3927 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3929 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3930 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3931 bfd_vma static_tls_size
;
3933 /* If tls_segment is NULL, we should have signalled an error already. */
3934 if (htab
->tls_sec
== NULL
)
3937 /* Consider special static TLS alignment requirements. */
3938 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3939 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3942 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3946 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3948 /* Opcode Instruction
3951 0x0f 0x8x conditional jump */
3953 && (contents
[offset
- 1] == 0xe8
3954 || contents
[offset
- 1] == 0xe9))
3956 && contents
[offset
- 2] == 0x0f
3957 && (contents
[offset
- 1] & 0xf0) == 0x80));
3960 /* Relocate an x86_64 ELF section. */
3963 elf_x86_64_relocate_section (bfd
*output_bfd
,
3964 struct bfd_link_info
*info
,
3966 asection
*input_section
,
3968 Elf_Internal_Rela
*relocs
,
3969 Elf_Internal_Sym
*local_syms
,
3970 asection
**local_sections
)
3972 struct elf_x86_64_link_hash_table
*htab
;
3973 Elf_Internal_Shdr
*symtab_hdr
;
3974 struct elf_link_hash_entry
**sym_hashes
;
3975 bfd_vma
*local_got_offsets
;
3976 bfd_vma
*local_tlsdesc_gotents
;
3977 Elf_Internal_Rela
*rel
;
3978 Elf_Internal_Rela
*wrel
;
3979 Elf_Internal_Rela
*relend
;
3980 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3982 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3984 /* Skip if check_relocs failed. */
3985 if (input_section
->check_relocs_failed
)
3988 htab
= elf_x86_64_hash_table (info
);
3991 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3992 sym_hashes
= elf_sym_hashes (input_bfd
);
3993 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3994 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3996 elf_x86_64_set_tls_module_base (info
);
3998 rel
= wrel
= relocs
;
3999 relend
= relocs
+ input_section
->reloc_count
;
4000 for (; rel
< relend
; wrel
++, rel
++)
4002 unsigned int r_type
;
4003 reloc_howto_type
*howto
;
4004 unsigned long r_symndx
;
4005 struct elf_link_hash_entry
*h
;
4006 struct elf_x86_64_link_hash_entry
*eh
;
4007 Elf_Internal_Sym
*sym
;
4009 bfd_vma off
, offplt
, plt_offset
;
4011 bfd_boolean unresolved_reloc
;
4012 bfd_reloc_status_type r
;
4014 asection
*base_got
, *resolved_plt
;
4016 bfd_boolean resolved_to_zero
;
4018 r_type
= ELF32_R_TYPE (rel
->r_info
);
4019 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4020 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4027 if (r_type
>= (int) R_X86_64_standard
)
4029 (*_bfd_error_handler
)
4030 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4031 input_bfd
, input_section
, r_type
);
4032 bfd_set_error (bfd_error_bad_value
);
4036 if (r_type
!= (int) R_X86_64_32
4037 || ABI_64_P (output_bfd
))
4038 howto
= x86_64_elf_howto_table
+ r_type
;
4040 howto
= (x86_64_elf_howto_table
4041 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4042 r_symndx
= htab
->r_sym (rel
->r_info
);
4046 unresolved_reloc
= FALSE
;
4047 if (r_symndx
< symtab_hdr
->sh_info
)
4049 sym
= local_syms
+ r_symndx
;
4050 sec
= local_sections
[r_symndx
];
4052 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4054 st_size
= sym
->st_size
;
4056 /* Relocate against local STT_GNU_IFUNC symbol. */
4057 if (!bfd_link_relocatable (info
)
4058 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4060 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4065 /* Set STT_GNU_IFUNC symbol value. */
4066 h
->root
.u
.def
.value
= sym
->st_value
;
4067 h
->root
.u
.def
.section
= sec
;
4072 bfd_boolean warned ATTRIBUTE_UNUSED
;
4073 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4075 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4076 r_symndx
, symtab_hdr
, sym_hashes
,
4078 unresolved_reloc
, warned
, ignored
);
4082 if (sec
!= NULL
&& discarded_section (sec
))
4084 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4085 contents
+ rel
->r_offset
);
4086 wrel
->r_offset
= rel
->r_offset
;
4090 /* For ld -r, remove relocations in debug sections against
4091 sections defined in discarded sections. Not done for
4092 eh_frame editing code expects to be present. */
4093 if (bfd_link_relocatable (info
)
4094 && (input_section
->flags
& SEC_DEBUGGING
))
4100 if (bfd_link_relocatable (info
))
4107 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4109 if (r_type
== R_X86_64_64
)
4111 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4112 zero-extend it to 64bit if addend is zero. */
4113 r_type
= R_X86_64_32
;
4114 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4116 else if (r_type
== R_X86_64_SIZE64
)
4118 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4119 zero-extend it to 64bit if addend is zero. */
4120 r_type
= R_X86_64_SIZE32
;
4121 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4125 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4127 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4128 it here if it is defined in a non-shared object. */
4130 && h
->type
== STT_GNU_IFUNC
4136 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4138 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4139 sections because such sections are not SEC_ALLOC and
4140 thus ld.so will not process them. */
4141 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4145 else if (h
->plt
.offset
== (bfd_vma
) -1)
4148 /* STT_GNU_IFUNC symbol must go through PLT. */
4149 if (htab
->elf
.splt
!= NULL
)
4151 if (htab
->plt_bnd
!= NULL
)
4153 resolved_plt
= htab
->plt_bnd
;
4154 plt_offset
= eh
->plt_bnd
.offset
;
4158 resolved_plt
= htab
->elf
.splt
;
4159 plt_offset
= h
->plt
.offset
;
4164 resolved_plt
= htab
->elf
.iplt
;
4165 plt_offset
= h
->plt
.offset
;
4168 relocation
= (resolved_plt
->output_section
->vma
4169 + resolved_plt
->output_offset
+ plt_offset
);
4174 if (h
->root
.root
.string
)
4175 name
= h
->root
.root
.string
;
4177 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4179 (*_bfd_error_handler
)
4180 (_("%B: relocation %s against STT_GNU_IFUNC "
4181 "symbol `%s' isn't handled by %s"), input_bfd
,
4182 howto
->name
, name
, __FUNCTION__
);
4183 bfd_set_error (bfd_error_bad_value
);
4187 if (bfd_link_pic (info
))
4192 if (ABI_64_P (output_bfd
))
4196 if (rel
->r_addend
!= 0)
4198 if (h
->root
.root
.string
)
4199 name
= h
->root
.root
.string
;
4201 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4203 (*_bfd_error_handler
)
4204 (_("%B: relocation %s against STT_GNU_IFUNC "
4205 "symbol `%s' has non-zero addend: %d"),
4206 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4207 bfd_set_error (bfd_error_bad_value
);
4211 /* Generate dynamic relcoation only when there is a
4212 non-GOT reference in a shared object. */
4213 if (bfd_link_pic (info
) && h
->non_got_ref
)
4215 Elf_Internal_Rela outrel
;
4218 /* Need a dynamic relocation to get the real function
4220 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4224 if (outrel
.r_offset
== (bfd_vma
) -1
4225 || outrel
.r_offset
== (bfd_vma
) -2)
4228 outrel
.r_offset
+= (input_section
->output_section
->vma
4229 + input_section
->output_offset
);
4231 if (h
->dynindx
== -1
4233 || bfd_link_executable (info
))
4235 /* This symbol is resolved locally. */
4236 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4237 outrel
.r_addend
= (h
->root
.u
.def
.value
4238 + h
->root
.u
.def
.section
->output_section
->vma
4239 + h
->root
.u
.def
.section
->output_offset
);
4243 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4244 outrel
.r_addend
= 0;
4247 sreloc
= htab
->elf
.irelifunc
;
4248 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4250 /* If this reloc is against an external symbol, we
4251 do not want to fiddle with the addend. Otherwise,
4252 we need to include the symbol value so that it
4253 becomes an addend for the dynamic reloc. For an
4254 internal symbol, we have updated addend. */
4259 case R_X86_64_PC32_BND
:
4261 case R_X86_64_PLT32
:
4262 case R_X86_64_PLT32_BND
:
4265 case R_X86_64_GOTPCREL
:
4266 case R_X86_64_GOTPCRELX
:
4267 case R_X86_64_REX_GOTPCRELX
:
4268 case R_X86_64_GOTPCREL64
:
4269 base_got
= htab
->elf
.sgot
;
4270 off
= h
->got
.offset
;
4272 if (base_got
== NULL
)
4275 if (off
== (bfd_vma
) -1)
4277 /* We can't use h->got.offset here to save state, or
4278 even just remember the offset, as finish_dynamic_symbol
4279 would use that as offset into .got. */
4281 if (htab
->elf
.splt
!= NULL
)
4283 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4284 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4285 base_got
= htab
->elf
.sgotplt
;
4289 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4290 off
= plt_index
* GOT_ENTRY_SIZE
;
4291 base_got
= htab
->elf
.igotplt
;
4294 if (h
->dynindx
== -1
4298 /* This references the local defitionion. We must
4299 initialize this entry in the global offset table.
4300 Since the offset must always be a multiple of 8,
4301 we use the least significant bit to record
4302 whether we have initialized it already.
4304 When doing a dynamic link, we create a .rela.got
4305 relocation entry to initialize the value. This
4306 is done in the finish_dynamic_symbol routine. */
4311 bfd_put_64 (output_bfd
, relocation
,
4312 base_got
->contents
+ off
);
4313 /* Note that this is harmless for the GOTPLT64
4314 case, as -1 | 1 still is -1. */
4320 relocation
= (base_got
->output_section
->vma
4321 + base_got
->output_offset
+ off
);
4327 resolved_to_zero
= (eh
!= NULL
4328 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4332 /* When generating a shared object, the relocations handled here are
4333 copied into the output file to be resolved at run time. */
4336 case R_X86_64_GOT32
:
4337 case R_X86_64_GOT64
:
4338 /* Relocation is to the entry for this symbol in the global
4340 case R_X86_64_GOTPCREL
:
4341 case R_X86_64_GOTPCRELX
:
4342 case R_X86_64_REX_GOTPCRELX
:
4343 case R_X86_64_GOTPCREL64
:
4344 /* Use global offset table entry as symbol value. */
4345 case R_X86_64_GOTPLT64
:
4346 /* This is obsolete and treated the the same as GOT64. */
4347 base_got
= htab
->elf
.sgot
;
4349 if (htab
->elf
.sgot
== NULL
)
4356 off
= h
->got
.offset
;
4358 && h
->plt
.offset
!= (bfd_vma
)-1
4359 && off
== (bfd_vma
)-1)
4361 /* We can't use h->got.offset here to save
4362 state, or even just remember the offset, as
4363 finish_dynamic_symbol would use that as offset into
4365 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4366 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4367 base_got
= htab
->elf
.sgotplt
;
4370 dyn
= htab
->elf
.dynamic_sections_created
;
4372 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4373 || (bfd_link_pic (info
)
4374 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4375 || (ELF_ST_VISIBILITY (h
->other
)
4376 && h
->root
.type
== bfd_link_hash_undefweak
))
4378 /* This is actually a static link, or it is a -Bsymbolic
4379 link and the symbol is defined locally, or the symbol
4380 was forced to be local because of a version file. We
4381 must initialize this entry in the global offset table.
4382 Since the offset must always be a multiple of 8, we
4383 use the least significant bit to record whether we
4384 have initialized it already.
4386 When doing a dynamic link, we create a .rela.got
4387 relocation entry to initialize the value. This is
4388 done in the finish_dynamic_symbol routine. */
4393 bfd_put_64 (output_bfd
, relocation
,
4394 base_got
->contents
+ off
);
4395 /* Note that this is harmless for the GOTPLT64 case,
4396 as -1 | 1 still is -1. */
4401 unresolved_reloc
= FALSE
;
4405 if (local_got_offsets
== NULL
)
4408 off
= local_got_offsets
[r_symndx
];
4410 /* The offset must always be a multiple of 8. We use
4411 the least significant bit to record whether we have
4412 already generated the necessary reloc. */
4417 bfd_put_64 (output_bfd
, relocation
,
4418 base_got
->contents
+ off
);
4420 if (bfd_link_pic (info
))
4423 Elf_Internal_Rela outrel
;
4425 /* We need to generate a R_X86_64_RELATIVE reloc
4426 for the dynamic linker. */
4427 s
= htab
->elf
.srelgot
;
4431 outrel
.r_offset
= (base_got
->output_section
->vma
4432 + base_got
->output_offset
4434 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4435 outrel
.r_addend
= relocation
;
4436 elf_append_rela (output_bfd
, s
, &outrel
);
4439 local_got_offsets
[r_symndx
] |= 1;
4443 if (off
>= (bfd_vma
) -2)
4446 relocation
= base_got
->output_section
->vma
4447 + base_got
->output_offset
+ off
;
4448 if (r_type
!= R_X86_64_GOTPCREL
4449 && r_type
!= R_X86_64_GOTPCRELX
4450 && r_type
!= R_X86_64_REX_GOTPCRELX
4451 && r_type
!= R_X86_64_GOTPCREL64
)
4452 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4453 - htab
->elf
.sgotplt
->output_offset
;
4457 case R_X86_64_GOTOFF64
:
4458 /* Relocation is relative to the start of the global offset
4461 /* Check to make sure it isn't a protected function or data
4462 symbol for shared library since it may not be local when
4463 used as function address or with copy relocation. We also
4464 need to make sure that a symbol is referenced locally. */
4465 if (bfd_link_pic (info
) && h
)
4467 if (!h
->def_regular
)
4471 switch (ELF_ST_VISIBILITY (h
->other
))
4474 v
= _("hidden symbol");
4477 v
= _("internal symbol");
4480 v
= _("protected symbol");
4487 (*_bfd_error_handler
)
4488 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4489 input_bfd
, v
, h
->root
.root
.string
);
4490 bfd_set_error (bfd_error_bad_value
);
4493 else if (!bfd_link_executable (info
)
4494 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4495 && (h
->type
== STT_FUNC
4496 || h
->type
== STT_OBJECT
)
4497 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4499 (*_bfd_error_handler
)
4500 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4502 h
->type
== STT_FUNC
? "function" : "data",
4503 h
->root
.root
.string
);
4504 bfd_set_error (bfd_error_bad_value
);
4509 /* Note that sgot is not involved in this
4510 calculation. We always want the start of .got.plt. If we
4511 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4512 permitted by the ABI, we might have to change this
4514 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4515 + htab
->elf
.sgotplt
->output_offset
;
4518 case R_X86_64_GOTPC32
:
4519 case R_X86_64_GOTPC64
:
4520 /* Use global offset table as symbol value. */
4521 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4522 + htab
->elf
.sgotplt
->output_offset
;
4523 unresolved_reloc
= FALSE
;
4526 case R_X86_64_PLTOFF64
:
4527 /* Relocation is PLT entry relative to GOT. For local
4528 symbols it's the symbol itself relative to GOT. */
4530 /* See PLT32 handling. */
4531 && h
->plt
.offset
!= (bfd_vma
) -1
4532 && htab
->elf
.splt
!= NULL
)
4534 if (htab
->plt_bnd
!= NULL
)
4536 resolved_plt
= htab
->plt_bnd
;
4537 plt_offset
= eh
->plt_bnd
.offset
;
4541 resolved_plt
= htab
->elf
.splt
;
4542 plt_offset
= h
->plt
.offset
;
4545 relocation
= (resolved_plt
->output_section
->vma
4546 + resolved_plt
->output_offset
4548 unresolved_reloc
= FALSE
;
4551 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4552 + htab
->elf
.sgotplt
->output_offset
;
4555 case R_X86_64_PLT32
:
4556 case R_X86_64_PLT32_BND
:
4557 /* Relocation is to the entry for this symbol in the
4558 procedure linkage table. */
4560 /* Resolve a PLT32 reloc against a local symbol directly,
4561 without using the procedure linkage table. */
4565 if ((h
->plt
.offset
== (bfd_vma
) -1
4566 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4567 || htab
->elf
.splt
== NULL
)
4569 /* We didn't make a PLT entry for this symbol. This
4570 happens when statically linking PIC code, or when
4571 using -Bsymbolic. */
4575 if (h
->plt
.offset
!= (bfd_vma
) -1)
4577 if (htab
->plt_bnd
!= NULL
)
4579 resolved_plt
= htab
->plt_bnd
;
4580 plt_offset
= eh
->plt_bnd
.offset
;
4584 resolved_plt
= htab
->elf
.splt
;
4585 plt_offset
= h
->plt
.offset
;
4590 /* Use the GOT PLT. */
4591 resolved_plt
= htab
->plt_got
;
4592 plt_offset
= eh
->plt_got
.offset
;
4595 relocation
= (resolved_plt
->output_section
->vma
4596 + resolved_plt
->output_offset
4598 unresolved_reloc
= FALSE
;
4601 case R_X86_64_SIZE32
:
4602 case R_X86_64_SIZE64
:
4603 /* Set to symbol size. */
4604 relocation
= st_size
;
4610 case R_X86_64_PC32_BND
:
4611 /* Don't complain about -fPIC if the symbol is undefined when
4612 building executable unless it is unresolved weak symbol. */
4613 if ((input_section
->flags
& SEC_ALLOC
) != 0
4614 && (input_section
->flags
& SEC_READONLY
) != 0
4616 && ((bfd_link_executable (info
)
4617 && h
->root
.type
== bfd_link_hash_undefweak
4618 && !resolved_to_zero
)
4619 || (bfd_link_pic (info
)
4620 && !(bfd_link_pie (info
)
4621 && h
->root
.type
== bfd_link_hash_undefined
))))
4623 bfd_boolean fail
= FALSE
;
4625 = ((r_type
== R_X86_64_PC32
4626 || r_type
== R_X86_64_PC32_BND
)
4627 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4629 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4631 /* Symbol is referenced locally. Make sure it is
4632 defined locally or for a branch. */
4633 fail
= !h
->def_regular
&& !branch
;
4635 else if (!(bfd_link_pie (info
)
4636 && (h
->needs_copy
|| eh
->needs_copy
)))
4638 /* Symbol doesn't need copy reloc and isn't referenced
4639 locally. We only allow branch to symbol with
4640 non-default visibility. */
4642 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4646 return elf_x86_64_need_pic (input_bfd
, input_section
,
4647 h
, NULL
, NULL
, howto
);
4656 /* FIXME: The ABI says the linker should make sure the value is
4657 the same when it's zeroextended to 64 bit. */
4660 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4663 /* Don't copy a pc-relative relocation into the output file
4664 if the symbol needs copy reloc or the symbol is undefined
4665 when building executable. Copy dynamic function pointer
4666 relocations. Don't generate dynamic relocations against
4667 resolved undefined weak symbols in PIE. */
4668 if ((bfd_link_pic (info
)
4669 && !(bfd_link_pie (info
)
4673 || h
->root
.type
== bfd_link_hash_undefined
)
4674 && IS_X86_64_PCREL_TYPE (r_type
))
4676 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4677 && !resolved_to_zero
)
4678 || h
->root
.type
!= bfd_link_hash_undefweak
))
4679 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4680 && r_type
!= R_X86_64_SIZE32
4681 && r_type
!= R_X86_64_SIZE64
)
4682 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4683 || (ELIMINATE_COPY_RELOCS
4684 && !bfd_link_pic (info
)
4688 || eh
->func_pointer_refcount
> 0
4689 || (h
->root
.type
== bfd_link_hash_undefweak
4690 && !resolved_to_zero
))
4691 && ((h
->def_dynamic
&& !h
->def_regular
)
4692 /* Undefined weak symbol is bound locally when
4694 || h
->root
.type
== bfd_link_hash_undefined
)))
4696 Elf_Internal_Rela outrel
;
4697 bfd_boolean skip
, relocate
;
4700 /* When generating a shared object, these relocations
4701 are copied into the output file to be resolved at run
4707 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4709 if (outrel
.r_offset
== (bfd_vma
) -1)
4711 else if (outrel
.r_offset
== (bfd_vma
) -2)
4712 skip
= TRUE
, relocate
= TRUE
;
4714 outrel
.r_offset
+= (input_section
->output_section
->vma
4715 + input_section
->output_offset
);
4718 memset (&outrel
, 0, sizeof outrel
);
4720 /* h->dynindx may be -1 if this symbol was marked to
4724 && (IS_X86_64_PCREL_TYPE (r_type
)
4725 || !(bfd_link_executable (info
)
4726 || SYMBOLIC_BIND (info
, h
))
4727 || ! h
->def_regular
))
4729 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4730 outrel
.r_addend
= rel
->r_addend
;
4734 /* This symbol is local, or marked to become local.
4735 When relocation overflow check is disabled, we
4736 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4737 if (r_type
== htab
->pointer_r_type
4738 || (r_type
== R_X86_64_32
4739 && info
->no_reloc_overflow_check
))
4742 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4743 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4745 else if (r_type
== R_X86_64_64
4746 && !ABI_64_P (output_bfd
))
4749 outrel
.r_info
= htab
->r_info (0,
4750 R_X86_64_RELATIVE64
);
4751 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4752 /* Check addend overflow. */
4753 if ((outrel
.r_addend
& 0x80000000)
4754 != (rel
->r_addend
& 0x80000000))
4757 int addend
= rel
->r_addend
;
4758 if (h
&& h
->root
.root
.string
)
4759 name
= h
->root
.root
.string
;
4761 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4764 (*_bfd_error_handler
)
4765 (_("%B: addend -0x%x in relocation %s against "
4766 "symbol `%s' at 0x%lx in section `%A' is "
4768 input_bfd
, input_section
, addend
,
4770 (unsigned long) rel
->r_offset
);
4772 (*_bfd_error_handler
)
4773 (_("%B: addend 0x%x in relocation %s against "
4774 "symbol `%s' at 0x%lx in section `%A' is "
4776 input_bfd
, input_section
, addend
,
4778 (unsigned long) rel
->r_offset
);
4779 bfd_set_error (bfd_error_bad_value
);
4787 if (bfd_is_abs_section (sec
))
4789 else if (sec
== NULL
|| sec
->owner
== NULL
)
4791 bfd_set_error (bfd_error_bad_value
);
4798 /* We are turning this relocation into one
4799 against a section symbol. It would be
4800 proper to subtract the symbol's value,
4801 osec->vma, from the emitted reloc addend,
4802 but ld.so expects buggy relocs. */
4803 osec
= sec
->output_section
;
4804 sindx
= elf_section_data (osec
)->dynindx
;
4807 asection
*oi
= htab
->elf
.text_index_section
;
4808 sindx
= elf_section_data (oi
)->dynindx
;
4810 BFD_ASSERT (sindx
!= 0);
4813 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4814 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4818 sreloc
= elf_section_data (input_section
)->sreloc
;
4820 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4822 r
= bfd_reloc_notsupported
;
4823 goto check_relocation_error
;
4826 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4828 /* If this reloc is against an external symbol, we do
4829 not want to fiddle with the addend. Otherwise, we
4830 need to include the symbol value so that it becomes
4831 an addend for the dynamic reloc. */
4838 case R_X86_64_TLSGD
:
4839 case R_X86_64_GOTPC32_TLSDESC
:
4840 case R_X86_64_TLSDESC_CALL
:
4841 case R_X86_64_GOTTPOFF
:
4842 tls_type
= GOT_UNKNOWN
;
4843 if (h
== NULL
&& local_got_offsets
)
4844 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4846 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4848 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4849 input_section
, contents
,
4850 symtab_hdr
, sym_hashes
,
4851 &r_type
, tls_type
, rel
,
4852 relend
, h
, r_symndx
, TRUE
))
4855 if (r_type
== R_X86_64_TPOFF32
)
4857 bfd_vma roff
= rel
->r_offset
;
4859 BFD_ASSERT (! unresolved_reloc
);
4861 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4863 /* GD->LE transition. For 64bit, change
4864 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4865 .word 0x6666; rex64; call __tls_get_addr
4868 leaq foo@tpoff(%rax), %rax
4870 leaq foo@tlsgd(%rip), %rdi
4871 .word 0x6666; rex64; call __tls_get_addr
4874 leaq foo@tpoff(%rax), %rax
4875 For largepic, change:
4876 leaq foo@tlsgd(%rip), %rdi
4877 movabsq $__tls_get_addr@pltoff, %rax
4882 leaq foo@tpoff(%rax), %rax
4883 nopw 0x0(%rax,%rax,1) */
4885 if (ABI_64_P (output_bfd
)
4886 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4888 memcpy (contents
+ roff
- 3,
4889 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4890 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4893 else if (ABI_64_P (output_bfd
))
4894 memcpy (contents
+ roff
- 4,
4895 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4898 memcpy (contents
+ roff
- 3,
4899 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4901 bfd_put_32 (output_bfd
,
4902 elf_x86_64_tpoff (info
, relocation
),
4903 contents
+ roff
+ 8 + largepic
);
4904 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4909 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4911 /* GDesc -> LE transition.
4912 It's originally something like:
4913 leaq x@tlsdesc(%rip), %rax
4916 movl $x@tpoff, %rax. */
4918 unsigned int val
, type
;
4920 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4921 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4922 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4923 contents
+ roff
- 3);
4924 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4925 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4926 contents
+ roff
- 1);
4927 bfd_put_32 (output_bfd
,
4928 elf_x86_64_tpoff (info
, relocation
),
4932 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4934 /* GDesc -> LE transition.
4939 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4940 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4943 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4945 /* IE->LE transition:
4946 For 64bit, originally it can be one of:
4947 movq foo@gottpoff(%rip), %reg
4948 addq foo@gottpoff(%rip), %reg
4951 leaq foo(%reg), %reg
4953 For 32bit, originally it can be one of:
4954 movq foo@gottpoff(%rip), %reg
4955 addl foo@gottpoff(%rip), %reg
4958 leal foo(%reg), %reg
4961 unsigned int val
, type
, reg
;
4964 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4967 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4968 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4974 bfd_put_8 (output_bfd
, 0x49,
4975 contents
+ roff
- 3);
4976 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4977 bfd_put_8 (output_bfd
, 0x41,
4978 contents
+ roff
- 3);
4979 bfd_put_8 (output_bfd
, 0xc7,
4980 contents
+ roff
- 2);
4981 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4982 contents
+ roff
- 1);
4986 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4989 bfd_put_8 (output_bfd
, 0x49,
4990 contents
+ roff
- 3);
4991 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4992 bfd_put_8 (output_bfd
, 0x41,
4993 contents
+ roff
- 3);
4994 bfd_put_8 (output_bfd
, 0x81,
4995 contents
+ roff
- 2);
4996 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4997 contents
+ roff
- 1);
5001 /* addq/addl -> leaq/leal */
5003 bfd_put_8 (output_bfd
, 0x4d,
5004 contents
+ roff
- 3);
5005 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5006 bfd_put_8 (output_bfd
, 0x45,
5007 contents
+ roff
- 3);
5008 bfd_put_8 (output_bfd
, 0x8d,
5009 contents
+ roff
- 2);
5010 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5011 contents
+ roff
- 1);
5013 bfd_put_32 (output_bfd
,
5014 elf_x86_64_tpoff (info
, relocation
),
5022 if (htab
->elf
.sgot
== NULL
)
5027 off
= h
->got
.offset
;
5028 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5032 if (local_got_offsets
== NULL
)
5035 off
= local_got_offsets
[r_symndx
];
5036 offplt
= local_tlsdesc_gotents
[r_symndx
];
5043 Elf_Internal_Rela outrel
;
5047 if (htab
->elf
.srelgot
== NULL
)
5050 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5052 if (GOT_TLS_GDESC_P (tls_type
))
5054 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5055 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5056 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5057 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5058 + htab
->elf
.sgotplt
->output_offset
5060 + htab
->sgotplt_jump_table_size
);
5061 sreloc
= htab
->elf
.srelplt
;
5063 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5065 outrel
.r_addend
= 0;
5066 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5069 sreloc
= htab
->elf
.srelgot
;
5071 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5072 + htab
->elf
.sgot
->output_offset
+ off
);
5074 if (GOT_TLS_GD_P (tls_type
))
5075 dr_type
= R_X86_64_DTPMOD64
;
5076 else if (GOT_TLS_GDESC_P (tls_type
))
5079 dr_type
= R_X86_64_TPOFF64
;
5081 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5082 outrel
.r_addend
= 0;
5083 if ((dr_type
== R_X86_64_TPOFF64
5084 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5085 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5086 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5088 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5090 if (GOT_TLS_GD_P (tls_type
))
5094 BFD_ASSERT (! unresolved_reloc
);
5095 bfd_put_64 (output_bfd
,
5096 relocation
- elf_x86_64_dtpoff_base (info
),
5097 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5101 bfd_put_64 (output_bfd
, 0,
5102 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5103 outrel
.r_info
= htab
->r_info (indx
,
5105 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5106 elf_append_rela (output_bfd
, sreloc
,
5115 local_got_offsets
[r_symndx
] |= 1;
5118 if (off
>= (bfd_vma
) -2
5119 && ! GOT_TLS_GDESC_P (tls_type
))
5121 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5123 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5124 || r_type
== R_X86_64_TLSDESC_CALL
)
5125 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5126 + htab
->elf
.sgotplt
->output_offset
5127 + offplt
+ htab
->sgotplt_jump_table_size
;
5129 relocation
= htab
->elf
.sgot
->output_section
->vma
5130 + htab
->elf
.sgot
->output_offset
+ off
;
5131 unresolved_reloc
= FALSE
;
5135 bfd_vma roff
= rel
->r_offset
;
5137 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5139 /* GD->IE transition. For 64bit, change
5140 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5141 .word 0x6666; rex64; call __tls_get_addr@plt
5144 addq foo@gottpoff(%rip), %rax
5146 leaq foo@tlsgd(%rip), %rdi
5147 .word 0x6666; rex64; call __tls_get_addr@plt
5150 addq foo@gottpoff(%rip), %rax
5151 For largepic, change:
5152 leaq foo@tlsgd(%rip), %rdi
5153 movabsq $__tls_get_addr@pltoff, %rax
5158 addq foo@gottpoff(%rax), %rax
5159 nopw 0x0(%rax,%rax,1) */
5161 if (ABI_64_P (output_bfd
)
5162 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5164 memcpy (contents
+ roff
- 3,
5165 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5166 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5169 else if (ABI_64_P (output_bfd
))
5170 memcpy (contents
+ roff
- 4,
5171 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5174 memcpy (contents
+ roff
- 3,
5175 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5178 relocation
= (htab
->elf
.sgot
->output_section
->vma
5179 + htab
->elf
.sgot
->output_offset
+ off
5182 - input_section
->output_section
->vma
5183 - input_section
->output_offset
5185 bfd_put_32 (output_bfd
, relocation
,
5186 contents
+ roff
+ 8 + largepic
);
5187 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5192 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5194 /* GDesc -> IE transition.
5195 It's originally something like:
5196 leaq x@tlsdesc(%rip), %rax
5199 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5201 /* Now modify the instruction as appropriate. To
5202 turn a leaq into a movq in the form we use it, it
5203 suffices to change the second byte from 0x8d to
5205 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5207 bfd_put_32 (output_bfd
,
5208 htab
->elf
.sgot
->output_section
->vma
5209 + htab
->elf
.sgot
->output_offset
+ off
5211 - input_section
->output_section
->vma
5212 - input_section
->output_offset
5217 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5219 /* GDesc -> IE transition.
5226 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5227 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5235 case R_X86_64_TLSLD
:
5236 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5237 input_section
, contents
,
5238 symtab_hdr
, sym_hashes
,
5239 &r_type
, GOT_UNKNOWN
, rel
,
5240 relend
, h
, r_symndx
, TRUE
))
5243 if (r_type
!= R_X86_64_TLSLD
)
5245 /* LD->LE transition:
5246 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5247 For 64bit, we change it into:
5248 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5249 For 32bit, we change it into:
5250 nopl 0x0(%rax); movl %fs:0, %eax.
5251 For largepic, change:
5252 leaq foo@tlsgd(%rip), %rdi
5253 movabsq $__tls_get_addr@pltoff, %rax
5257 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5260 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5261 if (ABI_64_P (output_bfd
)
5262 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5263 memcpy (contents
+ rel
->r_offset
- 3,
5264 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5265 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5266 else if (ABI_64_P (output_bfd
))
5267 memcpy (contents
+ rel
->r_offset
- 3,
5268 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5270 memcpy (contents
+ rel
->r_offset
- 3,
5271 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5272 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5278 if (htab
->elf
.sgot
== NULL
)
5281 off
= htab
->tls_ld_got
.offset
;
5286 Elf_Internal_Rela outrel
;
5288 if (htab
->elf
.srelgot
== NULL
)
5291 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5292 + htab
->elf
.sgot
->output_offset
+ off
);
5294 bfd_put_64 (output_bfd
, 0,
5295 htab
->elf
.sgot
->contents
+ off
);
5296 bfd_put_64 (output_bfd
, 0,
5297 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5298 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5299 outrel
.r_addend
= 0;
5300 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5302 htab
->tls_ld_got
.offset
|= 1;
5304 relocation
= htab
->elf
.sgot
->output_section
->vma
5305 + htab
->elf
.sgot
->output_offset
+ off
;
5306 unresolved_reloc
= FALSE
;
5309 case R_X86_64_DTPOFF32
:
5310 if (!bfd_link_executable (info
)
5311 || (input_section
->flags
& SEC_CODE
) == 0)
5312 relocation
-= elf_x86_64_dtpoff_base (info
);
5314 relocation
= elf_x86_64_tpoff (info
, relocation
);
5317 case R_X86_64_TPOFF32
:
5318 case R_X86_64_TPOFF64
:
5319 BFD_ASSERT (bfd_link_executable (info
));
5320 relocation
= elf_x86_64_tpoff (info
, relocation
);
5323 case R_X86_64_DTPOFF64
:
5324 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5325 relocation
-= elf_x86_64_dtpoff_base (info
);
5332 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5333 because such sections are not SEC_ALLOC and thus ld.so will
5334 not process them. */
5335 if (unresolved_reloc
5336 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5338 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5339 rel
->r_offset
) != (bfd_vma
) -1)
5341 (*_bfd_error_handler
)
5342 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5345 (long) rel
->r_offset
,
5347 h
->root
.root
.string
);
5352 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5353 contents
, rel
->r_offset
,
5354 relocation
, rel
->r_addend
);
5356 check_relocation_error
:
5357 if (r
!= bfd_reloc_ok
)
5362 name
= h
->root
.root
.string
;
5365 name
= bfd_elf_string_from_elf_section (input_bfd
,
5366 symtab_hdr
->sh_link
,
5371 name
= bfd_section_name (input_bfd
, sec
);
5374 if (r
== bfd_reloc_overflow
)
5375 (*info
->callbacks
->reloc_overflow
)
5376 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5377 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5380 (*_bfd_error_handler
)
5381 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5382 input_bfd
, input_section
,
5383 (long) rel
->r_offset
, name
, (int) r
);
5394 Elf_Internal_Shdr
*rel_hdr
;
5395 size_t deleted
= rel
- wrel
;
5397 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5398 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5399 if (rel_hdr
->sh_size
== 0)
5401 /* It is too late to remove an empty reloc section. Leave
5403 ??? What is wrong with an empty section??? */
5404 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5407 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5408 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5409 input_section
->reloc_count
-= deleted
;
5415 /* Finish up dynamic symbol handling. We set the contents of various
5416 dynamic sections here. */
5419 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5420 struct bfd_link_info
*info
,
5421 struct elf_link_hash_entry
*h
,
5422 Elf_Internal_Sym
*sym
)
5424 struct elf_x86_64_link_hash_table
*htab
;
5425 const struct elf_x86_64_backend_data
*abed
;
5426 bfd_boolean use_plt_bnd
;
5427 struct elf_x86_64_link_hash_entry
*eh
;
5428 bfd_boolean local_undefweak
;
5430 htab
= elf_x86_64_hash_table (info
);
5434 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5435 section only if there is .plt section. */
5436 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5438 ? &elf_x86_64_bnd_arch_bed
5439 : get_elf_x86_64_backend_data (output_bfd
));
5441 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5443 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5444 resolved undefined weak symbols in executable so that their
5445 references have value 0 at run-time. */
5446 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5450 if (h
->plt
.offset
!= (bfd_vma
) -1)
5453 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5454 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5455 Elf_Internal_Rela rela
;
5457 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5458 const struct elf_backend_data
*bed
;
5459 bfd_vma plt_got_pcrel_offset
;
5461 /* When building a static executable, use .iplt, .igot.plt and
5462 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5463 if (htab
->elf
.splt
!= NULL
)
5465 plt
= htab
->elf
.splt
;
5466 gotplt
= htab
->elf
.sgotplt
;
5467 relplt
= htab
->elf
.srelplt
;
5471 plt
= htab
->elf
.iplt
;
5472 gotplt
= htab
->elf
.igotplt
;
5473 relplt
= htab
->elf
.irelplt
;
5476 /* This symbol has an entry in the procedure linkage table. Set
5478 if ((h
->dynindx
== -1
5480 && !((h
->forced_local
|| bfd_link_executable (info
))
5482 && h
->type
== STT_GNU_IFUNC
))
5488 /* Get the index in the procedure linkage table which
5489 corresponds to this symbol. This is the index of this symbol
5490 in all the symbols for which we are making plt entries. The
5491 first entry in the procedure linkage table is reserved.
5493 Get the offset into the .got table of the entry that
5494 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5495 bytes. The first three are reserved for the dynamic linker.
5497 For static executables, we don't reserve anything. */
5499 if (plt
== htab
->elf
.splt
)
5501 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5502 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5506 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5507 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5510 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5511 plt_plt_offset
= abed
->plt_plt_offset
;
5512 plt_got_insn_size
= abed
->plt_got_insn_size
;
5513 plt_got_offset
= abed
->plt_got_offset
;
5516 /* Use the second PLT with BND relocations. */
5517 const bfd_byte
*plt_entry
, *plt2_entry
;
5519 if (eh
->has_bnd_reloc
)
5521 plt_entry
= elf_x86_64_bnd_plt_entry
;
5522 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5526 plt_entry
= elf_x86_64_legacy_plt_entry
;
5527 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5529 /* Subtract 1 since there is no BND prefix. */
5530 plt_plt_insn_end
-= 1;
5531 plt_plt_offset
-= 1;
5532 plt_got_insn_size
-= 1;
5533 plt_got_offset
-= 1;
5536 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5537 == sizeof (elf_x86_64_legacy_plt_entry
));
5539 /* Fill in the entry in the procedure linkage table. */
5540 memcpy (plt
->contents
+ h
->plt
.offset
,
5541 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5542 /* Fill in the entry in the second PLT. */
5543 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5544 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5546 resolved_plt
= htab
->plt_bnd
;
5547 plt_offset
= eh
->plt_bnd
.offset
;
5551 /* Fill in the entry in the procedure linkage table. */
5552 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5553 abed
->plt_entry_size
);
5556 plt_offset
= h
->plt
.offset
;
5559 /* Insert the relocation positions of the plt section. */
5561 /* Put offset the PC-relative instruction referring to the GOT entry,
5562 subtracting the size of that instruction. */
5563 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5564 + gotplt
->output_offset
5566 - resolved_plt
->output_section
->vma
5567 - resolved_plt
->output_offset
5569 - plt_got_insn_size
);
5571 /* Check PC-relative offset overflow in PLT entry. */
5572 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5573 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5574 output_bfd
, h
->root
.root
.string
);
5576 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5577 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5579 /* Fill in the entry in the global offset table, initially this
5580 points to the second part of the PLT entry. Leave the entry
5581 as zero for undefined weak symbol in PIE. No PLT relocation
5582 against undefined weak symbol in PIE. */
5583 if (!local_undefweak
)
5585 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5586 + plt
->output_offset
5588 + abed
->plt_lazy_offset
),
5589 gotplt
->contents
+ got_offset
);
5591 /* Fill in the entry in the .rela.plt section. */
5592 rela
.r_offset
= (gotplt
->output_section
->vma
5593 + gotplt
->output_offset
5595 if (h
->dynindx
== -1
5596 || ((bfd_link_executable (info
)
5597 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5599 && h
->type
== STT_GNU_IFUNC
))
5601 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5602 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5603 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5604 rela
.r_addend
= (h
->root
.u
.def
.value
5605 + h
->root
.u
.def
.section
->output_section
->vma
5606 + h
->root
.u
.def
.section
->output_offset
);
5607 /* R_X86_64_IRELATIVE comes last. */
5608 plt_index
= htab
->next_irelative_index
--;
5612 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5614 plt_index
= htab
->next_jump_slot_index
++;
5617 /* Don't fill PLT entry for static executables. */
5618 if (plt
== htab
->elf
.splt
)
5620 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5622 /* Put relocation index. */
5623 bfd_put_32 (output_bfd
, plt_index
,
5624 (plt
->contents
+ h
->plt
.offset
5625 + abed
->plt_reloc_offset
));
5627 /* Put offset for jmp .PLT0 and check for overflow. We don't
5628 check relocation index for overflow since branch displacement
5629 will overflow first. */
5630 if (plt0_offset
> 0x80000000)
5631 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5632 output_bfd
, h
->root
.root
.string
);
5633 bfd_put_32 (output_bfd
, - plt0_offset
,
5634 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5637 bed
= get_elf_backend_data (output_bfd
);
5638 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5639 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5642 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5644 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5645 asection
*plt
, *got
;
5646 bfd_boolean got_after_plt
;
5647 int32_t got_pcrel_offset
;
5648 const bfd_byte
*got_plt_entry
;
5650 /* Set the entry in the GOT procedure linkage table. */
5651 plt
= htab
->plt_got
;
5652 got
= htab
->elf
.sgot
;
5653 got_offset
= h
->got
.offset
;
5655 if (got_offset
== (bfd_vma
) -1
5656 || h
->type
== STT_GNU_IFUNC
5661 /* Use the second PLT entry template for the GOT PLT since they
5662 are the identical. */
5663 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5664 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5665 if (eh
->has_bnd_reloc
)
5666 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5669 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5671 /* Subtract 1 since there is no BND prefix. */
5672 plt_got_insn_size
-= 1;
5673 plt_got_offset
-= 1;
5676 /* Fill in the entry in the GOT procedure linkage table. */
5677 plt_offset
= eh
->plt_got
.offset
;
5678 memcpy (plt
->contents
+ plt_offset
,
5679 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5681 /* Put offset the PC-relative instruction referring to the GOT
5682 entry, subtracting the size of that instruction. */
5683 got_pcrel_offset
= (got
->output_section
->vma
5684 + got
->output_offset
5686 - plt
->output_section
->vma
5687 - plt
->output_offset
5689 - plt_got_insn_size
);
5691 /* Check PC-relative offset overflow in GOT PLT entry. */
5692 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5693 if ((got_after_plt
&& got_pcrel_offset
< 0)
5694 || (!got_after_plt
&& got_pcrel_offset
> 0))
5695 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5696 output_bfd
, h
->root
.root
.string
);
5698 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5699 plt
->contents
+ plt_offset
+ plt_got_offset
);
5702 if (!local_undefweak
5704 && (h
->plt
.offset
!= (bfd_vma
) -1
5705 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5707 /* Mark the symbol as undefined, rather than as defined in
5708 the .plt section. Leave the value if there were any
5709 relocations where pointer equality matters (this is a clue
5710 for the dynamic linker, to make function pointer
5711 comparisons work between an application and shared
5712 library), otherwise set it to zero. If a function is only
5713 called from a binary, there is no need to slow down
5714 shared libraries because of that. */
5715 sym
->st_shndx
= SHN_UNDEF
;
5716 if (!h
->pointer_equality_needed
)
5720 /* Don't generate dynamic GOT relocation against undefined weak
5721 symbol in executable. */
5722 if (h
->got
.offset
!= (bfd_vma
) -1
5723 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5724 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5725 && !local_undefweak
)
5727 Elf_Internal_Rela rela
;
5729 /* This symbol has an entry in the global offset table. Set it
5731 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5734 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5735 + htab
->elf
.sgot
->output_offset
5736 + (h
->got
.offset
&~ (bfd_vma
) 1));
5738 /* If this is a static link, or it is a -Bsymbolic link and the
5739 symbol is defined locally or was forced to be local because
5740 of a version file, we just want to emit a RELATIVE reloc.
5741 The entry in the global offset table will already have been
5742 initialized in the relocate_section function. */
5744 && h
->type
== STT_GNU_IFUNC
)
5746 if (bfd_link_pic (info
))
5748 /* Generate R_X86_64_GLOB_DAT. */
5755 if (!h
->pointer_equality_needed
)
5758 /* For non-shared object, we can't use .got.plt, which
5759 contains the real function addres if we need pointer
5760 equality. We load the GOT entry with the PLT entry. */
5761 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5762 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5763 + plt
->output_offset
5765 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5769 else if (bfd_link_pic (info
)
5770 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5772 if (!h
->def_regular
)
5774 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5775 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5776 rela
.r_addend
= (h
->root
.u
.def
.value
5777 + h
->root
.u
.def
.section
->output_section
->vma
5778 + h
->root
.u
.def
.section
->output_offset
);
5782 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5784 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5785 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5786 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5790 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5795 Elf_Internal_Rela rela
;
5797 /* This symbol needs a copy reloc. Set it up. */
5799 if (h
->dynindx
== -1
5800 || (h
->root
.type
!= bfd_link_hash_defined
5801 && h
->root
.type
!= bfd_link_hash_defweak
)
5802 || htab
->srelbss
== NULL
)
5805 rela
.r_offset
= (h
->root
.u
.def
.value
5806 + h
->root
.u
.def
.section
->output_section
->vma
5807 + h
->root
.u
.def
.section
->output_offset
);
5808 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5810 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5816 /* Finish up local dynamic symbol handling. We set the contents of
5817 various dynamic sections here. */
5820 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5822 struct elf_link_hash_entry
*h
5823 = (struct elf_link_hash_entry
*) *slot
;
5824 struct bfd_link_info
*info
5825 = (struct bfd_link_info
*) inf
;
5827 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5831 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5832 here since undefined weak symbol may not be dynamic and may not be
5833 called for elf_x86_64_finish_dynamic_symbol. */
5836 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5839 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5840 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5842 if (h
->root
.type
!= bfd_link_hash_undefweak
5843 || h
->dynindx
!= -1)
5846 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5850 /* Used to decide how to sort relocs in an optimal manner for the
5851 dynamic linker, before writing them out. */
5853 static enum elf_reloc_type_class
5854 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5855 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5856 const Elf_Internal_Rela
*rela
)
5858 bfd
*abfd
= info
->output_bfd
;
5859 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5860 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5862 if (htab
->elf
.dynsym
!= NULL
5863 && htab
->elf
.dynsym
->contents
!= NULL
)
5865 /* Check relocation against STT_GNU_IFUNC symbol if there are
5867 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5868 Elf_Internal_Sym sym
;
5869 if (!bed
->s
->swap_symbol_in (abfd
,
5870 (htab
->elf
.dynsym
->contents
5871 + r_symndx
* bed
->s
->sizeof_sym
),
5875 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5876 return reloc_class_ifunc
;
5879 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5881 case R_X86_64_RELATIVE
:
5882 case R_X86_64_RELATIVE64
:
5883 return reloc_class_relative
;
5884 case R_X86_64_JUMP_SLOT
:
5885 return reloc_class_plt
;
5887 return reloc_class_copy
;
5889 return reloc_class_normal
;
5893 /* Finish up the dynamic sections. */
5896 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5897 struct bfd_link_info
*info
)
5899 struct elf_x86_64_link_hash_table
*htab
;
5902 const struct elf_x86_64_backend_data
*abed
;
5904 htab
= elf_x86_64_hash_table (info
);
5908 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5909 section only if there is .plt section. */
5910 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5911 ? &elf_x86_64_bnd_arch_bed
5912 : get_elf_x86_64_backend_data (output_bfd
));
5914 dynobj
= htab
->elf
.dynobj
;
5915 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5917 if (htab
->elf
.dynamic_sections_created
)
5919 bfd_byte
*dyncon
, *dynconend
;
5920 const struct elf_backend_data
*bed
;
5921 bfd_size_type sizeof_dyn
;
5923 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5926 bed
= get_elf_backend_data (dynobj
);
5927 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5928 dyncon
= sdyn
->contents
;
5929 dynconend
= sdyn
->contents
+ sdyn
->size
;
5930 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5932 Elf_Internal_Dyn dyn
;
5935 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5943 s
= htab
->elf
.sgotplt
;
5944 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5948 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5952 s
= htab
->elf
.srelplt
->output_section
;
5953 dyn
.d_un
.d_val
= s
->size
;
5957 /* The procedure linkage table relocs (DT_JMPREL) should
5958 not be included in the overall relocs (DT_RELA).
5959 Therefore, we override the DT_RELASZ entry here to
5960 make it not include the JMPREL relocs. Since the
5961 linker script arranges for .rela.plt to follow all
5962 other relocation sections, we don't have to worry
5963 about changing the DT_RELA entry. */
5964 if (htab
->elf
.srelplt
!= NULL
)
5966 s
= htab
->elf
.srelplt
->output_section
;
5967 dyn
.d_un
.d_val
-= s
->size
;
5971 case DT_TLSDESC_PLT
:
5973 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5974 + htab
->tlsdesc_plt
;
5977 case DT_TLSDESC_GOT
:
5979 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5980 + htab
->tlsdesc_got
;
5984 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5987 /* Fill in the special first entry in the procedure linkage table. */
5988 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5990 /* Fill in the first entry in the procedure linkage table. */
5991 memcpy (htab
->elf
.splt
->contents
,
5992 abed
->plt0_entry
, abed
->plt_entry_size
);
5993 /* Add offset for pushq GOT+8(%rip), since the instruction
5994 uses 6 bytes subtract this value. */
5995 bfd_put_32 (output_bfd
,
5996 (htab
->elf
.sgotplt
->output_section
->vma
5997 + htab
->elf
.sgotplt
->output_offset
5999 - htab
->elf
.splt
->output_section
->vma
6000 - htab
->elf
.splt
->output_offset
6002 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6003 /* Add offset for the PC-relative instruction accessing GOT+16,
6004 subtracting the offset to the end of that instruction. */
6005 bfd_put_32 (output_bfd
,
6006 (htab
->elf
.sgotplt
->output_section
->vma
6007 + htab
->elf
.sgotplt
->output_offset
6009 - htab
->elf
.splt
->output_section
->vma
6010 - htab
->elf
.splt
->output_offset
6011 - abed
->plt0_got2_insn_end
),
6012 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6014 elf_section_data (htab
->elf
.splt
->output_section
)
6015 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6017 if (htab
->tlsdesc_plt
)
6019 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6020 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6022 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6023 abed
->plt0_entry
, abed
->plt_entry_size
);
6025 /* Add offset for pushq GOT+8(%rip), since the
6026 instruction uses 6 bytes subtract this value. */
6027 bfd_put_32 (output_bfd
,
6028 (htab
->elf
.sgotplt
->output_section
->vma
6029 + htab
->elf
.sgotplt
->output_offset
6031 - htab
->elf
.splt
->output_section
->vma
6032 - htab
->elf
.splt
->output_offset
6035 htab
->elf
.splt
->contents
6036 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6037 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6038 where TGD stands for htab->tlsdesc_got, subtracting the offset
6039 to the end of that instruction. */
6040 bfd_put_32 (output_bfd
,
6041 (htab
->elf
.sgot
->output_section
->vma
6042 + htab
->elf
.sgot
->output_offset
6044 - htab
->elf
.splt
->output_section
->vma
6045 - htab
->elf
.splt
->output_offset
6047 - abed
->plt0_got2_insn_end
),
6048 htab
->elf
.splt
->contents
6049 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6054 if (htab
->plt_bnd
!= NULL
)
6055 elf_section_data (htab
->plt_bnd
->output_section
)
6056 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6058 if (htab
->elf
.sgotplt
)
6060 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6062 (*_bfd_error_handler
)
6063 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6067 /* Fill in the first three entries in the global offset table. */
6068 if (htab
->elf
.sgotplt
->size
> 0)
6070 /* Set the first entry in the global offset table to the address of
6071 the dynamic section. */
6073 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6075 bfd_put_64 (output_bfd
,
6076 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6077 htab
->elf
.sgotplt
->contents
);
6078 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6079 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6080 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6083 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6087 /* Adjust .eh_frame for .plt section. */
6088 if (htab
->plt_eh_frame
!= NULL
6089 && htab
->plt_eh_frame
->contents
!= NULL
)
6091 if (htab
->elf
.splt
!= NULL
6092 && htab
->elf
.splt
->size
!= 0
6093 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6094 && htab
->elf
.splt
->output_section
!= NULL
6095 && htab
->plt_eh_frame
->output_section
!= NULL
)
6097 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6098 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6099 + htab
->plt_eh_frame
->output_offset
6100 + PLT_FDE_START_OFFSET
;
6101 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6102 htab
->plt_eh_frame
->contents
6103 + PLT_FDE_START_OFFSET
);
6105 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6107 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6109 htab
->plt_eh_frame
->contents
))
6114 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6115 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6118 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6119 htab_traverse (htab
->loc_hash_table
,
6120 elf_x86_64_finish_local_dynamic_symbol
,
6123 /* Fill PLT entries for undefined weak symbols in PIE. */
6124 if (bfd_link_pie (info
))
6125 bfd_hash_traverse (&info
->hash
->table
,
6126 elf_x86_64_pie_finish_undefweak_symbol
,
6132 /* Return an array of PLT entry symbol values. */
6135 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6138 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6141 bfd_vma
*plt_sym_val
;
6143 bfd_byte
*plt_contents
;
6144 const struct elf_x86_64_backend_data
*bed
;
6145 Elf_Internal_Shdr
*hdr
;
6148 /* Get the .plt section contents. PLT passed down may point to the
6149 .plt.bnd section. Make sure that PLT always points to the .plt
6151 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6156 plt
= bfd_get_section_by_name (abfd
, ".plt");
6159 bed
= &elf_x86_64_bnd_arch_bed
;
6162 bed
= get_elf_x86_64_backend_data (abfd
);
6164 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6165 if (plt_contents
== NULL
)
6167 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6168 plt_contents
, 0, plt
->size
))
6171 free (plt_contents
);
6175 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6176 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6179 hdr
= &elf_section_data (relplt
)->this_hdr
;
6180 count
= relplt
->size
/ hdr
->sh_entsize
;
6182 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6183 if (plt_sym_val
== NULL
)
6186 for (i
= 0; i
< count
; i
++)
6187 plt_sym_val
[i
] = -1;
6189 plt_offset
= bed
->plt_entry_size
;
6190 p
= relplt
->relocation
;
6191 for (i
= 0; i
< count
; i
++, p
++)
6195 /* Skip unknown relocation. */
6196 if (p
->howto
== NULL
)
6199 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6200 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6203 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6204 + bed
->plt_reloc_offset
));
6205 if (reloc_index
< count
)
6209 /* This is the index in .plt section. */
6210 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6211 /* Store VMA + the offset in .plt.bnd section. */
6212 plt_sym_val
[reloc_index
] =
6214 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6217 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6219 plt_offset
+= bed
->plt_entry_size
;
6221 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6223 if (plt_offset
>= plt
->size
)
6227 free (plt_contents
);
6232 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6236 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6243 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6244 as PLT if it exists. */
6245 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6247 plt
= bfd_get_section_by_name (abfd
, ".plt");
6248 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6249 dynsymcount
, dynsyms
, ret
,
6251 elf_x86_64_get_plt_sym_val
);
6254 /* Handle an x86-64 specific section when reading an object file. This
6255 is called when elfcode.h finds a section with an unknown type. */
6258 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6259 const char *name
, int shindex
)
6261 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6264 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6270 /* Hook called by the linker routine which adds symbols from an object
6271 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6275 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6276 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6277 Elf_Internal_Sym
*sym
,
6278 const char **namep ATTRIBUTE_UNUSED
,
6279 flagword
*flagsp ATTRIBUTE_UNUSED
,
6285 switch (sym
->st_shndx
)
6287 case SHN_X86_64_LCOMMON
:
6288 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6291 lcomm
= bfd_make_section_with_flags (abfd
,
6295 | SEC_LINKER_CREATED
));
6298 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6301 *valp
= sym
->st_size
;
6309 /* Given a BFD section, try to locate the corresponding ELF section
6313 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6314 asection
*sec
, int *index_return
)
6316 if (sec
== &_bfd_elf_large_com_section
)
6318 *index_return
= SHN_X86_64_LCOMMON
;
6324 /* Process a symbol. */
6327 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6330 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6332 switch (elfsym
->internal_elf_sym
.st_shndx
)
6334 case SHN_X86_64_LCOMMON
:
6335 asym
->section
= &_bfd_elf_large_com_section
;
6336 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6337 /* Common symbol doesn't set BSF_GLOBAL. */
6338 asym
->flags
&= ~BSF_GLOBAL
;
6344 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6346 return (sym
->st_shndx
== SHN_COMMON
6347 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6351 elf_x86_64_common_section_index (asection
*sec
)
6353 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6356 return SHN_X86_64_LCOMMON
;
6360 elf_x86_64_common_section (asection
*sec
)
6362 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6363 return bfd_com_section_ptr
;
6365 return &_bfd_elf_large_com_section
;
6369 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6370 const Elf_Internal_Sym
*sym
,
6375 const asection
*oldsec
)
6377 /* A normal common symbol and a large common symbol result in a
6378 normal common symbol. We turn the large common symbol into a
6381 && h
->root
.type
== bfd_link_hash_common
6383 && bfd_is_com_section (*psec
)
6386 if (sym
->st_shndx
== SHN_COMMON
6387 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6389 h
->root
.u
.c
.p
->section
6390 = bfd_make_section_old_way (oldbfd
, "COMMON");
6391 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6393 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6394 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6395 *psec
= bfd_com_section_ptr
;
6402 elf_x86_64_additional_program_headers (bfd
*abfd
,
6403 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6408 /* Check to see if we need a large readonly segment. */
6409 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6410 if (s
&& (s
->flags
& SEC_LOAD
))
6413 /* Check to see if we need a large data segment. Since .lbss sections
6414 is placed right after the .bss section, there should be no need for
6415 a large data segment just because of .lbss. */
6416 s
= bfd_get_section_by_name (abfd
, ".ldata");
6417 if (s
&& (s
->flags
& SEC_LOAD
))
6423 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6426 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6428 if (h
->plt
.offset
!= (bfd_vma
) -1
6430 && !h
->pointer_equality_needed
)
6433 return _bfd_elf_hash_symbol (h
);
6436 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6439 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6440 const bfd_target
*output
)
6442 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6443 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6444 && _bfd_elf_relocs_compatible (input
, output
));
6447 static const struct bfd_elf_special_section
6448 elf_x86_64_special_sections
[]=
6450 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6451 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6452 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6453 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6454 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6455 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6456 { NULL
, 0, 0, 0, 0 }
6459 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6460 #define TARGET_LITTLE_NAME "elf64-x86-64"
6461 #define ELF_ARCH bfd_arch_i386
6462 #define ELF_TARGET_ID X86_64_ELF_DATA
6463 #define ELF_MACHINE_CODE EM_X86_64
6464 #define ELF_MAXPAGESIZE 0x200000
6465 #define ELF_MINPAGESIZE 0x1000
6466 #define ELF_COMMONPAGESIZE 0x1000
6468 #define elf_backend_can_gc_sections 1
6469 #define elf_backend_can_refcount 1
6470 #define elf_backend_want_got_plt 1
6471 #define elf_backend_plt_readonly 1
6472 #define elf_backend_want_plt_sym 0
6473 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6474 #define elf_backend_rela_normal 1
6475 #define elf_backend_plt_alignment 4
6476 #define elf_backend_extern_protected_data 1
6477 #define elf_backend_caches_rawsize 1
6479 #define elf_info_to_howto elf_x86_64_info_to_howto
6481 #define bfd_elf64_bfd_link_hash_table_create \
6482 elf_x86_64_link_hash_table_create
6483 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6484 #define bfd_elf64_bfd_reloc_name_lookup \
6485 elf_x86_64_reloc_name_lookup
6487 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6488 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6489 #define elf_backend_check_relocs elf_x86_64_check_relocs
6490 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6491 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6492 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6493 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6494 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6495 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6496 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6498 #define elf_backend_write_core_note elf_x86_64_write_core_note
6500 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6501 #define elf_backend_relocate_section elf_x86_64_relocate_section
6502 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6503 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6504 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6505 #define elf_backend_object_p elf64_x86_64_elf_object_p
6506 #define bfd_elf64_mkobject elf_x86_64_mkobject
6507 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6509 #define elf_backend_section_from_shdr \
6510 elf_x86_64_section_from_shdr
6512 #define elf_backend_section_from_bfd_section \
6513 elf_x86_64_elf_section_from_bfd_section
6514 #define elf_backend_add_symbol_hook \
6515 elf_x86_64_add_symbol_hook
6516 #define elf_backend_symbol_processing \
6517 elf_x86_64_symbol_processing
6518 #define elf_backend_common_section_index \
6519 elf_x86_64_common_section_index
6520 #define elf_backend_common_section \
6521 elf_x86_64_common_section
6522 #define elf_backend_common_definition \
6523 elf_x86_64_common_definition
6524 #define elf_backend_merge_symbol \
6525 elf_x86_64_merge_symbol
6526 #define elf_backend_special_sections \
6527 elf_x86_64_special_sections
6528 #define elf_backend_additional_program_headers \
6529 elf_x86_64_additional_program_headers
6530 #define elf_backend_hash_symbol \
6531 elf_x86_64_hash_symbol
6532 #define elf_backend_omit_section_dynsym \
6533 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6534 #define elf_backend_fixup_symbol \
6535 elf_x86_64_fixup_symbol
6537 #include "elf64-target.h"
6539 /* CloudABI support. */
6541 #undef TARGET_LITTLE_SYM
6542 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6543 #undef TARGET_LITTLE_NAME
6544 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6547 #define ELF_OSABI ELFOSABI_CLOUDABI
6550 #define elf64_bed elf64_x86_64_cloudabi_bed
6552 #include "elf64-target.h"
6554 /* FreeBSD support. */
6556 #undef TARGET_LITTLE_SYM
6557 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6558 #undef TARGET_LITTLE_NAME
6559 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6562 #define ELF_OSABI ELFOSABI_FREEBSD
6565 #define elf64_bed elf64_x86_64_fbsd_bed
6567 #include "elf64-target.h"
6569 /* Solaris 2 support. */
6571 #undef TARGET_LITTLE_SYM
6572 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6573 #undef TARGET_LITTLE_NAME
6574 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6576 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6577 objects won't be recognized. */
6581 #define elf64_bed elf64_x86_64_sol2_bed
6583 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6585 #undef elf_backend_static_tls_alignment
6586 #define elf_backend_static_tls_alignment 16
6588 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6590 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6592 #undef elf_backend_want_plt_sym
6593 #define elf_backend_want_plt_sym 1
6595 #undef elf_backend_strtab_flags
6596 #define elf_backend_strtab_flags SHF_STRINGS
6599 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6600 bfd
*obfd ATTRIBUTE_UNUSED
,
6601 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6602 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6604 /* PR 19938: FIXME: Need to add code for setting the sh_info
6605 and sh_link fields of Solaris specific section types. */
6609 #undef elf_backend_copy_special_section_fields
6610 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6612 #include "elf64-target.h"
6614 /* Native Client support. */
6617 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6619 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6620 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6624 #undef TARGET_LITTLE_SYM
6625 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6626 #undef TARGET_LITTLE_NAME
6627 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6629 #define elf64_bed elf64_x86_64_nacl_bed
6631 #undef ELF_MAXPAGESIZE
6632 #undef ELF_MINPAGESIZE
6633 #undef ELF_COMMONPAGESIZE
6634 #define ELF_MAXPAGESIZE 0x10000
6635 #define ELF_MINPAGESIZE 0x10000
6636 #define ELF_COMMONPAGESIZE 0x10000
6638 /* Restore defaults. */
6640 #undef elf_backend_static_tls_alignment
6641 #undef elf_backend_want_plt_sym
6642 #define elf_backend_want_plt_sym 0
6643 #undef elf_backend_strtab_flags
6644 #undef elf_backend_copy_special_section_fields
6646 /* NaCl uses substantially different PLT entries for the same effects. */
6648 #undef elf_backend_plt_alignment
6649 #define elf_backend_plt_alignment 5
6650 #define NACL_PLT_ENTRY_SIZE 64
6651 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6653 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6655 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6656 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6657 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6658 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6659 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6661 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6662 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6664 /* 32 bytes of nop to pad out to the standard size. */
6665 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6666 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6667 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6668 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6669 0x66, /* excess data32 prefix */
6673 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6675 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6676 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6677 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6678 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6680 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6681 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6682 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6684 /* Lazy GOT entries point here (32-byte aligned). */
6685 0x68, /* pushq immediate */
6686 0, 0, 0, 0, /* replaced with index into relocation table. */
6687 0xe9, /* jmp relative */
6688 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6690 /* 22 bytes of nop to pad out to the standard size. */
6691 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6692 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6693 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6696 /* .eh_frame covering the .plt section. */
6698 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6700 #if (PLT_CIE_LENGTH != 20 \
6701 || PLT_FDE_LENGTH != 36 \
6702 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6703 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6704 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6706 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6707 0, 0, 0, 0, /* CIE ID */
6708 1, /* CIE version */
6709 'z', 'R', 0, /* Augmentation string */
6710 1, /* Code alignment factor */
6711 0x78, /* Data alignment factor */
6712 16, /* Return address column */
6713 1, /* Augmentation size */
6714 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6715 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6716 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6717 DW_CFA_nop
, DW_CFA_nop
,
6719 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6720 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6721 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6722 0, 0, 0, 0, /* .plt size goes here */
6723 0, /* Augmentation size */
6724 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6725 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6726 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6727 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6728 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6729 13, /* Block length */
6730 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6731 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6732 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6733 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6734 DW_CFA_nop
, DW_CFA_nop
6737 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6739 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6740 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6741 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6742 2, /* plt0_got1_offset */
6743 9, /* plt0_got2_offset */
6744 13, /* plt0_got2_insn_end */
6745 3, /* plt_got_offset */
6746 33, /* plt_reloc_offset */
6747 38, /* plt_plt_offset */
6748 7, /* plt_got_insn_size */
6749 42, /* plt_plt_insn_end */
6750 32, /* plt_lazy_offset */
6751 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6752 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6755 #undef elf_backend_arch_data
6756 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6758 #undef elf_backend_object_p
6759 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6760 #undef elf_backend_modify_segment_map
6761 #define elf_backend_modify_segment_map nacl_modify_segment_map
6762 #undef elf_backend_modify_program_headers
6763 #define elf_backend_modify_program_headers nacl_modify_program_headers
6764 #undef elf_backend_final_write_processing
6765 #define elf_backend_final_write_processing nacl_final_write_processing
6767 #include "elf64-target.h"
6769 /* Native Client x32 support. */
6772 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6774 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6775 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6779 #undef TARGET_LITTLE_SYM
6780 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6781 #undef TARGET_LITTLE_NAME
6782 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6784 #define elf32_bed elf32_x86_64_nacl_bed
6786 #define bfd_elf32_bfd_link_hash_table_create \
6787 elf_x86_64_link_hash_table_create
6788 #define bfd_elf32_bfd_reloc_type_lookup \
6789 elf_x86_64_reloc_type_lookup
6790 #define bfd_elf32_bfd_reloc_name_lookup \
6791 elf_x86_64_reloc_name_lookup
6792 #define bfd_elf32_mkobject \
6794 #define bfd_elf32_get_synthetic_symtab \
6795 elf_x86_64_get_synthetic_symtab
6797 #undef elf_backend_object_p
6798 #define elf_backend_object_p \
6799 elf32_x86_64_nacl_elf_object_p
6801 #undef elf_backend_bfd_from_remote_memory
6802 #define elf_backend_bfd_from_remote_memory \
6803 _bfd_elf32_bfd_from_remote_memory
6805 #undef elf_backend_size_info
6806 #define elf_backend_size_info \
6807 _bfd_elf32_size_info
6809 #include "elf32-target.h"
6811 /* Restore defaults. */
6812 #undef elf_backend_object_p
6813 #define elf_backend_object_p elf64_x86_64_elf_object_p
6814 #undef elf_backend_bfd_from_remote_memory
6815 #undef elf_backend_size_info
6816 #undef elf_backend_modify_segment_map
6817 #undef elf_backend_modify_program_headers
6818 #undef elf_backend_final_write_processing
6820 /* Intel L1OM support. */
6823 elf64_l1om_elf_object_p (bfd
*abfd
)
6825 /* Set the right machine number for an L1OM elf64 file. */
6826 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6830 #undef TARGET_LITTLE_SYM
6831 #define TARGET_LITTLE_SYM l1om_elf64_vec
6832 #undef TARGET_LITTLE_NAME
6833 #define TARGET_LITTLE_NAME "elf64-l1om"
6835 #define ELF_ARCH bfd_arch_l1om
6837 #undef ELF_MACHINE_CODE
6838 #define ELF_MACHINE_CODE EM_L1OM
6843 #define elf64_bed elf64_l1om_bed
6845 #undef elf_backend_object_p
6846 #define elf_backend_object_p elf64_l1om_elf_object_p
6848 /* Restore defaults. */
6849 #undef ELF_MAXPAGESIZE
6850 #undef ELF_MINPAGESIZE
6851 #undef ELF_COMMONPAGESIZE
6852 #define ELF_MAXPAGESIZE 0x200000
6853 #define ELF_MINPAGESIZE 0x1000
6854 #define ELF_COMMONPAGESIZE 0x1000
6855 #undef elf_backend_plt_alignment
6856 #define elf_backend_plt_alignment 4
6857 #undef elf_backend_arch_data
6858 #define elf_backend_arch_data &elf_x86_64_arch_bed
6860 #include "elf64-target.h"
6862 /* FreeBSD L1OM support. */
6864 #undef TARGET_LITTLE_SYM
6865 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6866 #undef TARGET_LITTLE_NAME
6867 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6870 #define ELF_OSABI ELFOSABI_FREEBSD
6873 #define elf64_bed elf64_l1om_fbsd_bed
6875 #include "elf64-target.h"
6877 /* Intel K1OM support. */
6880 elf64_k1om_elf_object_p (bfd
*abfd
)
6882 /* Set the right machine number for an K1OM elf64 file. */
6883 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6887 #undef TARGET_LITTLE_SYM
6888 #define TARGET_LITTLE_SYM k1om_elf64_vec
6889 #undef TARGET_LITTLE_NAME
6890 #define TARGET_LITTLE_NAME "elf64-k1om"
6892 #define ELF_ARCH bfd_arch_k1om
6894 #undef ELF_MACHINE_CODE
6895 #define ELF_MACHINE_CODE EM_K1OM
6900 #define elf64_bed elf64_k1om_bed
6902 #undef elf_backend_object_p
6903 #define elf_backend_object_p elf64_k1om_elf_object_p
6905 #undef elf_backend_static_tls_alignment
6907 #undef elf_backend_want_plt_sym
6908 #define elf_backend_want_plt_sym 0
6910 #include "elf64-target.h"
6912 /* FreeBSD K1OM support. */
6914 #undef TARGET_LITTLE_SYM
6915 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6916 #undef TARGET_LITTLE_NAME
6917 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6920 #define ELF_OSABI ELFOSABI_FREEBSD
6923 #define elf64_bed elf64_k1om_fbsd_bed
6925 #include "elf64-target.h"
6927 /* 32bit x86-64 support. */
6929 #undef TARGET_LITTLE_SYM
6930 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6931 #undef TARGET_LITTLE_NAME
6932 #define TARGET_LITTLE_NAME "elf32-x86-64"
6936 #define ELF_ARCH bfd_arch_i386
6938 #undef ELF_MACHINE_CODE
6939 #define ELF_MACHINE_CODE EM_X86_64
6943 #undef elf_backend_object_p
6944 #define elf_backend_object_p \
6945 elf32_x86_64_elf_object_p
6947 #undef elf_backend_bfd_from_remote_memory
6948 #define elf_backend_bfd_from_remote_memory \
6949 _bfd_elf32_bfd_from_remote_memory
6951 #undef elf_backend_size_info
6952 #define elf_backend_size_info \
6953 _bfd_elf32_size_info
6955 #include "elf32-target.h"