1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 /* Set the contents of the .interp section to the interpreter. */
1113 if (bfd_link_executable (info
) && !info
->nointerp
)
1115 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1118 s
->size
= htab
->dynamic_interpreter_size
;
1119 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1123 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1127 if (bfd_link_executable (info
))
1129 /* Always allow copy relocs for building executables. */
1130 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1133 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1134 s
= bfd_make_section_anyway_with_flags (dynobj
,
1136 (bed
->dynamic_sec_flags
1139 || ! bfd_set_section_alignment (dynobj
, s
,
1140 bed
->s
->log_file_align
))
1146 if (!info
->no_ld_generated_unwind_info
1147 && htab
->plt_eh_frame
== NULL
1148 && htab
->elf
.splt
!= NULL
)
1150 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1151 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1152 | SEC_LINKER_CREATED
);
1154 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1155 if (htab
->plt_eh_frame
== NULL
1156 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1162 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1165 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1166 struct elf_link_hash_entry
*dir
,
1167 struct elf_link_hash_entry
*ind
)
1169 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1171 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1172 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1174 if (!edir
->has_bnd_reloc
)
1175 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1177 if (!edir
->has_got_reloc
)
1178 edir
->has_got_reloc
= eind
->has_got_reloc
;
1180 if (!edir
->has_non_got_reloc
)
1181 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1183 if (eind
->dyn_relocs
!= NULL
)
1185 if (edir
->dyn_relocs
!= NULL
)
1187 struct elf_dyn_relocs
**pp
;
1188 struct elf_dyn_relocs
*p
;
1190 /* Add reloc counts against the indirect sym to the direct sym
1191 list. Merge any entries against the same section. */
1192 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1194 struct elf_dyn_relocs
*q
;
1196 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1197 if (q
->sec
== p
->sec
)
1199 q
->pc_count
+= p
->pc_count
;
1200 q
->count
+= p
->count
;
1207 *pp
= edir
->dyn_relocs
;
1210 edir
->dyn_relocs
= eind
->dyn_relocs
;
1211 eind
->dyn_relocs
= NULL
;
1214 if (ind
->root
.type
== bfd_link_hash_indirect
1215 && dir
->got
.refcount
<= 0)
1217 edir
->tls_type
= eind
->tls_type
;
1218 eind
->tls_type
= GOT_UNKNOWN
;
1221 if (ELIMINATE_COPY_RELOCS
1222 && ind
->root
.type
!= bfd_link_hash_indirect
1223 && dir
->dynamic_adjusted
)
1225 /* If called to transfer flags for a weakdef during processing
1226 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1227 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1228 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1229 dir
->ref_regular
|= ind
->ref_regular
;
1230 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1231 dir
->needs_plt
|= ind
->needs_plt
;
1232 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1236 if (eind
->func_pointer_refcount
> 0)
1238 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1239 eind
->func_pointer_refcount
= 0;
1242 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1247 elf64_x86_64_elf_object_p (bfd
*abfd
)
1249 /* Set the right machine number for an x86-64 elf64 file. */
1250 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1255 elf32_x86_64_elf_object_p (bfd
*abfd
)
1257 /* Set the right machine number for an x86-64 elf32 file. */
1258 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1262 /* Return TRUE if the TLS access code sequence support transition
1266 elf_x86_64_check_tls_transition (bfd
*abfd
,
1267 struct bfd_link_info
*info
,
1270 Elf_Internal_Shdr
*symtab_hdr
,
1271 struct elf_link_hash_entry
**sym_hashes
,
1272 unsigned int r_type
,
1273 const Elf_Internal_Rela
*rel
,
1274 const Elf_Internal_Rela
*relend
)
1277 unsigned long r_symndx
;
1278 bfd_boolean largepic
= FALSE
;
1279 struct elf_link_hash_entry
*h
;
1281 struct elf_x86_64_link_hash_table
*htab
;
1283 htab
= elf_x86_64_hash_table (info
);
1284 offset
= rel
->r_offset
;
1287 case R_X86_64_TLSGD
:
1288 case R_X86_64_TLSLD
:
1289 if ((rel
+ 1) >= relend
)
1292 if (r_type
== R_X86_64_TLSGD
)
1294 /* Check transition from GD access model. For 64bit, only
1295 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1296 .word 0x6666; rex64; call __tls_get_addr
1297 can transit to different access model. For 32bit, only
1298 leaq foo@tlsgd(%rip), %rdi
1299 .word 0x6666; rex64; call __tls_get_addr
1300 can transit to different access model. For largepic
1302 leaq foo@tlsgd(%rip), %rdi
1303 movabsq $__tls_get_addr@pltoff, %rax
1307 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1308 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1310 if ((offset
+ 12) > sec
->size
)
1313 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1315 if (!ABI_64_P (abfd
)
1316 || (offset
+ 19) > sec
->size
1318 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1319 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1320 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1325 else if (ABI_64_P (abfd
))
1328 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1334 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1340 /* Check transition from LD access model. Only
1341 leaq foo@tlsld(%rip), %rdi;
1343 can transit to different access model. For largepic
1345 leaq foo@tlsld(%rip), %rdi
1346 movabsq $__tls_get_addr@pltoff, %rax
1350 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1352 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1355 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1358 if (0xe8 != *(contents
+ offset
+ 4))
1360 if (!ABI_64_P (abfd
)
1361 || (offset
+ 19) > sec
->size
1362 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1363 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1370 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1371 if (r_symndx
< symtab_hdr
->sh_info
)
1374 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1375 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1376 may be versioned. */
1378 && h
->root
.root
.string
!= NULL
1380 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1381 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1382 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1383 && (strncmp (h
->root
.root
.string
,
1384 "__tls_get_addr", 14) == 0));
1386 case R_X86_64_GOTTPOFF
:
1387 /* Check transition from IE access model:
1388 mov foo@gottpoff(%rip), %reg
1389 add foo@gottpoff(%rip), %reg
1392 /* Check REX prefix first. */
1393 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1395 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1396 if (val
!= 0x48 && val
!= 0x4c)
1398 /* X32 may have 0x44 REX prefix or no REX prefix. */
1399 if (ABI_64_P (abfd
))
1405 /* X32 may not have any REX prefix. */
1406 if (ABI_64_P (abfd
))
1408 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1412 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1413 if (val
!= 0x8b && val
!= 0x03)
1416 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1417 return (val
& 0xc7) == 5;
1419 case R_X86_64_GOTPC32_TLSDESC
:
1420 /* Check transition from GDesc access model:
1421 leaq x@tlsdesc(%rip), %rax
1423 Make sure it's a leaq adding rip to a 32-bit offset
1424 into any register, although it's probably almost always
1427 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1430 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1431 if ((val
& 0xfb) != 0x48)
1434 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1437 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1438 return (val
& 0xc7) == 0x05;
1440 case R_X86_64_TLSDESC_CALL
:
1441 /* Check transition from GDesc access model:
1442 call *x@tlsdesc(%rax)
1444 if (offset
+ 2 <= sec
->size
)
1446 /* Make sure that it's a call *x@tlsdesc(%rax). */
1447 static const unsigned char call
[] = { 0xff, 0x10 };
1448 return memcmp (contents
+ offset
, call
, 2) == 0;
1458 /* Return TRUE if the TLS access transition is OK or no transition
1459 will be performed. Update R_TYPE if there is a transition. */
1462 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1463 asection
*sec
, bfd_byte
*contents
,
1464 Elf_Internal_Shdr
*symtab_hdr
,
1465 struct elf_link_hash_entry
**sym_hashes
,
1466 unsigned int *r_type
, int tls_type
,
1467 const Elf_Internal_Rela
*rel
,
1468 const Elf_Internal_Rela
*relend
,
1469 struct elf_link_hash_entry
*h
,
1470 unsigned long r_symndx
,
1471 bfd_boolean from_relocate_section
)
1473 unsigned int from_type
= *r_type
;
1474 unsigned int to_type
= from_type
;
1475 bfd_boolean check
= TRUE
;
1477 /* Skip TLS transition for functions. */
1479 && (h
->type
== STT_FUNC
1480 || h
->type
== STT_GNU_IFUNC
))
1485 case R_X86_64_TLSGD
:
1486 case R_X86_64_GOTPC32_TLSDESC
:
1487 case R_X86_64_TLSDESC_CALL
:
1488 case R_X86_64_GOTTPOFF
:
1489 if (bfd_link_executable (info
))
1492 to_type
= R_X86_64_TPOFF32
;
1494 to_type
= R_X86_64_GOTTPOFF
;
1497 /* When we are called from elf_x86_64_relocate_section, there may
1498 be additional transitions based on TLS_TYPE. */
1499 if (from_relocate_section
)
1501 unsigned int new_to_type
= to_type
;
1503 if (bfd_link_executable (info
)
1506 && tls_type
== GOT_TLS_IE
)
1507 new_to_type
= R_X86_64_TPOFF32
;
1509 if (to_type
== R_X86_64_TLSGD
1510 || to_type
== R_X86_64_GOTPC32_TLSDESC
1511 || to_type
== R_X86_64_TLSDESC_CALL
)
1513 if (tls_type
== GOT_TLS_IE
)
1514 new_to_type
= R_X86_64_GOTTPOFF
;
1517 /* We checked the transition before when we were called from
1518 elf_x86_64_check_relocs. We only want to check the new
1519 transition which hasn't been checked before. */
1520 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1521 to_type
= new_to_type
;
1526 case R_X86_64_TLSLD
:
1527 if (bfd_link_executable (info
))
1528 to_type
= R_X86_64_TPOFF32
;
1535 /* Return TRUE if there is no transition. */
1536 if (from_type
== to_type
)
1539 /* Check if the transition can be performed. */
1541 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1542 symtab_hdr
, sym_hashes
,
1543 from_type
, rel
, relend
))
1545 reloc_howto_type
*from
, *to
;
1548 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1549 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1552 name
= h
->root
.root
.string
;
1555 struct elf_x86_64_link_hash_table
*htab
;
1557 htab
= elf_x86_64_hash_table (info
);
1562 Elf_Internal_Sym
*isym
;
1564 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1566 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1570 (*_bfd_error_handler
)
1571 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1572 "in section `%A' failed"),
1573 abfd
, sec
, from
->name
, to
->name
, name
,
1574 (unsigned long) rel
->r_offset
);
1575 bfd_set_error (bfd_error_bad_value
);
1583 /* Rename some of the generic section flags to better document how they
1585 #define need_convert_load sec_flg0
1586 #define check_relocs_failed sec_flg1
1589 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1590 struct elf_link_hash_entry
*h
,
1591 Elf_Internal_Shdr
*symtab_hdr
,
1592 Elf_Internal_Sym
*isym
,
1593 reloc_howto_type
*howto
)
1596 const char *und
= "";
1597 const char *pic
= "";
1602 name
= h
->root
.root
.string
;
1603 switch (ELF_ST_VISIBILITY (h
->other
))
1606 v
= _("hidden symbol ");
1609 v
= _("internal symbol ");
1612 v
= _("protected symbol ");
1616 pic
= _("; recompile with -fPIC");
1620 if (!h
->def_regular
&& !h
->def_dynamic
)
1621 und
= _("undefined ");
1625 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1626 pic
= _("; recompile with -fPIC");
1629 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1630 "not be used when making a shared object%s"),
1631 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1632 bfd_set_error (bfd_error_bad_value
);
1633 sec
->check_relocs_failed
= 1;
1637 /* With the local symbol, foo, we convert
1638 mov foo@GOTPCREL(%rip), %reg
1642 call/jmp *foo@GOTPCREL(%rip)
1644 nop call foo/jmp foo nop
1645 When PIC is false, convert
1646 test %reg, foo@GOTPCREL(%rip)
1650 binop foo@GOTPCREL(%rip), %reg
1653 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1657 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1659 Elf_Internal_Rela
*irel
,
1660 struct elf_link_hash_entry
*h
,
1661 bfd_boolean
*converted
,
1662 struct bfd_link_info
*link_info
)
1664 struct elf_x86_64_link_hash_table
*htab
;
1666 bfd_boolean require_reloc_pc32
;
1668 bfd_boolean to_reloc_pc32
;
1671 bfd_signed_vma raddend
;
1672 unsigned int opcode
;
1674 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1675 unsigned int r_symndx
;
1677 bfd_vma roff
= irel
->r_offset
;
1679 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1682 raddend
= irel
->r_addend
;
1683 /* Addend for 32-bit PC-relative relocation must be -4. */
1687 htab
= elf_x86_64_hash_table (link_info
);
1688 is_pic
= bfd_link_pic (link_info
);
1690 relocx
= (r_type
== R_X86_64_GOTPCRELX
1691 || r_type
== R_X86_64_REX_GOTPCRELX
);
1693 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1696 = link_info
->disable_target_specific_optimizations
> 1;
1698 r_symndx
= htab
->r_sym (irel
->r_info
);
1700 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1702 /* Convert mov to lea since it has been done for a while. */
1705 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1706 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1707 test, xor instructions. */
1712 /* We convert only to R_X86_64_PC32:
1714 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1715 3. require_reloc_pc32 is true.
1718 to_reloc_pc32
= (opcode
== 0xff
1720 || require_reloc_pc32
1723 /* Get the symbol referred to by the reloc. */
1726 Elf_Internal_Sym
*isym
1727 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1729 /* Skip relocation against undefined symbols. */
1730 if (isym
->st_shndx
== SHN_UNDEF
)
1733 symtype
= ELF_ST_TYPE (isym
->st_info
);
1735 if (isym
->st_shndx
== SHN_ABS
)
1736 tsec
= bfd_abs_section_ptr
;
1737 else if (isym
->st_shndx
== SHN_COMMON
)
1738 tsec
= bfd_com_section_ptr
;
1739 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1740 tsec
= &_bfd_elf_large_com_section
;
1742 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1744 toff
= isym
->st_value
;
1748 /* Undefined weak symbol is only bound locally in executable
1749 and its reference is resolved as 0 without relocation
1750 overflow. We can only perform this optimization for
1751 GOTPCRELX relocations since we need to modify REX byte.
1752 It is OK convert mov with R_X86_64_GOTPCREL to
1754 if ((relocx
|| opcode
== 0x8b)
1755 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1757 elf_x86_64_hash_entry (h
)))
1761 /* Skip for branch instructions since R_X86_64_PC32
1763 if (require_reloc_pc32
)
1768 /* For non-branch instructions, we can convert to
1769 R_X86_64_32/R_X86_64_32S since we know if there
1771 to_reloc_pc32
= FALSE
;
1774 /* Since we don't know the current PC when PIC is true,
1775 we can't convert to R_X86_64_PC32. */
1776 if (to_reloc_pc32
&& is_pic
)
1781 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1782 ld.so may use its link-time address. */
1783 else if ((h
->def_regular
1784 || h
->root
.type
== bfd_link_hash_defined
1785 || h
->root
.type
== bfd_link_hash_defweak
)
1786 && h
!= htab
->elf
.hdynamic
1787 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1789 /* bfd_link_hash_new or bfd_link_hash_undefined is
1790 set by an assignment in a linker script in
1791 bfd_elf_record_link_assignment. */
1793 && (h
->root
.type
== bfd_link_hash_new
1794 || h
->root
.type
== bfd_link_hash_undefined
))
1796 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1797 if (require_reloc_pc32
)
1801 tsec
= h
->root
.u
.def
.section
;
1802 toff
= h
->root
.u
.def
.value
;
1809 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1813 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1815 /* At this stage in linking, no SEC_MERGE symbol has been
1816 adjusted, so all references to such symbols need to be
1817 passed through _bfd_merged_section_offset. (Later, in
1818 relocate_section, all SEC_MERGE symbols *except* for
1819 section symbols have been adjusted.)
1821 gas may reduce relocations against symbols in SEC_MERGE
1822 sections to a relocation against the section symbol when
1823 the original addend was zero. When the reloc is against
1824 a section symbol we should include the addend in the
1825 offset passed to _bfd_merged_section_offset, since the
1826 location of interest is the original symbol. On the
1827 other hand, an access to "sym+addend" where "sym" is not
1828 a section symbol should not include the addend; Such an
1829 access is presumed to be an offset from "sym"; The
1830 location of interest is just "sym". */
1831 if (symtype
== STT_SECTION
)
1834 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1835 elf_section_data (tsec
)->sec_info
,
1838 if (symtype
!= STT_SECTION
)
1844 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1845 if (tsec
->output_section
== sec
->output_section
)
1847 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1852 bfd_signed_vma distance
;
1854 /* At this point, we don't know the load addresses of TSEC
1855 section nor SEC section. We estimate the distrance between
1856 SEC and TSEC. We store the estimated distances in the
1857 compressed_size field of the output section, which is only
1858 used to decompress the compressed input section. */
1859 if (sec
->output_section
->compressed_size
== 0)
1862 bfd_size_type size
= 0;
1863 for (asect
= link_info
->output_bfd
->sections
;
1865 asect
= asect
->next
)
1866 /* Skip debug sections since compressed_size is used to
1867 compress debug sections. */
1868 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1871 for (i
= asect
->map_head
.s
;
1875 size
= align_power (size
, i
->alignment_power
);
1878 asect
->compressed_size
= size
;
1882 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1884 distance
= (tsec
->output_section
->compressed_size
1885 - sec
->output_section
->compressed_size
);
1889 /* Take PT_GNU_RELRO segment into account by adding
1891 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1892 - roff
+ 0x80000000) > 0xffffffff)
1899 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1904 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1906 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1909 /* Convert to "jmp foo nop". */
1912 nop_offset
= irel
->r_offset
+ 3;
1913 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1914 irel
->r_offset
-= 1;
1915 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1919 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1922 nop
= link_info
->call_nop_byte
;
1923 if (link_info
->call_nop_as_suffix
)
1925 nop_offset
= irel
->r_offset
+ 3;
1926 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1927 irel
->r_offset
-= 1;
1928 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1931 nop_offset
= irel
->r_offset
- 2;
1933 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1934 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1935 r_type
= R_X86_64_PC32
;
1940 unsigned int rex_mask
= REX_R
;
1942 if (r_type
== R_X86_64_REX_GOTPCRELX
)
1943 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
1951 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1952 "lea foo(%rip), %reg". */
1954 r_type
= R_X86_64_PC32
;
1958 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1959 "mov $foo, %reg". */
1961 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1962 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1963 if ((rex
& REX_W
) != 0
1964 && ABI_64_P (link_info
->output_bfd
))
1966 /* Keep the REX_W bit in REX byte for LP64. */
1967 r_type
= R_X86_64_32S
;
1968 goto rewrite_modrm_rex
;
1972 /* If the REX_W bit in REX byte isn't needed,
1973 use R_X86_64_32 and clear the W bit to avoid
1974 sign-extend imm32 to imm64. */
1975 r_type
= R_X86_64_32
;
1976 /* Clear the W bit in REX byte. */
1978 goto rewrite_modrm_rex
;
1984 /* R_X86_64_PC32 isn't supported. */
1988 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1991 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1992 "test $foo, %reg". */
1993 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1998 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
1999 "binop $foo, %reg". */
2000 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2004 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2005 overflow when sign-extending imm32 to imm64. */
2006 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2009 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2013 /* Move the R bit to the B bit in REX byte. */
2014 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2015 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2018 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2022 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2025 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2032 /* Look through the relocs for a section during the first phase, and
2033 calculate needed space in the global offset table, procedure
2034 linkage table, and dynamic reloc sections. */
2037 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2039 const Elf_Internal_Rela
*relocs
)
2041 struct elf_x86_64_link_hash_table
*htab
;
2042 Elf_Internal_Shdr
*symtab_hdr
;
2043 struct elf_link_hash_entry
**sym_hashes
;
2044 const Elf_Internal_Rela
*rel
;
2045 const Elf_Internal_Rela
*rel_end
;
2048 bfd_boolean use_plt_got
;
2050 if (bfd_link_relocatable (info
))
2053 BFD_ASSERT (is_x86_64_elf (abfd
));
2055 htab
= elf_x86_64_hash_table (info
);
2058 sec
->check_relocs_failed
= 1;
2062 /* Get the section contents. */
2063 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2064 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2065 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2067 sec
->check_relocs_failed
= 1;
2071 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2073 symtab_hdr
= &elf_symtab_hdr (abfd
);
2074 sym_hashes
= elf_sym_hashes (abfd
);
2078 rel_end
= relocs
+ sec
->reloc_count
;
2079 for (rel
= relocs
; rel
< rel_end
; rel
++)
2081 unsigned int r_type
;
2082 unsigned long r_symndx
;
2083 struct elf_link_hash_entry
*h
;
2084 struct elf_x86_64_link_hash_entry
*eh
;
2085 Elf_Internal_Sym
*isym
;
2087 bfd_boolean size_reloc
;
2089 r_symndx
= htab
->r_sym (rel
->r_info
);
2090 r_type
= ELF32_R_TYPE (rel
->r_info
);
2092 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2094 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2099 if (r_symndx
< symtab_hdr
->sh_info
)
2101 /* A local symbol. */
2102 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2107 /* Check relocation against local STT_GNU_IFUNC symbol. */
2108 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2110 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2115 /* Fake a STT_GNU_IFUNC symbol. */
2116 h
->type
= STT_GNU_IFUNC
;
2119 h
->forced_local
= 1;
2120 h
->root
.type
= bfd_link_hash_defined
;
2128 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2129 while (h
->root
.type
== bfd_link_hash_indirect
2130 || h
->root
.type
== bfd_link_hash_warning
)
2131 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2134 /* Check invalid x32 relocations. */
2135 if (!ABI_64_P (abfd
))
2141 case R_X86_64_DTPOFF64
:
2142 case R_X86_64_TPOFF64
:
2144 case R_X86_64_GOTOFF64
:
2145 case R_X86_64_GOT64
:
2146 case R_X86_64_GOTPCREL64
:
2147 case R_X86_64_GOTPC64
:
2148 case R_X86_64_GOTPLT64
:
2149 case R_X86_64_PLTOFF64
:
2152 name
= h
->root
.root
.string
;
2154 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2156 (*_bfd_error_handler
)
2157 (_("%B: relocation %s against symbol `%s' isn't "
2158 "supported in x32 mode"), abfd
,
2159 x86_64_elf_howto_table
[r_type
].name
, name
);
2160 bfd_set_error (bfd_error_bad_value
);
2173 case R_X86_64_PC32_BND
:
2174 case R_X86_64_PLT32_BND
:
2176 case R_X86_64_PLT32
:
2179 /* MPX PLT is supported only if elf_x86_64_arch_bed
2180 is used in 64-bit mode. */
2183 && (get_elf_x86_64_backend_data (abfd
)
2184 == &elf_x86_64_arch_bed
))
2186 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2188 /* Create the second PLT for Intel MPX support. */
2189 if (htab
->plt_bnd
== NULL
)
2191 unsigned int plt_bnd_align
;
2192 const struct elf_backend_data
*bed
;
2194 bed
= get_elf_backend_data (info
->output_bfd
);
2195 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2196 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2197 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2200 if (htab
->elf
.dynobj
== NULL
)
2201 htab
->elf
.dynobj
= abfd
;
2203 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2205 (bed
->dynamic_sec_flags
2210 if (htab
->plt_bnd
== NULL
2211 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2220 case R_X86_64_GOTPCREL
:
2221 case R_X86_64_GOTPCRELX
:
2222 case R_X86_64_REX_GOTPCRELX
:
2223 case R_X86_64_GOTPCREL64
:
2224 if (htab
->elf
.dynobj
== NULL
)
2225 htab
->elf
.dynobj
= abfd
;
2226 /* Create the ifunc sections for static executables. */
2227 if (h
->type
== STT_GNU_IFUNC
2228 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2234 /* It is referenced by a non-shared object. */
2236 h
->root
.non_ir_ref
= 1;
2238 if (h
->type
== STT_GNU_IFUNC
)
2239 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2240 |= elf_gnu_symbol_ifunc
;
2243 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2244 symtab_hdr
, sym_hashes
,
2245 &r_type
, GOT_UNKNOWN
,
2246 rel
, rel_end
, h
, r_symndx
, FALSE
))
2249 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2252 case R_X86_64_TLSLD
:
2253 htab
->tls_ld_got
.refcount
+= 1;
2256 case R_X86_64_TPOFF32
:
2257 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2258 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2259 &x86_64_elf_howto_table
[r_type
]);
2261 eh
->has_got_reloc
= 1;
2264 case R_X86_64_GOTTPOFF
:
2265 if (!bfd_link_executable (info
))
2266 info
->flags
|= DF_STATIC_TLS
;
2269 case R_X86_64_GOT32
:
2270 case R_X86_64_GOTPCREL
:
2271 case R_X86_64_GOTPCRELX
:
2272 case R_X86_64_REX_GOTPCRELX
:
2273 case R_X86_64_TLSGD
:
2274 case R_X86_64_GOT64
:
2275 case R_X86_64_GOTPCREL64
:
2276 case R_X86_64_GOTPLT64
:
2277 case R_X86_64_GOTPC32_TLSDESC
:
2278 case R_X86_64_TLSDESC_CALL
:
2279 /* This symbol requires a global offset table entry. */
2281 int tls_type
, old_tls_type
;
2285 default: tls_type
= GOT_NORMAL
; break;
2286 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2287 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2288 case R_X86_64_GOTPC32_TLSDESC
:
2289 case R_X86_64_TLSDESC_CALL
:
2290 tls_type
= GOT_TLS_GDESC
; break;
2295 h
->got
.refcount
+= 1;
2296 old_tls_type
= eh
->tls_type
;
2300 bfd_signed_vma
*local_got_refcounts
;
2302 /* This is a global offset table entry for a local symbol. */
2303 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2304 if (local_got_refcounts
== NULL
)
2308 size
= symtab_hdr
->sh_info
;
2309 size
*= sizeof (bfd_signed_vma
)
2310 + sizeof (bfd_vma
) + sizeof (char);
2311 local_got_refcounts
= ((bfd_signed_vma
*)
2312 bfd_zalloc (abfd
, size
));
2313 if (local_got_refcounts
== NULL
)
2315 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2316 elf_x86_64_local_tlsdesc_gotent (abfd
)
2317 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2318 elf_x86_64_local_got_tls_type (abfd
)
2319 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2321 local_got_refcounts
[r_symndx
] += 1;
2323 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2326 /* If a TLS symbol is accessed using IE at least once,
2327 there is no point to use dynamic model for it. */
2328 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2329 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2330 || tls_type
!= GOT_TLS_IE
))
2332 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2333 tls_type
= old_tls_type
;
2334 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2335 && GOT_TLS_GD_ANY_P (tls_type
))
2336 tls_type
|= old_tls_type
;
2340 name
= h
->root
.root
.string
;
2342 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2344 (*_bfd_error_handler
)
2345 (_("%B: '%s' accessed both as normal and thread local symbol"),
2347 bfd_set_error (bfd_error_bad_value
);
2352 if (old_tls_type
!= tls_type
)
2355 eh
->tls_type
= tls_type
;
2357 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2362 case R_X86_64_GOTOFF64
:
2363 case R_X86_64_GOTPC32
:
2364 case R_X86_64_GOTPC64
:
2367 eh
->has_got_reloc
= 1;
2368 if (htab
->elf
.sgot
== NULL
)
2370 if (htab
->elf
.dynobj
== NULL
)
2371 htab
->elf
.dynobj
= abfd
;
2372 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2378 case R_X86_64_PLT32
:
2379 case R_X86_64_PLT32_BND
:
2380 /* This symbol requires a procedure linkage table entry. We
2381 actually build the entry in adjust_dynamic_symbol,
2382 because this might be a case of linking PIC code which is
2383 never referenced by a dynamic object, in which case we
2384 don't need to generate a procedure linkage table entry
2387 /* If this is a local symbol, we resolve it directly without
2388 creating a procedure linkage table entry. */
2392 eh
->has_got_reloc
= 1;
2394 h
->plt
.refcount
+= 1;
2397 case R_X86_64_PLTOFF64
:
2398 /* This tries to form the 'address' of a function relative
2399 to GOT. For global symbols we need a PLT entry. */
2403 h
->plt
.refcount
+= 1;
2407 case R_X86_64_SIZE32
:
2408 case R_X86_64_SIZE64
:
2413 if (!ABI_64_P (abfd
))
2418 /* Check relocation overflow as these relocs may lead to
2419 run-time relocation overflow. Don't error out for
2420 sections we don't care about, such as debug sections or
2421 when relocation overflow check is disabled. */
2422 if (!info
->no_reloc_overflow_check
2423 && (bfd_link_pic (info
)
2424 || (bfd_link_executable (info
)
2428 && (sec
->flags
& SEC_READONLY
) == 0))
2429 && (sec
->flags
& SEC_ALLOC
) != 0)
2430 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2431 &x86_64_elf_howto_table
[r_type
]);
2437 case R_X86_64_PC32_BND
:
2441 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2442 eh
->has_non_got_reloc
= 1;
2443 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2444 locally defined and undefined symbol may turn out to be
2445 a STT_GNU_IFUNC symbol later. */
2447 && (bfd_link_executable (info
)
2448 || ((h
->type
== STT_GNU_IFUNC
2449 || h
->root
.type
== bfd_link_hash_undefweak
2450 || h
->root
.type
== bfd_link_hash_undefined
)
2451 && SYMBOLIC_BIND (info
, h
))))
2453 /* If this reloc is in a read-only section, we might
2454 need a copy reloc. We can't check reliably at this
2455 stage whether the section is read-only, as input
2456 sections have not yet been mapped to output sections.
2457 Tentatively set the flag for now, and correct in
2458 adjust_dynamic_symbol. */
2461 /* We may need a .plt entry if the function this reloc
2462 refers to is in a shared lib. */
2463 h
->plt
.refcount
+= 1;
2464 if (r_type
== R_X86_64_PC32
)
2466 /* Since something like ".long foo - ." may be used
2467 as pointer, make sure that PLT is used if foo is
2468 a function defined in a shared library. */
2469 if ((sec
->flags
& SEC_CODE
) == 0)
2470 h
->pointer_equality_needed
= 1;
2472 else if (r_type
!= R_X86_64_PC32_BND
2473 && r_type
!= R_X86_64_PC64
)
2475 h
->pointer_equality_needed
= 1;
2476 /* At run-time, R_X86_64_64 can be resolved for both
2477 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2478 can only be resolved for x32. */
2479 if ((sec
->flags
& SEC_READONLY
) == 0
2480 && (r_type
== R_X86_64_64
2481 || (!ABI_64_P (abfd
)
2482 && (r_type
== R_X86_64_32
2483 || r_type
== R_X86_64_32S
))))
2484 eh
->func_pointer_refcount
+= 1;
2490 /* If we are creating a shared library, and this is a reloc
2491 against a global symbol, or a non PC relative reloc
2492 against a local symbol, then we need to copy the reloc
2493 into the shared library. However, if we are linking with
2494 -Bsymbolic, we do not need to copy a reloc against a
2495 global symbol which is defined in an object we are
2496 including in the link (i.e., DEF_REGULAR is set). At
2497 this point we have not seen all the input files, so it is
2498 possible that DEF_REGULAR is not set now but will be set
2499 later (it is never cleared). In case of a weak definition,
2500 DEF_REGULAR may be cleared later by a strong definition in
2501 a shared library. We account for that possibility below by
2502 storing information in the relocs_copied field of the hash
2503 table entry. A similar situation occurs when creating
2504 shared libraries and symbol visibility changes render the
2507 If on the other hand, we are creating an executable, we
2508 may need to keep relocations for symbols satisfied by a
2509 dynamic library if we manage to avoid copy relocs for the
2511 if ((bfd_link_pic (info
)
2512 && (sec
->flags
& SEC_ALLOC
) != 0
2513 && (! IS_X86_64_PCREL_TYPE (r_type
)
2515 && (! (bfd_link_pie (info
)
2516 || SYMBOLIC_BIND (info
, h
))
2517 || h
->root
.type
== bfd_link_hash_defweak
2518 || !h
->def_regular
))))
2519 || (ELIMINATE_COPY_RELOCS
2520 && !bfd_link_pic (info
)
2521 && (sec
->flags
& SEC_ALLOC
) != 0
2523 && (h
->root
.type
== bfd_link_hash_defweak
2524 || !h
->def_regular
)))
2526 struct elf_dyn_relocs
*p
;
2527 struct elf_dyn_relocs
**head
;
2529 /* We must copy these reloc types into the output file.
2530 Create a reloc section in dynobj and make room for
2534 if (htab
->elf
.dynobj
== NULL
)
2535 htab
->elf
.dynobj
= abfd
;
2537 sreloc
= _bfd_elf_make_dynamic_reloc_section
2538 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2539 abfd
, /*rela?*/ TRUE
);
2545 /* If this is a global symbol, we count the number of
2546 relocations we need for this symbol. */
2548 head
= &eh
->dyn_relocs
;
2551 /* Track dynamic relocs needed for local syms too.
2552 We really need local syms available to do this
2557 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2562 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2566 /* Beware of type punned pointers vs strict aliasing
2568 vpp
= &(elf_section_data (s
)->local_dynrel
);
2569 head
= (struct elf_dyn_relocs
**)vpp
;
2573 if (p
== NULL
|| p
->sec
!= sec
)
2575 bfd_size_type amt
= sizeof *p
;
2577 p
= ((struct elf_dyn_relocs
*)
2578 bfd_alloc (htab
->elf
.dynobj
, amt
));
2589 /* Count size relocation as PC-relative relocation. */
2590 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2595 /* This relocation describes the C++ object vtable hierarchy.
2596 Reconstruct it for later use during GC. */
2597 case R_X86_64_GNU_VTINHERIT
:
2598 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2602 /* This relocation describes which C++ vtable entries are actually
2603 used. Record for later use during GC. */
2604 case R_X86_64_GNU_VTENTRY
:
2605 BFD_ASSERT (h
!= NULL
);
2607 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2617 && h
->plt
.refcount
> 0
2618 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2619 || h
->got
.refcount
> 0)
2620 && htab
->plt_got
== NULL
)
2622 /* Create the GOT procedure linkage table. */
2623 unsigned int plt_got_align
;
2624 const struct elf_backend_data
*bed
;
2626 bed
= get_elf_backend_data (info
->output_bfd
);
2627 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2628 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2629 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2632 if (htab
->elf
.dynobj
== NULL
)
2633 htab
->elf
.dynobj
= abfd
;
2635 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2637 (bed
->dynamic_sec_flags
2642 if (htab
->plt_got
== NULL
2643 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2649 if ((r_type
== R_X86_64_GOTPCREL
2650 || r_type
== R_X86_64_GOTPCRELX
2651 || r_type
== R_X86_64_REX_GOTPCRELX
)
2652 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2653 sec
->need_convert_load
= 1;
2656 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2658 if (!info
->keep_memory
)
2662 /* Cache the section contents for elf_link_input_bfd. */
2663 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2670 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2672 sec
->check_relocs_failed
= 1;
2676 /* Return the section that should be marked against GC for a given
2680 elf_x86_64_gc_mark_hook (asection
*sec
,
2681 struct bfd_link_info
*info
,
2682 Elf_Internal_Rela
*rel
,
2683 struct elf_link_hash_entry
*h
,
2684 Elf_Internal_Sym
*sym
)
2687 switch (ELF32_R_TYPE (rel
->r_info
))
2689 case R_X86_64_GNU_VTINHERIT
:
2690 case R_X86_64_GNU_VTENTRY
:
2694 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2697 /* Remove undefined weak symbol from the dynamic symbol table if it
2698 is resolved to 0. */
2701 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2702 struct elf_link_hash_entry
*h
)
2704 if (h
->dynindx
!= -1
2705 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2706 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2707 elf_x86_64_hash_entry (h
)))
2710 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2716 /* Adjust a symbol defined by a dynamic object and referenced by a
2717 regular object. The current definition is in some section of the
2718 dynamic object, but we're not including those sections. We have to
2719 change the definition to something the rest of the link can
2723 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2724 struct elf_link_hash_entry
*h
)
2726 struct elf_x86_64_link_hash_table
*htab
;
2728 struct elf_x86_64_link_hash_entry
*eh
;
2729 struct elf_dyn_relocs
*p
;
2731 /* STT_GNU_IFUNC symbol must go through PLT. */
2732 if (h
->type
== STT_GNU_IFUNC
)
2734 /* All local STT_GNU_IFUNC references must be treate as local
2735 calls via local PLT. */
2737 && SYMBOL_CALLS_LOCAL (info
, h
))
2739 bfd_size_type pc_count
= 0, count
= 0;
2740 struct elf_dyn_relocs
**pp
;
2742 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2743 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2745 pc_count
+= p
->pc_count
;
2746 p
->count
-= p
->pc_count
;
2755 if (pc_count
|| count
)
2759 if (h
->plt
.refcount
<= 0)
2760 h
->plt
.refcount
= 1;
2762 h
->plt
.refcount
+= 1;
2766 if (h
->plt
.refcount
<= 0)
2768 h
->plt
.offset
= (bfd_vma
) -1;
2774 /* If this is a function, put it in the procedure linkage table. We
2775 will fill in the contents of the procedure linkage table later,
2776 when we know the address of the .got section. */
2777 if (h
->type
== STT_FUNC
2780 if (h
->plt
.refcount
<= 0
2781 || SYMBOL_CALLS_LOCAL (info
, h
)
2782 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2783 && h
->root
.type
== bfd_link_hash_undefweak
))
2785 /* This case can occur if we saw a PLT32 reloc in an input
2786 file, but the symbol was never referred to by a dynamic
2787 object, or if all references were garbage collected. In
2788 such a case, we don't actually need to build a procedure
2789 linkage table, and we can just do a PC32 reloc instead. */
2790 h
->plt
.offset
= (bfd_vma
) -1;
2797 /* It's possible that we incorrectly decided a .plt reloc was
2798 needed for an R_X86_64_PC32 reloc to a non-function sym in
2799 check_relocs. We can't decide accurately between function and
2800 non-function syms in check-relocs; Objects loaded later in
2801 the link may change h->type. So fix it now. */
2802 h
->plt
.offset
= (bfd_vma
) -1;
2804 /* If this is a weak symbol, and there is a real definition, the
2805 processor independent code will have arranged for us to see the
2806 real definition first, and we can just use the same value. */
2807 if (h
->u
.weakdef
!= NULL
)
2809 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2810 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2811 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2812 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2813 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2815 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2816 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2817 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2822 /* This is a reference to a symbol defined by a dynamic object which
2823 is not a function. */
2825 /* If we are creating a shared library, we must presume that the
2826 only references to the symbol are via the global offset table.
2827 For such cases we need not do anything here; the relocations will
2828 be handled correctly by relocate_section. */
2829 if (!bfd_link_executable (info
))
2832 /* If there are no references to this symbol that do not use the
2833 GOT, we don't need to generate a copy reloc. */
2834 if (!h
->non_got_ref
)
2837 /* If -z nocopyreloc was given, we won't generate them either. */
2838 if (info
->nocopyreloc
)
2844 if (ELIMINATE_COPY_RELOCS
)
2846 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2847 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2849 s
= p
->sec
->output_section
;
2850 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2854 /* If we didn't find any dynamic relocs in read-only sections, then
2855 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2863 /* We must allocate the symbol in our .dynbss section, which will
2864 become part of the .bss section of the executable. There will be
2865 an entry for this symbol in the .dynsym section. The dynamic
2866 object will contain position independent code, so all references
2867 from the dynamic object to this symbol will go through the global
2868 offset table. The dynamic linker will use the .dynsym entry to
2869 determine the address it must put in the global offset table, so
2870 both the dynamic object and the regular object will refer to the
2871 same memory location for the variable. */
2873 htab
= elf_x86_64_hash_table (info
);
2877 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2878 to copy the initial value out of the dynamic object and into the
2879 runtime process image. */
2880 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2882 const struct elf_backend_data
*bed
;
2883 bed
= get_elf_backend_data (info
->output_bfd
);
2884 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2890 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2893 /* Allocate space in .plt, .got and associated reloc sections for
2897 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2899 struct bfd_link_info
*info
;
2900 struct elf_x86_64_link_hash_table
*htab
;
2901 struct elf_x86_64_link_hash_entry
*eh
;
2902 struct elf_dyn_relocs
*p
;
2903 const struct elf_backend_data
*bed
;
2904 unsigned int plt_entry_size
;
2905 bfd_boolean resolved_to_zero
;
2907 if (h
->root
.type
== bfd_link_hash_indirect
)
2910 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2912 info
= (struct bfd_link_info
*) inf
;
2913 htab
= elf_x86_64_hash_table (info
);
2916 bed
= get_elf_backend_data (info
->output_bfd
);
2917 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2919 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2923 /* We can't use the GOT PLT if pointer equality is needed since
2924 finish_dynamic_symbol won't clear symbol value and the dynamic
2925 linker won't update the GOT slot. We will get into an infinite
2926 loop at run-time. */
2927 if (htab
->plt_got
!= NULL
2928 && h
->type
!= STT_GNU_IFUNC
2929 && !h
->pointer_equality_needed
2930 && h
->plt
.refcount
> 0
2931 && h
->got
.refcount
> 0)
2933 /* Don't use the regular PLT if there are both GOT and GOTPLT
2935 h
->plt
.offset
= (bfd_vma
) -1;
2937 /* Use the GOT PLT. */
2938 eh
->plt_got
.refcount
= 1;
2941 /* Clear the reference count of function pointer relocations if
2942 symbol isn't a normal function. */
2943 if (h
->type
!= STT_FUNC
)
2944 eh
->func_pointer_refcount
= 0;
2946 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2947 here if it is defined and referenced in a non-shared object. */
2948 if (h
->type
== STT_GNU_IFUNC
2951 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2953 &htab
->readonly_dynrelocs_against_ifunc
,
2958 asection
*s
= htab
->plt_bnd
;
2959 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2961 /* Use the .plt.bnd section if it is created. */
2962 eh
->plt_bnd
.offset
= s
->size
;
2964 /* Make room for this entry in the .plt.bnd section. */
2965 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2973 /* Don't create the PLT entry if there are only function pointer
2974 relocations which can be resolved at run-time. */
2975 else if (htab
->elf
.dynamic_sections_created
2976 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2977 || eh
->plt_got
.refcount
> 0))
2979 bfd_boolean use_plt_got
;
2981 /* Clear the reference count of function pointer relocations
2983 eh
->func_pointer_refcount
= 0;
2985 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2987 /* Don't use the regular PLT for DF_BIND_NOW. */
2988 h
->plt
.offset
= (bfd_vma
) -1;
2990 /* Use the GOT PLT. */
2991 h
->got
.refcount
= 1;
2992 eh
->plt_got
.refcount
= 1;
2995 use_plt_got
= eh
->plt_got
.refcount
> 0;
2997 /* Make sure this symbol is output as a dynamic symbol.
2998 Undefined weak syms won't yet be marked as dynamic. */
2999 if (h
->dynindx
== -1
3001 && !resolved_to_zero
)
3003 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3007 if (bfd_link_pic (info
)
3008 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3010 asection
*s
= htab
->elf
.splt
;
3011 asection
*bnd_s
= htab
->plt_bnd
;
3012 asection
*got_s
= htab
->plt_got
;
3014 /* If this is the first .plt entry, make room for the special
3015 first entry. The .plt section is used by prelink to undo
3016 prelinking for dynamic relocations. */
3018 s
->size
= plt_entry_size
;
3021 eh
->plt_got
.offset
= got_s
->size
;
3024 h
->plt
.offset
= s
->size
;
3026 eh
->plt_bnd
.offset
= bnd_s
->size
;
3029 /* If this symbol is not defined in a regular file, and we are
3030 not generating a shared library, then set the symbol to this
3031 location in the .plt. This is required to make function
3032 pointers compare as equal between the normal executable and
3033 the shared library. */
3034 if (! bfd_link_pic (info
)
3039 /* We need to make a call to the entry of the GOT PLT
3040 instead of regular PLT entry. */
3041 h
->root
.u
.def
.section
= got_s
;
3042 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3048 /* We need to make a call to the entry of the second
3049 PLT instead of regular PLT entry. */
3050 h
->root
.u
.def
.section
= bnd_s
;
3051 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3055 h
->root
.u
.def
.section
= s
;
3056 h
->root
.u
.def
.value
= h
->plt
.offset
;
3061 /* Make room for this entry. */
3063 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3066 s
->size
+= plt_entry_size
;
3068 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3070 /* We also need to make an entry in the .got.plt section,
3071 which will be placed in the .got section by the linker
3073 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3075 /* There should be no PLT relocation against resolved
3076 undefined weak symbol in executable. */
3077 if (!resolved_to_zero
)
3079 /* We also need to make an entry in the .rela.plt
3081 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3082 htab
->elf
.srelplt
->reloc_count
++;
3088 eh
->plt_got
.offset
= (bfd_vma
) -1;
3089 h
->plt
.offset
= (bfd_vma
) -1;
3095 eh
->plt_got
.offset
= (bfd_vma
) -1;
3096 h
->plt
.offset
= (bfd_vma
) -1;
3100 eh
->tlsdesc_got
= (bfd_vma
) -1;
3102 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3103 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3104 if (h
->got
.refcount
> 0
3105 && bfd_link_executable (info
)
3107 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3109 h
->got
.offset
= (bfd_vma
) -1;
3111 else if (h
->got
.refcount
> 0)
3115 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3117 /* Make sure this symbol is output as a dynamic symbol.
3118 Undefined weak syms won't yet be marked as dynamic. */
3119 if (h
->dynindx
== -1
3121 && !resolved_to_zero
)
3123 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3127 if (GOT_TLS_GDESC_P (tls_type
))
3129 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3130 - elf_x86_64_compute_jump_table_size (htab
);
3131 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3132 h
->got
.offset
= (bfd_vma
) -2;
3134 if (! GOT_TLS_GDESC_P (tls_type
)
3135 || GOT_TLS_GD_P (tls_type
))
3138 h
->got
.offset
= s
->size
;
3139 s
->size
+= GOT_ENTRY_SIZE
;
3140 if (GOT_TLS_GD_P (tls_type
))
3141 s
->size
+= GOT_ENTRY_SIZE
;
3143 dyn
= htab
->elf
.dynamic_sections_created
;
3144 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3145 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3146 relocation. No dynamic relocation against resolved undefined
3147 weak symbol in executable. */
3148 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3149 || tls_type
== GOT_TLS_IE
)
3150 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3151 else if (GOT_TLS_GD_P (tls_type
))
3152 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3153 else if (! GOT_TLS_GDESC_P (tls_type
)
3154 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3155 && !resolved_to_zero
)
3156 || h
->root
.type
!= bfd_link_hash_undefweak
)
3157 && (bfd_link_pic (info
)
3158 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3159 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3160 if (GOT_TLS_GDESC_P (tls_type
))
3162 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3163 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3167 h
->got
.offset
= (bfd_vma
) -1;
3169 if (eh
->dyn_relocs
== NULL
)
3172 /* In the shared -Bsymbolic case, discard space allocated for
3173 dynamic pc-relative relocs against symbols which turn out to be
3174 defined in regular objects. For the normal shared case, discard
3175 space for pc-relative relocs that have become local due to symbol
3176 visibility changes. */
3178 if (bfd_link_pic (info
))
3180 /* Relocs that use pc_count are those that appear on a call
3181 insn, or certain REL relocs that can generated via assembly.
3182 We want calls to protected symbols to resolve directly to the
3183 function rather than going via the plt. If people want
3184 function pointer comparisons to work as expected then they
3185 should avoid writing weird assembly. */
3186 if (SYMBOL_CALLS_LOCAL (info
, h
))
3188 struct elf_dyn_relocs
**pp
;
3190 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3192 p
->count
-= p
->pc_count
;
3201 /* Also discard relocs on undefined weak syms with non-default
3202 visibility or in PIE. */
3203 if (eh
->dyn_relocs
!= NULL
)
3205 if (h
->root
.type
== bfd_link_hash_undefweak
)
3207 /* Undefined weak symbol is never bound locally in shared
3209 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3210 || resolved_to_zero
)
3211 eh
->dyn_relocs
= NULL
;
3212 else if (h
->dynindx
== -1
3213 && ! h
->forced_local
3214 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3217 /* For PIE, discard space for pc-relative relocs against
3218 symbols which turn out to need copy relocs. */
3219 else if (bfd_link_executable (info
)
3220 && (h
->needs_copy
|| eh
->needs_copy
)
3224 struct elf_dyn_relocs
**pp
;
3226 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3228 if (p
->pc_count
!= 0)
3236 else if (ELIMINATE_COPY_RELOCS
)
3238 /* For the non-shared case, discard space for relocs against
3239 symbols which turn out to need copy relocs or are not
3240 dynamic. Keep dynamic relocations for run-time function
3241 pointer initialization. */
3243 if ((!h
->non_got_ref
3244 || eh
->func_pointer_refcount
> 0
3245 || (h
->root
.type
== bfd_link_hash_undefweak
3246 && !resolved_to_zero
))
3249 || (htab
->elf
.dynamic_sections_created
3250 && (h
->root
.type
== bfd_link_hash_undefweak
3251 || h
->root
.type
== bfd_link_hash_undefined
))))
3253 /* Make sure this symbol is output as a dynamic symbol.
3254 Undefined weak syms won't yet be marked as dynamic. */
3255 if (h
->dynindx
== -1
3256 && ! h
->forced_local
3257 && ! resolved_to_zero
3258 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3261 /* If that succeeded, we know we'll be keeping all the
3263 if (h
->dynindx
!= -1)
3267 eh
->dyn_relocs
= NULL
;
3268 eh
->func_pointer_refcount
= 0;
3273 /* Finally, allocate space. */
3274 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3278 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3280 BFD_ASSERT (sreloc
!= NULL
);
3282 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3288 /* Allocate space in .plt, .got and associated reloc sections for
3289 local dynamic relocs. */
3292 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3294 struct elf_link_hash_entry
*h
3295 = (struct elf_link_hash_entry
*) *slot
;
3297 if (h
->type
!= STT_GNU_IFUNC
3301 || h
->root
.type
!= bfd_link_hash_defined
)
3304 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3307 /* Find any dynamic relocs that apply to read-only sections. */
3310 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3313 struct elf_x86_64_link_hash_entry
*eh
;
3314 struct elf_dyn_relocs
*p
;
3316 /* Skip local IFUNC symbols. */
3317 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3320 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3321 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3323 asection
*s
= p
->sec
->output_section
;
3325 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3327 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3329 info
->flags
|= DF_TEXTREL
;
3331 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3332 || info
->error_textrel
)
3333 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3334 p
->sec
->owner
, h
->root
.root
.string
,
3337 /* Not an error, just cut short the traversal. */
3344 /* Convert load via the GOT slot to load immediate. */
3347 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3348 struct bfd_link_info
*link_info
)
3350 Elf_Internal_Shdr
*symtab_hdr
;
3351 Elf_Internal_Rela
*internal_relocs
;
3352 Elf_Internal_Rela
*irel
, *irelend
;
3354 struct elf_x86_64_link_hash_table
*htab
;
3355 bfd_boolean changed
;
3356 bfd_signed_vma
*local_got_refcounts
;
3358 /* Don't even try to convert non-ELF outputs. */
3359 if (!is_elf_hash_table (link_info
->hash
))
3362 /* Nothing to do if there is no need or no output. */
3363 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3364 || sec
->need_convert_load
== 0
3365 || bfd_is_abs_section (sec
->output_section
))
3368 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3370 /* Load the relocations for this section. */
3371 internal_relocs
= (_bfd_elf_link_read_relocs
3372 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3373 link_info
->keep_memory
));
3374 if (internal_relocs
== NULL
)
3378 htab
= elf_x86_64_hash_table (link_info
);
3379 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3381 /* Get the section contents. */
3382 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3383 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3386 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3390 irelend
= internal_relocs
+ sec
->reloc_count
;
3391 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3393 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3394 unsigned int r_symndx
;
3395 struct elf_link_hash_entry
*h
;
3396 bfd_boolean converted
;
3398 if (r_type
!= R_X86_64_GOTPCRELX
3399 && r_type
!= R_X86_64_REX_GOTPCRELX
3400 && r_type
!= R_X86_64_GOTPCREL
)
3403 r_symndx
= htab
->r_sym (irel
->r_info
);
3404 if (r_symndx
< symtab_hdr
->sh_info
)
3405 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3406 (const Elf_Internal_Rela
*) irel
,
3410 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3411 while (h
->root
.type
== bfd_link_hash_indirect
3412 || h
->root
.type
== bfd_link_hash_warning
)
3413 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3416 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3417 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3421 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3422 &converted
, link_info
))
3427 changed
= converted
;
3430 if (h
->got
.refcount
> 0)
3431 h
->got
.refcount
-= 1;
3435 if (local_got_refcounts
!= NULL
3436 && local_got_refcounts
[r_symndx
] > 0)
3437 local_got_refcounts
[r_symndx
] -= 1;
3442 if (contents
!= NULL
3443 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3445 if (!changed
&& !link_info
->keep_memory
)
3449 /* Cache the section contents for elf_link_input_bfd. */
3450 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3454 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3457 free (internal_relocs
);
3459 elf_section_data (sec
)->relocs
= internal_relocs
;
3465 if (contents
!= NULL
3466 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3468 if (internal_relocs
!= NULL
3469 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3470 free (internal_relocs
);
3474 /* Set the sizes of the dynamic sections. */
3477 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3478 struct bfd_link_info
*info
)
3480 struct elf_x86_64_link_hash_table
*htab
;
3485 const struct elf_backend_data
*bed
;
3487 htab
= elf_x86_64_hash_table (info
);
3490 bed
= get_elf_backend_data (output_bfd
);
3492 dynobj
= htab
->elf
.dynobj
;
3496 /* Set up .got offsets for local syms, and space for local dynamic
3498 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3500 bfd_signed_vma
*local_got
;
3501 bfd_signed_vma
*end_local_got
;
3502 char *local_tls_type
;
3503 bfd_vma
*local_tlsdesc_gotent
;
3504 bfd_size_type locsymcount
;
3505 Elf_Internal_Shdr
*symtab_hdr
;
3508 if (! is_x86_64_elf (ibfd
))
3511 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3513 struct elf_dyn_relocs
*p
;
3515 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3518 for (p
= (struct elf_dyn_relocs
*)
3519 (elf_section_data (s
)->local_dynrel
);
3523 if (!bfd_is_abs_section (p
->sec
)
3524 && bfd_is_abs_section (p
->sec
->output_section
))
3526 /* Input section has been discarded, either because
3527 it is a copy of a linkonce section or due to
3528 linker script /DISCARD/, so we'll be discarding
3531 else if (p
->count
!= 0)
3533 srel
= elf_section_data (p
->sec
)->sreloc
;
3534 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3535 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3536 && (info
->flags
& DF_TEXTREL
) == 0)
3538 info
->flags
|= DF_TEXTREL
;
3539 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3540 || info
->error_textrel
)
3541 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3542 p
->sec
->owner
, p
->sec
);
3548 local_got
= elf_local_got_refcounts (ibfd
);
3552 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3553 locsymcount
= symtab_hdr
->sh_info
;
3554 end_local_got
= local_got
+ locsymcount
;
3555 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3556 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3558 srel
= htab
->elf
.srelgot
;
3559 for (; local_got
< end_local_got
;
3560 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3562 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3565 if (GOT_TLS_GDESC_P (*local_tls_type
))
3567 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3568 - elf_x86_64_compute_jump_table_size (htab
);
3569 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3570 *local_got
= (bfd_vma
) -2;
3572 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3573 || GOT_TLS_GD_P (*local_tls_type
))
3575 *local_got
= s
->size
;
3576 s
->size
+= GOT_ENTRY_SIZE
;
3577 if (GOT_TLS_GD_P (*local_tls_type
))
3578 s
->size
+= GOT_ENTRY_SIZE
;
3580 if (bfd_link_pic (info
)
3581 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3582 || *local_tls_type
== GOT_TLS_IE
)
3584 if (GOT_TLS_GDESC_P (*local_tls_type
))
3586 htab
->elf
.srelplt
->size
3587 += bed
->s
->sizeof_rela
;
3588 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3590 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3591 || GOT_TLS_GD_P (*local_tls_type
))
3592 srel
->size
+= bed
->s
->sizeof_rela
;
3596 *local_got
= (bfd_vma
) -1;
3600 if (htab
->tls_ld_got
.refcount
> 0)
3602 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3604 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3605 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3606 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3609 htab
->tls_ld_got
.offset
= -1;
3611 /* Allocate global sym .plt and .got entries, and space for global
3612 sym dynamic relocs. */
3613 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3616 /* Allocate .plt and .got entries, and space for local symbols. */
3617 htab_traverse (htab
->loc_hash_table
,
3618 elf_x86_64_allocate_local_dynrelocs
,
3621 /* For every jump slot reserved in the sgotplt, reloc_count is
3622 incremented. However, when we reserve space for TLS descriptors,
3623 it's not incremented, so in order to compute the space reserved
3624 for them, it suffices to multiply the reloc count by the jump
3627 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3628 so that R_X86_64_IRELATIVE entries come last. */
3629 if (htab
->elf
.srelplt
)
3631 htab
->sgotplt_jump_table_size
3632 = elf_x86_64_compute_jump_table_size (htab
);
3633 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3635 else if (htab
->elf
.irelplt
)
3636 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3638 if (htab
->tlsdesc_plt
)
3640 /* If we're not using lazy TLS relocations, don't generate the
3641 PLT and GOT entries they require. */
3642 if ((info
->flags
& DF_BIND_NOW
))
3643 htab
->tlsdesc_plt
= 0;
3646 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3647 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3648 /* Reserve room for the initial entry.
3649 FIXME: we could probably do away with it in this case. */
3650 if (htab
->elf
.splt
->size
== 0)
3651 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3652 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3653 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3657 if (htab
->elf
.sgotplt
)
3659 /* Don't allocate .got.plt section if there are no GOT nor PLT
3660 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3661 if ((htab
->elf
.hgot
== NULL
3662 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3663 && (htab
->elf
.sgotplt
->size
3664 == get_elf_backend_data (output_bfd
)->got_header_size
)
3665 && (htab
->elf
.splt
== NULL
3666 || htab
->elf
.splt
->size
== 0)
3667 && (htab
->elf
.sgot
== NULL
3668 || htab
->elf
.sgot
->size
== 0)
3669 && (htab
->elf
.iplt
== NULL
3670 || htab
->elf
.iplt
->size
== 0)
3671 && (htab
->elf
.igotplt
== NULL
3672 || htab
->elf
.igotplt
->size
== 0))
3673 htab
->elf
.sgotplt
->size
= 0;
3676 if (htab
->plt_eh_frame
!= NULL
3677 && htab
->elf
.splt
!= NULL
3678 && htab
->elf
.splt
->size
!= 0
3679 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3680 && _bfd_elf_eh_frame_present (info
))
3682 const struct elf_x86_64_backend_data
*arch_data
3683 = get_elf_x86_64_arch_data (bed
);
3684 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3687 /* We now have determined the sizes of the various dynamic sections.
3688 Allocate memory for them. */
3690 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3692 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3695 if (s
== htab
->elf
.splt
3696 || s
== htab
->elf
.sgot
3697 || s
== htab
->elf
.sgotplt
3698 || s
== htab
->elf
.iplt
3699 || s
== htab
->elf
.igotplt
3700 || s
== htab
->plt_bnd
3701 || s
== htab
->plt_got
3702 || s
== htab
->plt_eh_frame
3703 || s
== htab
->sdynbss
)
3705 /* Strip this section if we don't need it; see the
3708 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3710 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3713 /* We use the reloc_count field as a counter if we need
3714 to copy relocs into the output file. */
3715 if (s
!= htab
->elf
.srelplt
)
3720 /* It's not one of our sections, so don't allocate space. */
3726 /* If we don't need this section, strip it from the
3727 output file. This is mostly to handle .rela.bss and
3728 .rela.plt. We must create both sections in
3729 create_dynamic_sections, because they must be created
3730 before the linker maps input sections to output
3731 sections. The linker does that before
3732 adjust_dynamic_symbol is called, and it is that
3733 function which decides whether anything needs to go
3734 into these sections. */
3736 s
->flags
|= SEC_EXCLUDE
;
3740 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3743 /* Allocate memory for the section contents. We use bfd_zalloc
3744 here in case unused entries are not reclaimed before the
3745 section's contents are written out. This should not happen,
3746 but this way if it does, we get a R_X86_64_NONE reloc instead
3748 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3749 if (s
->contents
== NULL
)
3753 if (htab
->plt_eh_frame
!= NULL
3754 && htab
->plt_eh_frame
->contents
!= NULL
)
3756 const struct elf_x86_64_backend_data
*arch_data
3757 = get_elf_x86_64_arch_data (bed
);
3759 memcpy (htab
->plt_eh_frame
->contents
,
3760 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3761 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3762 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3765 if (htab
->elf
.dynamic_sections_created
)
3767 /* Add some entries to the .dynamic section. We fill in the
3768 values later, in elf_x86_64_finish_dynamic_sections, but we
3769 must add the entries now so that we get the correct size for
3770 the .dynamic section. The DT_DEBUG entry is filled in by the
3771 dynamic linker and used by the debugger. */
3772 #define add_dynamic_entry(TAG, VAL) \
3773 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3775 if (bfd_link_executable (info
))
3777 if (!add_dynamic_entry (DT_DEBUG
, 0))
3781 if (htab
->elf
.splt
->size
!= 0)
3783 /* DT_PLTGOT is used by prelink even if there is no PLT
3785 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3788 if (htab
->elf
.srelplt
->size
!= 0)
3790 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3791 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3792 || !add_dynamic_entry (DT_JMPREL
, 0))
3796 if (htab
->tlsdesc_plt
3797 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3798 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3804 if (!add_dynamic_entry (DT_RELA
, 0)
3805 || !add_dynamic_entry (DT_RELASZ
, 0)
3806 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3809 /* If any dynamic relocs apply to a read-only section,
3810 then we need a DT_TEXTREL entry. */
3811 if ((info
->flags
& DF_TEXTREL
) == 0)
3812 elf_link_hash_traverse (&htab
->elf
,
3813 elf_x86_64_readonly_dynrelocs
,
3816 if ((info
->flags
& DF_TEXTREL
) != 0)
3818 if (htab
->readonly_dynrelocs_against_ifunc
)
3820 info
->callbacks
->einfo
3821 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3822 bfd_set_error (bfd_error_bad_value
);
3826 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3831 #undef add_dynamic_entry
3837 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3838 struct bfd_link_info
*info
)
3840 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3844 struct elf_link_hash_entry
*tlsbase
;
3846 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3847 "_TLS_MODULE_BASE_",
3848 FALSE
, FALSE
, FALSE
);
3850 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3852 struct elf_x86_64_link_hash_table
*htab
;
3853 struct bfd_link_hash_entry
*bh
= NULL
;
3854 const struct elf_backend_data
*bed
3855 = get_elf_backend_data (output_bfd
);
3857 htab
= elf_x86_64_hash_table (info
);
3861 if (!(_bfd_generic_link_add_one_symbol
3862 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3863 tls_sec
, 0, NULL
, FALSE
,
3864 bed
->collect
, &bh
)))
3867 htab
->tls_module_base
= bh
;
3869 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3870 tlsbase
->def_regular
= 1;
3871 tlsbase
->other
= STV_HIDDEN
;
3872 tlsbase
->root
.linker_def
= 1;
3873 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3880 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3881 executables. Rather than setting it to the beginning of the TLS
3882 section, we have to set it to the end. This function may be called
3883 multiple times, it is idempotent. */
3886 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3888 struct elf_x86_64_link_hash_table
*htab
;
3889 struct bfd_link_hash_entry
*base
;
3891 if (!bfd_link_executable (info
))
3894 htab
= elf_x86_64_hash_table (info
);
3898 base
= htab
->tls_module_base
;
3902 base
->u
.def
.value
= htab
->elf
.tls_size
;
3905 /* Return the base VMA address which should be subtracted from real addresses
3906 when resolving @dtpoff relocation.
3907 This is PT_TLS segment p_vaddr. */
3910 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3912 /* If tls_sec is NULL, we should have signalled an error already. */
3913 if (elf_hash_table (info
)->tls_sec
== NULL
)
3915 return elf_hash_table (info
)->tls_sec
->vma
;
3918 /* Return the relocation value for @tpoff relocation
3919 if STT_TLS virtual address is ADDRESS. */
3922 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3924 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3925 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3926 bfd_vma static_tls_size
;
3928 /* If tls_segment is NULL, we should have signalled an error already. */
3929 if (htab
->tls_sec
== NULL
)
3932 /* Consider special static TLS alignment requirements. */
3933 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3934 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3937 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3941 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3943 /* Opcode Instruction
3946 0x0f 0x8x conditional jump */
3948 && (contents
[offset
- 1] == 0xe8
3949 || contents
[offset
- 1] == 0xe9))
3951 && contents
[offset
- 2] == 0x0f
3952 && (contents
[offset
- 1] & 0xf0) == 0x80));
3955 /* Relocate an x86_64 ELF section. */
3958 elf_x86_64_relocate_section (bfd
*output_bfd
,
3959 struct bfd_link_info
*info
,
3961 asection
*input_section
,
3963 Elf_Internal_Rela
*relocs
,
3964 Elf_Internal_Sym
*local_syms
,
3965 asection
**local_sections
)
3967 struct elf_x86_64_link_hash_table
*htab
;
3968 Elf_Internal_Shdr
*symtab_hdr
;
3969 struct elf_link_hash_entry
**sym_hashes
;
3970 bfd_vma
*local_got_offsets
;
3971 bfd_vma
*local_tlsdesc_gotents
;
3972 Elf_Internal_Rela
*rel
;
3973 Elf_Internal_Rela
*wrel
;
3974 Elf_Internal_Rela
*relend
;
3975 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3977 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3979 /* Skip if check_relocs failed. */
3980 if (input_section
->check_relocs_failed
)
3983 htab
= elf_x86_64_hash_table (info
);
3986 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3987 sym_hashes
= elf_sym_hashes (input_bfd
);
3988 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3989 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3991 elf_x86_64_set_tls_module_base (info
);
3993 rel
= wrel
= relocs
;
3994 relend
= relocs
+ input_section
->reloc_count
;
3995 for (; rel
< relend
; wrel
++, rel
++)
3997 unsigned int r_type
;
3998 reloc_howto_type
*howto
;
3999 unsigned long r_symndx
;
4000 struct elf_link_hash_entry
*h
;
4001 struct elf_x86_64_link_hash_entry
*eh
;
4002 Elf_Internal_Sym
*sym
;
4004 bfd_vma off
, offplt
, plt_offset
;
4006 bfd_boolean unresolved_reloc
;
4007 bfd_reloc_status_type r
;
4009 asection
*base_got
, *resolved_plt
;
4011 bfd_boolean resolved_to_zero
;
4013 r_type
= ELF32_R_TYPE (rel
->r_info
);
4014 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4015 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4022 if (r_type
>= (int) R_X86_64_standard
)
4024 (*_bfd_error_handler
)
4025 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4026 input_bfd
, input_section
, r_type
);
4027 bfd_set_error (bfd_error_bad_value
);
4031 if (r_type
!= (int) R_X86_64_32
4032 || ABI_64_P (output_bfd
))
4033 howto
= x86_64_elf_howto_table
+ r_type
;
4035 howto
= (x86_64_elf_howto_table
4036 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4037 r_symndx
= htab
->r_sym (rel
->r_info
);
4041 unresolved_reloc
= FALSE
;
4042 if (r_symndx
< symtab_hdr
->sh_info
)
4044 sym
= local_syms
+ r_symndx
;
4045 sec
= local_sections
[r_symndx
];
4047 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4049 st_size
= sym
->st_size
;
4051 /* Relocate against local STT_GNU_IFUNC symbol. */
4052 if (!bfd_link_relocatable (info
)
4053 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4055 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4060 /* Set STT_GNU_IFUNC symbol value. */
4061 h
->root
.u
.def
.value
= sym
->st_value
;
4062 h
->root
.u
.def
.section
= sec
;
4067 bfd_boolean warned ATTRIBUTE_UNUSED
;
4068 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4070 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4071 r_symndx
, symtab_hdr
, sym_hashes
,
4073 unresolved_reloc
, warned
, ignored
);
4077 if (sec
!= NULL
&& discarded_section (sec
))
4079 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4080 contents
+ rel
->r_offset
);
4081 wrel
->r_offset
= rel
->r_offset
;
4085 /* For ld -r, remove relocations in debug sections against
4086 sections defined in discarded sections. Not done for
4087 eh_frame editing code expects to be present. */
4088 if (bfd_link_relocatable (info
)
4089 && (input_section
->flags
& SEC_DEBUGGING
))
4095 if (bfd_link_relocatable (info
))
4102 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4104 if (r_type
== R_X86_64_64
)
4106 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4107 zero-extend it to 64bit if addend is zero. */
4108 r_type
= R_X86_64_32
;
4109 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4111 else if (r_type
== R_X86_64_SIZE64
)
4113 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4114 zero-extend it to 64bit if addend is zero. */
4115 r_type
= R_X86_64_SIZE32
;
4116 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4120 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4122 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4123 it here if it is defined in a non-shared object. */
4125 && h
->type
== STT_GNU_IFUNC
4131 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4133 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4134 sections because such sections are not SEC_ALLOC and
4135 thus ld.so will not process them. */
4136 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4140 else if (h
->plt
.offset
== (bfd_vma
) -1)
4143 /* STT_GNU_IFUNC symbol must go through PLT. */
4144 if (htab
->elf
.splt
!= NULL
)
4146 if (htab
->plt_bnd
!= NULL
)
4148 resolved_plt
= htab
->plt_bnd
;
4149 plt_offset
= eh
->plt_bnd
.offset
;
4153 resolved_plt
= htab
->elf
.splt
;
4154 plt_offset
= h
->plt
.offset
;
4159 resolved_plt
= htab
->elf
.iplt
;
4160 plt_offset
= h
->plt
.offset
;
4163 relocation
= (resolved_plt
->output_section
->vma
4164 + resolved_plt
->output_offset
+ plt_offset
);
4169 if (h
->root
.root
.string
)
4170 name
= h
->root
.root
.string
;
4172 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4174 (*_bfd_error_handler
)
4175 (_("%B: relocation %s against STT_GNU_IFUNC "
4176 "symbol `%s' isn't handled by %s"), input_bfd
,
4177 howto
->name
, name
, __FUNCTION__
);
4178 bfd_set_error (bfd_error_bad_value
);
4182 if (bfd_link_pic (info
))
4187 if (ABI_64_P (output_bfd
))
4191 if (rel
->r_addend
!= 0)
4193 if (h
->root
.root
.string
)
4194 name
= h
->root
.root
.string
;
4196 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4198 (*_bfd_error_handler
)
4199 (_("%B: relocation %s against STT_GNU_IFUNC "
4200 "symbol `%s' has non-zero addend: %d"),
4201 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4202 bfd_set_error (bfd_error_bad_value
);
4206 /* Generate dynamic relcoation only when there is a
4207 non-GOT reference in a shared object. */
4208 if (bfd_link_pic (info
) && h
->non_got_ref
)
4210 Elf_Internal_Rela outrel
;
4213 /* Need a dynamic relocation to get the real function
4215 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4219 if (outrel
.r_offset
== (bfd_vma
) -1
4220 || outrel
.r_offset
== (bfd_vma
) -2)
4223 outrel
.r_offset
+= (input_section
->output_section
->vma
4224 + input_section
->output_offset
);
4226 if (h
->dynindx
== -1
4228 || bfd_link_executable (info
))
4230 /* This symbol is resolved locally. */
4231 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4232 outrel
.r_addend
= (h
->root
.u
.def
.value
4233 + h
->root
.u
.def
.section
->output_section
->vma
4234 + h
->root
.u
.def
.section
->output_offset
);
4238 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4239 outrel
.r_addend
= 0;
4242 sreloc
= htab
->elf
.irelifunc
;
4243 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4245 /* If this reloc is against an external symbol, we
4246 do not want to fiddle with the addend. Otherwise,
4247 we need to include the symbol value so that it
4248 becomes an addend for the dynamic reloc. For an
4249 internal symbol, we have updated addend. */
4254 case R_X86_64_PC32_BND
:
4256 case R_X86_64_PLT32
:
4257 case R_X86_64_PLT32_BND
:
4260 case R_X86_64_GOTPCREL
:
4261 case R_X86_64_GOTPCRELX
:
4262 case R_X86_64_REX_GOTPCRELX
:
4263 case R_X86_64_GOTPCREL64
:
4264 base_got
= htab
->elf
.sgot
;
4265 off
= h
->got
.offset
;
4267 if (base_got
== NULL
)
4270 if (off
== (bfd_vma
) -1)
4272 /* We can't use h->got.offset here to save state, or
4273 even just remember the offset, as finish_dynamic_symbol
4274 would use that as offset into .got. */
4276 if (htab
->elf
.splt
!= NULL
)
4278 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4279 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4280 base_got
= htab
->elf
.sgotplt
;
4284 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4285 off
= plt_index
* GOT_ENTRY_SIZE
;
4286 base_got
= htab
->elf
.igotplt
;
4289 if (h
->dynindx
== -1
4293 /* This references the local defitionion. We must
4294 initialize this entry in the global offset table.
4295 Since the offset must always be a multiple of 8,
4296 we use the least significant bit to record
4297 whether we have initialized it already.
4299 When doing a dynamic link, we create a .rela.got
4300 relocation entry to initialize the value. This
4301 is done in the finish_dynamic_symbol routine. */
4306 bfd_put_64 (output_bfd
, relocation
,
4307 base_got
->contents
+ off
);
4308 /* Note that this is harmless for the GOTPLT64
4309 case, as -1 | 1 still is -1. */
4315 relocation
= (base_got
->output_section
->vma
4316 + base_got
->output_offset
+ off
);
4322 resolved_to_zero
= (eh
!= NULL
4323 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4327 /* When generating a shared object, the relocations handled here are
4328 copied into the output file to be resolved at run time. */
4331 case R_X86_64_GOT32
:
4332 case R_X86_64_GOT64
:
4333 /* Relocation is to the entry for this symbol in the global
4335 case R_X86_64_GOTPCREL
:
4336 case R_X86_64_GOTPCRELX
:
4337 case R_X86_64_REX_GOTPCRELX
:
4338 case R_X86_64_GOTPCREL64
:
4339 /* Use global offset table entry as symbol value. */
4340 case R_X86_64_GOTPLT64
:
4341 /* This is obsolete and treated the the same as GOT64. */
4342 base_got
= htab
->elf
.sgot
;
4344 if (htab
->elf
.sgot
== NULL
)
4351 off
= h
->got
.offset
;
4353 && h
->plt
.offset
!= (bfd_vma
)-1
4354 && off
== (bfd_vma
)-1)
4356 /* We can't use h->got.offset here to save
4357 state, or even just remember the offset, as
4358 finish_dynamic_symbol would use that as offset into
4360 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4361 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4362 base_got
= htab
->elf
.sgotplt
;
4365 dyn
= htab
->elf
.dynamic_sections_created
;
4367 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4368 || (bfd_link_pic (info
)
4369 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4370 || (ELF_ST_VISIBILITY (h
->other
)
4371 && h
->root
.type
== bfd_link_hash_undefweak
))
4373 /* This is actually a static link, or it is a -Bsymbolic
4374 link and the symbol is defined locally, or the symbol
4375 was forced to be local because of a version file. We
4376 must initialize this entry in the global offset table.
4377 Since the offset must always be a multiple of 8, we
4378 use the least significant bit to record whether we
4379 have initialized it already.
4381 When doing a dynamic link, we create a .rela.got
4382 relocation entry to initialize the value. This is
4383 done in the finish_dynamic_symbol routine. */
4388 bfd_put_64 (output_bfd
, relocation
,
4389 base_got
->contents
+ off
);
4390 /* Note that this is harmless for the GOTPLT64 case,
4391 as -1 | 1 still is -1. */
4396 unresolved_reloc
= FALSE
;
4400 if (local_got_offsets
== NULL
)
4403 off
= local_got_offsets
[r_symndx
];
4405 /* The offset must always be a multiple of 8. We use
4406 the least significant bit to record whether we have
4407 already generated the necessary reloc. */
4412 bfd_put_64 (output_bfd
, relocation
,
4413 base_got
->contents
+ off
);
4415 if (bfd_link_pic (info
))
4418 Elf_Internal_Rela outrel
;
4420 /* We need to generate a R_X86_64_RELATIVE reloc
4421 for the dynamic linker. */
4422 s
= htab
->elf
.srelgot
;
4426 outrel
.r_offset
= (base_got
->output_section
->vma
4427 + base_got
->output_offset
4429 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4430 outrel
.r_addend
= relocation
;
4431 elf_append_rela (output_bfd
, s
, &outrel
);
4434 local_got_offsets
[r_symndx
] |= 1;
4438 if (off
>= (bfd_vma
) -2)
4441 relocation
= base_got
->output_section
->vma
4442 + base_got
->output_offset
+ off
;
4443 if (r_type
!= R_X86_64_GOTPCREL
4444 && r_type
!= R_X86_64_GOTPCRELX
4445 && r_type
!= R_X86_64_REX_GOTPCRELX
4446 && r_type
!= R_X86_64_GOTPCREL64
)
4447 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4448 - htab
->elf
.sgotplt
->output_offset
;
4452 case R_X86_64_GOTOFF64
:
4453 /* Relocation is relative to the start of the global offset
4456 /* Check to make sure it isn't a protected function or data
4457 symbol for shared library since it may not be local when
4458 used as function address or with copy relocation. We also
4459 need to make sure that a symbol is referenced locally. */
4460 if (bfd_link_pic (info
) && h
)
4462 if (!h
->def_regular
)
4466 switch (ELF_ST_VISIBILITY (h
->other
))
4469 v
= _("hidden symbol");
4472 v
= _("internal symbol");
4475 v
= _("protected symbol");
4482 (*_bfd_error_handler
)
4483 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4484 input_bfd
, v
, h
->root
.root
.string
);
4485 bfd_set_error (bfd_error_bad_value
);
4488 else if (!bfd_link_executable (info
)
4489 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4490 && (h
->type
== STT_FUNC
4491 || h
->type
== STT_OBJECT
)
4492 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4494 (*_bfd_error_handler
)
4495 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4497 h
->type
== STT_FUNC
? "function" : "data",
4498 h
->root
.root
.string
);
4499 bfd_set_error (bfd_error_bad_value
);
4504 /* Note that sgot is not involved in this
4505 calculation. We always want the start of .got.plt. If we
4506 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4507 permitted by the ABI, we might have to change this
4509 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4510 + htab
->elf
.sgotplt
->output_offset
;
4513 case R_X86_64_GOTPC32
:
4514 case R_X86_64_GOTPC64
:
4515 /* Use global offset table as symbol value. */
4516 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4517 + htab
->elf
.sgotplt
->output_offset
;
4518 unresolved_reloc
= FALSE
;
4521 case R_X86_64_PLTOFF64
:
4522 /* Relocation is PLT entry relative to GOT. For local
4523 symbols it's the symbol itself relative to GOT. */
4525 /* See PLT32 handling. */
4526 && h
->plt
.offset
!= (bfd_vma
) -1
4527 && htab
->elf
.splt
!= NULL
)
4529 if (htab
->plt_bnd
!= NULL
)
4531 resolved_plt
= htab
->plt_bnd
;
4532 plt_offset
= eh
->plt_bnd
.offset
;
4536 resolved_plt
= htab
->elf
.splt
;
4537 plt_offset
= h
->plt
.offset
;
4540 relocation
= (resolved_plt
->output_section
->vma
4541 + resolved_plt
->output_offset
4543 unresolved_reloc
= FALSE
;
4546 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4547 + htab
->elf
.sgotplt
->output_offset
;
4550 case R_X86_64_PLT32
:
4551 case R_X86_64_PLT32_BND
:
4552 /* Relocation is to the entry for this symbol in the
4553 procedure linkage table. */
4555 /* Resolve a PLT32 reloc against a local symbol directly,
4556 without using the procedure linkage table. */
4560 if ((h
->plt
.offset
== (bfd_vma
) -1
4561 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4562 || htab
->elf
.splt
== NULL
)
4564 /* We didn't make a PLT entry for this symbol. This
4565 happens when statically linking PIC code, or when
4566 using -Bsymbolic. */
4570 if (h
->plt
.offset
!= (bfd_vma
) -1)
4572 if (htab
->plt_bnd
!= NULL
)
4574 resolved_plt
= htab
->plt_bnd
;
4575 plt_offset
= eh
->plt_bnd
.offset
;
4579 resolved_plt
= htab
->elf
.splt
;
4580 plt_offset
= h
->plt
.offset
;
4585 /* Use the GOT PLT. */
4586 resolved_plt
= htab
->plt_got
;
4587 plt_offset
= eh
->plt_got
.offset
;
4590 relocation
= (resolved_plt
->output_section
->vma
4591 + resolved_plt
->output_offset
4593 unresolved_reloc
= FALSE
;
4596 case R_X86_64_SIZE32
:
4597 case R_X86_64_SIZE64
:
4598 /* Set to symbol size. */
4599 relocation
= st_size
;
4605 case R_X86_64_PC32_BND
:
4606 /* Don't complain about -fPIC if the symbol is undefined when
4607 building executable unless it is unresolved weak symbol. */
4608 if ((input_section
->flags
& SEC_ALLOC
) != 0
4609 && (input_section
->flags
& SEC_READONLY
) != 0
4611 && ((bfd_link_executable (info
)
4612 && h
->root
.type
== bfd_link_hash_undefweak
4613 && !resolved_to_zero
)
4614 || (bfd_link_pic (info
)
4615 && !(bfd_link_pie (info
)
4616 && h
->root
.type
== bfd_link_hash_undefined
))))
4618 bfd_boolean fail
= FALSE
;
4620 = ((r_type
== R_X86_64_PC32
4621 || r_type
== R_X86_64_PC32_BND
)
4622 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4624 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4626 /* Symbol is referenced locally. Make sure it is
4627 defined locally or for a branch. */
4628 fail
= !h
->def_regular
&& !branch
;
4630 else if (!(bfd_link_pie (info
)
4631 && (h
->needs_copy
|| eh
->needs_copy
)))
4633 /* Symbol doesn't need copy reloc and isn't referenced
4634 locally. We only allow branch to symbol with
4635 non-default visibility. */
4637 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4641 return elf_x86_64_need_pic (input_bfd
, input_section
,
4642 h
, NULL
, NULL
, howto
);
4651 /* FIXME: The ABI says the linker should make sure the value is
4652 the same when it's zeroextended to 64 bit. */
4655 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4658 /* Don't copy a pc-relative relocation into the output file
4659 if the symbol needs copy reloc or the symbol is undefined
4660 when building executable. Copy dynamic function pointer
4661 relocations. Don't generate dynamic relocations against
4662 resolved undefined weak symbols in PIE. */
4663 if ((bfd_link_pic (info
)
4664 && !(bfd_link_pie (info
)
4668 || h
->root
.type
== bfd_link_hash_undefined
)
4669 && IS_X86_64_PCREL_TYPE (r_type
))
4671 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4672 && !resolved_to_zero
)
4673 || h
->root
.type
!= bfd_link_hash_undefweak
))
4674 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4675 && r_type
!= R_X86_64_SIZE32
4676 && r_type
!= R_X86_64_SIZE64
)
4677 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4678 || (ELIMINATE_COPY_RELOCS
4679 && !bfd_link_pic (info
)
4683 || eh
->func_pointer_refcount
> 0
4684 || (h
->root
.type
== bfd_link_hash_undefweak
4685 && !resolved_to_zero
))
4686 && ((h
->def_dynamic
&& !h
->def_regular
)
4687 /* Undefined weak symbol is bound locally when
4689 || h
->root
.type
== bfd_link_hash_undefined
)))
4691 Elf_Internal_Rela outrel
;
4692 bfd_boolean skip
, relocate
;
4695 /* When generating a shared object, these relocations
4696 are copied into the output file to be resolved at run
4702 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4704 if (outrel
.r_offset
== (bfd_vma
) -1)
4706 else if (outrel
.r_offset
== (bfd_vma
) -2)
4707 skip
= TRUE
, relocate
= TRUE
;
4709 outrel
.r_offset
+= (input_section
->output_section
->vma
4710 + input_section
->output_offset
);
4713 memset (&outrel
, 0, sizeof outrel
);
4715 /* h->dynindx may be -1 if this symbol was marked to
4719 && (IS_X86_64_PCREL_TYPE (r_type
)
4720 || !(bfd_link_executable (info
)
4721 || SYMBOLIC_BIND (info
, h
))
4722 || ! h
->def_regular
))
4724 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4725 outrel
.r_addend
= rel
->r_addend
;
4729 /* This symbol is local, or marked to become local.
4730 When relocation overflow check is disabled, we
4731 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4732 if (r_type
== htab
->pointer_r_type
4733 || (r_type
== R_X86_64_32
4734 && info
->no_reloc_overflow_check
))
4737 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4738 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4740 else if (r_type
== R_X86_64_64
4741 && !ABI_64_P (output_bfd
))
4744 outrel
.r_info
= htab
->r_info (0,
4745 R_X86_64_RELATIVE64
);
4746 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4747 /* Check addend overflow. */
4748 if ((outrel
.r_addend
& 0x80000000)
4749 != (rel
->r_addend
& 0x80000000))
4752 int addend
= rel
->r_addend
;
4753 if (h
&& h
->root
.root
.string
)
4754 name
= h
->root
.root
.string
;
4756 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4759 (*_bfd_error_handler
)
4760 (_("%B: addend -0x%x in relocation %s against "
4761 "symbol `%s' at 0x%lx in section `%A' is "
4763 input_bfd
, input_section
, addend
,
4765 (unsigned long) rel
->r_offset
);
4767 (*_bfd_error_handler
)
4768 (_("%B: addend 0x%x in relocation %s against "
4769 "symbol `%s' at 0x%lx in section `%A' is "
4771 input_bfd
, input_section
, addend
,
4773 (unsigned long) rel
->r_offset
);
4774 bfd_set_error (bfd_error_bad_value
);
4782 if (bfd_is_abs_section (sec
))
4784 else if (sec
== NULL
|| sec
->owner
== NULL
)
4786 bfd_set_error (bfd_error_bad_value
);
4793 /* We are turning this relocation into one
4794 against a section symbol. It would be
4795 proper to subtract the symbol's value,
4796 osec->vma, from the emitted reloc addend,
4797 but ld.so expects buggy relocs. */
4798 osec
= sec
->output_section
;
4799 sindx
= elf_section_data (osec
)->dynindx
;
4802 asection
*oi
= htab
->elf
.text_index_section
;
4803 sindx
= elf_section_data (oi
)->dynindx
;
4805 BFD_ASSERT (sindx
!= 0);
4808 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4809 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4813 sreloc
= elf_section_data (input_section
)->sreloc
;
4815 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4817 r
= bfd_reloc_notsupported
;
4818 goto check_relocation_error
;
4821 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4823 /* If this reloc is against an external symbol, we do
4824 not want to fiddle with the addend. Otherwise, we
4825 need to include the symbol value so that it becomes
4826 an addend for the dynamic reloc. */
4833 case R_X86_64_TLSGD
:
4834 case R_X86_64_GOTPC32_TLSDESC
:
4835 case R_X86_64_TLSDESC_CALL
:
4836 case R_X86_64_GOTTPOFF
:
4837 tls_type
= GOT_UNKNOWN
;
4838 if (h
== NULL
&& local_got_offsets
)
4839 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4841 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4843 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4844 input_section
, contents
,
4845 symtab_hdr
, sym_hashes
,
4846 &r_type
, tls_type
, rel
,
4847 relend
, h
, r_symndx
, TRUE
))
4850 if (r_type
== R_X86_64_TPOFF32
)
4852 bfd_vma roff
= rel
->r_offset
;
4854 BFD_ASSERT (! unresolved_reloc
);
4856 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4858 /* GD->LE transition. For 64bit, change
4859 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4860 .word 0x6666; rex64; call __tls_get_addr
4863 leaq foo@tpoff(%rax), %rax
4865 leaq foo@tlsgd(%rip), %rdi
4866 .word 0x6666; rex64; call __tls_get_addr
4869 leaq foo@tpoff(%rax), %rax
4870 For largepic, change:
4871 leaq foo@tlsgd(%rip), %rdi
4872 movabsq $__tls_get_addr@pltoff, %rax
4877 leaq foo@tpoff(%rax), %rax
4878 nopw 0x0(%rax,%rax,1) */
4880 if (ABI_64_P (output_bfd
)
4881 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4883 memcpy (contents
+ roff
- 3,
4884 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4885 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4888 else if (ABI_64_P (output_bfd
))
4889 memcpy (contents
+ roff
- 4,
4890 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4893 memcpy (contents
+ roff
- 3,
4894 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4896 bfd_put_32 (output_bfd
,
4897 elf_x86_64_tpoff (info
, relocation
),
4898 contents
+ roff
+ 8 + largepic
);
4899 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4904 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4906 /* GDesc -> LE transition.
4907 It's originally something like:
4908 leaq x@tlsdesc(%rip), %rax
4911 movl $x@tpoff, %rax. */
4913 unsigned int val
, type
;
4915 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4916 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4917 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4918 contents
+ roff
- 3);
4919 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4920 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4921 contents
+ roff
- 1);
4922 bfd_put_32 (output_bfd
,
4923 elf_x86_64_tpoff (info
, relocation
),
4927 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4929 /* GDesc -> LE transition.
4934 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4935 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4938 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4940 /* IE->LE transition:
4941 For 64bit, originally it can be one of:
4942 movq foo@gottpoff(%rip), %reg
4943 addq foo@gottpoff(%rip), %reg
4946 leaq foo(%reg), %reg
4948 For 32bit, originally it can be one of:
4949 movq foo@gottpoff(%rip), %reg
4950 addl foo@gottpoff(%rip), %reg
4953 leal foo(%reg), %reg
4956 unsigned int val
, type
, reg
;
4959 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4962 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4963 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4969 bfd_put_8 (output_bfd
, 0x49,
4970 contents
+ roff
- 3);
4971 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4972 bfd_put_8 (output_bfd
, 0x41,
4973 contents
+ roff
- 3);
4974 bfd_put_8 (output_bfd
, 0xc7,
4975 contents
+ roff
- 2);
4976 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4977 contents
+ roff
- 1);
4981 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4984 bfd_put_8 (output_bfd
, 0x49,
4985 contents
+ roff
- 3);
4986 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4987 bfd_put_8 (output_bfd
, 0x41,
4988 contents
+ roff
- 3);
4989 bfd_put_8 (output_bfd
, 0x81,
4990 contents
+ roff
- 2);
4991 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4992 contents
+ roff
- 1);
4996 /* addq/addl -> leaq/leal */
4998 bfd_put_8 (output_bfd
, 0x4d,
4999 contents
+ roff
- 3);
5000 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5001 bfd_put_8 (output_bfd
, 0x45,
5002 contents
+ roff
- 3);
5003 bfd_put_8 (output_bfd
, 0x8d,
5004 contents
+ roff
- 2);
5005 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5006 contents
+ roff
- 1);
5008 bfd_put_32 (output_bfd
,
5009 elf_x86_64_tpoff (info
, relocation
),
5017 if (htab
->elf
.sgot
== NULL
)
5022 off
= h
->got
.offset
;
5023 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5027 if (local_got_offsets
== NULL
)
5030 off
= local_got_offsets
[r_symndx
];
5031 offplt
= local_tlsdesc_gotents
[r_symndx
];
5038 Elf_Internal_Rela outrel
;
5042 if (htab
->elf
.srelgot
== NULL
)
5045 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5047 if (GOT_TLS_GDESC_P (tls_type
))
5049 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5050 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5051 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5052 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5053 + htab
->elf
.sgotplt
->output_offset
5055 + htab
->sgotplt_jump_table_size
);
5056 sreloc
= htab
->elf
.srelplt
;
5058 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5060 outrel
.r_addend
= 0;
5061 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5064 sreloc
= htab
->elf
.srelgot
;
5066 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5067 + htab
->elf
.sgot
->output_offset
+ off
);
5069 if (GOT_TLS_GD_P (tls_type
))
5070 dr_type
= R_X86_64_DTPMOD64
;
5071 else if (GOT_TLS_GDESC_P (tls_type
))
5074 dr_type
= R_X86_64_TPOFF64
;
5076 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5077 outrel
.r_addend
= 0;
5078 if ((dr_type
== R_X86_64_TPOFF64
5079 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5080 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5081 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5083 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5085 if (GOT_TLS_GD_P (tls_type
))
5089 BFD_ASSERT (! unresolved_reloc
);
5090 bfd_put_64 (output_bfd
,
5091 relocation
- elf_x86_64_dtpoff_base (info
),
5092 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5096 bfd_put_64 (output_bfd
, 0,
5097 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5098 outrel
.r_info
= htab
->r_info (indx
,
5100 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5101 elf_append_rela (output_bfd
, sreloc
,
5110 local_got_offsets
[r_symndx
] |= 1;
5113 if (off
>= (bfd_vma
) -2
5114 && ! GOT_TLS_GDESC_P (tls_type
))
5116 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5118 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5119 || r_type
== R_X86_64_TLSDESC_CALL
)
5120 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5121 + htab
->elf
.sgotplt
->output_offset
5122 + offplt
+ htab
->sgotplt_jump_table_size
;
5124 relocation
= htab
->elf
.sgot
->output_section
->vma
5125 + htab
->elf
.sgot
->output_offset
+ off
;
5126 unresolved_reloc
= FALSE
;
5130 bfd_vma roff
= rel
->r_offset
;
5132 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5134 /* GD->IE transition. For 64bit, change
5135 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5136 .word 0x6666; rex64; call __tls_get_addr@plt
5139 addq foo@gottpoff(%rip), %rax
5141 leaq foo@tlsgd(%rip), %rdi
5142 .word 0x6666; rex64; call __tls_get_addr@plt
5145 addq foo@gottpoff(%rip), %rax
5146 For largepic, change:
5147 leaq foo@tlsgd(%rip), %rdi
5148 movabsq $__tls_get_addr@pltoff, %rax
5153 addq foo@gottpoff(%rax), %rax
5154 nopw 0x0(%rax,%rax,1) */
5156 if (ABI_64_P (output_bfd
)
5157 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5159 memcpy (contents
+ roff
- 3,
5160 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5161 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5164 else if (ABI_64_P (output_bfd
))
5165 memcpy (contents
+ roff
- 4,
5166 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5169 memcpy (contents
+ roff
- 3,
5170 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5173 relocation
= (htab
->elf
.sgot
->output_section
->vma
5174 + htab
->elf
.sgot
->output_offset
+ off
5177 - input_section
->output_section
->vma
5178 - input_section
->output_offset
5180 bfd_put_32 (output_bfd
, relocation
,
5181 contents
+ roff
+ 8 + largepic
);
5182 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5187 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5189 /* GDesc -> IE transition.
5190 It's originally something like:
5191 leaq x@tlsdesc(%rip), %rax
5194 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5196 /* Now modify the instruction as appropriate. To
5197 turn a leaq into a movq in the form we use it, it
5198 suffices to change the second byte from 0x8d to
5200 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5202 bfd_put_32 (output_bfd
,
5203 htab
->elf
.sgot
->output_section
->vma
5204 + htab
->elf
.sgot
->output_offset
+ off
5206 - input_section
->output_section
->vma
5207 - input_section
->output_offset
5212 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5214 /* GDesc -> IE transition.
5221 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5222 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5230 case R_X86_64_TLSLD
:
5231 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5232 input_section
, contents
,
5233 symtab_hdr
, sym_hashes
,
5234 &r_type
, GOT_UNKNOWN
, rel
,
5235 relend
, h
, r_symndx
, TRUE
))
5238 if (r_type
!= R_X86_64_TLSLD
)
5240 /* LD->LE transition:
5241 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5242 For 64bit, we change it into:
5243 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5244 For 32bit, we change it into:
5245 nopl 0x0(%rax); movl %fs:0, %eax.
5246 For largepic, change:
5247 leaq foo@tlsgd(%rip), %rdi
5248 movabsq $__tls_get_addr@pltoff, %rax
5252 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5255 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5256 if (ABI_64_P (output_bfd
)
5257 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5258 memcpy (contents
+ rel
->r_offset
- 3,
5259 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5260 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5261 else if (ABI_64_P (output_bfd
))
5262 memcpy (contents
+ rel
->r_offset
- 3,
5263 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5265 memcpy (contents
+ rel
->r_offset
- 3,
5266 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5267 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5273 if (htab
->elf
.sgot
== NULL
)
5276 off
= htab
->tls_ld_got
.offset
;
5281 Elf_Internal_Rela outrel
;
5283 if (htab
->elf
.srelgot
== NULL
)
5286 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5287 + htab
->elf
.sgot
->output_offset
+ off
);
5289 bfd_put_64 (output_bfd
, 0,
5290 htab
->elf
.sgot
->contents
+ off
);
5291 bfd_put_64 (output_bfd
, 0,
5292 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5293 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5294 outrel
.r_addend
= 0;
5295 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5297 htab
->tls_ld_got
.offset
|= 1;
5299 relocation
= htab
->elf
.sgot
->output_section
->vma
5300 + htab
->elf
.sgot
->output_offset
+ off
;
5301 unresolved_reloc
= FALSE
;
5304 case R_X86_64_DTPOFF32
:
5305 if (!bfd_link_executable (info
)
5306 || (input_section
->flags
& SEC_CODE
) == 0)
5307 relocation
-= elf_x86_64_dtpoff_base (info
);
5309 relocation
= elf_x86_64_tpoff (info
, relocation
);
5312 case R_X86_64_TPOFF32
:
5313 case R_X86_64_TPOFF64
:
5314 BFD_ASSERT (bfd_link_executable (info
));
5315 relocation
= elf_x86_64_tpoff (info
, relocation
);
5318 case R_X86_64_DTPOFF64
:
5319 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5320 relocation
-= elf_x86_64_dtpoff_base (info
);
5327 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5328 because such sections are not SEC_ALLOC and thus ld.so will
5329 not process them. */
5330 if (unresolved_reloc
5331 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5333 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5334 rel
->r_offset
) != (bfd_vma
) -1)
5336 (*_bfd_error_handler
)
5337 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5340 (long) rel
->r_offset
,
5342 h
->root
.root
.string
);
5347 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5348 contents
, rel
->r_offset
,
5349 relocation
, rel
->r_addend
);
5351 check_relocation_error
:
5352 if (r
!= bfd_reloc_ok
)
5357 name
= h
->root
.root
.string
;
5360 name
= bfd_elf_string_from_elf_section (input_bfd
,
5361 symtab_hdr
->sh_link
,
5366 name
= bfd_section_name (input_bfd
, sec
);
5369 if (r
== bfd_reloc_overflow
)
5371 if (! ((*info
->callbacks
->reloc_overflow
)
5372 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5373 (bfd_vma
) 0, input_bfd
, input_section
,
5379 (*_bfd_error_handler
)
5380 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5381 input_bfd
, input_section
,
5382 (long) rel
->r_offset
, name
, (int) r
);
5393 Elf_Internal_Shdr
*rel_hdr
;
5394 size_t deleted
= rel
- wrel
;
5396 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5397 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5398 if (rel_hdr
->sh_size
== 0)
5400 /* It is too late to remove an empty reloc section. Leave
5402 ??? What is wrong with an empty section??? */
5403 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5406 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5407 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5408 input_section
->reloc_count
-= deleted
;
5414 /* Finish up dynamic symbol handling. We set the contents of various
5415 dynamic sections here. */
5418 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5419 struct bfd_link_info
*info
,
5420 struct elf_link_hash_entry
*h
,
5421 Elf_Internal_Sym
*sym
)
5423 struct elf_x86_64_link_hash_table
*htab
;
5424 const struct elf_x86_64_backend_data
*abed
;
5425 bfd_boolean use_plt_bnd
;
5426 struct elf_x86_64_link_hash_entry
*eh
;
5427 bfd_boolean local_undefweak
;
5429 htab
= elf_x86_64_hash_table (info
);
5433 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5434 section only if there is .plt section. */
5435 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5437 ? &elf_x86_64_bnd_arch_bed
5438 : get_elf_x86_64_backend_data (output_bfd
));
5440 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5442 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5443 resolved undefined weak symbols in executable so that their
5444 references have value 0 at run-time. */
5445 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5449 if (h
->plt
.offset
!= (bfd_vma
) -1)
5452 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5453 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5454 Elf_Internal_Rela rela
;
5456 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5457 const struct elf_backend_data
*bed
;
5458 bfd_vma plt_got_pcrel_offset
;
5460 /* When building a static executable, use .iplt, .igot.plt and
5461 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5462 if (htab
->elf
.splt
!= NULL
)
5464 plt
= htab
->elf
.splt
;
5465 gotplt
= htab
->elf
.sgotplt
;
5466 relplt
= htab
->elf
.srelplt
;
5470 plt
= htab
->elf
.iplt
;
5471 gotplt
= htab
->elf
.igotplt
;
5472 relplt
= htab
->elf
.irelplt
;
5475 /* This symbol has an entry in the procedure linkage table. Set
5477 if ((h
->dynindx
== -1
5479 && !((h
->forced_local
|| bfd_link_executable (info
))
5481 && h
->type
== STT_GNU_IFUNC
))
5487 /* Get the index in the procedure linkage table which
5488 corresponds to this symbol. This is the index of this symbol
5489 in all the symbols for which we are making plt entries. The
5490 first entry in the procedure linkage table is reserved.
5492 Get the offset into the .got table of the entry that
5493 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5494 bytes. The first three are reserved for the dynamic linker.
5496 For static executables, we don't reserve anything. */
5498 if (plt
== htab
->elf
.splt
)
5500 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5501 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5505 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5506 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5509 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5510 plt_plt_offset
= abed
->plt_plt_offset
;
5511 plt_got_insn_size
= abed
->plt_got_insn_size
;
5512 plt_got_offset
= abed
->plt_got_offset
;
5515 /* Use the second PLT with BND relocations. */
5516 const bfd_byte
*plt_entry
, *plt2_entry
;
5518 if (eh
->has_bnd_reloc
)
5520 plt_entry
= elf_x86_64_bnd_plt_entry
;
5521 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5525 plt_entry
= elf_x86_64_legacy_plt_entry
;
5526 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5528 /* Subtract 1 since there is no BND prefix. */
5529 plt_plt_insn_end
-= 1;
5530 plt_plt_offset
-= 1;
5531 plt_got_insn_size
-= 1;
5532 plt_got_offset
-= 1;
5535 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5536 == sizeof (elf_x86_64_legacy_plt_entry
));
5538 /* Fill in the entry in the procedure linkage table. */
5539 memcpy (plt
->contents
+ h
->plt
.offset
,
5540 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5541 /* Fill in the entry in the second PLT. */
5542 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5543 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5545 resolved_plt
= htab
->plt_bnd
;
5546 plt_offset
= eh
->plt_bnd
.offset
;
5550 /* Fill in the entry in the procedure linkage table. */
5551 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5552 abed
->plt_entry_size
);
5555 plt_offset
= h
->plt
.offset
;
5558 /* Insert the relocation positions of the plt section. */
5560 /* Put offset the PC-relative instruction referring to the GOT entry,
5561 subtracting the size of that instruction. */
5562 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5563 + gotplt
->output_offset
5565 - resolved_plt
->output_section
->vma
5566 - resolved_plt
->output_offset
5568 - plt_got_insn_size
);
5570 /* Check PC-relative offset overflow in PLT entry. */
5571 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5572 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5573 output_bfd
, h
->root
.root
.string
);
5575 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5576 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5578 /* Fill in the entry in the global offset table, initially this
5579 points to the second part of the PLT entry. Leave the entry
5580 as zero for undefined weak symbol in PIE. No PLT relocation
5581 against undefined weak symbol in PIE. */
5582 if (!local_undefweak
)
5584 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5585 + plt
->output_offset
5587 + abed
->plt_lazy_offset
),
5588 gotplt
->contents
+ got_offset
);
5590 /* Fill in the entry in the .rela.plt section. */
5591 rela
.r_offset
= (gotplt
->output_section
->vma
5592 + gotplt
->output_offset
5594 if (h
->dynindx
== -1
5595 || ((bfd_link_executable (info
)
5596 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5598 && h
->type
== STT_GNU_IFUNC
))
5600 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5601 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5602 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5603 rela
.r_addend
= (h
->root
.u
.def
.value
5604 + h
->root
.u
.def
.section
->output_section
->vma
5605 + h
->root
.u
.def
.section
->output_offset
);
5606 /* R_X86_64_IRELATIVE comes last. */
5607 plt_index
= htab
->next_irelative_index
--;
5611 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5613 plt_index
= htab
->next_jump_slot_index
++;
5616 /* Don't fill PLT entry for static executables. */
5617 if (plt
== htab
->elf
.splt
)
5619 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5621 /* Put relocation index. */
5622 bfd_put_32 (output_bfd
, plt_index
,
5623 (plt
->contents
+ h
->plt
.offset
5624 + abed
->plt_reloc_offset
));
5626 /* Put offset for jmp .PLT0 and check for overflow. We don't
5627 check relocation index for overflow since branch displacement
5628 will overflow first. */
5629 if (plt0_offset
> 0x80000000)
5630 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5631 output_bfd
, h
->root
.root
.string
);
5632 bfd_put_32 (output_bfd
, - plt0_offset
,
5633 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5636 bed
= get_elf_backend_data (output_bfd
);
5637 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5638 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5641 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5643 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5644 asection
*plt
, *got
;
5645 bfd_boolean got_after_plt
;
5646 int32_t got_pcrel_offset
;
5647 const bfd_byte
*got_plt_entry
;
5649 /* Set the entry in the GOT procedure linkage table. */
5650 plt
= htab
->plt_got
;
5651 got
= htab
->elf
.sgot
;
5652 got_offset
= h
->got
.offset
;
5654 if (got_offset
== (bfd_vma
) -1
5655 || h
->type
== STT_GNU_IFUNC
5660 /* Use the second PLT entry template for the GOT PLT since they
5661 are the identical. */
5662 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5663 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5664 if (eh
->has_bnd_reloc
)
5665 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5668 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5670 /* Subtract 1 since there is no BND prefix. */
5671 plt_got_insn_size
-= 1;
5672 plt_got_offset
-= 1;
5675 /* Fill in the entry in the GOT procedure linkage table. */
5676 plt_offset
= eh
->plt_got
.offset
;
5677 memcpy (plt
->contents
+ plt_offset
,
5678 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5680 /* Put offset the PC-relative instruction referring to the GOT
5681 entry, subtracting the size of that instruction. */
5682 got_pcrel_offset
= (got
->output_section
->vma
5683 + got
->output_offset
5685 - plt
->output_section
->vma
5686 - plt
->output_offset
5688 - plt_got_insn_size
);
5690 /* Check PC-relative offset overflow in GOT PLT entry. */
5691 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5692 if ((got_after_plt
&& got_pcrel_offset
< 0)
5693 || (!got_after_plt
&& got_pcrel_offset
> 0))
5694 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5695 output_bfd
, h
->root
.root
.string
);
5697 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5698 plt
->contents
+ plt_offset
+ plt_got_offset
);
5701 if (!local_undefweak
5703 && (h
->plt
.offset
!= (bfd_vma
) -1
5704 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5706 /* Mark the symbol as undefined, rather than as defined in
5707 the .plt section. Leave the value if there were any
5708 relocations where pointer equality matters (this is a clue
5709 for the dynamic linker, to make function pointer
5710 comparisons work between an application and shared
5711 library), otherwise set it to zero. If a function is only
5712 called from a binary, there is no need to slow down
5713 shared libraries because of that. */
5714 sym
->st_shndx
= SHN_UNDEF
;
5715 if (!h
->pointer_equality_needed
)
5719 /* Don't generate dynamic GOT relocation against undefined weak
5720 symbol in executable. */
5721 if (h
->got
.offset
!= (bfd_vma
) -1
5722 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5723 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5724 && !local_undefweak
)
5726 Elf_Internal_Rela rela
;
5728 /* This symbol has an entry in the global offset table. Set it
5730 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5733 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5734 + htab
->elf
.sgot
->output_offset
5735 + (h
->got
.offset
&~ (bfd_vma
) 1));
5737 /* If this is a static link, or it is a -Bsymbolic link and the
5738 symbol is defined locally or was forced to be local because
5739 of a version file, we just want to emit a RELATIVE reloc.
5740 The entry in the global offset table will already have been
5741 initialized in the relocate_section function. */
5743 && h
->type
== STT_GNU_IFUNC
)
5745 if (bfd_link_pic (info
))
5747 /* Generate R_X86_64_GLOB_DAT. */
5754 if (!h
->pointer_equality_needed
)
5757 /* For non-shared object, we can't use .got.plt, which
5758 contains the real function addres if we need pointer
5759 equality. We load the GOT entry with the PLT entry. */
5760 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5761 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5762 + plt
->output_offset
5764 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5768 else if (bfd_link_pic (info
)
5769 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5771 if (!h
->def_regular
)
5773 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5774 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5775 rela
.r_addend
= (h
->root
.u
.def
.value
5776 + h
->root
.u
.def
.section
->output_section
->vma
5777 + h
->root
.u
.def
.section
->output_offset
);
5781 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5783 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5784 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5785 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5789 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5794 Elf_Internal_Rela rela
;
5796 /* This symbol needs a copy reloc. Set it up. */
5798 if (h
->dynindx
== -1
5799 || (h
->root
.type
!= bfd_link_hash_defined
5800 && h
->root
.type
!= bfd_link_hash_defweak
)
5801 || htab
->srelbss
== NULL
)
5804 rela
.r_offset
= (h
->root
.u
.def
.value
5805 + h
->root
.u
.def
.section
->output_section
->vma
5806 + h
->root
.u
.def
.section
->output_offset
);
5807 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5809 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5815 /* Finish up local dynamic symbol handling. We set the contents of
5816 various dynamic sections here. */
5819 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5821 struct elf_link_hash_entry
*h
5822 = (struct elf_link_hash_entry
*) *slot
;
5823 struct bfd_link_info
*info
5824 = (struct bfd_link_info
*) inf
;
5826 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5830 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5831 here since undefined weak symbol may not be dynamic and may not be
5832 called for elf_x86_64_finish_dynamic_symbol. */
5835 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5838 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5839 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5841 if (h
->root
.type
!= bfd_link_hash_undefweak
5842 || h
->dynindx
!= -1)
5845 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5849 /* Used to decide how to sort relocs in an optimal manner for the
5850 dynamic linker, before writing them out. */
5852 static enum elf_reloc_type_class
5853 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5854 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5855 const Elf_Internal_Rela
*rela
)
5857 bfd
*abfd
= info
->output_bfd
;
5858 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5859 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5861 if (htab
->elf
.dynsym
!= NULL
5862 && htab
->elf
.dynsym
->contents
!= NULL
)
5864 /* Check relocation against STT_GNU_IFUNC symbol if there are
5866 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5867 Elf_Internal_Sym sym
;
5868 if (!bed
->s
->swap_symbol_in (abfd
,
5869 (htab
->elf
.dynsym
->contents
5870 + r_symndx
* bed
->s
->sizeof_sym
),
5874 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5875 return reloc_class_ifunc
;
5878 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5880 case R_X86_64_RELATIVE
:
5881 case R_X86_64_RELATIVE64
:
5882 return reloc_class_relative
;
5883 case R_X86_64_JUMP_SLOT
:
5884 return reloc_class_plt
;
5886 return reloc_class_copy
;
5888 return reloc_class_normal
;
5892 /* Finish up the dynamic sections. */
5895 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5896 struct bfd_link_info
*info
)
5898 struct elf_x86_64_link_hash_table
*htab
;
5901 const struct elf_x86_64_backend_data
*abed
;
5903 htab
= elf_x86_64_hash_table (info
);
5907 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5908 section only if there is .plt section. */
5909 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5910 ? &elf_x86_64_bnd_arch_bed
5911 : get_elf_x86_64_backend_data (output_bfd
));
5913 dynobj
= htab
->elf
.dynobj
;
5914 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5916 if (htab
->elf
.dynamic_sections_created
)
5918 bfd_byte
*dyncon
, *dynconend
;
5919 const struct elf_backend_data
*bed
;
5920 bfd_size_type sizeof_dyn
;
5922 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5925 bed
= get_elf_backend_data (dynobj
);
5926 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5927 dyncon
= sdyn
->contents
;
5928 dynconend
= sdyn
->contents
+ sdyn
->size
;
5929 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5931 Elf_Internal_Dyn dyn
;
5934 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5942 s
= htab
->elf
.sgotplt
;
5943 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5947 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5951 s
= htab
->elf
.srelplt
->output_section
;
5952 dyn
.d_un
.d_val
= s
->size
;
5956 /* The procedure linkage table relocs (DT_JMPREL) should
5957 not be included in the overall relocs (DT_RELA).
5958 Therefore, we override the DT_RELASZ entry here to
5959 make it not include the JMPREL relocs. Since the
5960 linker script arranges for .rela.plt to follow all
5961 other relocation sections, we don't have to worry
5962 about changing the DT_RELA entry. */
5963 if (htab
->elf
.srelplt
!= NULL
)
5965 s
= htab
->elf
.srelplt
->output_section
;
5966 dyn
.d_un
.d_val
-= s
->size
;
5970 case DT_TLSDESC_PLT
:
5972 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5973 + htab
->tlsdesc_plt
;
5976 case DT_TLSDESC_GOT
:
5978 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5979 + htab
->tlsdesc_got
;
5983 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5986 /* Fill in the special first entry in the procedure linkage table. */
5987 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5989 /* Fill in the first entry in the procedure linkage table. */
5990 memcpy (htab
->elf
.splt
->contents
,
5991 abed
->plt0_entry
, abed
->plt_entry_size
);
5992 /* Add offset for pushq GOT+8(%rip), since the instruction
5993 uses 6 bytes subtract this value. */
5994 bfd_put_32 (output_bfd
,
5995 (htab
->elf
.sgotplt
->output_section
->vma
5996 + htab
->elf
.sgotplt
->output_offset
5998 - htab
->elf
.splt
->output_section
->vma
5999 - htab
->elf
.splt
->output_offset
6001 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6002 /* Add offset for the PC-relative instruction accessing GOT+16,
6003 subtracting the offset to the end of that instruction. */
6004 bfd_put_32 (output_bfd
,
6005 (htab
->elf
.sgotplt
->output_section
->vma
6006 + htab
->elf
.sgotplt
->output_offset
6008 - htab
->elf
.splt
->output_section
->vma
6009 - htab
->elf
.splt
->output_offset
6010 - abed
->plt0_got2_insn_end
),
6011 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6013 elf_section_data (htab
->elf
.splt
->output_section
)
6014 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6016 if (htab
->tlsdesc_plt
)
6018 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6019 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6021 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6022 abed
->plt0_entry
, abed
->plt_entry_size
);
6024 /* Add offset for pushq GOT+8(%rip), since the
6025 instruction uses 6 bytes subtract this value. */
6026 bfd_put_32 (output_bfd
,
6027 (htab
->elf
.sgotplt
->output_section
->vma
6028 + htab
->elf
.sgotplt
->output_offset
6030 - htab
->elf
.splt
->output_section
->vma
6031 - htab
->elf
.splt
->output_offset
6034 htab
->elf
.splt
->contents
6035 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6036 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6037 where TGD stands for htab->tlsdesc_got, subtracting the offset
6038 to the end of that instruction. */
6039 bfd_put_32 (output_bfd
,
6040 (htab
->elf
.sgot
->output_section
->vma
6041 + htab
->elf
.sgot
->output_offset
6043 - htab
->elf
.splt
->output_section
->vma
6044 - htab
->elf
.splt
->output_offset
6046 - abed
->plt0_got2_insn_end
),
6047 htab
->elf
.splt
->contents
6048 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6053 if (htab
->plt_bnd
!= NULL
)
6054 elf_section_data (htab
->plt_bnd
->output_section
)
6055 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6057 if (htab
->elf
.sgotplt
)
6059 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6061 (*_bfd_error_handler
)
6062 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6066 /* Fill in the first three entries in the global offset table. */
6067 if (htab
->elf
.sgotplt
->size
> 0)
6069 /* Set the first entry in the global offset table to the address of
6070 the dynamic section. */
6072 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6074 bfd_put_64 (output_bfd
,
6075 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6076 htab
->elf
.sgotplt
->contents
);
6077 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6078 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6079 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6082 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6086 /* Adjust .eh_frame for .plt section. */
6087 if (htab
->plt_eh_frame
!= NULL
6088 && htab
->plt_eh_frame
->contents
!= NULL
)
6090 if (htab
->elf
.splt
!= NULL
6091 && htab
->elf
.splt
->size
!= 0
6092 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6093 && htab
->elf
.splt
->output_section
!= NULL
6094 && htab
->plt_eh_frame
->output_section
!= NULL
)
6096 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6097 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6098 + htab
->plt_eh_frame
->output_offset
6099 + PLT_FDE_START_OFFSET
;
6100 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6101 htab
->plt_eh_frame
->contents
6102 + PLT_FDE_START_OFFSET
);
6104 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6106 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6108 htab
->plt_eh_frame
->contents
))
6113 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6114 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6117 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6118 htab_traverse (htab
->loc_hash_table
,
6119 elf_x86_64_finish_local_dynamic_symbol
,
6122 /* Fill PLT entries for undefined weak symbols in PIE. */
6123 if (bfd_link_pie (info
))
6124 bfd_hash_traverse (&info
->hash
->table
,
6125 elf_x86_64_pie_finish_undefweak_symbol
,
6131 /* Return an array of PLT entry symbol values. */
6134 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6137 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6140 bfd_vma
*plt_sym_val
;
6142 bfd_byte
*plt_contents
;
6143 const struct elf_x86_64_backend_data
*bed
;
6144 Elf_Internal_Shdr
*hdr
;
6147 /* Get the .plt section contents. PLT passed down may point to the
6148 .plt.bnd section. Make sure that PLT always points to the .plt
6150 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6155 plt
= bfd_get_section_by_name (abfd
, ".plt");
6158 bed
= &elf_x86_64_bnd_arch_bed
;
6161 bed
= get_elf_x86_64_backend_data (abfd
);
6163 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6164 if (plt_contents
== NULL
)
6166 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6167 plt_contents
, 0, plt
->size
))
6170 free (plt_contents
);
6174 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6175 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6178 hdr
= &elf_section_data (relplt
)->this_hdr
;
6179 count
= relplt
->size
/ hdr
->sh_entsize
;
6181 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6182 if (plt_sym_val
== NULL
)
6185 for (i
= 0; i
< count
; i
++)
6186 plt_sym_val
[i
] = -1;
6188 plt_offset
= bed
->plt_entry_size
;
6189 p
= relplt
->relocation
;
6190 for (i
= 0; i
< count
; i
++, p
++)
6194 /* Skip unknown relocation. */
6195 if (p
->howto
== NULL
)
6198 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6199 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6202 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6203 + bed
->plt_reloc_offset
));
6204 if (reloc_index
< count
)
6208 /* This is the index in .plt section. */
6209 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6210 /* Store VMA + the offset in .plt.bnd section. */
6211 plt_sym_val
[reloc_index
] =
6213 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6216 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6218 plt_offset
+= bed
->plt_entry_size
;
6220 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6222 if (plt_offset
>= plt
->size
)
6226 free (plt_contents
);
6231 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6235 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6242 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6243 as PLT if it exists. */
6244 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6246 plt
= bfd_get_section_by_name (abfd
, ".plt");
6247 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6248 dynsymcount
, dynsyms
, ret
,
6250 elf_x86_64_get_plt_sym_val
);
6253 /* Handle an x86-64 specific section when reading an object file. This
6254 is called when elfcode.h finds a section with an unknown type. */
6257 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6258 const char *name
, int shindex
)
6260 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6263 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6269 /* Hook called by the linker routine which adds symbols from an object
6270 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6274 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6275 struct bfd_link_info
*info
,
6276 Elf_Internal_Sym
*sym
,
6277 const char **namep ATTRIBUTE_UNUSED
,
6278 flagword
*flagsp ATTRIBUTE_UNUSED
,
6284 switch (sym
->st_shndx
)
6286 case SHN_X86_64_LCOMMON
:
6287 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6290 lcomm
= bfd_make_section_with_flags (abfd
,
6294 | SEC_LINKER_CREATED
));
6297 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6300 *valp
= sym
->st_size
;
6304 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6305 && (abfd
->flags
& DYNAMIC
) == 0
6306 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6307 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6308 |= elf_gnu_symbol_unique
;
6314 /* Given a BFD section, try to locate the corresponding ELF section
6318 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6319 asection
*sec
, int *index_return
)
6321 if (sec
== &_bfd_elf_large_com_section
)
6323 *index_return
= SHN_X86_64_LCOMMON
;
6329 /* Process a symbol. */
6332 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6335 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6337 switch (elfsym
->internal_elf_sym
.st_shndx
)
6339 case SHN_X86_64_LCOMMON
:
6340 asym
->section
= &_bfd_elf_large_com_section
;
6341 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6342 /* Common symbol doesn't set BSF_GLOBAL. */
6343 asym
->flags
&= ~BSF_GLOBAL
;
6349 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6351 return (sym
->st_shndx
== SHN_COMMON
6352 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6356 elf_x86_64_common_section_index (asection
*sec
)
6358 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6361 return SHN_X86_64_LCOMMON
;
6365 elf_x86_64_common_section (asection
*sec
)
6367 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6368 return bfd_com_section_ptr
;
6370 return &_bfd_elf_large_com_section
;
6374 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6375 const Elf_Internal_Sym
*sym
,
6380 const asection
*oldsec
)
6382 /* A normal common symbol and a large common symbol result in a
6383 normal common symbol. We turn the large common symbol into a
6386 && h
->root
.type
== bfd_link_hash_common
6388 && bfd_is_com_section (*psec
)
6391 if (sym
->st_shndx
== SHN_COMMON
6392 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6394 h
->root
.u
.c
.p
->section
6395 = bfd_make_section_old_way (oldbfd
, "COMMON");
6396 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6398 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6399 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6400 *psec
= bfd_com_section_ptr
;
6407 elf_x86_64_additional_program_headers (bfd
*abfd
,
6408 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6413 /* Check to see if we need a large readonly segment. */
6414 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6415 if (s
&& (s
->flags
& SEC_LOAD
))
6418 /* Check to see if we need a large data segment. Since .lbss sections
6419 is placed right after the .bss section, there should be no need for
6420 a large data segment just because of .lbss. */
6421 s
= bfd_get_section_by_name (abfd
, ".ldata");
6422 if (s
&& (s
->flags
& SEC_LOAD
))
6428 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6431 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6433 if (h
->plt
.offset
!= (bfd_vma
) -1
6435 && !h
->pointer_equality_needed
)
6438 return _bfd_elf_hash_symbol (h
);
6441 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6444 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6445 const bfd_target
*output
)
6447 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6448 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6449 && _bfd_elf_relocs_compatible (input
, output
));
6452 static const struct bfd_elf_special_section
6453 elf_x86_64_special_sections
[]=
6455 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6456 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6457 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6458 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6459 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6460 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6461 { NULL
, 0, 0, 0, 0 }
6464 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6465 #define TARGET_LITTLE_NAME "elf64-x86-64"
6466 #define ELF_ARCH bfd_arch_i386
6467 #define ELF_TARGET_ID X86_64_ELF_DATA
6468 #define ELF_MACHINE_CODE EM_X86_64
6469 #define ELF_MAXPAGESIZE 0x200000
6470 #define ELF_MINPAGESIZE 0x1000
6471 #define ELF_COMMONPAGESIZE 0x1000
6473 #define elf_backend_can_gc_sections 1
6474 #define elf_backend_can_refcount 1
6475 #define elf_backend_want_got_plt 1
6476 #define elf_backend_plt_readonly 1
6477 #define elf_backend_want_plt_sym 0
6478 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6479 #define elf_backend_rela_normal 1
6480 #define elf_backend_plt_alignment 4
6481 #define elf_backend_extern_protected_data 1
6482 #define elf_backend_caches_rawsize 1
6484 #define elf_info_to_howto elf_x86_64_info_to_howto
6486 #define bfd_elf64_bfd_link_hash_table_create \
6487 elf_x86_64_link_hash_table_create
6488 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6489 #define bfd_elf64_bfd_reloc_name_lookup \
6490 elf_x86_64_reloc_name_lookup
6492 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6493 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6494 #define elf_backend_check_relocs elf_x86_64_check_relocs
6495 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6496 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6497 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6498 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6499 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6500 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6501 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6503 #define elf_backend_write_core_note elf_x86_64_write_core_note
6505 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6506 #define elf_backend_relocate_section elf_x86_64_relocate_section
6507 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6508 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6509 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6510 #define elf_backend_object_p elf64_x86_64_elf_object_p
6511 #define bfd_elf64_mkobject elf_x86_64_mkobject
6512 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6514 #define elf_backend_section_from_shdr \
6515 elf_x86_64_section_from_shdr
6517 #define elf_backend_section_from_bfd_section \
6518 elf_x86_64_elf_section_from_bfd_section
6519 #define elf_backend_add_symbol_hook \
6520 elf_x86_64_add_symbol_hook
6521 #define elf_backend_symbol_processing \
6522 elf_x86_64_symbol_processing
6523 #define elf_backend_common_section_index \
6524 elf_x86_64_common_section_index
6525 #define elf_backend_common_section \
6526 elf_x86_64_common_section
6527 #define elf_backend_common_definition \
6528 elf_x86_64_common_definition
6529 #define elf_backend_merge_symbol \
6530 elf_x86_64_merge_symbol
6531 #define elf_backend_special_sections \
6532 elf_x86_64_special_sections
6533 #define elf_backend_additional_program_headers \
6534 elf_x86_64_additional_program_headers
6535 #define elf_backend_hash_symbol \
6536 elf_x86_64_hash_symbol
6537 #define elf_backend_omit_section_dynsym \
6538 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6539 #define elf_backend_fixup_symbol \
6540 elf_x86_64_fixup_symbol
6542 #include "elf64-target.h"
6544 /* CloudABI support. */
6546 #undef TARGET_LITTLE_SYM
6547 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6548 #undef TARGET_LITTLE_NAME
6549 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6552 #define ELF_OSABI ELFOSABI_CLOUDABI
6555 #define elf64_bed elf64_x86_64_cloudabi_bed
6557 #include "elf64-target.h"
6559 /* FreeBSD support. */
6561 #undef TARGET_LITTLE_SYM
6562 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6563 #undef TARGET_LITTLE_NAME
6564 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6567 #define ELF_OSABI ELFOSABI_FREEBSD
6570 #define elf64_bed elf64_x86_64_fbsd_bed
6572 #include "elf64-target.h"
6574 /* Solaris 2 support. */
6576 #undef TARGET_LITTLE_SYM
6577 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6578 #undef TARGET_LITTLE_NAME
6579 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6581 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6582 objects won't be recognized. */
6586 #define elf64_bed elf64_x86_64_sol2_bed
6588 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6590 #undef elf_backend_static_tls_alignment
6591 #define elf_backend_static_tls_alignment 16
6593 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6595 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6597 #undef elf_backend_want_plt_sym
6598 #define elf_backend_want_plt_sym 1
6600 #undef elf_backend_strtab_flags
6601 #define elf_backend_strtab_flags SHF_STRINGS
6604 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6605 bfd
*obfd ATTRIBUTE_UNUSED
,
6606 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6607 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6609 /* PR 19938: FIXME: Need to add code for setting the sh_info
6610 and sh_link fields of Solaris specific section types. */
6614 #undef elf_backend_copy_special_section_fields
6615 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6617 #include "elf64-target.h"
6619 /* Native Client support. */
6622 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6624 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6625 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6629 #undef TARGET_LITTLE_SYM
6630 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6631 #undef TARGET_LITTLE_NAME
6632 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6634 #define elf64_bed elf64_x86_64_nacl_bed
6636 #undef ELF_MAXPAGESIZE
6637 #undef ELF_MINPAGESIZE
6638 #undef ELF_COMMONPAGESIZE
6639 #define ELF_MAXPAGESIZE 0x10000
6640 #define ELF_MINPAGESIZE 0x10000
6641 #define ELF_COMMONPAGESIZE 0x10000
6643 /* Restore defaults. */
6645 #undef elf_backend_static_tls_alignment
6646 #undef elf_backend_want_plt_sym
6647 #define elf_backend_want_plt_sym 0
6648 #undef elf_backend_strtab_flags
6649 #undef elf_backend_copy_special_section_fields
6651 /* NaCl uses substantially different PLT entries for the same effects. */
6653 #undef elf_backend_plt_alignment
6654 #define elf_backend_plt_alignment 5
6655 #define NACL_PLT_ENTRY_SIZE 64
6656 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6658 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6660 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6661 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6662 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6663 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6664 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6666 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6667 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6669 /* 32 bytes of nop to pad out to the standard size. */
6670 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6671 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6672 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6673 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6674 0x66, /* excess data32 prefix */
6678 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6680 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6681 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6682 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6683 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6685 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6686 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6687 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6689 /* Lazy GOT entries point here (32-byte aligned). */
6690 0x68, /* pushq immediate */
6691 0, 0, 0, 0, /* replaced with index into relocation table. */
6692 0xe9, /* jmp relative */
6693 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6695 /* 22 bytes of nop to pad out to the standard size. */
6696 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6697 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6698 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6701 /* .eh_frame covering the .plt section. */
6703 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6705 #if (PLT_CIE_LENGTH != 20 \
6706 || PLT_FDE_LENGTH != 36 \
6707 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6708 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6709 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6711 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6712 0, 0, 0, 0, /* CIE ID */
6713 1, /* CIE version */
6714 'z', 'R', 0, /* Augmentation string */
6715 1, /* Code alignment factor */
6716 0x78, /* Data alignment factor */
6717 16, /* Return address column */
6718 1, /* Augmentation size */
6719 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6720 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6721 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6722 DW_CFA_nop
, DW_CFA_nop
,
6724 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6725 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6726 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6727 0, 0, 0, 0, /* .plt size goes here */
6728 0, /* Augmentation size */
6729 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6730 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6731 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6732 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6733 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6734 13, /* Block length */
6735 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6736 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6737 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6738 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6739 DW_CFA_nop
, DW_CFA_nop
6742 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6744 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6745 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6746 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6747 2, /* plt0_got1_offset */
6748 9, /* plt0_got2_offset */
6749 13, /* plt0_got2_insn_end */
6750 3, /* plt_got_offset */
6751 33, /* plt_reloc_offset */
6752 38, /* plt_plt_offset */
6753 7, /* plt_got_insn_size */
6754 42, /* plt_plt_insn_end */
6755 32, /* plt_lazy_offset */
6756 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6757 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6760 #undef elf_backend_arch_data
6761 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6763 #undef elf_backend_object_p
6764 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6765 #undef elf_backend_modify_segment_map
6766 #define elf_backend_modify_segment_map nacl_modify_segment_map
6767 #undef elf_backend_modify_program_headers
6768 #define elf_backend_modify_program_headers nacl_modify_program_headers
6769 #undef elf_backend_final_write_processing
6770 #define elf_backend_final_write_processing nacl_final_write_processing
6772 #include "elf64-target.h"
6774 /* Native Client x32 support. */
6777 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6779 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6780 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6784 #undef TARGET_LITTLE_SYM
6785 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6786 #undef TARGET_LITTLE_NAME
6787 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6789 #define elf32_bed elf32_x86_64_nacl_bed
6791 #define bfd_elf32_bfd_link_hash_table_create \
6792 elf_x86_64_link_hash_table_create
6793 #define bfd_elf32_bfd_reloc_type_lookup \
6794 elf_x86_64_reloc_type_lookup
6795 #define bfd_elf32_bfd_reloc_name_lookup \
6796 elf_x86_64_reloc_name_lookup
6797 #define bfd_elf32_mkobject \
6799 #define bfd_elf32_get_synthetic_symtab \
6800 elf_x86_64_get_synthetic_symtab
6802 #undef elf_backend_object_p
6803 #define elf_backend_object_p \
6804 elf32_x86_64_nacl_elf_object_p
6806 #undef elf_backend_bfd_from_remote_memory
6807 #define elf_backend_bfd_from_remote_memory \
6808 _bfd_elf32_bfd_from_remote_memory
6810 #undef elf_backend_size_info
6811 #define elf_backend_size_info \
6812 _bfd_elf32_size_info
6814 #include "elf32-target.h"
6816 /* Restore defaults. */
6817 #undef elf_backend_object_p
6818 #define elf_backend_object_p elf64_x86_64_elf_object_p
6819 #undef elf_backend_bfd_from_remote_memory
6820 #undef elf_backend_size_info
6821 #undef elf_backend_modify_segment_map
6822 #undef elf_backend_modify_program_headers
6823 #undef elf_backend_final_write_processing
6825 /* Intel L1OM support. */
6828 elf64_l1om_elf_object_p (bfd
*abfd
)
6830 /* Set the right machine number for an L1OM elf64 file. */
6831 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6835 #undef TARGET_LITTLE_SYM
6836 #define TARGET_LITTLE_SYM l1om_elf64_vec
6837 #undef TARGET_LITTLE_NAME
6838 #define TARGET_LITTLE_NAME "elf64-l1om"
6840 #define ELF_ARCH bfd_arch_l1om
6842 #undef ELF_MACHINE_CODE
6843 #define ELF_MACHINE_CODE EM_L1OM
6848 #define elf64_bed elf64_l1om_bed
6850 #undef elf_backend_object_p
6851 #define elf_backend_object_p elf64_l1om_elf_object_p
6853 /* Restore defaults. */
6854 #undef ELF_MAXPAGESIZE
6855 #undef ELF_MINPAGESIZE
6856 #undef ELF_COMMONPAGESIZE
6857 #define ELF_MAXPAGESIZE 0x200000
6858 #define ELF_MINPAGESIZE 0x1000
6859 #define ELF_COMMONPAGESIZE 0x1000
6860 #undef elf_backend_plt_alignment
6861 #define elf_backend_plt_alignment 4
6862 #undef elf_backend_arch_data
6863 #define elf_backend_arch_data &elf_x86_64_arch_bed
6865 #include "elf64-target.h"
6867 /* FreeBSD L1OM support. */
6869 #undef TARGET_LITTLE_SYM
6870 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6871 #undef TARGET_LITTLE_NAME
6872 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6875 #define ELF_OSABI ELFOSABI_FREEBSD
6878 #define elf64_bed elf64_l1om_fbsd_bed
6880 #include "elf64-target.h"
6882 /* Intel K1OM support. */
6885 elf64_k1om_elf_object_p (bfd
*abfd
)
6887 /* Set the right machine number for an K1OM elf64 file. */
6888 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6892 #undef TARGET_LITTLE_SYM
6893 #define TARGET_LITTLE_SYM k1om_elf64_vec
6894 #undef TARGET_LITTLE_NAME
6895 #define TARGET_LITTLE_NAME "elf64-k1om"
6897 #define ELF_ARCH bfd_arch_k1om
6899 #undef ELF_MACHINE_CODE
6900 #define ELF_MACHINE_CODE EM_K1OM
6905 #define elf64_bed elf64_k1om_bed
6907 #undef elf_backend_object_p
6908 #define elf_backend_object_p elf64_k1om_elf_object_p
6910 #undef elf_backend_static_tls_alignment
6912 #undef elf_backend_want_plt_sym
6913 #define elf_backend_want_plt_sym 0
6915 #include "elf64-target.h"
6917 /* FreeBSD K1OM support. */
6919 #undef TARGET_LITTLE_SYM
6920 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6921 #undef TARGET_LITTLE_NAME
6922 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6925 #define ELF_OSABI ELFOSABI_FREEBSD
6928 #define elf64_bed elf64_k1om_fbsd_bed
6930 #include "elf64-target.h"
6932 /* 32bit x86-64 support. */
6934 #undef TARGET_LITTLE_SYM
6935 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6936 #undef TARGET_LITTLE_NAME
6937 #define TARGET_LITTLE_NAME "elf32-x86-64"
6941 #define ELF_ARCH bfd_arch_i386
6943 #undef ELF_MACHINE_CODE
6944 #define ELF_MACHINE_CODE EM_X86_64
6948 #undef elf_backend_object_p
6949 #define elf_backend_object_p \
6950 elf32_x86_64_elf_object_p
6952 #undef elf_backend_bfd_from_remote_memory
6953 #define elf_backend_bfd_from_remote_memory \
6954 _bfd_elf32_bfd_from_remote_memory
6956 #undef elf_backend_size_info
6957 #define elf_backend_size_info \
6958 _bfd_elf32_size_info
6960 #include "elf32-target.h"