1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1116 if (bfd_link_executable (info
))
1118 /* Always allow copy relocs for building executables. */
1119 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1122 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1123 s
= bfd_make_section_anyway_with_flags (dynobj
,
1125 (bed
->dynamic_sec_flags
1128 || ! bfd_set_section_alignment (dynobj
, s
,
1129 bed
->s
->log_file_align
))
1135 if (!info
->no_ld_generated_unwind_info
1136 && htab
->plt_eh_frame
== NULL
1137 && htab
->elf
.splt
!= NULL
)
1139 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1140 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1141 | SEC_LINKER_CREATED
);
1143 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1144 if (htab
->plt_eh_frame
== NULL
1145 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1151 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1154 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1155 struct elf_link_hash_entry
*dir
,
1156 struct elf_link_hash_entry
*ind
)
1158 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1160 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1161 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1163 if (!edir
->has_bnd_reloc
)
1164 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1166 if (!edir
->has_got_reloc
)
1167 edir
->has_got_reloc
= eind
->has_got_reloc
;
1169 if (!edir
->has_non_got_reloc
)
1170 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1172 if (eind
->dyn_relocs
!= NULL
)
1174 if (edir
->dyn_relocs
!= NULL
)
1176 struct elf_dyn_relocs
**pp
;
1177 struct elf_dyn_relocs
*p
;
1179 /* Add reloc counts against the indirect sym to the direct sym
1180 list. Merge any entries against the same section. */
1181 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1183 struct elf_dyn_relocs
*q
;
1185 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1186 if (q
->sec
== p
->sec
)
1188 q
->pc_count
+= p
->pc_count
;
1189 q
->count
+= p
->count
;
1196 *pp
= edir
->dyn_relocs
;
1199 edir
->dyn_relocs
= eind
->dyn_relocs
;
1200 eind
->dyn_relocs
= NULL
;
1203 if (ind
->root
.type
== bfd_link_hash_indirect
1204 && dir
->got
.refcount
<= 0)
1206 edir
->tls_type
= eind
->tls_type
;
1207 eind
->tls_type
= GOT_UNKNOWN
;
1210 if (ELIMINATE_COPY_RELOCS
1211 && ind
->root
.type
!= bfd_link_hash_indirect
1212 && dir
->dynamic_adjusted
)
1214 /* If called to transfer flags for a weakdef during processing
1215 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1216 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1217 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1218 dir
->ref_regular
|= ind
->ref_regular
;
1219 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1220 dir
->needs_plt
|= ind
->needs_plt
;
1221 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1225 if (eind
->func_pointer_refcount
> 0)
1227 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1228 eind
->func_pointer_refcount
= 0;
1231 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1236 elf64_x86_64_elf_object_p (bfd
*abfd
)
1238 /* Set the right machine number for an x86-64 elf64 file. */
1239 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1244 elf32_x86_64_elf_object_p (bfd
*abfd
)
1246 /* Set the right machine number for an x86-64 elf32 file. */
1247 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1251 /* Return TRUE if the TLS access code sequence support transition
1255 elf_x86_64_check_tls_transition (bfd
*abfd
,
1256 struct bfd_link_info
*info
,
1259 Elf_Internal_Shdr
*symtab_hdr
,
1260 struct elf_link_hash_entry
**sym_hashes
,
1261 unsigned int r_type
,
1262 const Elf_Internal_Rela
*rel
,
1263 const Elf_Internal_Rela
*relend
)
1266 unsigned long r_symndx
;
1267 bfd_boolean largepic
= FALSE
;
1268 struct elf_link_hash_entry
*h
;
1270 struct elf_x86_64_link_hash_table
*htab
;
1272 /* Get the section contents. */
1273 if (contents
== NULL
)
1275 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1276 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1279 /* FIXME: How to better handle error condition? */
1280 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1283 /* Cache the section contents for elf_link_input_bfd. */
1284 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1288 htab
= elf_x86_64_hash_table (info
);
1289 offset
= rel
->r_offset
;
1292 case R_X86_64_TLSGD
:
1293 case R_X86_64_TLSLD
:
1294 if ((rel
+ 1) >= relend
)
1297 if (r_type
== R_X86_64_TLSGD
)
1299 /* Check transition from GD access model. For 64bit, only
1300 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1301 .word 0x6666; rex64; call __tls_get_addr
1302 can transit to different access model. For 32bit, only
1303 leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr
1305 can transit to different access model. For largepic
1307 leaq foo@tlsgd(%rip), %rdi
1308 movabsq $__tls_get_addr@pltoff, %rax
1312 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1313 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1315 if ((offset
+ 12) > sec
->size
)
1318 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1320 if (!ABI_64_P (abfd
)
1321 || (offset
+ 19) > sec
->size
1323 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1324 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1325 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1330 else if (ABI_64_P (abfd
))
1333 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1339 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1345 /* Check transition from LD access model. Only
1346 leaq foo@tlsld(%rip), %rdi;
1348 can transit to different access model. For largepic
1350 leaq foo@tlsld(%rip), %rdi
1351 movabsq $__tls_get_addr@pltoff, %rax
1355 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1357 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1360 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1363 if (0xe8 != *(contents
+ offset
+ 4))
1365 if (!ABI_64_P (abfd
)
1366 || (offset
+ 19) > sec
->size
1367 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1368 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1375 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1376 if (r_symndx
< symtab_hdr
->sh_info
)
1379 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1380 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1381 may be versioned. */
1383 && h
->root
.root
.string
!= NULL
1385 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1386 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1387 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1388 && (strncmp (h
->root
.root
.string
,
1389 "__tls_get_addr", 14) == 0));
1391 case R_X86_64_GOTTPOFF
:
1392 /* Check transition from IE access model:
1393 mov foo@gottpoff(%rip), %reg
1394 add foo@gottpoff(%rip), %reg
1397 /* Check REX prefix first. */
1398 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1400 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1401 if (val
!= 0x48 && val
!= 0x4c)
1403 /* X32 may have 0x44 REX prefix or no REX prefix. */
1404 if (ABI_64_P (abfd
))
1410 /* X32 may not have any REX prefix. */
1411 if (ABI_64_P (abfd
))
1413 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1418 if (val
!= 0x8b && val
!= 0x03)
1421 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1422 return (val
& 0xc7) == 5;
1424 case R_X86_64_GOTPC32_TLSDESC
:
1425 /* Check transition from GDesc access model:
1426 leaq x@tlsdesc(%rip), %rax
1428 Make sure it's a leaq adding rip to a 32-bit offset
1429 into any register, although it's probably almost always
1432 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1435 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1436 if ((val
& 0xfb) != 0x48)
1439 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1442 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1443 return (val
& 0xc7) == 0x05;
1445 case R_X86_64_TLSDESC_CALL
:
1446 /* Check transition from GDesc access model:
1447 call *x@tlsdesc(%rax)
1449 if (offset
+ 2 <= sec
->size
)
1451 /* Make sure that it's a call *x@tlsdesc(%rax). */
1452 static const unsigned char call
[] = { 0xff, 0x10 };
1453 return memcmp (contents
+ offset
, call
, 2) == 0;
1463 /* Return TRUE if the TLS access transition is OK or no transition
1464 will be performed. Update R_TYPE if there is a transition. */
1467 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1468 asection
*sec
, bfd_byte
*contents
,
1469 Elf_Internal_Shdr
*symtab_hdr
,
1470 struct elf_link_hash_entry
**sym_hashes
,
1471 unsigned int *r_type
, int tls_type
,
1472 const Elf_Internal_Rela
*rel
,
1473 const Elf_Internal_Rela
*relend
,
1474 struct elf_link_hash_entry
*h
,
1475 unsigned long r_symndx
)
1477 unsigned int from_type
= *r_type
;
1478 unsigned int to_type
= from_type
;
1479 bfd_boolean check
= TRUE
;
1481 /* Skip TLS transition for functions. */
1483 && (h
->type
== STT_FUNC
1484 || h
->type
== STT_GNU_IFUNC
))
1489 case R_X86_64_TLSGD
:
1490 case R_X86_64_GOTPC32_TLSDESC
:
1491 case R_X86_64_TLSDESC_CALL
:
1492 case R_X86_64_GOTTPOFF
:
1493 if (bfd_link_executable (info
))
1496 to_type
= R_X86_64_TPOFF32
;
1498 to_type
= R_X86_64_GOTTPOFF
;
1501 /* When we are called from elf_x86_64_relocate_section,
1502 CONTENTS isn't NULL and there may be additional transitions
1503 based on TLS_TYPE. */
1504 if (contents
!= NULL
)
1506 unsigned int new_to_type
= to_type
;
1508 if (bfd_link_executable (info
)
1511 && tls_type
== GOT_TLS_IE
)
1512 new_to_type
= R_X86_64_TPOFF32
;
1514 if (to_type
== R_X86_64_TLSGD
1515 || to_type
== R_X86_64_GOTPC32_TLSDESC
1516 || to_type
== R_X86_64_TLSDESC_CALL
)
1518 if (tls_type
== GOT_TLS_IE
)
1519 new_to_type
= R_X86_64_GOTTPOFF
;
1522 /* We checked the transition before when we were called from
1523 elf_x86_64_check_relocs. We only want to check the new
1524 transition which hasn't been checked before. */
1525 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1526 to_type
= new_to_type
;
1531 case R_X86_64_TLSLD
:
1532 if (bfd_link_executable (info
))
1533 to_type
= R_X86_64_TPOFF32
;
1540 /* Return TRUE if there is no transition. */
1541 if (from_type
== to_type
)
1544 /* Check if the transition can be performed. */
1546 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1547 symtab_hdr
, sym_hashes
,
1548 from_type
, rel
, relend
))
1550 reloc_howto_type
*from
, *to
;
1553 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1554 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1557 name
= h
->root
.root
.string
;
1560 struct elf_x86_64_link_hash_table
*htab
;
1562 htab
= elf_x86_64_hash_table (info
);
1567 Elf_Internal_Sym
*isym
;
1569 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1571 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1575 (*_bfd_error_handler
)
1576 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1577 "in section `%A' failed"),
1578 abfd
, sec
, from
->name
, to
->name
, name
,
1579 (unsigned long) rel
->r_offset
);
1580 bfd_set_error (bfd_error_bad_value
);
1588 /* Rename some of the generic section flags to better document how they
1590 #define need_convert_load sec_flg0
1591 #define check_relocs_failed sec_flg1
1594 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1595 struct elf_link_hash_entry
*h
,
1596 Elf_Internal_Shdr
*symtab_hdr
,
1597 Elf_Internal_Sym
*isym
,
1598 reloc_howto_type
*howto
)
1601 const char *und
= "";
1602 const char *pic
= "";
1607 name
= h
->root
.root
.string
;
1608 switch (ELF_ST_VISIBILITY (h
->other
))
1611 v
= _("hidden symbol ");
1614 v
= _("internal symbol ");
1617 v
= _("protected symbol ");
1621 pic
= _("; recompile with -fPIC");
1625 if (!h
->def_regular
&& !h
->def_dynamic
)
1626 und
= _("undefined ");
1630 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1631 pic
= _("; recompile with -fPIC");
1634 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1635 "not be used when making a shared object%s"),
1636 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1637 bfd_set_error (bfd_error_bad_value
);
1638 sec
->check_relocs_failed
= 1;
1642 /* Look through the relocs for a section during the first phase, and
1643 calculate needed space in the global offset table, procedure
1644 linkage table, and dynamic reloc sections. */
1647 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1649 const Elf_Internal_Rela
*relocs
)
1651 struct elf_x86_64_link_hash_table
*htab
;
1652 Elf_Internal_Shdr
*symtab_hdr
;
1653 struct elf_link_hash_entry
**sym_hashes
;
1654 const Elf_Internal_Rela
*rel
;
1655 const Elf_Internal_Rela
*rel_end
;
1657 bfd_boolean use_plt_got
;
1659 if (bfd_link_relocatable (info
))
1662 BFD_ASSERT (is_x86_64_elf (abfd
));
1664 htab
= elf_x86_64_hash_table (info
);
1668 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1670 symtab_hdr
= &elf_symtab_hdr (abfd
);
1671 sym_hashes
= elf_sym_hashes (abfd
);
1675 rel_end
= relocs
+ sec
->reloc_count
;
1676 for (rel
= relocs
; rel
< rel_end
; rel
++)
1678 unsigned int r_type
;
1679 unsigned long r_symndx
;
1680 struct elf_link_hash_entry
*h
;
1681 struct elf_x86_64_link_hash_entry
*eh
;
1682 Elf_Internal_Sym
*isym
;
1684 bfd_boolean size_reloc
;
1686 r_symndx
= htab
->r_sym (rel
->r_info
);
1687 r_type
= ELF32_R_TYPE (rel
->r_info
);
1689 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1691 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1696 if (r_symndx
< symtab_hdr
->sh_info
)
1698 /* A local symbol. */
1699 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1704 /* Check relocation against local STT_GNU_IFUNC symbol. */
1705 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1707 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1712 /* Fake a STT_GNU_IFUNC symbol. */
1713 h
->type
= STT_GNU_IFUNC
;
1716 h
->forced_local
= 1;
1717 h
->root
.type
= bfd_link_hash_defined
;
1725 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1726 while (h
->root
.type
== bfd_link_hash_indirect
1727 || h
->root
.type
== bfd_link_hash_warning
)
1728 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1731 /* Check invalid x32 relocations. */
1732 if (!ABI_64_P (abfd
))
1738 case R_X86_64_DTPOFF64
:
1739 case R_X86_64_TPOFF64
:
1741 case R_X86_64_GOTOFF64
:
1742 case R_X86_64_GOT64
:
1743 case R_X86_64_GOTPCREL64
:
1744 case R_X86_64_GOTPC64
:
1745 case R_X86_64_GOTPLT64
:
1746 case R_X86_64_PLTOFF64
:
1749 name
= h
->root
.root
.string
;
1751 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1753 (*_bfd_error_handler
)
1754 (_("%B: relocation %s against symbol `%s' isn't "
1755 "supported in x32 mode"), abfd
,
1756 x86_64_elf_howto_table
[r_type
].name
, name
);
1757 bfd_set_error (bfd_error_bad_value
);
1770 case R_X86_64_PC32_BND
:
1771 case R_X86_64_PLT32_BND
:
1773 case R_X86_64_PLT32
:
1776 /* MPX PLT is supported only if elf_x86_64_arch_bed
1777 is used in 64-bit mode. */
1780 && (get_elf_x86_64_backend_data (abfd
)
1781 == &elf_x86_64_arch_bed
))
1783 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1785 /* Create the second PLT for Intel MPX support. */
1786 if (htab
->plt_bnd
== NULL
)
1788 unsigned int plt_bnd_align
;
1789 const struct elf_backend_data
*bed
;
1791 bed
= get_elf_backend_data (info
->output_bfd
);
1792 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1793 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1794 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1797 if (htab
->elf
.dynobj
== NULL
)
1798 htab
->elf
.dynobj
= abfd
;
1800 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1802 (bed
->dynamic_sec_flags
1807 if (htab
->plt_bnd
== NULL
1808 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1817 case R_X86_64_GOTPCREL
:
1818 case R_X86_64_GOTPCRELX
:
1819 case R_X86_64_REX_GOTPCRELX
:
1820 case R_X86_64_GOTPCREL64
:
1821 if (htab
->elf
.dynobj
== NULL
)
1822 htab
->elf
.dynobj
= abfd
;
1823 /* Create the ifunc sections for static executables. */
1824 if (h
->type
== STT_GNU_IFUNC
1825 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1831 /* It is referenced by a non-shared object. */
1833 h
->root
.non_ir_ref
= 1;
1835 if (h
->type
== STT_GNU_IFUNC
)
1836 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1837 |= elf_gnu_symbol_ifunc
;
1840 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1841 symtab_hdr
, sym_hashes
,
1842 &r_type
, GOT_UNKNOWN
,
1843 rel
, rel_end
, h
, r_symndx
))
1846 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1849 case R_X86_64_TLSLD
:
1850 htab
->tls_ld_got
.refcount
+= 1;
1853 case R_X86_64_TPOFF32
:
1854 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1855 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
1856 &x86_64_elf_howto_table
[r_type
]);
1858 eh
->has_got_reloc
= 1;
1861 case R_X86_64_GOTTPOFF
:
1862 if (!bfd_link_executable (info
))
1863 info
->flags
|= DF_STATIC_TLS
;
1866 case R_X86_64_GOT32
:
1867 case R_X86_64_GOTPCREL
:
1868 case R_X86_64_GOTPCRELX
:
1869 case R_X86_64_REX_GOTPCRELX
:
1870 case R_X86_64_TLSGD
:
1871 case R_X86_64_GOT64
:
1872 case R_X86_64_GOTPCREL64
:
1873 case R_X86_64_GOTPLT64
:
1874 case R_X86_64_GOTPC32_TLSDESC
:
1875 case R_X86_64_TLSDESC_CALL
:
1876 /* This symbol requires a global offset table entry. */
1878 int tls_type
, old_tls_type
;
1882 default: tls_type
= GOT_NORMAL
; break;
1883 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1884 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1885 case R_X86_64_GOTPC32_TLSDESC
:
1886 case R_X86_64_TLSDESC_CALL
:
1887 tls_type
= GOT_TLS_GDESC
; break;
1892 h
->got
.refcount
+= 1;
1893 old_tls_type
= eh
->tls_type
;
1897 bfd_signed_vma
*local_got_refcounts
;
1899 /* This is a global offset table entry for a local symbol. */
1900 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1901 if (local_got_refcounts
== NULL
)
1905 size
= symtab_hdr
->sh_info
;
1906 size
*= sizeof (bfd_signed_vma
)
1907 + sizeof (bfd_vma
) + sizeof (char);
1908 local_got_refcounts
= ((bfd_signed_vma
*)
1909 bfd_zalloc (abfd
, size
));
1910 if (local_got_refcounts
== NULL
)
1912 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1913 elf_x86_64_local_tlsdesc_gotent (abfd
)
1914 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1915 elf_x86_64_local_got_tls_type (abfd
)
1916 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1918 local_got_refcounts
[r_symndx
] += 1;
1920 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1923 /* If a TLS symbol is accessed using IE at least once,
1924 there is no point to use dynamic model for it. */
1925 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1926 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1927 || tls_type
!= GOT_TLS_IE
))
1929 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1930 tls_type
= old_tls_type
;
1931 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1932 && GOT_TLS_GD_ANY_P (tls_type
))
1933 tls_type
|= old_tls_type
;
1937 name
= h
->root
.root
.string
;
1939 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1941 (*_bfd_error_handler
)
1942 (_("%B: '%s' accessed both as normal and thread local symbol"),
1944 bfd_set_error (bfd_error_bad_value
);
1949 if (old_tls_type
!= tls_type
)
1952 eh
->tls_type
= tls_type
;
1954 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1959 case R_X86_64_GOTOFF64
:
1960 case R_X86_64_GOTPC32
:
1961 case R_X86_64_GOTPC64
:
1964 eh
->has_got_reloc
= 1;
1965 if (htab
->elf
.sgot
== NULL
)
1967 if (htab
->elf
.dynobj
== NULL
)
1968 htab
->elf
.dynobj
= abfd
;
1969 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1975 case R_X86_64_PLT32
:
1976 case R_X86_64_PLT32_BND
:
1977 /* This symbol requires a procedure linkage table entry. We
1978 actually build the entry in adjust_dynamic_symbol,
1979 because this might be a case of linking PIC code which is
1980 never referenced by a dynamic object, in which case we
1981 don't need to generate a procedure linkage table entry
1984 /* If this is a local symbol, we resolve it directly without
1985 creating a procedure linkage table entry. */
1989 eh
->has_got_reloc
= 1;
1991 h
->plt
.refcount
+= 1;
1994 case R_X86_64_PLTOFF64
:
1995 /* This tries to form the 'address' of a function relative
1996 to GOT. For global symbols we need a PLT entry. */
2000 h
->plt
.refcount
+= 1;
2004 case R_X86_64_SIZE32
:
2005 case R_X86_64_SIZE64
:
2010 if (!ABI_64_P (abfd
))
2015 /* Check relocation overflow as these relocs may lead to
2016 run-time relocation overflow. Don't error out for
2017 sections we don't care about, such as debug sections or
2018 when relocation overflow check is disabled. */
2019 if (!info
->no_reloc_overflow_check
2020 && (bfd_link_pic (info
)
2021 || (bfd_link_executable (info
)
2025 && (sec
->flags
& SEC_READONLY
) == 0))
2026 && (sec
->flags
& SEC_ALLOC
) != 0)
2027 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2028 &x86_64_elf_howto_table
[r_type
]);
2034 case R_X86_64_PC32_BND
:
2038 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2039 eh
->has_non_got_reloc
= 1;
2040 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2041 locally defined and undefined symbol may turn out to be
2042 a STT_GNU_IFUNC symbol later. */
2044 && (bfd_link_executable (info
)
2045 || ((h
->type
== STT_GNU_IFUNC
2046 || h
->root
.type
== bfd_link_hash_undefweak
2047 || h
->root
.type
== bfd_link_hash_undefined
)
2048 && SYMBOLIC_BIND (info
, h
))))
2050 /* If this reloc is in a read-only section, we might
2051 need a copy reloc. We can't check reliably at this
2052 stage whether the section is read-only, as input
2053 sections have not yet been mapped to output sections.
2054 Tentatively set the flag for now, and correct in
2055 adjust_dynamic_symbol. */
2058 /* We may need a .plt entry if the function this reloc
2059 refers to is in a shared lib. */
2060 h
->plt
.refcount
+= 1;
2061 if (r_type
== R_X86_64_PC32
)
2063 /* Since something like ".long foo - ." may be used
2064 as pointer, make sure that PLT is used if foo is
2065 a function defined in a shared library. */
2066 if ((sec
->flags
& SEC_CODE
) == 0)
2067 h
->pointer_equality_needed
= 1;
2069 else if (r_type
!= R_X86_64_PC32_BND
2070 && r_type
!= R_X86_64_PC64
)
2072 h
->pointer_equality_needed
= 1;
2073 /* At run-time, R_X86_64_64 can be resolved for both
2074 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2075 can only be resolved for x32. */
2076 if ((sec
->flags
& SEC_READONLY
) == 0
2077 && (r_type
== R_X86_64_64
2078 || (!ABI_64_P (abfd
)
2079 && (r_type
== R_X86_64_32
2080 || r_type
== R_X86_64_32S
))))
2081 eh
->func_pointer_refcount
+= 1;
2087 /* If we are creating a shared library, and this is a reloc
2088 against a global symbol, or a non PC relative reloc
2089 against a local symbol, then we need to copy the reloc
2090 into the shared library. However, if we are linking with
2091 -Bsymbolic, we do not need to copy a reloc against a
2092 global symbol which is defined in an object we are
2093 including in the link (i.e., DEF_REGULAR is set). At
2094 this point we have not seen all the input files, so it is
2095 possible that DEF_REGULAR is not set now but will be set
2096 later (it is never cleared). In case of a weak definition,
2097 DEF_REGULAR may be cleared later by a strong definition in
2098 a shared library. We account for that possibility below by
2099 storing information in the relocs_copied field of the hash
2100 table entry. A similar situation occurs when creating
2101 shared libraries and symbol visibility changes render the
2104 If on the other hand, we are creating an executable, we
2105 may need to keep relocations for symbols satisfied by a
2106 dynamic library if we manage to avoid copy relocs for the
2108 if ((bfd_link_pic (info
)
2109 && (sec
->flags
& SEC_ALLOC
) != 0
2110 && (! IS_X86_64_PCREL_TYPE (r_type
)
2112 && (! (bfd_link_pie (info
)
2113 || SYMBOLIC_BIND (info
, h
))
2114 || h
->root
.type
== bfd_link_hash_defweak
2115 || !h
->def_regular
))))
2116 || (ELIMINATE_COPY_RELOCS
2117 && !bfd_link_pic (info
)
2118 && (sec
->flags
& SEC_ALLOC
) != 0
2120 && (h
->root
.type
== bfd_link_hash_defweak
2121 || !h
->def_regular
)))
2123 struct elf_dyn_relocs
*p
;
2124 struct elf_dyn_relocs
**head
;
2126 /* We must copy these reloc types into the output file.
2127 Create a reloc section in dynobj and make room for
2131 if (htab
->elf
.dynobj
== NULL
)
2132 htab
->elf
.dynobj
= abfd
;
2134 sreloc
= _bfd_elf_make_dynamic_reloc_section
2135 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2136 abfd
, /*rela?*/ TRUE
);
2142 /* If this is a global symbol, we count the number of
2143 relocations we need for this symbol. */
2145 head
= &eh
->dyn_relocs
;
2148 /* Track dynamic relocs needed for local syms too.
2149 We really need local syms available to do this
2154 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2159 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2163 /* Beware of type punned pointers vs strict aliasing
2165 vpp
= &(elf_section_data (s
)->local_dynrel
);
2166 head
= (struct elf_dyn_relocs
**)vpp
;
2170 if (p
== NULL
|| p
->sec
!= sec
)
2172 bfd_size_type amt
= sizeof *p
;
2174 p
= ((struct elf_dyn_relocs
*)
2175 bfd_alloc (htab
->elf
.dynobj
, amt
));
2186 /* Count size relocation as PC-relative relocation. */
2187 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2192 /* This relocation describes the C++ object vtable hierarchy.
2193 Reconstruct it for later use during GC. */
2194 case R_X86_64_GNU_VTINHERIT
:
2195 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2199 /* This relocation describes which C++ vtable entries are actually
2200 used. Record for later use during GC. */
2201 case R_X86_64_GNU_VTENTRY
:
2202 BFD_ASSERT (h
!= NULL
);
2204 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2214 && h
->plt
.refcount
> 0
2215 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2216 || h
->got
.refcount
> 0)
2217 && htab
->plt_got
== NULL
)
2219 /* Create the GOT procedure linkage table. */
2220 unsigned int plt_got_align
;
2221 const struct elf_backend_data
*bed
;
2223 bed
= get_elf_backend_data (info
->output_bfd
);
2224 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2225 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2226 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2229 if (htab
->elf
.dynobj
== NULL
)
2230 htab
->elf
.dynobj
= abfd
;
2232 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2234 (bed
->dynamic_sec_flags
2239 if (htab
->plt_got
== NULL
2240 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2246 if ((r_type
== R_X86_64_GOTPCREL
2247 || r_type
== R_X86_64_GOTPCRELX
2248 || r_type
== R_X86_64_REX_GOTPCRELX
)
2249 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2250 sec
->need_convert_load
= 1;
2256 /* Return the section that should be marked against GC for a given
2260 elf_x86_64_gc_mark_hook (asection
*sec
,
2261 struct bfd_link_info
*info
,
2262 Elf_Internal_Rela
*rel
,
2263 struct elf_link_hash_entry
*h
,
2264 Elf_Internal_Sym
*sym
)
2267 switch (ELF32_R_TYPE (rel
->r_info
))
2269 case R_X86_64_GNU_VTINHERIT
:
2270 case R_X86_64_GNU_VTENTRY
:
2274 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2277 /* Remove undefined weak symbol from the dynamic symbol table if it
2278 is resolved to 0. */
2281 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2282 struct elf_link_hash_entry
*h
)
2284 if (h
->dynindx
!= -1
2285 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2286 elf_x86_64_hash_entry (h
)))
2289 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2295 /* Adjust a symbol defined by a dynamic object and referenced by a
2296 regular object. The current definition is in some section of the
2297 dynamic object, but we're not including those sections. We have to
2298 change the definition to something the rest of the link can
2302 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2303 struct elf_link_hash_entry
*h
)
2305 struct elf_x86_64_link_hash_table
*htab
;
2307 struct elf_x86_64_link_hash_entry
*eh
;
2308 struct elf_dyn_relocs
*p
;
2310 /* STT_GNU_IFUNC symbol must go through PLT. */
2311 if (h
->type
== STT_GNU_IFUNC
)
2313 /* All local STT_GNU_IFUNC references must be treate as local
2314 calls via local PLT. */
2316 && SYMBOL_CALLS_LOCAL (info
, h
))
2318 bfd_size_type pc_count
= 0, count
= 0;
2319 struct elf_dyn_relocs
**pp
;
2321 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2322 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2324 pc_count
+= p
->pc_count
;
2325 p
->count
-= p
->pc_count
;
2334 if (pc_count
|| count
)
2338 if (h
->plt
.refcount
<= 0)
2339 h
->plt
.refcount
= 1;
2341 h
->plt
.refcount
+= 1;
2345 if (h
->plt
.refcount
<= 0)
2347 h
->plt
.offset
= (bfd_vma
) -1;
2353 /* If this is a function, put it in the procedure linkage table. We
2354 will fill in the contents of the procedure linkage table later,
2355 when we know the address of the .got section. */
2356 if (h
->type
== STT_FUNC
2359 if (h
->plt
.refcount
<= 0
2360 || SYMBOL_CALLS_LOCAL (info
, h
)
2361 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2362 && h
->root
.type
== bfd_link_hash_undefweak
))
2364 /* This case can occur if we saw a PLT32 reloc in an input
2365 file, but the symbol was never referred to by a dynamic
2366 object, or if all references were garbage collected. In
2367 such a case, we don't actually need to build a procedure
2368 linkage table, and we can just do a PC32 reloc instead. */
2369 h
->plt
.offset
= (bfd_vma
) -1;
2376 /* It's possible that we incorrectly decided a .plt reloc was
2377 needed for an R_X86_64_PC32 reloc to a non-function sym in
2378 check_relocs. We can't decide accurately between function and
2379 non-function syms in check-relocs; Objects loaded later in
2380 the link may change h->type. So fix it now. */
2381 h
->plt
.offset
= (bfd_vma
) -1;
2383 /* If this is a weak symbol, and there is a real definition, the
2384 processor independent code will have arranged for us to see the
2385 real definition first, and we can just use the same value. */
2386 if (h
->u
.weakdef
!= NULL
)
2388 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2389 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2390 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2391 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2392 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2394 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2395 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2396 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2401 /* This is a reference to a symbol defined by a dynamic object which
2402 is not a function. */
2404 /* If we are creating a shared library, we must presume that the
2405 only references to the symbol are via the global offset table.
2406 For such cases we need not do anything here; the relocations will
2407 be handled correctly by relocate_section. */
2408 if (!bfd_link_executable (info
))
2411 /* If there are no references to this symbol that do not use the
2412 GOT, we don't need to generate a copy reloc. */
2413 if (!h
->non_got_ref
)
2416 /* If -z nocopyreloc was given, we won't generate them either. */
2417 if (info
->nocopyreloc
)
2423 if (ELIMINATE_COPY_RELOCS
)
2425 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2426 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2428 s
= p
->sec
->output_section
;
2429 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2433 /* If we didn't find any dynamic relocs in read-only sections, then
2434 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2442 /* We must allocate the symbol in our .dynbss section, which will
2443 become part of the .bss section of the executable. There will be
2444 an entry for this symbol in the .dynsym section. The dynamic
2445 object will contain position independent code, so all references
2446 from the dynamic object to this symbol will go through the global
2447 offset table. The dynamic linker will use the .dynsym entry to
2448 determine the address it must put in the global offset table, so
2449 both the dynamic object and the regular object will refer to the
2450 same memory location for the variable. */
2452 htab
= elf_x86_64_hash_table (info
);
2456 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2457 to copy the initial value out of the dynamic object and into the
2458 runtime process image. */
2459 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2461 const struct elf_backend_data
*bed
;
2462 bed
= get_elf_backend_data (info
->output_bfd
);
2463 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2469 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2472 /* Allocate space in .plt, .got and associated reloc sections for
2476 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2478 struct bfd_link_info
*info
;
2479 struct elf_x86_64_link_hash_table
*htab
;
2480 struct elf_x86_64_link_hash_entry
*eh
;
2481 struct elf_dyn_relocs
*p
;
2482 const struct elf_backend_data
*bed
;
2483 unsigned int plt_entry_size
;
2484 bfd_boolean resolved_to_zero
;
2486 if (h
->root
.type
== bfd_link_hash_indirect
)
2489 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2491 info
= (struct bfd_link_info
*) inf
;
2492 htab
= elf_x86_64_hash_table (info
);
2495 bed
= get_elf_backend_data (info
->output_bfd
);
2496 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2498 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2500 /* We can't use the GOT PLT if pointer equality is needed since
2501 finish_dynamic_symbol won't clear symbol value and the dynamic
2502 linker won't update the GOT slot. We will get into an infinite
2503 loop at run-time. */
2504 if (htab
->plt_got
!= NULL
2505 && h
->type
!= STT_GNU_IFUNC
2506 && !h
->pointer_equality_needed
2507 && h
->plt
.refcount
> 0
2508 && h
->got
.refcount
> 0)
2510 /* Don't use the regular PLT if there are both GOT and GOTPLT
2512 h
->plt
.offset
= (bfd_vma
) -1;
2514 /* Use the GOT PLT. */
2515 eh
->plt_got
.refcount
= 1;
2518 /* Clear the reference count of function pointer relocations if
2519 symbol isn't a normal function. */
2520 if (h
->type
!= STT_FUNC
)
2521 eh
->func_pointer_refcount
= 0;
2523 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2524 here if it is defined and referenced in a non-shared object. */
2525 if (h
->type
== STT_GNU_IFUNC
2528 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2530 &htab
->readonly_dynrelocs_against_ifunc
,
2535 asection
*s
= htab
->plt_bnd
;
2536 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2538 /* Use the .plt.bnd section if it is created. */
2539 eh
->plt_bnd
.offset
= s
->size
;
2541 /* Make room for this entry in the .plt.bnd section. */
2542 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2550 /* Don't create the PLT entry if there are only function pointer
2551 relocations which can be resolved at run-time. */
2552 else if (htab
->elf
.dynamic_sections_created
2553 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2554 || eh
->plt_got
.refcount
> 0))
2556 bfd_boolean use_plt_got
;
2558 /* Clear the reference count of function pointer relocations
2560 eh
->func_pointer_refcount
= 0;
2562 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2564 /* Don't use the regular PLT for DF_BIND_NOW. */
2565 h
->plt
.offset
= (bfd_vma
) -1;
2567 /* Use the GOT PLT. */
2568 h
->got
.refcount
= 1;
2569 eh
->plt_got
.refcount
= 1;
2572 use_plt_got
= eh
->plt_got
.refcount
> 0;
2574 /* Make sure this symbol is output as a dynamic symbol.
2575 Undefined weak syms won't yet be marked as dynamic. */
2576 if (h
->dynindx
== -1
2578 && !resolved_to_zero
)
2580 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2584 if (bfd_link_pic (info
)
2585 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2587 asection
*s
= htab
->elf
.splt
;
2588 asection
*bnd_s
= htab
->plt_bnd
;
2589 asection
*got_s
= htab
->plt_got
;
2591 /* If this is the first .plt entry, make room for the special
2592 first entry. The .plt section is used by prelink to undo
2593 prelinking for dynamic relocations. */
2595 s
->size
= plt_entry_size
;
2598 eh
->plt_got
.offset
= got_s
->size
;
2601 h
->plt
.offset
= s
->size
;
2603 eh
->plt_bnd
.offset
= bnd_s
->size
;
2606 /* If this symbol is not defined in a regular file, and we are
2607 not generating a shared library, then set the symbol to this
2608 location in the .plt. This is required to make function
2609 pointers compare as equal between the normal executable and
2610 the shared library. */
2611 if (! bfd_link_pic (info
)
2616 /* We need to make a call to the entry of the GOT PLT
2617 instead of regular PLT entry. */
2618 h
->root
.u
.def
.section
= got_s
;
2619 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2625 /* We need to make a call to the entry of the second
2626 PLT instead of regular PLT entry. */
2627 h
->root
.u
.def
.section
= bnd_s
;
2628 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2632 h
->root
.u
.def
.section
= s
;
2633 h
->root
.u
.def
.value
= h
->plt
.offset
;
2638 /* Make room for this entry. */
2640 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2643 s
->size
+= plt_entry_size
;
2645 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2647 /* We also need to make an entry in the .got.plt section,
2648 which will be placed in the .got section by the linker
2650 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2652 /* There should be no PLT relocation against resolved
2653 undefined weak symbol in executable. */
2654 if (!resolved_to_zero
)
2656 /* We also need to make an entry in the .rela.plt
2658 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2659 htab
->elf
.srelplt
->reloc_count
++;
2665 eh
->plt_got
.offset
= (bfd_vma
) -1;
2666 h
->plt
.offset
= (bfd_vma
) -1;
2672 eh
->plt_got
.offset
= (bfd_vma
) -1;
2673 h
->plt
.offset
= (bfd_vma
) -1;
2677 eh
->tlsdesc_got
= (bfd_vma
) -1;
2679 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2680 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2681 if (h
->got
.refcount
> 0
2682 && bfd_link_executable (info
)
2684 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2686 h
->got
.offset
= (bfd_vma
) -1;
2688 else if (h
->got
.refcount
> 0)
2692 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2694 /* Make sure this symbol is output as a dynamic symbol.
2695 Undefined weak syms won't yet be marked as dynamic. */
2696 if (h
->dynindx
== -1
2698 && !resolved_to_zero
)
2700 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2704 if (GOT_TLS_GDESC_P (tls_type
))
2706 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2707 - elf_x86_64_compute_jump_table_size (htab
);
2708 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2709 h
->got
.offset
= (bfd_vma
) -2;
2711 if (! GOT_TLS_GDESC_P (tls_type
)
2712 || GOT_TLS_GD_P (tls_type
))
2715 h
->got
.offset
= s
->size
;
2716 s
->size
+= GOT_ENTRY_SIZE
;
2717 if (GOT_TLS_GD_P (tls_type
))
2718 s
->size
+= GOT_ENTRY_SIZE
;
2720 dyn
= htab
->elf
.dynamic_sections_created
;
2721 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2722 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2723 relocation. No dynamic relocation against resolved undefined
2724 weak symbol in executable. */
2725 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2726 || tls_type
== GOT_TLS_IE
)
2727 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2728 else if (GOT_TLS_GD_P (tls_type
))
2729 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2730 else if (! GOT_TLS_GDESC_P (tls_type
)
2731 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2732 && !resolved_to_zero
)
2733 || h
->root
.type
!= bfd_link_hash_undefweak
)
2734 && (bfd_link_pic (info
)
2735 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2736 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2737 if (GOT_TLS_GDESC_P (tls_type
))
2739 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2740 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2744 h
->got
.offset
= (bfd_vma
) -1;
2746 if (eh
->dyn_relocs
== NULL
)
2749 /* In the shared -Bsymbolic case, discard space allocated for
2750 dynamic pc-relative relocs against symbols which turn out to be
2751 defined in regular objects. For the normal shared case, discard
2752 space for pc-relative relocs that have become local due to symbol
2753 visibility changes. */
2755 if (bfd_link_pic (info
))
2757 /* Relocs that use pc_count are those that appear on a call
2758 insn, or certain REL relocs that can generated via assembly.
2759 We want calls to protected symbols to resolve directly to the
2760 function rather than going via the plt. If people want
2761 function pointer comparisons to work as expected then they
2762 should avoid writing weird assembly. */
2763 if (SYMBOL_CALLS_LOCAL (info
, h
))
2765 struct elf_dyn_relocs
**pp
;
2767 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2769 p
->count
-= p
->pc_count
;
2778 /* Also discard relocs on undefined weak syms with non-default
2779 visibility or in PIE. */
2780 if (eh
->dyn_relocs
!= NULL
)
2782 if (h
->root
.type
== bfd_link_hash_undefweak
)
2784 /* Undefined weak symbol is never bound locally in shared
2786 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2787 || resolved_to_zero
)
2788 eh
->dyn_relocs
= NULL
;
2789 else if (h
->dynindx
== -1
2790 && ! h
->forced_local
2791 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2794 /* For PIE, discard space for pc-relative relocs against
2795 symbols which turn out to need copy relocs. */
2796 else if (bfd_link_executable (info
)
2797 && (h
->needs_copy
|| eh
->needs_copy
)
2801 struct elf_dyn_relocs
**pp
;
2803 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2805 if (p
->pc_count
!= 0)
2813 else if (ELIMINATE_COPY_RELOCS
)
2815 /* For the non-shared case, discard space for relocs against
2816 symbols which turn out to need copy relocs or are not
2817 dynamic. Keep dynamic relocations for run-time function
2818 pointer initialization. */
2820 if ((!h
->non_got_ref
2821 || eh
->func_pointer_refcount
> 0
2822 || (h
->root
.type
== bfd_link_hash_undefweak
2823 && !resolved_to_zero
))
2826 || (htab
->elf
.dynamic_sections_created
2827 && (h
->root
.type
== bfd_link_hash_undefweak
2828 || h
->root
.type
== bfd_link_hash_undefined
))))
2830 /* Make sure this symbol is output as a dynamic symbol.
2831 Undefined weak syms won't yet be marked as dynamic. */
2832 if (h
->dynindx
== -1
2833 && ! h
->forced_local
2834 && ! resolved_to_zero
2835 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2838 /* If that succeeded, we know we'll be keeping all the
2840 if (h
->dynindx
!= -1)
2844 eh
->dyn_relocs
= NULL
;
2845 eh
->func_pointer_refcount
= 0;
2850 /* Finally, allocate space. */
2851 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2855 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2857 BFD_ASSERT (sreloc
!= NULL
);
2859 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2865 /* Allocate space in .plt, .got and associated reloc sections for
2866 local dynamic relocs. */
2869 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2871 struct elf_link_hash_entry
*h
2872 = (struct elf_link_hash_entry
*) *slot
;
2874 if (h
->type
!= STT_GNU_IFUNC
2878 || h
->root
.type
!= bfd_link_hash_defined
)
2881 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2884 /* Find any dynamic relocs that apply to read-only sections. */
2887 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2890 struct elf_x86_64_link_hash_entry
*eh
;
2891 struct elf_dyn_relocs
*p
;
2893 /* Skip local IFUNC symbols. */
2894 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2897 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2898 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2900 asection
*s
= p
->sec
->output_section
;
2902 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2904 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2906 info
->flags
|= DF_TEXTREL
;
2908 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2909 || info
->error_textrel
)
2910 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2911 p
->sec
->owner
, h
->root
.root
.string
,
2914 /* Not an error, just cut short the traversal. */
2921 /* With the local symbol, foo, we convert
2922 mov foo@GOTPCREL(%rip), %reg
2926 call/jmp *foo@GOTPCREL(%rip)
2928 nop call foo/jmp foo nop
2929 When PIC is false, convert
2930 test %reg, foo@GOTPCREL(%rip)
2934 binop foo@GOTPCREL(%rip), %reg
2937 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2941 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
2942 struct bfd_link_info
*link_info
)
2944 Elf_Internal_Shdr
*symtab_hdr
;
2945 Elf_Internal_Rela
*internal_relocs
;
2946 Elf_Internal_Rela
*irel
, *irelend
;
2948 struct elf_x86_64_link_hash_table
*htab
;
2949 bfd_boolean changed_contents
;
2950 bfd_boolean changed_relocs
;
2951 bfd_signed_vma
*local_got_refcounts
;
2952 bfd_vma maxpagesize
;
2954 bfd_boolean require_reloc_pc32
;
2956 /* Don't even try to convert non-ELF outputs. */
2957 if (!is_elf_hash_table (link_info
->hash
))
2960 /* Nothing to do if there is no need or no output. */
2961 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2962 || sec
->need_convert_load
== 0
2963 || bfd_is_abs_section (sec
->output_section
))
2966 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2968 /* Load the relocations for this section. */
2969 internal_relocs
= (_bfd_elf_link_read_relocs
2970 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2971 link_info
->keep_memory
));
2972 if (internal_relocs
== NULL
)
2975 htab
= elf_x86_64_hash_table (link_info
);
2976 changed_contents
= FALSE
;
2977 changed_relocs
= FALSE
;
2978 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2979 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2981 /* Get the section contents. */
2982 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2983 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2986 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2990 is_pic
= bfd_link_pic (link_info
);
2992 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
2995 = link_info
->disable_target_specific_optimizations
> 1;
2997 irelend
= internal_relocs
+ sec
->reloc_count
;
2998 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3000 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3001 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3003 struct elf_link_hash_entry
*h
;
3007 bfd_signed_vma raddend
;
3008 unsigned int opcode
;
3011 bfd_boolean to_reloc_pc32
;
3013 relocx
= (r_type
== R_X86_64_GOTPCRELX
3014 || r_type
== R_X86_64_REX_GOTPCRELX
);
3015 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3018 roff
= irel
->r_offset
;
3019 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3022 raddend
= irel
->r_addend
;
3023 /* Addend for 32-bit PC-relative relocation must be -4. */
3027 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3029 /* Convert mov to lea since it has been done for a while. */
3032 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3033 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3034 test, xor instructions. */
3039 /* We convert only to R_X86_64_PC32:
3041 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3042 3. require_reloc_pc32 is true.
3045 to_reloc_pc32
= (opcode
== 0xff
3047 || require_reloc_pc32
3050 /* Get the symbol referred to by the reloc. */
3051 if (r_symndx
< symtab_hdr
->sh_info
)
3053 Elf_Internal_Sym
*isym
;
3055 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3058 symtype
= ELF_ST_TYPE (isym
->st_info
);
3060 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3061 relocation against undefined symbols. */
3062 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3065 if (isym
->st_shndx
== SHN_ABS
)
3066 tsec
= bfd_abs_section_ptr
;
3067 else if (isym
->st_shndx
== SHN_COMMON
)
3068 tsec
= bfd_com_section_ptr
;
3069 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3070 tsec
= &_bfd_elf_large_com_section
;
3072 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3075 toff
= isym
->st_value
;
3079 indx
= r_symndx
- symtab_hdr
->sh_info
;
3080 h
= elf_sym_hashes (abfd
)[indx
];
3081 BFD_ASSERT (h
!= NULL
);
3083 while (h
->root
.type
== bfd_link_hash_indirect
3084 || h
->root
.type
== bfd_link_hash_warning
)
3085 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3087 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3088 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3089 since ld.so may use its link-time address. */
3090 if (h
->type
== STT_GNU_IFUNC
)
3093 /* Undefined weak symbol is only bound locally in executable
3094 and its reference is resolved as 0 without relocation
3095 overflow. We can only perform this optimization for
3096 GOTPCRELX relocations since we need to modify REX byte.
3097 It is OK convert mov with R_X86_64_GOTPCREL to
3099 if ((relocx
|| opcode
== 0x8b)
3100 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3101 elf_x86_64_hash_entry (h
)))
3105 /* Skip for branch instructions since R_X86_64_PC32
3107 if (require_reloc_pc32
)
3112 /* For non-branch instructions, we can convert to
3113 R_X86_64_32/R_X86_64_32S since we know if there
3115 to_reloc_pc32
= FALSE
;
3118 /* Since we don't know the current PC when PIC is true,
3119 we can't convert to R_X86_64_PC32. */
3120 if (to_reloc_pc32
&& is_pic
)
3125 else if ((h
->def_regular
3126 || h
->root
.type
== bfd_link_hash_defined
3127 || h
->root
.type
== bfd_link_hash_defweak
)
3128 && h
!= htab
->elf
.hdynamic
3129 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3131 /* bfd_link_hash_new or bfd_link_hash_undefined is
3132 set by an assignment in a linker script in
3133 bfd_elf_record_link_assignment. */
3135 && (h
->root
.type
== bfd_link_hash_new
3136 || h
->root
.type
== bfd_link_hash_undefined
))
3138 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3139 if (require_reloc_pc32
)
3143 tsec
= h
->root
.u
.def
.section
;
3144 toff
= h
->root
.u
.def
.value
;
3151 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3155 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3157 /* At this stage in linking, no SEC_MERGE symbol has been
3158 adjusted, so all references to such symbols need to be
3159 passed through _bfd_merged_section_offset. (Later, in
3160 relocate_section, all SEC_MERGE symbols *except* for
3161 section symbols have been adjusted.)
3163 gas may reduce relocations against symbols in SEC_MERGE
3164 sections to a relocation against the section symbol when
3165 the original addend was zero. When the reloc is against
3166 a section symbol we should include the addend in the
3167 offset passed to _bfd_merged_section_offset, since the
3168 location of interest is the original symbol. On the
3169 other hand, an access to "sym+addend" where "sym" is not
3170 a section symbol should not include the addend; Such an
3171 access is presumed to be an offset from "sym"; The
3172 location of interest is just "sym". */
3173 if (symtype
== STT_SECTION
)
3176 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3177 elf_section_data (tsec
)->sec_info
,
3180 if (symtype
!= STT_SECTION
)
3186 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3187 if (tsec
->output_section
== sec
->output_section
)
3189 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3194 bfd_signed_vma distance
;
3196 /* At this point, we don't know the load addresses of TSEC
3197 section nor SEC section. We estimate the distrance between
3198 SEC and TSEC. We store the estimated distances in the
3199 compressed_size field of the output section, which is only
3200 used to decompress the compressed input section. */
3201 if (sec
->output_section
->compressed_size
== 0)
3204 bfd_size_type size
= 0;
3205 for (asect
= link_info
->output_bfd
->sections
;
3207 asect
= asect
->next
)
3208 /* Skip debug sections since compressed_size is used to
3209 compress debug sections. */
3210 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
3213 for (i
= asect
->map_head
.s
;
3217 size
= align_power (size
, i
->alignment_power
);
3220 asect
->compressed_size
= size
;
3224 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3226 distance
= (tsec
->output_section
->compressed_size
3227 - sec
->output_section
->compressed_size
);
3231 /* Take PT_GNU_RELRO segment into account by adding
3233 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3241 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3246 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3248 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3251 /* Convert to "jmp foo nop". */
3254 nop_offset
= irel
->r_offset
+ 3;
3255 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3256 irel
->r_offset
-= 1;
3257 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3261 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3264 nop
= link_info
->call_nop_byte
;
3265 if (link_info
->call_nop_as_suffix
)
3267 nop_offset
= irel
->r_offset
+ 3;
3268 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3269 irel
->r_offset
-= 1;
3270 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3273 nop_offset
= irel
->r_offset
- 2;
3275 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3276 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3277 r_type
= R_X86_64_PC32
;
3282 unsigned int rex_mask
= REX_R
;
3284 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3285 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3293 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3294 "lea foo(%rip), %reg". */
3296 r_type
= R_X86_64_PC32
;
3300 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3301 "mov $foo, %reg". */
3303 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3304 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3305 if ((rex
& REX_W
) != 0
3306 && ABI_64_P (link_info
->output_bfd
))
3308 /* Keep the REX_W bit in REX byte for LP64. */
3309 r_type
= R_X86_64_32S
;
3310 goto rewrite_modrm_rex
;
3314 /* If the REX_W bit in REX byte isn't needed,
3315 use R_X86_64_32 and clear the W bit to avoid
3316 sign-extend imm32 to imm64. */
3317 r_type
= R_X86_64_32
;
3318 /* Clear the W bit in REX byte. */
3320 goto rewrite_modrm_rex
;
3326 /* R_X86_64_PC32 isn't supported. */
3330 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3333 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3334 "test $foo, %reg". */
3335 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3340 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3341 "binop $foo, %reg". */
3342 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3346 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3347 overflow when sign-extending imm32 to imm64. */
3348 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3351 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3355 /* Move the R bit to the B bit in REX byte. */
3356 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3357 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3360 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3364 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3367 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3368 changed_contents
= TRUE
;
3369 changed_relocs
= TRUE
;
3373 if (h
->got
.refcount
> 0)
3374 h
->got
.refcount
-= 1;
3378 if (local_got_refcounts
!= NULL
3379 && local_got_refcounts
[r_symndx
] > 0)
3380 local_got_refcounts
[r_symndx
] -= 1;
3384 if (contents
!= NULL
3385 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3387 if (!changed_contents
&& !link_info
->keep_memory
)
3391 /* Cache the section contents for elf_link_input_bfd. */
3392 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3396 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3398 if (!changed_relocs
)
3399 free (internal_relocs
);
3401 elf_section_data (sec
)->relocs
= internal_relocs
;
3407 if (contents
!= NULL
3408 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3410 if (internal_relocs
!= NULL
3411 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3412 free (internal_relocs
);
3416 /* Set the sizes of the dynamic sections. */
3419 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3420 struct bfd_link_info
*info
)
3422 struct elf_x86_64_link_hash_table
*htab
;
3427 const struct elf_backend_data
*bed
;
3429 htab
= elf_x86_64_hash_table (info
);
3432 bed
= get_elf_backend_data (output_bfd
);
3434 dynobj
= htab
->elf
.dynobj
;
3438 if (htab
->elf
.dynamic_sections_created
)
3440 /* Set the contents of the .interp section to the interpreter. */
3441 if (bfd_link_executable (info
) && !info
->nointerp
)
3443 s
= bfd_get_linker_section (dynobj
, ".interp");
3446 s
->size
= htab
->dynamic_interpreter_size
;
3447 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3452 /* Set up .got offsets for local syms, and space for local dynamic
3454 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3456 bfd_signed_vma
*local_got
;
3457 bfd_signed_vma
*end_local_got
;
3458 char *local_tls_type
;
3459 bfd_vma
*local_tlsdesc_gotent
;
3460 bfd_size_type locsymcount
;
3461 Elf_Internal_Shdr
*symtab_hdr
;
3464 if (! is_x86_64_elf (ibfd
))
3467 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3469 struct elf_dyn_relocs
*p
;
3471 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3474 for (p
= (struct elf_dyn_relocs
*)
3475 (elf_section_data (s
)->local_dynrel
);
3479 if (!bfd_is_abs_section (p
->sec
)
3480 && bfd_is_abs_section (p
->sec
->output_section
))
3482 /* Input section has been discarded, either because
3483 it is a copy of a linkonce section or due to
3484 linker script /DISCARD/, so we'll be discarding
3487 else if (p
->count
!= 0)
3489 srel
= elf_section_data (p
->sec
)->sreloc
;
3490 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3491 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3492 && (info
->flags
& DF_TEXTREL
) == 0)
3494 info
->flags
|= DF_TEXTREL
;
3495 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3496 || info
->error_textrel
)
3497 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3498 p
->sec
->owner
, p
->sec
);
3504 local_got
= elf_local_got_refcounts (ibfd
);
3508 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3509 locsymcount
= symtab_hdr
->sh_info
;
3510 end_local_got
= local_got
+ locsymcount
;
3511 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3512 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3514 srel
= htab
->elf
.srelgot
;
3515 for (; local_got
< end_local_got
;
3516 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3518 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3521 if (GOT_TLS_GDESC_P (*local_tls_type
))
3523 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3524 - elf_x86_64_compute_jump_table_size (htab
);
3525 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3526 *local_got
= (bfd_vma
) -2;
3528 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3529 || GOT_TLS_GD_P (*local_tls_type
))
3531 *local_got
= s
->size
;
3532 s
->size
+= GOT_ENTRY_SIZE
;
3533 if (GOT_TLS_GD_P (*local_tls_type
))
3534 s
->size
+= GOT_ENTRY_SIZE
;
3536 if (bfd_link_pic (info
)
3537 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3538 || *local_tls_type
== GOT_TLS_IE
)
3540 if (GOT_TLS_GDESC_P (*local_tls_type
))
3542 htab
->elf
.srelplt
->size
3543 += bed
->s
->sizeof_rela
;
3544 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3546 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3547 || GOT_TLS_GD_P (*local_tls_type
))
3548 srel
->size
+= bed
->s
->sizeof_rela
;
3552 *local_got
= (bfd_vma
) -1;
3556 if (htab
->tls_ld_got
.refcount
> 0)
3558 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3560 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3561 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3562 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3565 htab
->tls_ld_got
.offset
= -1;
3567 /* Allocate global sym .plt and .got entries, and space for global
3568 sym dynamic relocs. */
3569 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3572 /* Allocate .plt and .got entries, and space for local symbols. */
3573 htab_traverse (htab
->loc_hash_table
,
3574 elf_x86_64_allocate_local_dynrelocs
,
3577 /* For every jump slot reserved in the sgotplt, reloc_count is
3578 incremented. However, when we reserve space for TLS descriptors,
3579 it's not incremented, so in order to compute the space reserved
3580 for them, it suffices to multiply the reloc count by the jump
3583 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3584 so that R_X86_64_IRELATIVE entries come last. */
3585 if (htab
->elf
.srelplt
)
3587 htab
->sgotplt_jump_table_size
3588 = elf_x86_64_compute_jump_table_size (htab
);
3589 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3591 else if (htab
->elf
.irelplt
)
3592 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3594 if (htab
->tlsdesc_plt
)
3596 /* If we're not using lazy TLS relocations, don't generate the
3597 PLT and GOT entries they require. */
3598 if ((info
->flags
& DF_BIND_NOW
))
3599 htab
->tlsdesc_plt
= 0;
3602 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3603 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3604 /* Reserve room for the initial entry.
3605 FIXME: we could probably do away with it in this case. */
3606 if (htab
->elf
.splt
->size
== 0)
3607 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3608 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3609 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3613 if (htab
->elf
.sgotplt
)
3615 /* Don't allocate .got.plt section if there are no GOT nor PLT
3616 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3617 if ((htab
->elf
.hgot
== NULL
3618 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3619 && (htab
->elf
.sgotplt
->size
3620 == get_elf_backend_data (output_bfd
)->got_header_size
)
3621 && (htab
->elf
.splt
== NULL
3622 || htab
->elf
.splt
->size
== 0)
3623 && (htab
->elf
.sgot
== NULL
3624 || htab
->elf
.sgot
->size
== 0)
3625 && (htab
->elf
.iplt
== NULL
3626 || htab
->elf
.iplt
->size
== 0)
3627 && (htab
->elf
.igotplt
== NULL
3628 || htab
->elf
.igotplt
->size
== 0))
3629 htab
->elf
.sgotplt
->size
= 0;
3632 if (htab
->plt_eh_frame
!= NULL
3633 && htab
->elf
.splt
!= NULL
3634 && htab
->elf
.splt
->size
!= 0
3635 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3636 && _bfd_elf_eh_frame_present (info
))
3638 const struct elf_x86_64_backend_data
*arch_data
3639 = get_elf_x86_64_arch_data (bed
);
3640 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3643 /* We now have determined the sizes of the various dynamic sections.
3644 Allocate memory for them. */
3646 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3648 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3651 if (s
== htab
->elf
.splt
3652 || s
== htab
->elf
.sgot
3653 || s
== htab
->elf
.sgotplt
3654 || s
== htab
->elf
.iplt
3655 || s
== htab
->elf
.igotplt
3656 || s
== htab
->plt_bnd
3657 || s
== htab
->plt_got
3658 || s
== htab
->plt_eh_frame
3659 || s
== htab
->sdynbss
)
3661 /* Strip this section if we don't need it; see the
3664 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3666 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3669 /* We use the reloc_count field as a counter if we need
3670 to copy relocs into the output file. */
3671 if (s
!= htab
->elf
.srelplt
)
3676 /* It's not one of our sections, so don't allocate space. */
3682 /* If we don't need this section, strip it from the
3683 output file. This is mostly to handle .rela.bss and
3684 .rela.plt. We must create both sections in
3685 create_dynamic_sections, because they must be created
3686 before the linker maps input sections to output
3687 sections. The linker does that before
3688 adjust_dynamic_symbol is called, and it is that
3689 function which decides whether anything needs to go
3690 into these sections. */
3692 s
->flags
|= SEC_EXCLUDE
;
3696 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3699 /* Allocate memory for the section contents. We use bfd_zalloc
3700 here in case unused entries are not reclaimed before the
3701 section's contents are written out. This should not happen,
3702 but this way if it does, we get a R_X86_64_NONE reloc instead
3704 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3705 if (s
->contents
== NULL
)
3709 if (htab
->plt_eh_frame
!= NULL
3710 && htab
->plt_eh_frame
->contents
!= NULL
)
3712 const struct elf_x86_64_backend_data
*arch_data
3713 = get_elf_x86_64_arch_data (bed
);
3715 memcpy (htab
->plt_eh_frame
->contents
,
3716 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3717 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3718 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3721 if (htab
->elf
.dynamic_sections_created
)
3723 /* Add some entries to the .dynamic section. We fill in the
3724 values later, in elf_x86_64_finish_dynamic_sections, but we
3725 must add the entries now so that we get the correct size for
3726 the .dynamic section. The DT_DEBUG entry is filled in by the
3727 dynamic linker and used by the debugger. */
3728 #define add_dynamic_entry(TAG, VAL) \
3729 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3731 if (bfd_link_executable (info
))
3733 if (!add_dynamic_entry (DT_DEBUG
, 0))
3737 if (htab
->elf
.splt
->size
!= 0)
3739 /* DT_PLTGOT is used by prelink even if there is no PLT
3741 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3744 if (htab
->elf
.srelplt
->size
!= 0)
3746 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3747 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3748 || !add_dynamic_entry (DT_JMPREL
, 0))
3752 if (htab
->tlsdesc_plt
3753 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3754 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3760 if (!add_dynamic_entry (DT_RELA
, 0)
3761 || !add_dynamic_entry (DT_RELASZ
, 0)
3762 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3765 /* If any dynamic relocs apply to a read-only section,
3766 then we need a DT_TEXTREL entry. */
3767 if ((info
->flags
& DF_TEXTREL
) == 0)
3768 elf_link_hash_traverse (&htab
->elf
,
3769 elf_x86_64_readonly_dynrelocs
,
3772 if ((info
->flags
& DF_TEXTREL
) != 0)
3774 if (htab
->readonly_dynrelocs_against_ifunc
)
3776 info
->callbacks
->einfo
3777 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3778 bfd_set_error (bfd_error_bad_value
);
3782 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3787 #undef add_dynamic_entry
3793 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3794 struct bfd_link_info
*info
)
3796 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3800 struct elf_link_hash_entry
*tlsbase
;
3802 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3803 "_TLS_MODULE_BASE_",
3804 FALSE
, FALSE
, FALSE
);
3806 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3808 struct elf_x86_64_link_hash_table
*htab
;
3809 struct bfd_link_hash_entry
*bh
= NULL
;
3810 const struct elf_backend_data
*bed
3811 = get_elf_backend_data (output_bfd
);
3813 htab
= elf_x86_64_hash_table (info
);
3817 if (!(_bfd_generic_link_add_one_symbol
3818 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3819 tls_sec
, 0, NULL
, FALSE
,
3820 bed
->collect
, &bh
)))
3823 htab
->tls_module_base
= bh
;
3825 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3826 tlsbase
->def_regular
= 1;
3827 tlsbase
->other
= STV_HIDDEN
;
3828 tlsbase
->root
.linker_def
= 1;
3829 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3836 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3837 executables. Rather than setting it to the beginning of the TLS
3838 section, we have to set it to the end. This function may be called
3839 multiple times, it is idempotent. */
3842 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3844 struct elf_x86_64_link_hash_table
*htab
;
3845 struct bfd_link_hash_entry
*base
;
3847 if (!bfd_link_executable (info
))
3850 htab
= elf_x86_64_hash_table (info
);
3854 base
= htab
->tls_module_base
;
3858 base
->u
.def
.value
= htab
->elf
.tls_size
;
3861 /* Return the base VMA address which should be subtracted from real addresses
3862 when resolving @dtpoff relocation.
3863 This is PT_TLS segment p_vaddr. */
3866 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3868 /* If tls_sec is NULL, we should have signalled an error already. */
3869 if (elf_hash_table (info
)->tls_sec
== NULL
)
3871 return elf_hash_table (info
)->tls_sec
->vma
;
3874 /* Return the relocation value for @tpoff relocation
3875 if STT_TLS virtual address is ADDRESS. */
3878 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3880 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3881 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3882 bfd_vma static_tls_size
;
3884 /* If tls_segment is NULL, we should have signalled an error already. */
3885 if (htab
->tls_sec
== NULL
)
3888 /* Consider special static TLS alignment requirements. */
3889 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3890 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3893 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3897 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3899 /* Opcode Instruction
3902 0x0f 0x8x conditional jump */
3904 && (contents
[offset
- 1] == 0xe8
3905 || contents
[offset
- 1] == 0xe9))
3907 && contents
[offset
- 2] == 0x0f
3908 && (contents
[offset
- 1] & 0xf0) == 0x80));
3911 /* Relocate an x86_64 ELF section. */
3914 elf_x86_64_relocate_section (bfd
*output_bfd
,
3915 struct bfd_link_info
*info
,
3917 asection
*input_section
,
3919 Elf_Internal_Rela
*relocs
,
3920 Elf_Internal_Sym
*local_syms
,
3921 asection
**local_sections
)
3923 struct elf_x86_64_link_hash_table
*htab
;
3924 Elf_Internal_Shdr
*symtab_hdr
;
3925 struct elf_link_hash_entry
**sym_hashes
;
3926 bfd_vma
*local_got_offsets
;
3927 bfd_vma
*local_tlsdesc_gotents
;
3928 Elf_Internal_Rela
*rel
;
3929 Elf_Internal_Rela
*wrel
;
3930 Elf_Internal_Rela
*relend
;
3931 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3933 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3935 /* Skip if check_relocs failed. */
3936 if (input_section
->check_relocs_failed
)
3939 htab
= elf_x86_64_hash_table (info
);
3942 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3943 sym_hashes
= elf_sym_hashes (input_bfd
);
3944 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3945 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3947 elf_x86_64_set_tls_module_base (info
);
3949 rel
= wrel
= relocs
;
3950 relend
= relocs
+ input_section
->reloc_count
;
3951 for (; rel
< relend
; wrel
++, rel
++)
3953 unsigned int r_type
;
3954 reloc_howto_type
*howto
;
3955 unsigned long r_symndx
;
3956 struct elf_link_hash_entry
*h
;
3957 struct elf_x86_64_link_hash_entry
*eh
;
3958 Elf_Internal_Sym
*sym
;
3960 bfd_vma off
, offplt
, plt_offset
;
3962 bfd_boolean unresolved_reloc
;
3963 bfd_reloc_status_type r
;
3965 asection
*base_got
, *resolved_plt
;
3967 bfd_boolean resolved_to_zero
;
3969 r_type
= ELF32_R_TYPE (rel
->r_info
);
3970 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3971 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3978 if (r_type
>= (int) R_X86_64_standard
)
3980 (*_bfd_error_handler
)
3981 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3982 input_bfd
, input_section
, r_type
);
3983 bfd_set_error (bfd_error_bad_value
);
3987 if (r_type
!= (int) R_X86_64_32
3988 || ABI_64_P (output_bfd
))
3989 howto
= x86_64_elf_howto_table
+ r_type
;
3991 howto
= (x86_64_elf_howto_table
3992 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3993 r_symndx
= htab
->r_sym (rel
->r_info
);
3997 unresolved_reloc
= FALSE
;
3998 if (r_symndx
< symtab_hdr
->sh_info
)
4000 sym
= local_syms
+ r_symndx
;
4001 sec
= local_sections
[r_symndx
];
4003 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4005 st_size
= sym
->st_size
;
4007 /* Relocate against local STT_GNU_IFUNC symbol. */
4008 if (!bfd_link_relocatable (info
)
4009 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4011 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4016 /* Set STT_GNU_IFUNC symbol value. */
4017 h
->root
.u
.def
.value
= sym
->st_value
;
4018 h
->root
.u
.def
.section
= sec
;
4023 bfd_boolean warned ATTRIBUTE_UNUSED
;
4024 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4026 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4027 r_symndx
, symtab_hdr
, sym_hashes
,
4029 unresolved_reloc
, warned
, ignored
);
4033 if (sec
!= NULL
&& discarded_section (sec
))
4035 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4036 contents
+ rel
->r_offset
);
4037 wrel
->r_offset
= rel
->r_offset
;
4041 /* For ld -r, remove relocations in debug sections against
4042 sections defined in discarded sections. Not done for
4043 eh_frame editing code expects to be present. */
4044 if (bfd_link_relocatable (info
)
4045 && (input_section
->flags
& SEC_DEBUGGING
))
4051 if (bfd_link_relocatable (info
))
4058 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4060 if (r_type
== R_X86_64_64
)
4062 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4063 zero-extend it to 64bit if addend is zero. */
4064 r_type
= R_X86_64_32
;
4065 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4067 else if (r_type
== R_X86_64_SIZE64
)
4069 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4070 zero-extend it to 64bit if addend is zero. */
4071 r_type
= R_X86_64_SIZE32
;
4072 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4076 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4078 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4079 it here if it is defined in a non-shared object. */
4081 && h
->type
== STT_GNU_IFUNC
4087 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4089 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4090 sections because such sections are not SEC_ALLOC and
4091 thus ld.so will not process them. */
4092 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4096 else if (h
->plt
.offset
== (bfd_vma
) -1)
4099 /* STT_GNU_IFUNC symbol must go through PLT. */
4100 if (htab
->elf
.splt
!= NULL
)
4102 if (htab
->plt_bnd
!= NULL
)
4104 resolved_plt
= htab
->plt_bnd
;
4105 plt_offset
= eh
->plt_bnd
.offset
;
4109 resolved_plt
= htab
->elf
.splt
;
4110 plt_offset
= h
->plt
.offset
;
4115 resolved_plt
= htab
->elf
.iplt
;
4116 plt_offset
= h
->plt
.offset
;
4119 relocation
= (resolved_plt
->output_section
->vma
4120 + resolved_plt
->output_offset
+ plt_offset
);
4125 if (h
->root
.root
.string
)
4126 name
= h
->root
.root
.string
;
4128 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4130 (*_bfd_error_handler
)
4131 (_("%B: relocation %s against STT_GNU_IFUNC "
4132 "symbol `%s' isn't handled by %s"), input_bfd
,
4133 howto
->name
, name
, __FUNCTION__
);
4134 bfd_set_error (bfd_error_bad_value
);
4138 if (bfd_link_pic (info
))
4143 if (ABI_64_P (output_bfd
))
4147 if (rel
->r_addend
!= 0)
4149 if (h
->root
.root
.string
)
4150 name
= h
->root
.root
.string
;
4152 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4154 (*_bfd_error_handler
)
4155 (_("%B: relocation %s against STT_GNU_IFUNC "
4156 "symbol `%s' has non-zero addend: %d"),
4157 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4158 bfd_set_error (bfd_error_bad_value
);
4162 /* Generate dynamic relcoation only when there is a
4163 non-GOT reference in a shared object. */
4164 if (bfd_link_pic (info
) && h
->non_got_ref
)
4166 Elf_Internal_Rela outrel
;
4169 /* Need a dynamic relocation to get the real function
4171 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4175 if (outrel
.r_offset
== (bfd_vma
) -1
4176 || outrel
.r_offset
== (bfd_vma
) -2)
4179 outrel
.r_offset
+= (input_section
->output_section
->vma
4180 + input_section
->output_offset
);
4182 if (h
->dynindx
== -1
4184 || bfd_link_executable (info
))
4186 /* This symbol is resolved locally. */
4187 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4188 outrel
.r_addend
= (h
->root
.u
.def
.value
4189 + h
->root
.u
.def
.section
->output_section
->vma
4190 + h
->root
.u
.def
.section
->output_offset
);
4194 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4195 outrel
.r_addend
= 0;
4198 sreloc
= htab
->elf
.irelifunc
;
4199 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4201 /* If this reloc is against an external symbol, we
4202 do not want to fiddle with the addend. Otherwise,
4203 we need to include the symbol value so that it
4204 becomes an addend for the dynamic reloc. For an
4205 internal symbol, we have updated addend. */
4210 case R_X86_64_PC32_BND
:
4212 case R_X86_64_PLT32
:
4213 case R_X86_64_PLT32_BND
:
4216 case R_X86_64_GOTPCREL
:
4217 case R_X86_64_GOTPCRELX
:
4218 case R_X86_64_REX_GOTPCRELX
:
4219 case R_X86_64_GOTPCREL64
:
4220 base_got
= htab
->elf
.sgot
;
4221 off
= h
->got
.offset
;
4223 if (base_got
== NULL
)
4226 if (off
== (bfd_vma
) -1)
4228 /* We can't use h->got.offset here to save state, or
4229 even just remember the offset, as finish_dynamic_symbol
4230 would use that as offset into .got. */
4232 if (htab
->elf
.splt
!= NULL
)
4234 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4235 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4236 base_got
= htab
->elf
.sgotplt
;
4240 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4241 off
= plt_index
* GOT_ENTRY_SIZE
;
4242 base_got
= htab
->elf
.igotplt
;
4245 if (h
->dynindx
== -1
4249 /* This references the local defitionion. We must
4250 initialize this entry in the global offset table.
4251 Since the offset must always be a multiple of 8,
4252 we use the least significant bit to record
4253 whether we have initialized it already.
4255 When doing a dynamic link, we create a .rela.got
4256 relocation entry to initialize the value. This
4257 is done in the finish_dynamic_symbol routine. */
4262 bfd_put_64 (output_bfd
, relocation
,
4263 base_got
->contents
+ off
);
4264 /* Note that this is harmless for the GOTPLT64
4265 case, as -1 | 1 still is -1. */
4271 relocation
= (base_got
->output_section
->vma
4272 + base_got
->output_offset
+ off
);
4278 resolved_to_zero
= (eh
!= NULL
4279 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4281 /* When generating a shared object, the relocations handled here are
4282 copied into the output file to be resolved at run time. */
4285 case R_X86_64_GOT32
:
4286 case R_X86_64_GOT64
:
4287 /* Relocation is to the entry for this symbol in the global
4289 case R_X86_64_GOTPCREL
:
4290 case R_X86_64_GOTPCRELX
:
4291 case R_X86_64_REX_GOTPCRELX
:
4292 case R_X86_64_GOTPCREL64
:
4293 /* Use global offset table entry as symbol value. */
4294 case R_X86_64_GOTPLT64
:
4295 /* This is obsolete and treated the the same as GOT64. */
4296 base_got
= htab
->elf
.sgot
;
4298 if (htab
->elf
.sgot
== NULL
)
4305 off
= h
->got
.offset
;
4307 && h
->plt
.offset
!= (bfd_vma
)-1
4308 && off
== (bfd_vma
)-1)
4310 /* We can't use h->got.offset here to save
4311 state, or even just remember the offset, as
4312 finish_dynamic_symbol would use that as offset into
4314 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4315 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4316 base_got
= htab
->elf
.sgotplt
;
4319 dyn
= htab
->elf
.dynamic_sections_created
;
4321 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4322 || (bfd_link_pic (info
)
4323 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4324 || (ELF_ST_VISIBILITY (h
->other
)
4325 && h
->root
.type
== bfd_link_hash_undefweak
))
4327 /* This is actually a static link, or it is a -Bsymbolic
4328 link and the symbol is defined locally, or the symbol
4329 was forced to be local because of a version file. We
4330 must initialize this entry in the global offset table.
4331 Since the offset must always be a multiple of 8, we
4332 use the least significant bit to record whether we
4333 have initialized it already.
4335 When doing a dynamic link, we create a .rela.got
4336 relocation entry to initialize the value. This is
4337 done in the finish_dynamic_symbol routine. */
4342 bfd_put_64 (output_bfd
, relocation
,
4343 base_got
->contents
+ off
);
4344 /* Note that this is harmless for the GOTPLT64 case,
4345 as -1 | 1 still is -1. */
4350 unresolved_reloc
= FALSE
;
4354 if (local_got_offsets
== NULL
)
4357 off
= local_got_offsets
[r_symndx
];
4359 /* The offset must always be a multiple of 8. We use
4360 the least significant bit to record whether we have
4361 already generated the necessary reloc. */
4366 bfd_put_64 (output_bfd
, relocation
,
4367 base_got
->contents
+ off
);
4369 if (bfd_link_pic (info
))
4372 Elf_Internal_Rela outrel
;
4374 /* We need to generate a R_X86_64_RELATIVE reloc
4375 for the dynamic linker. */
4376 s
= htab
->elf
.srelgot
;
4380 outrel
.r_offset
= (base_got
->output_section
->vma
4381 + base_got
->output_offset
4383 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4384 outrel
.r_addend
= relocation
;
4385 elf_append_rela (output_bfd
, s
, &outrel
);
4388 local_got_offsets
[r_symndx
] |= 1;
4392 if (off
>= (bfd_vma
) -2)
4395 relocation
= base_got
->output_section
->vma
4396 + base_got
->output_offset
+ off
;
4397 if (r_type
!= R_X86_64_GOTPCREL
4398 && r_type
!= R_X86_64_GOTPCRELX
4399 && r_type
!= R_X86_64_REX_GOTPCRELX
4400 && r_type
!= R_X86_64_GOTPCREL64
)
4401 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4402 - htab
->elf
.sgotplt
->output_offset
;
4406 case R_X86_64_GOTOFF64
:
4407 /* Relocation is relative to the start of the global offset
4410 /* Check to make sure it isn't a protected function or data
4411 symbol for shared library since it may not be local when
4412 used as function address or with copy relocation. We also
4413 need to make sure that a symbol is referenced locally. */
4414 if (bfd_link_pic (info
) && h
)
4416 if (!h
->def_regular
)
4420 switch (ELF_ST_VISIBILITY (h
->other
))
4423 v
= _("hidden symbol");
4426 v
= _("internal symbol");
4429 v
= _("protected symbol");
4436 (*_bfd_error_handler
)
4437 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4438 input_bfd
, v
, h
->root
.root
.string
);
4439 bfd_set_error (bfd_error_bad_value
);
4442 else if (!bfd_link_executable (info
)
4443 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4444 && (h
->type
== STT_FUNC
4445 || h
->type
== STT_OBJECT
)
4446 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4448 (*_bfd_error_handler
)
4449 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4451 h
->type
== STT_FUNC
? "function" : "data",
4452 h
->root
.root
.string
);
4453 bfd_set_error (bfd_error_bad_value
);
4458 /* Note that sgot is not involved in this
4459 calculation. We always want the start of .got.plt. If we
4460 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4461 permitted by the ABI, we might have to change this
4463 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4464 + htab
->elf
.sgotplt
->output_offset
;
4467 case R_X86_64_GOTPC32
:
4468 case R_X86_64_GOTPC64
:
4469 /* Use global offset table as symbol value. */
4470 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4471 + htab
->elf
.sgotplt
->output_offset
;
4472 unresolved_reloc
= FALSE
;
4475 case R_X86_64_PLTOFF64
:
4476 /* Relocation is PLT entry relative to GOT. For local
4477 symbols it's the symbol itself relative to GOT. */
4479 /* See PLT32 handling. */
4480 && h
->plt
.offset
!= (bfd_vma
) -1
4481 && htab
->elf
.splt
!= NULL
)
4483 if (htab
->plt_bnd
!= NULL
)
4485 resolved_plt
= htab
->plt_bnd
;
4486 plt_offset
= eh
->plt_bnd
.offset
;
4490 resolved_plt
= htab
->elf
.splt
;
4491 plt_offset
= h
->plt
.offset
;
4494 relocation
= (resolved_plt
->output_section
->vma
4495 + resolved_plt
->output_offset
4497 unresolved_reloc
= FALSE
;
4500 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4501 + htab
->elf
.sgotplt
->output_offset
;
4504 case R_X86_64_PLT32
:
4505 case R_X86_64_PLT32_BND
:
4506 /* Relocation is to the entry for this symbol in the
4507 procedure linkage table. */
4509 /* Resolve a PLT32 reloc against a local symbol directly,
4510 without using the procedure linkage table. */
4514 if ((h
->plt
.offset
== (bfd_vma
) -1
4515 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4516 || htab
->elf
.splt
== NULL
)
4518 /* We didn't make a PLT entry for this symbol. This
4519 happens when statically linking PIC code, or when
4520 using -Bsymbolic. */
4524 if (h
->plt
.offset
!= (bfd_vma
) -1)
4526 if (htab
->plt_bnd
!= NULL
)
4528 resolved_plt
= htab
->plt_bnd
;
4529 plt_offset
= eh
->plt_bnd
.offset
;
4533 resolved_plt
= htab
->elf
.splt
;
4534 plt_offset
= h
->plt
.offset
;
4539 /* Use the GOT PLT. */
4540 resolved_plt
= htab
->plt_got
;
4541 plt_offset
= eh
->plt_got
.offset
;
4544 relocation
= (resolved_plt
->output_section
->vma
4545 + resolved_plt
->output_offset
4547 unresolved_reloc
= FALSE
;
4550 case R_X86_64_SIZE32
:
4551 case R_X86_64_SIZE64
:
4552 /* Set to symbol size. */
4553 relocation
= st_size
;
4559 case R_X86_64_PC32_BND
:
4560 /* Don't complain about -fPIC if the symbol is undefined when
4561 building executable unless it is unresolved weak symbol. */
4562 if ((input_section
->flags
& SEC_ALLOC
) != 0
4563 && (input_section
->flags
& SEC_READONLY
) != 0
4565 && ((bfd_link_executable (info
)
4566 && h
->root
.type
== bfd_link_hash_undefweak
4567 && !resolved_to_zero
)
4568 || (bfd_link_pic (info
)
4569 && !(bfd_link_pie (info
)
4570 && h
->root
.type
== bfd_link_hash_undefined
))))
4572 bfd_boolean fail
= FALSE
;
4574 = ((r_type
== R_X86_64_PC32
4575 || r_type
== R_X86_64_PC32_BND
)
4576 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4578 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4580 /* Symbol is referenced locally. Make sure it is
4581 defined locally or for a branch. */
4582 fail
= !h
->def_regular
&& !branch
;
4584 else if (!(bfd_link_pie (info
)
4585 && (h
->needs_copy
|| eh
->needs_copy
)))
4587 /* Symbol doesn't need copy reloc and isn't referenced
4588 locally. We only allow branch to symbol with
4589 non-default visibility. */
4591 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4595 return elf_x86_64_need_pic (input_bfd
, input_section
,
4596 h
, NULL
, NULL
, howto
);
4605 /* FIXME: The ABI says the linker should make sure the value is
4606 the same when it's zeroextended to 64 bit. */
4609 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4612 /* Don't copy a pc-relative relocation into the output file
4613 if the symbol needs copy reloc or the symbol is undefined
4614 when building executable. Copy dynamic function pointer
4615 relocations. Don't generate dynamic relocations against
4616 resolved undefined weak symbols in PIE. */
4617 if ((bfd_link_pic (info
)
4618 && !(bfd_link_pie (info
)
4622 || h
->root
.type
== bfd_link_hash_undefined
)
4623 && IS_X86_64_PCREL_TYPE (r_type
))
4625 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4626 && !resolved_to_zero
)
4627 || h
->root
.type
!= bfd_link_hash_undefweak
))
4628 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4629 && r_type
!= R_X86_64_SIZE32
4630 && r_type
!= R_X86_64_SIZE64
)
4631 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4632 || (ELIMINATE_COPY_RELOCS
4633 && !bfd_link_pic (info
)
4637 || eh
->func_pointer_refcount
> 0
4638 || (h
->root
.type
== bfd_link_hash_undefweak
4639 && !resolved_to_zero
))
4640 && ((h
->def_dynamic
&& !h
->def_regular
)
4641 /* Undefined weak symbol is bound locally when
4643 || h
->root
.type
== bfd_link_hash_undefined
)))
4645 Elf_Internal_Rela outrel
;
4646 bfd_boolean skip
, relocate
;
4649 /* When generating a shared object, these relocations
4650 are copied into the output file to be resolved at run
4656 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4658 if (outrel
.r_offset
== (bfd_vma
) -1)
4660 else if (outrel
.r_offset
== (bfd_vma
) -2)
4661 skip
= TRUE
, relocate
= TRUE
;
4663 outrel
.r_offset
+= (input_section
->output_section
->vma
4664 + input_section
->output_offset
);
4667 memset (&outrel
, 0, sizeof outrel
);
4669 /* h->dynindx may be -1 if this symbol was marked to
4673 && (IS_X86_64_PCREL_TYPE (r_type
)
4674 || !(bfd_link_executable (info
)
4675 || SYMBOLIC_BIND (info
, h
))
4676 || ! h
->def_regular
))
4678 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4679 outrel
.r_addend
= rel
->r_addend
;
4683 /* This symbol is local, or marked to become local.
4684 When relocation overflow check is disabled, we
4685 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4686 if (r_type
== htab
->pointer_r_type
4687 || (r_type
== R_X86_64_32
4688 && info
->no_reloc_overflow_check
))
4691 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4692 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4694 else if (r_type
== R_X86_64_64
4695 && !ABI_64_P (output_bfd
))
4698 outrel
.r_info
= htab
->r_info (0,
4699 R_X86_64_RELATIVE64
);
4700 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4701 /* Check addend overflow. */
4702 if ((outrel
.r_addend
& 0x80000000)
4703 != (rel
->r_addend
& 0x80000000))
4706 int addend
= rel
->r_addend
;
4707 if (h
&& h
->root
.root
.string
)
4708 name
= h
->root
.root
.string
;
4710 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4713 (*_bfd_error_handler
)
4714 (_("%B: addend -0x%x in relocation %s against "
4715 "symbol `%s' at 0x%lx in section `%A' is "
4717 input_bfd
, input_section
, addend
,
4719 (unsigned long) rel
->r_offset
);
4721 (*_bfd_error_handler
)
4722 (_("%B: addend 0x%x in relocation %s against "
4723 "symbol `%s' at 0x%lx in section `%A' is "
4725 input_bfd
, input_section
, addend
,
4727 (unsigned long) rel
->r_offset
);
4728 bfd_set_error (bfd_error_bad_value
);
4736 if (bfd_is_abs_section (sec
))
4738 else if (sec
== NULL
|| sec
->owner
== NULL
)
4740 bfd_set_error (bfd_error_bad_value
);
4747 /* We are turning this relocation into one
4748 against a section symbol. It would be
4749 proper to subtract the symbol's value,
4750 osec->vma, from the emitted reloc addend,
4751 but ld.so expects buggy relocs. */
4752 osec
= sec
->output_section
;
4753 sindx
= elf_section_data (osec
)->dynindx
;
4756 asection
*oi
= htab
->elf
.text_index_section
;
4757 sindx
= elf_section_data (oi
)->dynindx
;
4759 BFD_ASSERT (sindx
!= 0);
4762 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4763 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4767 sreloc
= elf_section_data (input_section
)->sreloc
;
4769 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4771 r
= bfd_reloc_notsupported
;
4772 goto check_relocation_error
;
4775 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4777 /* If this reloc is against an external symbol, we do
4778 not want to fiddle with the addend. Otherwise, we
4779 need to include the symbol value so that it becomes
4780 an addend for the dynamic reloc. */
4787 case R_X86_64_TLSGD
:
4788 case R_X86_64_GOTPC32_TLSDESC
:
4789 case R_X86_64_TLSDESC_CALL
:
4790 case R_X86_64_GOTTPOFF
:
4791 tls_type
= GOT_UNKNOWN
;
4792 if (h
== NULL
&& local_got_offsets
)
4793 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4795 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4797 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4798 input_section
, contents
,
4799 symtab_hdr
, sym_hashes
,
4800 &r_type
, tls_type
, rel
,
4801 relend
, h
, r_symndx
))
4804 if (r_type
== R_X86_64_TPOFF32
)
4806 bfd_vma roff
= rel
->r_offset
;
4808 BFD_ASSERT (! unresolved_reloc
);
4810 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4812 /* GD->LE transition. For 64bit, change
4813 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4814 .word 0x6666; rex64; call __tls_get_addr
4817 leaq foo@tpoff(%rax), %rax
4819 leaq foo@tlsgd(%rip), %rdi
4820 .word 0x6666; rex64; call __tls_get_addr
4823 leaq foo@tpoff(%rax), %rax
4824 For largepic, change:
4825 leaq foo@tlsgd(%rip), %rdi
4826 movabsq $__tls_get_addr@pltoff, %rax
4831 leaq foo@tpoff(%rax), %rax
4832 nopw 0x0(%rax,%rax,1) */
4834 if (ABI_64_P (output_bfd
)
4835 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4837 memcpy (contents
+ roff
- 3,
4838 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4839 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4842 else if (ABI_64_P (output_bfd
))
4843 memcpy (contents
+ roff
- 4,
4844 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4847 memcpy (contents
+ roff
- 3,
4848 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4850 bfd_put_32 (output_bfd
,
4851 elf_x86_64_tpoff (info
, relocation
),
4852 contents
+ roff
+ 8 + largepic
);
4853 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4858 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4860 /* GDesc -> LE transition.
4861 It's originally something like:
4862 leaq x@tlsdesc(%rip), %rax
4865 movl $x@tpoff, %rax. */
4867 unsigned int val
, type
;
4869 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4870 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4871 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4872 contents
+ roff
- 3);
4873 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4874 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4875 contents
+ roff
- 1);
4876 bfd_put_32 (output_bfd
,
4877 elf_x86_64_tpoff (info
, relocation
),
4881 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4883 /* GDesc -> LE transition.
4888 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4889 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4892 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4894 /* IE->LE transition:
4895 For 64bit, originally it can be one of:
4896 movq foo@gottpoff(%rip), %reg
4897 addq foo@gottpoff(%rip), %reg
4900 leaq foo(%reg), %reg
4902 For 32bit, originally it can be one of:
4903 movq foo@gottpoff(%rip), %reg
4904 addl foo@gottpoff(%rip), %reg
4907 leal foo(%reg), %reg
4910 unsigned int val
, type
, reg
;
4913 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4916 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4917 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4923 bfd_put_8 (output_bfd
, 0x49,
4924 contents
+ roff
- 3);
4925 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4926 bfd_put_8 (output_bfd
, 0x41,
4927 contents
+ roff
- 3);
4928 bfd_put_8 (output_bfd
, 0xc7,
4929 contents
+ roff
- 2);
4930 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4931 contents
+ roff
- 1);
4935 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4938 bfd_put_8 (output_bfd
, 0x49,
4939 contents
+ roff
- 3);
4940 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4941 bfd_put_8 (output_bfd
, 0x41,
4942 contents
+ roff
- 3);
4943 bfd_put_8 (output_bfd
, 0x81,
4944 contents
+ roff
- 2);
4945 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4946 contents
+ roff
- 1);
4950 /* addq/addl -> leaq/leal */
4952 bfd_put_8 (output_bfd
, 0x4d,
4953 contents
+ roff
- 3);
4954 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4955 bfd_put_8 (output_bfd
, 0x45,
4956 contents
+ roff
- 3);
4957 bfd_put_8 (output_bfd
, 0x8d,
4958 contents
+ roff
- 2);
4959 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4960 contents
+ roff
- 1);
4962 bfd_put_32 (output_bfd
,
4963 elf_x86_64_tpoff (info
, relocation
),
4971 if (htab
->elf
.sgot
== NULL
)
4976 off
= h
->got
.offset
;
4977 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4981 if (local_got_offsets
== NULL
)
4984 off
= local_got_offsets
[r_symndx
];
4985 offplt
= local_tlsdesc_gotents
[r_symndx
];
4992 Elf_Internal_Rela outrel
;
4996 if (htab
->elf
.srelgot
== NULL
)
4999 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5001 if (GOT_TLS_GDESC_P (tls_type
))
5003 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5004 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5005 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5006 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5007 + htab
->elf
.sgotplt
->output_offset
5009 + htab
->sgotplt_jump_table_size
);
5010 sreloc
= htab
->elf
.srelplt
;
5012 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5014 outrel
.r_addend
= 0;
5015 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5018 sreloc
= htab
->elf
.srelgot
;
5020 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5021 + htab
->elf
.sgot
->output_offset
+ off
);
5023 if (GOT_TLS_GD_P (tls_type
))
5024 dr_type
= R_X86_64_DTPMOD64
;
5025 else if (GOT_TLS_GDESC_P (tls_type
))
5028 dr_type
= R_X86_64_TPOFF64
;
5030 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5031 outrel
.r_addend
= 0;
5032 if ((dr_type
== R_X86_64_TPOFF64
5033 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5034 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5035 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5037 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5039 if (GOT_TLS_GD_P (tls_type
))
5043 BFD_ASSERT (! unresolved_reloc
);
5044 bfd_put_64 (output_bfd
,
5045 relocation
- elf_x86_64_dtpoff_base (info
),
5046 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5050 bfd_put_64 (output_bfd
, 0,
5051 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5052 outrel
.r_info
= htab
->r_info (indx
,
5054 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5055 elf_append_rela (output_bfd
, sreloc
,
5064 local_got_offsets
[r_symndx
] |= 1;
5067 if (off
>= (bfd_vma
) -2
5068 && ! GOT_TLS_GDESC_P (tls_type
))
5070 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5072 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5073 || r_type
== R_X86_64_TLSDESC_CALL
)
5074 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5075 + htab
->elf
.sgotplt
->output_offset
5076 + offplt
+ htab
->sgotplt_jump_table_size
;
5078 relocation
= htab
->elf
.sgot
->output_section
->vma
5079 + htab
->elf
.sgot
->output_offset
+ off
;
5080 unresolved_reloc
= FALSE
;
5084 bfd_vma roff
= rel
->r_offset
;
5086 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5088 /* GD->IE transition. For 64bit, change
5089 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5090 .word 0x6666; rex64; call __tls_get_addr@plt
5093 addq foo@gottpoff(%rip), %rax
5095 leaq foo@tlsgd(%rip), %rdi
5096 .word 0x6666; rex64; call __tls_get_addr@plt
5099 addq foo@gottpoff(%rip), %rax
5100 For largepic, change:
5101 leaq foo@tlsgd(%rip), %rdi
5102 movabsq $__tls_get_addr@pltoff, %rax
5107 addq foo@gottpoff(%rax), %rax
5108 nopw 0x0(%rax,%rax,1) */
5110 if (ABI_64_P (output_bfd
)
5111 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5113 memcpy (contents
+ roff
- 3,
5114 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5115 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5118 else if (ABI_64_P (output_bfd
))
5119 memcpy (contents
+ roff
- 4,
5120 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5123 memcpy (contents
+ roff
- 3,
5124 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5127 relocation
= (htab
->elf
.sgot
->output_section
->vma
5128 + htab
->elf
.sgot
->output_offset
+ off
5131 - input_section
->output_section
->vma
5132 - input_section
->output_offset
5134 bfd_put_32 (output_bfd
, relocation
,
5135 contents
+ roff
+ 8 + largepic
);
5136 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5141 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5143 /* GDesc -> IE transition.
5144 It's originally something like:
5145 leaq x@tlsdesc(%rip), %rax
5148 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5150 /* Now modify the instruction as appropriate. To
5151 turn a leaq into a movq in the form we use it, it
5152 suffices to change the second byte from 0x8d to
5154 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5156 bfd_put_32 (output_bfd
,
5157 htab
->elf
.sgot
->output_section
->vma
5158 + htab
->elf
.sgot
->output_offset
+ off
5160 - input_section
->output_section
->vma
5161 - input_section
->output_offset
5166 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5168 /* GDesc -> IE transition.
5175 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5176 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5184 case R_X86_64_TLSLD
:
5185 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5186 input_section
, contents
,
5187 symtab_hdr
, sym_hashes
,
5188 &r_type
, GOT_UNKNOWN
,
5189 rel
, relend
, h
, r_symndx
))
5192 if (r_type
!= R_X86_64_TLSLD
)
5194 /* LD->LE transition:
5195 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5196 For 64bit, we change it into:
5197 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5198 For 32bit, we change it into:
5199 nopl 0x0(%rax); movl %fs:0, %eax.
5200 For largepic, change:
5201 leaq foo@tlsgd(%rip), %rdi
5202 movabsq $__tls_get_addr@pltoff, %rax
5206 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5209 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5210 if (ABI_64_P (output_bfd
)
5211 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5212 memcpy (contents
+ rel
->r_offset
- 3,
5213 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5214 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5215 else if (ABI_64_P (output_bfd
))
5216 memcpy (contents
+ rel
->r_offset
- 3,
5217 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5219 memcpy (contents
+ rel
->r_offset
- 3,
5220 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5221 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5227 if (htab
->elf
.sgot
== NULL
)
5230 off
= htab
->tls_ld_got
.offset
;
5235 Elf_Internal_Rela outrel
;
5237 if (htab
->elf
.srelgot
== NULL
)
5240 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5241 + htab
->elf
.sgot
->output_offset
+ off
);
5243 bfd_put_64 (output_bfd
, 0,
5244 htab
->elf
.sgot
->contents
+ off
);
5245 bfd_put_64 (output_bfd
, 0,
5246 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5247 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5248 outrel
.r_addend
= 0;
5249 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5251 htab
->tls_ld_got
.offset
|= 1;
5253 relocation
= htab
->elf
.sgot
->output_section
->vma
5254 + htab
->elf
.sgot
->output_offset
+ off
;
5255 unresolved_reloc
= FALSE
;
5258 case R_X86_64_DTPOFF32
:
5259 if (!bfd_link_executable (info
)
5260 || (input_section
->flags
& SEC_CODE
) == 0)
5261 relocation
-= elf_x86_64_dtpoff_base (info
);
5263 relocation
= elf_x86_64_tpoff (info
, relocation
);
5266 case R_X86_64_TPOFF32
:
5267 case R_X86_64_TPOFF64
:
5268 BFD_ASSERT (bfd_link_executable (info
));
5269 relocation
= elf_x86_64_tpoff (info
, relocation
);
5272 case R_X86_64_DTPOFF64
:
5273 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5274 relocation
-= elf_x86_64_dtpoff_base (info
);
5281 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5282 because such sections are not SEC_ALLOC and thus ld.so will
5283 not process them. */
5284 if (unresolved_reloc
5285 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5287 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5288 rel
->r_offset
) != (bfd_vma
) -1)
5290 (*_bfd_error_handler
)
5291 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5294 (long) rel
->r_offset
,
5296 h
->root
.root
.string
);
5301 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5302 contents
, rel
->r_offset
,
5303 relocation
, rel
->r_addend
);
5305 check_relocation_error
:
5306 if (r
!= bfd_reloc_ok
)
5311 name
= h
->root
.root
.string
;
5314 name
= bfd_elf_string_from_elf_section (input_bfd
,
5315 symtab_hdr
->sh_link
,
5320 name
= bfd_section_name (input_bfd
, sec
);
5323 if (r
== bfd_reloc_overflow
)
5325 if (! ((*info
->callbacks
->reloc_overflow
)
5326 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5327 (bfd_vma
) 0, input_bfd
, input_section
,
5333 (*_bfd_error_handler
)
5334 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5335 input_bfd
, input_section
,
5336 (long) rel
->r_offset
, name
, (int) r
);
5347 Elf_Internal_Shdr
*rel_hdr
;
5348 size_t deleted
= rel
- wrel
;
5350 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5351 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5352 if (rel_hdr
->sh_size
== 0)
5354 /* It is too late to remove an empty reloc section. Leave
5356 ??? What is wrong with an empty section??? */
5357 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5360 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5361 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5362 input_section
->reloc_count
-= deleted
;
5368 /* Finish up dynamic symbol handling. We set the contents of various
5369 dynamic sections here. */
5372 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5373 struct bfd_link_info
*info
,
5374 struct elf_link_hash_entry
*h
,
5375 Elf_Internal_Sym
*sym
)
5377 struct elf_x86_64_link_hash_table
*htab
;
5378 const struct elf_x86_64_backend_data
*abed
;
5379 bfd_boolean use_plt_bnd
;
5380 struct elf_x86_64_link_hash_entry
*eh
;
5381 bfd_boolean local_undefweak
;
5383 htab
= elf_x86_64_hash_table (info
);
5387 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5388 section only if there is .plt section. */
5389 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5391 ? &elf_x86_64_bnd_arch_bed
5392 : get_elf_x86_64_backend_data (output_bfd
));
5394 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5396 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5397 resolved undefined weak symbols in executable so that their
5398 references have value 0 at run-time. */
5399 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5401 if (h
->plt
.offset
!= (bfd_vma
) -1)
5404 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5405 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5406 Elf_Internal_Rela rela
;
5408 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5409 const struct elf_backend_data
*bed
;
5410 bfd_vma plt_got_pcrel_offset
;
5412 /* When building a static executable, use .iplt, .igot.plt and
5413 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5414 if (htab
->elf
.splt
!= NULL
)
5416 plt
= htab
->elf
.splt
;
5417 gotplt
= htab
->elf
.sgotplt
;
5418 relplt
= htab
->elf
.srelplt
;
5422 plt
= htab
->elf
.iplt
;
5423 gotplt
= htab
->elf
.igotplt
;
5424 relplt
= htab
->elf
.irelplt
;
5427 /* This symbol has an entry in the procedure linkage table. Set
5429 if ((h
->dynindx
== -1
5431 && !((h
->forced_local
|| bfd_link_executable (info
))
5433 && h
->type
== STT_GNU_IFUNC
))
5439 /* Get the index in the procedure linkage table which
5440 corresponds to this symbol. This is the index of this symbol
5441 in all the symbols for which we are making plt entries. The
5442 first entry in the procedure linkage table is reserved.
5444 Get the offset into the .got table of the entry that
5445 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5446 bytes. The first three are reserved for the dynamic linker.
5448 For static executables, we don't reserve anything. */
5450 if (plt
== htab
->elf
.splt
)
5452 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5453 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5457 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5458 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5461 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5462 plt_plt_offset
= abed
->plt_plt_offset
;
5463 plt_got_insn_size
= abed
->plt_got_insn_size
;
5464 plt_got_offset
= abed
->plt_got_offset
;
5467 /* Use the second PLT with BND relocations. */
5468 const bfd_byte
*plt_entry
, *plt2_entry
;
5470 if (eh
->has_bnd_reloc
)
5472 plt_entry
= elf_x86_64_bnd_plt_entry
;
5473 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5477 plt_entry
= elf_x86_64_legacy_plt_entry
;
5478 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5480 /* Subtract 1 since there is no BND prefix. */
5481 plt_plt_insn_end
-= 1;
5482 plt_plt_offset
-= 1;
5483 plt_got_insn_size
-= 1;
5484 plt_got_offset
-= 1;
5487 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5488 == sizeof (elf_x86_64_legacy_plt_entry
));
5490 /* Fill in the entry in the procedure linkage table. */
5491 memcpy (plt
->contents
+ h
->plt
.offset
,
5492 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5493 /* Fill in the entry in the second PLT. */
5494 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5495 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5497 resolved_plt
= htab
->plt_bnd
;
5498 plt_offset
= eh
->plt_bnd
.offset
;
5502 /* Fill in the entry in the procedure linkage table. */
5503 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5504 abed
->plt_entry_size
);
5507 plt_offset
= h
->plt
.offset
;
5510 /* Insert the relocation positions of the plt section. */
5512 /* Put offset the PC-relative instruction referring to the GOT entry,
5513 subtracting the size of that instruction. */
5514 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5515 + gotplt
->output_offset
5517 - resolved_plt
->output_section
->vma
5518 - resolved_plt
->output_offset
5520 - plt_got_insn_size
);
5522 /* Check PC-relative offset overflow in PLT entry. */
5523 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5524 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5525 output_bfd
, h
->root
.root
.string
);
5527 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5528 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5530 /* Fill in the entry in the global offset table, initially this
5531 points to the second part of the PLT entry. Leave the entry
5532 as zero for undefined weak symbol in PIE. No PLT relocation
5533 against undefined weak symbol in PIE. */
5534 if (!local_undefweak
)
5536 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5537 + plt
->output_offset
5539 + abed
->plt_lazy_offset
),
5540 gotplt
->contents
+ got_offset
);
5542 /* Fill in the entry in the .rela.plt section. */
5543 rela
.r_offset
= (gotplt
->output_section
->vma
5544 + gotplt
->output_offset
5546 if (h
->dynindx
== -1
5547 || ((bfd_link_executable (info
)
5548 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5550 && h
->type
== STT_GNU_IFUNC
))
5552 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5553 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5554 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5555 rela
.r_addend
= (h
->root
.u
.def
.value
5556 + h
->root
.u
.def
.section
->output_section
->vma
5557 + h
->root
.u
.def
.section
->output_offset
);
5558 /* R_X86_64_IRELATIVE comes last. */
5559 plt_index
= htab
->next_irelative_index
--;
5563 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5565 plt_index
= htab
->next_jump_slot_index
++;
5568 /* Don't fill PLT entry for static executables. */
5569 if (plt
== htab
->elf
.splt
)
5571 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5573 /* Put relocation index. */
5574 bfd_put_32 (output_bfd
, plt_index
,
5575 (plt
->contents
+ h
->plt
.offset
5576 + abed
->plt_reloc_offset
));
5578 /* Put offset for jmp .PLT0 and check for overflow. We don't
5579 check relocation index for overflow since branch displacement
5580 will overflow first. */
5581 if (plt0_offset
> 0x80000000)
5582 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5583 output_bfd
, h
->root
.root
.string
);
5584 bfd_put_32 (output_bfd
, - plt0_offset
,
5585 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5588 bed
= get_elf_backend_data (output_bfd
);
5589 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5590 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5593 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5595 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5596 asection
*plt
, *got
;
5597 bfd_boolean got_after_plt
;
5598 int32_t got_pcrel_offset
;
5599 const bfd_byte
*got_plt_entry
;
5601 /* Set the entry in the GOT procedure linkage table. */
5602 plt
= htab
->plt_got
;
5603 got
= htab
->elf
.sgot
;
5604 got_offset
= h
->got
.offset
;
5606 if (got_offset
== (bfd_vma
) -1
5607 || h
->type
== STT_GNU_IFUNC
5612 /* Use the second PLT entry template for the GOT PLT since they
5613 are the identical. */
5614 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5615 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5616 if (eh
->has_bnd_reloc
)
5617 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5620 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5622 /* Subtract 1 since there is no BND prefix. */
5623 plt_got_insn_size
-= 1;
5624 plt_got_offset
-= 1;
5627 /* Fill in the entry in the GOT procedure linkage table. */
5628 plt_offset
= eh
->plt_got
.offset
;
5629 memcpy (plt
->contents
+ plt_offset
,
5630 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5632 /* Put offset the PC-relative instruction referring to the GOT
5633 entry, subtracting the size of that instruction. */
5634 got_pcrel_offset
= (got
->output_section
->vma
5635 + got
->output_offset
5637 - plt
->output_section
->vma
5638 - plt
->output_offset
5640 - plt_got_insn_size
);
5642 /* Check PC-relative offset overflow in GOT PLT entry. */
5643 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5644 if ((got_after_plt
&& got_pcrel_offset
< 0)
5645 || (!got_after_plt
&& got_pcrel_offset
> 0))
5646 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5647 output_bfd
, h
->root
.root
.string
);
5649 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5650 plt
->contents
+ plt_offset
+ plt_got_offset
);
5653 if (!local_undefweak
5655 && (h
->plt
.offset
!= (bfd_vma
) -1
5656 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5658 /* Mark the symbol as undefined, rather than as defined in
5659 the .plt section. Leave the value if there were any
5660 relocations where pointer equality matters (this is a clue
5661 for the dynamic linker, to make function pointer
5662 comparisons work between an application and shared
5663 library), otherwise set it to zero. If a function is only
5664 called from a binary, there is no need to slow down
5665 shared libraries because of that. */
5666 sym
->st_shndx
= SHN_UNDEF
;
5667 if (!h
->pointer_equality_needed
)
5671 /* Don't generate dynamic GOT relocation against undefined weak
5672 symbol in executable. */
5673 if (h
->got
.offset
!= (bfd_vma
) -1
5674 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5675 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5676 && !local_undefweak
)
5678 Elf_Internal_Rela rela
;
5680 /* This symbol has an entry in the global offset table. Set it
5682 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5685 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5686 + htab
->elf
.sgot
->output_offset
5687 + (h
->got
.offset
&~ (bfd_vma
) 1));
5689 /* If this is a static link, or it is a -Bsymbolic link and the
5690 symbol is defined locally or was forced to be local because
5691 of a version file, we just want to emit a RELATIVE reloc.
5692 The entry in the global offset table will already have been
5693 initialized in the relocate_section function. */
5695 && h
->type
== STT_GNU_IFUNC
)
5697 if (bfd_link_pic (info
))
5699 /* Generate R_X86_64_GLOB_DAT. */
5706 if (!h
->pointer_equality_needed
)
5709 /* For non-shared object, we can't use .got.plt, which
5710 contains the real function addres if we need pointer
5711 equality. We load the GOT entry with the PLT entry. */
5712 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5713 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5714 + plt
->output_offset
5716 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5720 else if (bfd_link_pic (info
)
5721 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5723 if (!h
->def_regular
)
5725 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5726 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5727 rela
.r_addend
= (h
->root
.u
.def
.value
5728 + h
->root
.u
.def
.section
->output_section
->vma
5729 + h
->root
.u
.def
.section
->output_offset
);
5733 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5735 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5736 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5737 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5741 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5746 Elf_Internal_Rela rela
;
5748 /* This symbol needs a copy reloc. Set it up. */
5750 if (h
->dynindx
== -1
5751 || (h
->root
.type
!= bfd_link_hash_defined
5752 && h
->root
.type
!= bfd_link_hash_defweak
)
5753 || htab
->srelbss
== NULL
)
5756 rela
.r_offset
= (h
->root
.u
.def
.value
5757 + h
->root
.u
.def
.section
->output_section
->vma
5758 + h
->root
.u
.def
.section
->output_offset
);
5759 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5761 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5767 /* Finish up local dynamic symbol handling. We set the contents of
5768 various dynamic sections here. */
5771 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5773 struct elf_link_hash_entry
*h
5774 = (struct elf_link_hash_entry
*) *slot
;
5775 struct bfd_link_info
*info
5776 = (struct bfd_link_info
*) inf
;
5778 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5782 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5783 here since undefined weak symbol may not be dynamic and may not be
5784 called for elf_x86_64_finish_dynamic_symbol. */
5787 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5790 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5791 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5793 if (h
->root
.type
!= bfd_link_hash_undefweak
5794 || h
->dynindx
!= -1)
5797 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5801 /* Used to decide how to sort relocs in an optimal manner for the
5802 dynamic linker, before writing them out. */
5804 static enum elf_reloc_type_class
5805 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5806 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5807 const Elf_Internal_Rela
*rela
)
5809 bfd
*abfd
= info
->output_bfd
;
5810 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5811 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5813 if (htab
->elf
.dynsym
!= NULL
5814 && htab
->elf
.dynsym
->contents
!= NULL
)
5816 /* Check relocation against STT_GNU_IFUNC symbol if there are
5818 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5819 Elf_Internal_Sym sym
;
5820 if (!bed
->s
->swap_symbol_in (abfd
,
5821 (htab
->elf
.dynsym
->contents
5822 + r_symndx
* bed
->s
->sizeof_sym
),
5826 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5827 return reloc_class_ifunc
;
5830 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5832 case R_X86_64_RELATIVE
:
5833 case R_X86_64_RELATIVE64
:
5834 return reloc_class_relative
;
5835 case R_X86_64_JUMP_SLOT
:
5836 return reloc_class_plt
;
5838 return reloc_class_copy
;
5840 return reloc_class_normal
;
5844 /* Finish up the dynamic sections. */
5847 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5848 struct bfd_link_info
*info
)
5850 struct elf_x86_64_link_hash_table
*htab
;
5853 const struct elf_x86_64_backend_data
*abed
;
5855 htab
= elf_x86_64_hash_table (info
);
5859 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5860 section only if there is .plt section. */
5861 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5862 ? &elf_x86_64_bnd_arch_bed
5863 : get_elf_x86_64_backend_data (output_bfd
));
5865 dynobj
= htab
->elf
.dynobj
;
5866 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5868 if (htab
->elf
.dynamic_sections_created
)
5870 bfd_byte
*dyncon
, *dynconend
;
5871 const struct elf_backend_data
*bed
;
5872 bfd_size_type sizeof_dyn
;
5874 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5877 bed
= get_elf_backend_data (dynobj
);
5878 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5879 dyncon
= sdyn
->contents
;
5880 dynconend
= sdyn
->contents
+ sdyn
->size
;
5881 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5883 Elf_Internal_Dyn dyn
;
5886 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5894 s
= htab
->elf
.sgotplt
;
5895 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5899 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5903 s
= htab
->elf
.srelplt
->output_section
;
5904 dyn
.d_un
.d_val
= s
->size
;
5908 /* The procedure linkage table relocs (DT_JMPREL) should
5909 not be included in the overall relocs (DT_RELA).
5910 Therefore, we override the DT_RELASZ entry here to
5911 make it not include the JMPREL relocs. Since the
5912 linker script arranges for .rela.plt to follow all
5913 other relocation sections, we don't have to worry
5914 about changing the DT_RELA entry. */
5915 if (htab
->elf
.srelplt
!= NULL
)
5917 s
= htab
->elf
.srelplt
->output_section
;
5918 dyn
.d_un
.d_val
-= s
->size
;
5922 case DT_TLSDESC_PLT
:
5924 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5925 + htab
->tlsdesc_plt
;
5928 case DT_TLSDESC_GOT
:
5930 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5931 + htab
->tlsdesc_got
;
5935 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5938 /* Fill in the special first entry in the procedure linkage table. */
5939 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5941 /* Fill in the first entry in the procedure linkage table. */
5942 memcpy (htab
->elf
.splt
->contents
,
5943 abed
->plt0_entry
, abed
->plt_entry_size
);
5944 /* Add offset for pushq GOT+8(%rip), since the instruction
5945 uses 6 bytes subtract this value. */
5946 bfd_put_32 (output_bfd
,
5947 (htab
->elf
.sgotplt
->output_section
->vma
5948 + htab
->elf
.sgotplt
->output_offset
5950 - htab
->elf
.splt
->output_section
->vma
5951 - htab
->elf
.splt
->output_offset
5953 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5954 /* Add offset for the PC-relative instruction accessing GOT+16,
5955 subtracting the offset to the end of that instruction. */
5956 bfd_put_32 (output_bfd
,
5957 (htab
->elf
.sgotplt
->output_section
->vma
5958 + htab
->elf
.sgotplt
->output_offset
5960 - htab
->elf
.splt
->output_section
->vma
5961 - htab
->elf
.splt
->output_offset
5962 - abed
->plt0_got2_insn_end
),
5963 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5965 elf_section_data (htab
->elf
.splt
->output_section
)
5966 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5968 if (htab
->tlsdesc_plt
)
5970 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5971 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5973 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5974 abed
->plt0_entry
, abed
->plt_entry_size
);
5976 /* Add offset for pushq GOT+8(%rip), since the
5977 instruction uses 6 bytes subtract this value. */
5978 bfd_put_32 (output_bfd
,
5979 (htab
->elf
.sgotplt
->output_section
->vma
5980 + htab
->elf
.sgotplt
->output_offset
5982 - htab
->elf
.splt
->output_section
->vma
5983 - htab
->elf
.splt
->output_offset
5986 htab
->elf
.splt
->contents
5987 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5988 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5989 where TGD stands for htab->tlsdesc_got, subtracting the offset
5990 to the end of that instruction. */
5991 bfd_put_32 (output_bfd
,
5992 (htab
->elf
.sgot
->output_section
->vma
5993 + htab
->elf
.sgot
->output_offset
5995 - htab
->elf
.splt
->output_section
->vma
5996 - htab
->elf
.splt
->output_offset
5998 - abed
->plt0_got2_insn_end
),
5999 htab
->elf
.splt
->contents
6000 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6005 if (htab
->plt_bnd
!= NULL
)
6006 elf_section_data (htab
->plt_bnd
->output_section
)
6007 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6009 if (htab
->elf
.sgotplt
)
6011 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6013 (*_bfd_error_handler
)
6014 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6018 /* Fill in the first three entries in the global offset table. */
6019 if (htab
->elf
.sgotplt
->size
> 0)
6021 /* Set the first entry in the global offset table to the address of
6022 the dynamic section. */
6024 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6026 bfd_put_64 (output_bfd
,
6027 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6028 htab
->elf
.sgotplt
->contents
);
6029 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6030 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6031 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6034 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6038 /* Adjust .eh_frame for .plt section. */
6039 if (htab
->plt_eh_frame
!= NULL
6040 && htab
->plt_eh_frame
->contents
!= NULL
)
6042 if (htab
->elf
.splt
!= NULL
6043 && htab
->elf
.splt
->size
!= 0
6044 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6045 && htab
->elf
.splt
->output_section
!= NULL
6046 && htab
->plt_eh_frame
->output_section
!= NULL
)
6048 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6049 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6050 + htab
->plt_eh_frame
->output_offset
6051 + PLT_FDE_START_OFFSET
;
6052 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6053 htab
->plt_eh_frame
->contents
6054 + PLT_FDE_START_OFFSET
);
6056 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6058 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6060 htab
->plt_eh_frame
->contents
))
6065 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6066 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6069 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6070 htab_traverse (htab
->loc_hash_table
,
6071 elf_x86_64_finish_local_dynamic_symbol
,
6074 /* Fill PLT entries for undefined weak symbols in PIE. */
6075 if (bfd_link_pie (info
))
6076 bfd_hash_traverse (&info
->hash
->table
,
6077 elf_x86_64_pie_finish_undefweak_symbol
,
6083 /* Return an array of PLT entry symbol values. */
6086 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6089 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6092 bfd_vma
*plt_sym_val
;
6094 bfd_byte
*plt_contents
;
6095 const struct elf_x86_64_backend_data
*bed
;
6096 Elf_Internal_Shdr
*hdr
;
6099 /* Get the .plt section contents. PLT passed down may point to the
6100 .plt.bnd section. Make sure that PLT always points to the .plt
6102 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6107 plt
= bfd_get_section_by_name (abfd
, ".plt");
6110 bed
= &elf_x86_64_bnd_arch_bed
;
6113 bed
= get_elf_x86_64_backend_data (abfd
);
6115 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6116 if (plt_contents
== NULL
)
6118 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6119 plt_contents
, 0, plt
->size
))
6122 free (plt_contents
);
6126 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6127 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6130 hdr
= &elf_section_data (relplt
)->this_hdr
;
6131 count
= relplt
->size
/ hdr
->sh_entsize
;
6133 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6134 if (plt_sym_val
== NULL
)
6137 for (i
= 0; i
< count
; i
++)
6138 plt_sym_val
[i
] = -1;
6140 plt_offset
= bed
->plt_entry_size
;
6141 p
= relplt
->relocation
;
6142 for (i
= 0; i
< count
; i
++, p
++)
6146 /* Skip unknown relocation. */
6147 if (p
->howto
== NULL
)
6150 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6151 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6154 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6155 + bed
->plt_reloc_offset
));
6156 if (reloc_index
< count
)
6160 /* This is the index in .plt section. */
6161 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6162 /* Store VMA + the offset in .plt.bnd section. */
6163 plt_sym_val
[reloc_index
] =
6165 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6168 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6170 plt_offset
+= bed
->plt_entry_size
;
6172 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6174 if (plt_offset
>= plt
->size
)
6178 free (plt_contents
);
6183 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6187 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6194 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6195 as PLT if it exists. */
6196 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6198 plt
= bfd_get_section_by_name (abfd
, ".plt");
6199 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6200 dynsymcount
, dynsyms
, ret
,
6202 elf_x86_64_get_plt_sym_val
);
6205 /* Handle an x86-64 specific section when reading an object file. This
6206 is called when elfcode.h finds a section with an unknown type. */
6209 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6210 const char *name
, int shindex
)
6212 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6215 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6221 /* Hook called by the linker routine which adds symbols from an object
6222 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6226 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6227 struct bfd_link_info
*info
,
6228 Elf_Internal_Sym
*sym
,
6229 const char **namep ATTRIBUTE_UNUSED
,
6230 flagword
*flagsp ATTRIBUTE_UNUSED
,
6236 switch (sym
->st_shndx
)
6238 case SHN_X86_64_LCOMMON
:
6239 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6242 lcomm
= bfd_make_section_with_flags (abfd
,
6246 | SEC_LINKER_CREATED
));
6249 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6252 *valp
= sym
->st_size
;
6256 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6257 && (abfd
->flags
& DYNAMIC
) == 0
6258 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6259 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6260 |= elf_gnu_symbol_unique
;
6266 /* Given a BFD section, try to locate the corresponding ELF section
6270 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6271 asection
*sec
, int *index_return
)
6273 if (sec
== &_bfd_elf_large_com_section
)
6275 *index_return
= SHN_X86_64_LCOMMON
;
6281 /* Process a symbol. */
6284 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6287 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6289 switch (elfsym
->internal_elf_sym
.st_shndx
)
6291 case SHN_X86_64_LCOMMON
:
6292 asym
->section
= &_bfd_elf_large_com_section
;
6293 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6294 /* Common symbol doesn't set BSF_GLOBAL. */
6295 asym
->flags
&= ~BSF_GLOBAL
;
6301 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6303 return (sym
->st_shndx
== SHN_COMMON
6304 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6308 elf_x86_64_common_section_index (asection
*sec
)
6310 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6313 return SHN_X86_64_LCOMMON
;
6317 elf_x86_64_common_section (asection
*sec
)
6319 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6320 return bfd_com_section_ptr
;
6322 return &_bfd_elf_large_com_section
;
6326 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6327 const Elf_Internal_Sym
*sym
,
6332 const asection
*oldsec
)
6334 /* A normal common symbol and a large common symbol result in a
6335 normal common symbol. We turn the large common symbol into a
6338 && h
->root
.type
== bfd_link_hash_common
6340 && bfd_is_com_section (*psec
)
6343 if (sym
->st_shndx
== SHN_COMMON
6344 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6346 h
->root
.u
.c
.p
->section
6347 = bfd_make_section_old_way (oldbfd
, "COMMON");
6348 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6350 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6351 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6352 *psec
= bfd_com_section_ptr
;
6359 elf_x86_64_additional_program_headers (bfd
*abfd
,
6360 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6365 /* Check to see if we need a large readonly segment. */
6366 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6367 if (s
&& (s
->flags
& SEC_LOAD
))
6370 /* Check to see if we need a large data segment. Since .lbss sections
6371 is placed right after the .bss section, there should be no need for
6372 a large data segment just because of .lbss. */
6373 s
= bfd_get_section_by_name (abfd
, ".ldata");
6374 if (s
&& (s
->flags
& SEC_LOAD
))
6380 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6383 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6385 if (h
->plt
.offset
!= (bfd_vma
) -1
6387 && !h
->pointer_equality_needed
)
6390 return _bfd_elf_hash_symbol (h
);
6393 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6396 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6397 const bfd_target
*output
)
6399 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6400 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6401 && _bfd_elf_relocs_compatible (input
, output
));
6404 static const struct bfd_elf_special_section
6405 elf_x86_64_special_sections
[]=
6407 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6408 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6409 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6410 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6411 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6412 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6413 { NULL
, 0, 0, 0, 0 }
6416 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6417 #define TARGET_LITTLE_NAME "elf64-x86-64"
6418 #define ELF_ARCH bfd_arch_i386
6419 #define ELF_TARGET_ID X86_64_ELF_DATA
6420 #define ELF_MACHINE_CODE EM_X86_64
6421 #define ELF_MAXPAGESIZE 0x200000
6422 #define ELF_MINPAGESIZE 0x1000
6423 #define ELF_COMMONPAGESIZE 0x1000
6425 #define elf_backend_can_gc_sections 1
6426 #define elf_backend_can_refcount 1
6427 #define elf_backend_want_got_plt 1
6428 #define elf_backend_plt_readonly 1
6429 #define elf_backend_want_plt_sym 0
6430 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6431 #define elf_backend_rela_normal 1
6432 #define elf_backend_plt_alignment 4
6433 #define elf_backend_extern_protected_data 1
6435 #define elf_info_to_howto elf_x86_64_info_to_howto
6437 #define bfd_elf64_bfd_link_hash_table_create \
6438 elf_x86_64_link_hash_table_create
6439 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6440 #define bfd_elf64_bfd_reloc_name_lookup \
6441 elf_x86_64_reloc_name_lookup
6443 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6444 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6445 #define elf_backend_check_relocs elf_x86_64_check_relocs
6446 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6447 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6448 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6449 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6450 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6451 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6452 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6454 #define elf_backend_write_core_note elf_x86_64_write_core_note
6456 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6457 #define elf_backend_relocate_section elf_x86_64_relocate_section
6458 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6459 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6460 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6461 #define elf_backend_object_p elf64_x86_64_elf_object_p
6462 #define bfd_elf64_mkobject elf_x86_64_mkobject
6463 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6465 #define elf_backend_section_from_shdr \
6466 elf_x86_64_section_from_shdr
6468 #define elf_backend_section_from_bfd_section \
6469 elf_x86_64_elf_section_from_bfd_section
6470 #define elf_backend_add_symbol_hook \
6471 elf_x86_64_add_symbol_hook
6472 #define elf_backend_symbol_processing \
6473 elf_x86_64_symbol_processing
6474 #define elf_backend_common_section_index \
6475 elf_x86_64_common_section_index
6476 #define elf_backend_common_section \
6477 elf_x86_64_common_section
6478 #define elf_backend_common_definition \
6479 elf_x86_64_common_definition
6480 #define elf_backend_merge_symbol \
6481 elf_x86_64_merge_symbol
6482 #define elf_backend_special_sections \
6483 elf_x86_64_special_sections
6484 #define elf_backend_additional_program_headers \
6485 elf_x86_64_additional_program_headers
6486 #define elf_backend_hash_symbol \
6487 elf_x86_64_hash_symbol
6488 #define elf_backend_omit_section_dynsym \
6489 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6490 #define elf_backend_fixup_symbol \
6491 elf_x86_64_fixup_symbol
6493 #include "elf64-target.h"
6495 /* CloudABI support. */
6497 #undef TARGET_LITTLE_SYM
6498 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6499 #undef TARGET_LITTLE_NAME
6500 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6503 #define ELF_OSABI ELFOSABI_CLOUDABI
6506 #define elf64_bed elf64_x86_64_cloudabi_bed
6508 #include "elf64-target.h"
6510 /* FreeBSD support. */
6512 #undef TARGET_LITTLE_SYM
6513 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6514 #undef TARGET_LITTLE_NAME
6515 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6518 #define ELF_OSABI ELFOSABI_FREEBSD
6521 #define elf64_bed elf64_x86_64_fbsd_bed
6523 #include "elf64-target.h"
6525 /* Solaris 2 support. */
6527 #undef TARGET_LITTLE_SYM
6528 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6529 #undef TARGET_LITTLE_NAME
6530 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6532 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6533 objects won't be recognized. */
6537 #define elf64_bed elf64_x86_64_sol2_bed
6539 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6541 #undef elf_backend_static_tls_alignment
6542 #define elf_backend_static_tls_alignment 16
6544 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6546 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6548 #undef elf_backend_want_plt_sym
6549 #define elf_backend_want_plt_sym 1
6551 #undef elf_backend_strtab_flags
6552 #define elf_backend_strtab_flags SHF_STRINGS
6555 elf64_x86_64_set_special_info_link (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6556 bfd
*obfd ATTRIBUTE_UNUSED
,
6557 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6558 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6560 /* PR 19938: FIXME: Need to add code for setting the sh_info
6561 and sh_link fields of Solaris specific section types. */
6565 #undef elf_backend_set_special_section_info_and_link
6566 #define elf_backend_set_special_section_info_and_link elf64_x86_64_set_special_info_link
6568 #include "elf64-target.h"
6570 /* Native Client support. */
6573 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6575 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6576 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6580 #undef TARGET_LITTLE_SYM
6581 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6582 #undef TARGET_LITTLE_NAME
6583 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6585 #define elf64_bed elf64_x86_64_nacl_bed
6587 #undef ELF_MAXPAGESIZE
6588 #undef ELF_MINPAGESIZE
6589 #undef ELF_COMMONPAGESIZE
6590 #define ELF_MAXPAGESIZE 0x10000
6591 #define ELF_MINPAGESIZE 0x10000
6592 #define ELF_COMMONPAGESIZE 0x10000
6594 /* Restore defaults. */
6596 #undef elf_backend_static_tls_alignment
6597 #undef elf_backend_want_plt_sym
6598 #define elf_backend_want_plt_sym 0
6599 #undef elf_backend_strtab_flags
6600 #undef elf_backend_set_special_section_info_and_link
6602 /* NaCl uses substantially different PLT entries for the same effects. */
6604 #undef elf_backend_plt_alignment
6605 #define elf_backend_plt_alignment 5
6606 #define NACL_PLT_ENTRY_SIZE 64
6607 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6609 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6611 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6612 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6613 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6614 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6615 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6617 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6618 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6620 /* 32 bytes of nop to pad out to the standard size. */
6621 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6622 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6623 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6624 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6625 0x66, /* excess data32 prefix */
6629 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6631 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6632 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6633 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6634 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6636 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6637 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6638 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6640 /* Lazy GOT entries point here (32-byte aligned). */
6641 0x68, /* pushq immediate */
6642 0, 0, 0, 0, /* replaced with index into relocation table. */
6643 0xe9, /* jmp relative */
6644 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6646 /* 22 bytes of nop to pad out to the standard size. */
6647 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6648 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6649 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6652 /* .eh_frame covering the .plt section. */
6654 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6656 #if (PLT_CIE_LENGTH != 20 \
6657 || PLT_FDE_LENGTH != 36 \
6658 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6659 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6660 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6662 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6663 0, 0, 0, 0, /* CIE ID */
6664 1, /* CIE version */
6665 'z', 'R', 0, /* Augmentation string */
6666 1, /* Code alignment factor */
6667 0x78, /* Data alignment factor */
6668 16, /* Return address column */
6669 1, /* Augmentation size */
6670 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6671 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6672 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6673 DW_CFA_nop
, DW_CFA_nop
,
6675 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6676 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6677 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6678 0, 0, 0, 0, /* .plt size goes here */
6679 0, /* Augmentation size */
6680 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6681 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6682 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6683 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6684 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6685 13, /* Block length */
6686 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6687 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6688 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6689 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6690 DW_CFA_nop
, DW_CFA_nop
6693 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6695 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6696 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6697 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6698 2, /* plt0_got1_offset */
6699 9, /* plt0_got2_offset */
6700 13, /* plt0_got2_insn_end */
6701 3, /* plt_got_offset */
6702 33, /* plt_reloc_offset */
6703 38, /* plt_plt_offset */
6704 7, /* plt_got_insn_size */
6705 42, /* plt_plt_insn_end */
6706 32, /* plt_lazy_offset */
6707 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6708 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6711 #undef elf_backend_arch_data
6712 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6714 #undef elf_backend_object_p
6715 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6716 #undef elf_backend_modify_segment_map
6717 #define elf_backend_modify_segment_map nacl_modify_segment_map
6718 #undef elf_backend_modify_program_headers
6719 #define elf_backend_modify_program_headers nacl_modify_program_headers
6720 #undef elf_backend_final_write_processing
6721 #define elf_backend_final_write_processing nacl_final_write_processing
6723 #include "elf64-target.h"
6725 /* Native Client x32 support. */
6728 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6730 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6731 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6735 #undef TARGET_LITTLE_SYM
6736 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6737 #undef TARGET_LITTLE_NAME
6738 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6740 #define elf32_bed elf32_x86_64_nacl_bed
6742 #define bfd_elf32_bfd_link_hash_table_create \
6743 elf_x86_64_link_hash_table_create
6744 #define bfd_elf32_bfd_reloc_type_lookup \
6745 elf_x86_64_reloc_type_lookup
6746 #define bfd_elf32_bfd_reloc_name_lookup \
6747 elf_x86_64_reloc_name_lookup
6748 #define bfd_elf32_mkobject \
6750 #define bfd_elf32_get_synthetic_symtab \
6751 elf_x86_64_get_synthetic_symtab
6753 #undef elf_backend_object_p
6754 #define elf_backend_object_p \
6755 elf32_x86_64_nacl_elf_object_p
6757 #undef elf_backend_bfd_from_remote_memory
6758 #define elf_backend_bfd_from_remote_memory \
6759 _bfd_elf32_bfd_from_remote_memory
6761 #undef elf_backend_size_info
6762 #define elf_backend_size_info \
6763 _bfd_elf32_size_info
6765 #include "elf32-target.h"
6767 /* Restore defaults. */
6768 #undef elf_backend_object_p
6769 #define elf_backend_object_p elf64_x86_64_elf_object_p
6770 #undef elf_backend_bfd_from_remote_memory
6771 #undef elf_backend_size_info
6772 #undef elf_backend_modify_segment_map
6773 #undef elf_backend_modify_program_headers
6774 #undef elf_backend_final_write_processing
6776 /* Intel L1OM support. */
6779 elf64_l1om_elf_object_p (bfd
*abfd
)
6781 /* Set the right machine number for an L1OM elf64 file. */
6782 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6786 #undef TARGET_LITTLE_SYM
6787 #define TARGET_LITTLE_SYM l1om_elf64_vec
6788 #undef TARGET_LITTLE_NAME
6789 #define TARGET_LITTLE_NAME "elf64-l1om"
6791 #define ELF_ARCH bfd_arch_l1om
6793 #undef ELF_MACHINE_CODE
6794 #define ELF_MACHINE_CODE EM_L1OM
6799 #define elf64_bed elf64_l1om_bed
6801 #undef elf_backend_object_p
6802 #define elf_backend_object_p elf64_l1om_elf_object_p
6804 /* Restore defaults. */
6805 #undef ELF_MAXPAGESIZE
6806 #undef ELF_MINPAGESIZE
6807 #undef ELF_COMMONPAGESIZE
6808 #define ELF_MAXPAGESIZE 0x200000
6809 #define ELF_MINPAGESIZE 0x1000
6810 #define ELF_COMMONPAGESIZE 0x1000
6811 #undef elf_backend_plt_alignment
6812 #define elf_backend_plt_alignment 4
6813 #undef elf_backend_arch_data
6814 #define elf_backend_arch_data &elf_x86_64_arch_bed
6816 #include "elf64-target.h"
6818 /* FreeBSD L1OM support. */
6820 #undef TARGET_LITTLE_SYM
6821 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6822 #undef TARGET_LITTLE_NAME
6823 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6826 #define ELF_OSABI ELFOSABI_FREEBSD
6829 #define elf64_bed elf64_l1om_fbsd_bed
6831 #include "elf64-target.h"
6833 /* Intel K1OM support. */
6836 elf64_k1om_elf_object_p (bfd
*abfd
)
6838 /* Set the right machine number for an K1OM elf64 file. */
6839 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6843 #undef TARGET_LITTLE_SYM
6844 #define TARGET_LITTLE_SYM k1om_elf64_vec
6845 #undef TARGET_LITTLE_NAME
6846 #define TARGET_LITTLE_NAME "elf64-k1om"
6848 #define ELF_ARCH bfd_arch_k1om
6850 #undef ELF_MACHINE_CODE
6851 #define ELF_MACHINE_CODE EM_K1OM
6856 #define elf64_bed elf64_k1om_bed
6858 #undef elf_backend_object_p
6859 #define elf_backend_object_p elf64_k1om_elf_object_p
6861 #undef elf_backend_static_tls_alignment
6863 #undef elf_backend_want_plt_sym
6864 #define elf_backend_want_plt_sym 0
6866 #include "elf64-target.h"
6868 /* FreeBSD K1OM support. */
6870 #undef TARGET_LITTLE_SYM
6871 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6872 #undef TARGET_LITTLE_NAME
6873 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6876 #define ELF_OSABI ELFOSABI_FREEBSD
6879 #define elf64_bed elf64_k1om_fbsd_bed
6881 #include "elf64-target.h"
6883 /* 32bit x86-64 support. */
6885 #undef TARGET_LITTLE_SYM
6886 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6887 #undef TARGET_LITTLE_NAME
6888 #define TARGET_LITTLE_NAME "elf32-x86-64"
6892 #define ELF_ARCH bfd_arch_i386
6894 #undef ELF_MACHINE_CODE
6895 #define ELF_MACHINE_CODE EM_X86_64
6899 #undef elf_backend_object_p
6900 #define elf_backend_object_p \
6901 elf32_x86_64_elf_object_p
6903 #undef elf_backend_bfd_from_remote_memory
6904 #define elf_backend_bfd_from_remote_memory \
6905 _bfd_elf32_bfd_from_remote_memory
6907 #undef elf_backend_size_info
6908 #define elf_backend_size_info \
6909 _bfd_elf32_size_info
6911 #include "elf32-target.h"