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 /* 0: symbol isn't __tls_get_addr.
800 1: symbol is __tls_get_addr.
801 2: symbol is unknown. */
802 unsigned int tls_get_addr
: 2;
804 /* Reference count of C/C++ function pointer relocations in read-write
805 section which can be resolved at run-time. */
806 bfd_signed_vma func_pointer_refcount
;
808 /* Information about the GOT PLT entry. Filled when there are both
809 GOT and PLT relocations against the same function. */
810 union gotplt_union plt_got
;
812 /* Information about the second PLT entry. Filled when has_bnd_reloc is
814 union gotplt_union plt_bnd
;
816 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
817 starting at the end of the jump table. */
821 #define elf_x86_64_hash_entry(ent) \
822 ((struct elf_x86_64_link_hash_entry *)(ent))
824 struct elf_x86_64_obj_tdata
826 struct elf_obj_tdata root
;
828 /* tls_type for each local got entry. */
829 char *local_got_tls_type
;
831 /* GOTPLT entries for TLS descriptors. */
832 bfd_vma
*local_tlsdesc_gotent
;
835 #define elf_x86_64_tdata(abfd) \
836 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
838 #define elf_x86_64_local_got_tls_type(abfd) \
839 (elf_x86_64_tdata (abfd)->local_got_tls_type)
841 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
842 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
844 #define is_x86_64_elf(bfd) \
845 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
846 && elf_tdata (bfd) != NULL \
847 && elf_object_id (bfd) == X86_64_ELF_DATA)
850 elf_x86_64_mkobject (bfd
*abfd
)
852 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
856 /* x86-64 ELF linker hash table. */
858 struct elf_x86_64_link_hash_table
860 struct elf_link_hash_table elf
;
862 /* Short-cuts to get to dynamic linker sections. */
866 asection
*plt_eh_frame
;
872 bfd_signed_vma refcount
;
876 /* The amount of space used by the jump slots in the GOT. */
877 bfd_vma sgotplt_jump_table_size
;
879 /* Small local sym cache. */
880 struct sym_cache sym_cache
;
882 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
883 bfd_vma (*r_sym
) (bfd_vma
);
884 unsigned int pointer_r_type
;
885 const char *dynamic_interpreter
;
886 int dynamic_interpreter_size
;
888 /* _TLS_MODULE_BASE_ symbol. */
889 struct bfd_link_hash_entry
*tls_module_base
;
891 /* Used by local STT_GNU_IFUNC symbols. */
892 htab_t loc_hash_table
;
893 void * loc_hash_memory
;
895 /* The offset into splt of the PLT entry for the TLS descriptor
896 resolver. Special values are 0, if not necessary (or not found
897 to be necessary yet), and -1 if needed but not determined
900 /* The offset into sgot of the GOT entry used by the PLT entry
904 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
905 bfd_vma next_jump_slot_index
;
906 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
907 bfd_vma next_irelative_index
;
909 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
910 to read-only sections. */
911 bfd_boolean readonly_dynrelocs_against_ifunc
;
914 /* Get the x86-64 ELF linker hash table from a link_info structure. */
916 #define elf_x86_64_hash_table(p) \
917 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
918 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
920 #define elf_x86_64_compute_jump_table_size(htab) \
921 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
923 /* Create an entry in an x86-64 ELF linker hash table. */
925 static struct bfd_hash_entry
*
926 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
927 struct bfd_hash_table
*table
,
930 /* Allocate the structure if it has not already been allocated by a
934 entry
= (struct bfd_hash_entry
*)
935 bfd_hash_allocate (table
,
936 sizeof (struct elf_x86_64_link_hash_entry
));
941 /* Call the allocation method of the superclass. */
942 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
945 struct elf_x86_64_link_hash_entry
*eh
;
947 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
948 eh
->dyn_relocs
= NULL
;
949 eh
->tls_type
= GOT_UNKNOWN
;
951 eh
->has_bnd_reloc
= 0;
952 eh
->has_got_reloc
= 0;
953 eh
->has_non_got_reloc
= 0;
954 eh
->tls_get_addr
= 2;
955 eh
->func_pointer_refcount
= 0;
956 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
957 eh
->plt_got
.offset
= (bfd_vma
) -1;
958 eh
->tlsdesc_got
= (bfd_vma
) -1;
964 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
965 for local symbol so that we can handle local STT_GNU_IFUNC symbols
966 as global symbol. We reuse indx and dynstr_index for local symbol
967 hash since they aren't used by global symbols in this backend. */
970 elf_x86_64_local_htab_hash (const void *ptr
)
972 struct elf_link_hash_entry
*h
973 = (struct elf_link_hash_entry
*) ptr
;
974 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
977 /* Compare local hash entries. */
980 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
982 struct elf_link_hash_entry
*h1
983 = (struct elf_link_hash_entry
*) ptr1
;
984 struct elf_link_hash_entry
*h2
985 = (struct elf_link_hash_entry
*) ptr2
;
987 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
990 /* Find and/or create a hash entry for local symbol. */
992 static struct elf_link_hash_entry
*
993 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
994 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
997 struct elf_x86_64_link_hash_entry e
, *ret
;
998 asection
*sec
= abfd
->sections
;
999 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1000 htab
->r_sym (rel
->r_info
));
1003 e
.elf
.indx
= sec
->id
;
1004 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1005 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1006 create
? INSERT
: NO_INSERT
);
1013 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1017 ret
= (struct elf_x86_64_link_hash_entry
*)
1018 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1019 sizeof (struct elf_x86_64_link_hash_entry
));
1022 memset (ret
, 0, sizeof (*ret
));
1023 ret
->elf
.indx
= sec
->id
;
1024 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1025 ret
->elf
.dynindx
= -1;
1026 ret
->func_pointer_refcount
= 0;
1027 ret
->plt_got
.offset
= (bfd_vma
) -1;
1033 /* Destroy an X86-64 ELF linker hash table. */
1036 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1038 struct elf_x86_64_link_hash_table
*htab
1039 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1041 if (htab
->loc_hash_table
)
1042 htab_delete (htab
->loc_hash_table
);
1043 if (htab
->loc_hash_memory
)
1044 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1045 _bfd_elf_link_hash_table_free (obfd
);
1048 /* Create an X86-64 ELF linker hash table. */
1050 static struct bfd_link_hash_table
*
1051 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1053 struct elf_x86_64_link_hash_table
*ret
;
1054 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1056 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1060 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1061 elf_x86_64_link_hash_newfunc
,
1062 sizeof (struct elf_x86_64_link_hash_entry
),
1069 if (ABI_64_P (abfd
))
1071 ret
->r_info
= elf64_r_info
;
1072 ret
->r_sym
= elf64_r_sym
;
1073 ret
->pointer_r_type
= R_X86_64_64
;
1074 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1075 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1079 ret
->r_info
= elf32_r_info
;
1080 ret
->r_sym
= elf32_r_sym
;
1081 ret
->pointer_r_type
= R_X86_64_32
;
1082 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1083 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1086 ret
->loc_hash_table
= htab_try_create (1024,
1087 elf_x86_64_local_htab_hash
,
1088 elf_x86_64_local_htab_eq
,
1090 ret
->loc_hash_memory
= objalloc_create ();
1091 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1093 elf_x86_64_link_hash_table_free (abfd
);
1096 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1098 return &ret
->elf
.root
;
1101 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1102 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1106 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1107 struct bfd_link_info
*info
)
1109 struct elf_x86_64_link_hash_table
*htab
;
1111 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1114 htab
= elf_x86_64_hash_table (info
);
1118 /* Set the contents of the .interp section to the interpreter. */
1119 if (bfd_link_executable (info
) && !info
->nointerp
)
1121 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1124 s
->size
= htab
->dynamic_interpreter_size
;
1125 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1129 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1133 if (bfd_link_executable (info
))
1135 /* Always allow copy relocs for building executables. */
1136 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1139 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1140 s
= bfd_make_section_anyway_with_flags (dynobj
,
1142 (bed
->dynamic_sec_flags
1145 || ! bfd_set_section_alignment (dynobj
, s
,
1146 bed
->s
->log_file_align
))
1152 if (!info
->no_ld_generated_unwind_info
1153 && htab
->plt_eh_frame
== NULL
1154 && htab
->elf
.splt
!= NULL
)
1156 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1157 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1158 | SEC_LINKER_CREATED
);
1160 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1161 if (htab
->plt_eh_frame
== NULL
1162 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1168 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1171 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1172 struct elf_link_hash_entry
*dir
,
1173 struct elf_link_hash_entry
*ind
)
1175 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1177 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1178 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1180 if (!edir
->has_bnd_reloc
)
1181 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1183 if (!edir
->has_got_reloc
)
1184 edir
->has_got_reloc
= eind
->has_got_reloc
;
1186 if (!edir
->has_non_got_reloc
)
1187 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1189 if (eind
->dyn_relocs
!= NULL
)
1191 if (edir
->dyn_relocs
!= NULL
)
1193 struct elf_dyn_relocs
**pp
;
1194 struct elf_dyn_relocs
*p
;
1196 /* Add reloc counts against the indirect sym to the direct sym
1197 list. Merge any entries against the same section. */
1198 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1200 struct elf_dyn_relocs
*q
;
1202 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1203 if (q
->sec
== p
->sec
)
1205 q
->pc_count
+= p
->pc_count
;
1206 q
->count
+= p
->count
;
1213 *pp
= edir
->dyn_relocs
;
1216 edir
->dyn_relocs
= eind
->dyn_relocs
;
1217 eind
->dyn_relocs
= NULL
;
1220 if (ind
->root
.type
== bfd_link_hash_indirect
1221 && dir
->got
.refcount
<= 0)
1223 edir
->tls_type
= eind
->tls_type
;
1224 eind
->tls_type
= GOT_UNKNOWN
;
1227 if (ELIMINATE_COPY_RELOCS
1228 && ind
->root
.type
!= bfd_link_hash_indirect
1229 && dir
->dynamic_adjusted
)
1231 /* If called to transfer flags for a weakdef during processing
1232 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1233 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1234 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1235 dir
->ref_regular
|= ind
->ref_regular
;
1236 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1237 dir
->needs_plt
|= ind
->needs_plt
;
1238 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1242 if (eind
->func_pointer_refcount
> 0)
1244 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1245 eind
->func_pointer_refcount
= 0;
1248 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1253 elf64_x86_64_elf_object_p (bfd
*abfd
)
1255 /* Set the right machine number for an x86-64 elf64 file. */
1256 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1261 elf32_x86_64_elf_object_p (bfd
*abfd
)
1263 /* Set the right machine number for an x86-64 elf32 file. */
1264 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1268 /* Return TRUE if the TLS access code sequence support transition
1272 elf_x86_64_check_tls_transition (bfd
*abfd
,
1273 struct bfd_link_info
*info
,
1276 Elf_Internal_Shdr
*symtab_hdr
,
1277 struct elf_link_hash_entry
**sym_hashes
,
1278 unsigned int r_type
,
1279 const Elf_Internal_Rela
*rel
,
1280 const Elf_Internal_Rela
*relend
)
1283 unsigned long r_symndx
;
1284 bfd_boolean largepic
= FALSE
;
1285 struct elf_link_hash_entry
*h
;
1287 struct elf_x86_64_link_hash_table
*htab
;
1289 bfd_boolean indirect_call
, tls_get_addr
;
1291 htab
= elf_x86_64_hash_table (info
);
1292 offset
= rel
->r_offset
;
1295 case R_X86_64_TLSGD
:
1296 case R_X86_64_TLSLD
:
1297 if ((rel
+ 1) >= relend
)
1300 if (r_type
== R_X86_64_TLSGD
)
1302 /* Check transition from GD access model. For 64bit, only
1303 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr@PLT
1306 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1308 call *__tls_get_addr@GOTPCREL(%rip)
1309 which may be converted to
1310 addr32 call __tls_get_addr
1311 can transit to different access model. For 32bit, only
1312 leaq foo@tlsgd(%rip), %rdi
1313 .word 0x6666; rex64; call __tls_get_addr@PLT
1315 leaq foo@tlsgd(%rip), %rdi
1317 call *__tls_get_addr@GOTPCREL(%rip)
1318 which may be converted to
1319 addr32 call __tls_get_addr
1320 can transit to different access model. For largepic,
1322 leaq foo@tlsgd(%rip), %rdi
1323 movabsq $__tls_get_addr@pltoff, %rax
1327 leaq foo@tlsgd(%rip), %rdi
1328 movabsq $__tls_get_addr@pltoff, %rax
1332 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1334 if ((offset
+ 12) > sec
->size
)
1337 call
= contents
+ offset
+ 4;
1339 || !((call
[1] == 0x48
1347 && call
[3] == 0xe8)))
1349 if (!ABI_64_P (abfd
)
1350 || (offset
+ 19) > sec
->size
1352 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1353 || memcmp (call
, "\x48\xb8", 2) != 0
1357 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1358 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1362 else if (ABI_64_P (abfd
))
1365 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1371 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1374 indirect_call
= call
[2] == 0xff;
1378 /* Check transition from LD access model. Only
1379 leaq foo@tlsld(%rip), %rdi;
1380 call __tls_get_addr@PLT
1382 leaq foo@tlsld(%rip), %rdi;
1383 call *__tls_get_addr@GOTPCREL(%rip)
1384 which may be converted to
1385 addr32 call __tls_get_addr
1386 can transit to different access model. For largepic
1388 leaq foo@tlsld(%rip), %rdi
1389 movabsq $__tls_get_addr@pltoff, %rax
1393 leaq foo@tlsld(%rip), %rdi
1394 movabsq $__tls_get_addr@pltoff, %rax
1398 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1400 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1403 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1406 call
= contents
+ offset
+ 4;
1407 if (!(call
[0] == 0xe8
1408 || (call
[0] == 0xff && call
[1] == 0x15)
1409 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1411 if (!ABI_64_P (abfd
)
1412 || (offset
+ 19) > sec
->size
1413 || memcmp (call
, "\x48\xb8", 2) != 0
1417 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1418 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1422 indirect_call
= call
[0] == 0xff;
1425 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1426 if (r_symndx
< symtab_hdr
->sh_info
)
1429 tls_get_addr
= FALSE
;
1430 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1431 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1433 struct elf_x86_64_link_hash_entry
*eh
1434 = (struct elf_x86_64_link_hash_entry
*) h
;
1435 tls_get_addr
= eh
->tls_get_addr
== 1;
1436 if (eh
->tls_get_addr
> 1)
1438 /* Use strncmp to check __tls_get_addr since
1439 __tls_get_addr may be versioned. */
1440 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1443 eh
->tls_get_addr
= 1;
1444 tls_get_addr
= TRUE
;
1447 eh
->tls_get_addr
= 0;
1454 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1455 else if (indirect_call
)
1456 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1458 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1459 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1461 case R_X86_64_GOTTPOFF
:
1462 /* Check transition from IE access model:
1463 mov foo@gottpoff(%rip), %reg
1464 add foo@gottpoff(%rip), %reg
1467 /* Check REX prefix first. */
1468 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1470 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1471 if (val
!= 0x48 && val
!= 0x4c)
1473 /* X32 may have 0x44 REX prefix or no REX prefix. */
1474 if (ABI_64_P (abfd
))
1480 /* X32 may not have any REX prefix. */
1481 if (ABI_64_P (abfd
))
1483 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1487 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1488 if (val
!= 0x8b && val
!= 0x03)
1491 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1492 return (val
& 0xc7) == 5;
1494 case R_X86_64_GOTPC32_TLSDESC
:
1495 /* Check transition from GDesc access model:
1496 leaq x@tlsdesc(%rip), %rax
1498 Make sure it's a leaq adding rip to a 32-bit offset
1499 into any register, although it's probably almost always
1502 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1505 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1506 if ((val
& 0xfb) != 0x48)
1509 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1512 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1513 return (val
& 0xc7) == 0x05;
1515 case R_X86_64_TLSDESC_CALL
:
1516 /* Check transition from GDesc access model:
1517 call *x@tlsdesc(%rax)
1519 if (offset
+ 2 <= sec
->size
)
1521 /* Make sure that it's a call *x@tlsdesc(%rax). */
1522 call
= contents
+ offset
;
1523 return call
[0] == 0xff && call
[1] == 0x10;
1533 /* Return TRUE if the TLS access transition is OK or no transition
1534 will be performed. Update R_TYPE if there is a transition. */
1537 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1538 asection
*sec
, bfd_byte
*contents
,
1539 Elf_Internal_Shdr
*symtab_hdr
,
1540 struct elf_link_hash_entry
**sym_hashes
,
1541 unsigned int *r_type
, int tls_type
,
1542 const Elf_Internal_Rela
*rel
,
1543 const Elf_Internal_Rela
*relend
,
1544 struct elf_link_hash_entry
*h
,
1545 unsigned long r_symndx
,
1546 bfd_boolean from_relocate_section
)
1548 unsigned int from_type
= *r_type
;
1549 unsigned int to_type
= from_type
;
1550 bfd_boolean check
= TRUE
;
1552 /* Skip TLS transition for functions. */
1554 && (h
->type
== STT_FUNC
1555 || h
->type
== STT_GNU_IFUNC
))
1560 case R_X86_64_TLSGD
:
1561 case R_X86_64_GOTPC32_TLSDESC
:
1562 case R_X86_64_TLSDESC_CALL
:
1563 case R_X86_64_GOTTPOFF
:
1564 if (bfd_link_executable (info
))
1567 to_type
= R_X86_64_TPOFF32
;
1569 to_type
= R_X86_64_GOTTPOFF
;
1572 /* When we are called from elf_x86_64_relocate_section, there may
1573 be additional transitions based on TLS_TYPE. */
1574 if (from_relocate_section
)
1576 unsigned int new_to_type
= to_type
;
1578 if (bfd_link_executable (info
)
1581 && tls_type
== GOT_TLS_IE
)
1582 new_to_type
= R_X86_64_TPOFF32
;
1584 if (to_type
== R_X86_64_TLSGD
1585 || to_type
== R_X86_64_GOTPC32_TLSDESC
1586 || to_type
== R_X86_64_TLSDESC_CALL
)
1588 if (tls_type
== GOT_TLS_IE
)
1589 new_to_type
= R_X86_64_GOTTPOFF
;
1592 /* We checked the transition before when we were called from
1593 elf_x86_64_check_relocs. We only want to check the new
1594 transition which hasn't been checked before. */
1595 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1596 to_type
= new_to_type
;
1601 case R_X86_64_TLSLD
:
1602 if (bfd_link_executable (info
))
1603 to_type
= R_X86_64_TPOFF32
;
1610 /* Return TRUE if there is no transition. */
1611 if (from_type
== to_type
)
1614 /* Check if the transition can be performed. */
1616 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1617 symtab_hdr
, sym_hashes
,
1618 from_type
, rel
, relend
))
1620 reloc_howto_type
*from
, *to
;
1623 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1624 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1627 name
= h
->root
.root
.string
;
1630 struct elf_x86_64_link_hash_table
*htab
;
1632 htab
= elf_x86_64_hash_table (info
);
1637 Elf_Internal_Sym
*isym
;
1639 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1641 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1645 (*_bfd_error_handler
)
1646 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1647 "in section `%A' failed"),
1648 abfd
, sec
, from
->name
, to
->name
, name
,
1649 (unsigned long) rel
->r_offset
);
1650 bfd_set_error (bfd_error_bad_value
);
1658 /* Rename some of the generic section flags to better document how they
1660 #define need_convert_load sec_flg0
1661 #define check_relocs_failed sec_flg1
1664 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1665 struct elf_link_hash_entry
*h
,
1666 Elf_Internal_Shdr
*symtab_hdr
,
1667 Elf_Internal_Sym
*isym
,
1668 reloc_howto_type
*howto
)
1671 const char *und
= "";
1672 const char *pic
= "";
1677 name
= h
->root
.root
.string
;
1678 switch (ELF_ST_VISIBILITY (h
->other
))
1681 v
= _("hidden symbol ");
1684 v
= _("internal symbol ");
1687 v
= _("protected symbol ");
1691 pic
= _("; recompile with -fPIC");
1695 if (!h
->def_regular
&& !h
->def_dynamic
)
1696 und
= _("undefined ");
1700 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1701 pic
= _("; recompile with -fPIC");
1704 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1705 "not be used when making a shared object%s"),
1706 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1707 bfd_set_error (bfd_error_bad_value
);
1708 sec
->check_relocs_failed
= 1;
1712 /* With the local symbol, foo, we convert
1713 mov foo@GOTPCREL(%rip), %reg
1717 call/jmp *foo@GOTPCREL(%rip)
1719 nop call foo/jmp foo nop
1720 When PIC is false, convert
1721 test %reg, foo@GOTPCREL(%rip)
1725 binop foo@GOTPCREL(%rip), %reg
1728 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1732 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1734 Elf_Internal_Rela
*irel
,
1735 struct elf_link_hash_entry
*h
,
1736 bfd_boolean
*converted
,
1737 struct bfd_link_info
*link_info
)
1739 struct elf_x86_64_link_hash_table
*htab
;
1741 bfd_boolean require_reloc_pc32
;
1743 bfd_boolean to_reloc_pc32
;
1746 bfd_signed_vma raddend
;
1747 unsigned int opcode
;
1749 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1750 unsigned int r_symndx
;
1752 bfd_vma roff
= irel
->r_offset
;
1754 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1757 raddend
= irel
->r_addend
;
1758 /* Addend for 32-bit PC-relative relocation must be -4. */
1762 htab
= elf_x86_64_hash_table (link_info
);
1763 is_pic
= bfd_link_pic (link_info
);
1765 relocx
= (r_type
== R_X86_64_GOTPCRELX
1766 || r_type
== R_X86_64_REX_GOTPCRELX
);
1768 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1771 = link_info
->disable_target_specific_optimizations
> 1;
1773 r_symndx
= htab
->r_sym (irel
->r_info
);
1775 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1777 /* Convert mov to lea since it has been done for a while. */
1780 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1781 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1782 test, xor instructions. */
1787 /* We convert only to R_X86_64_PC32:
1789 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1790 3. require_reloc_pc32 is true.
1793 to_reloc_pc32
= (opcode
== 0xff
1795 || require_reloc_pc32
1798 /* Get the symbol referred to by the reloc. */
1801 Elf_Internal_Sym
*isym
1802 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1804 /* Skip relocation against undefined symbols. */
1805 if (isym
->st_shndx
== SHN_UNDEF
)
1808 symtype
= ELF_ST_TYPE (isym
->st_info
);
1810 if (isym
->st_shndx
== SHN_ABS
)
1811 tsec
= bfd_abs_section_ptr
;
1812 else if (isym
->st_shndx
== SHN_COMMON
)
1813 tsec
= bfd_com_section_ptr
;
1814 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1815 tsec
= &_bfd_elf_large_com_section
;
1817 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1819 toff
= isym
->st_value
;
1823 /* Undefined weak symbol is only bound locally in executable
1824 and its reference is resolved as 0 without relocation
1825 overflow. We can only perform this optimization for
1826 GOTPCRELX relocations since we need to modify REX byte.
1827 It is OK convert mov with R_X86_64_GOTPCREL to
1829 if ((relocx
|| opcode
== 0x8b)
1830 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1832 elf_x86_64_hash_entry (h
)))
1836 /* Skip for branch instructions since R_X86_64_PC32
1838 if (require_reloc_pc32
)
1843 /* For non-branch instructions, we can convert to
1844 R_X86_64_32/R_X86_64_32S since we know if there
1846 to_reloc_pc32
= FALSE
;
1849 /* Since we don't know the current PC when PIC is true,
1850 we can't convert to R_X86_64_PC32. */
1851 if (to_reloc_pc32
&& is_pic
)
1856 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1857 ld.so may use its link-time address. */
1858 else if ((h
->def_regular
1859 || h
->root
.type
== bfd_link_hash_defined
1860 || h
->root
.type
== bfd_link_hash_defweak
)
1861 && h
!= htab
->elf
.hdynamic
1862 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1864 /* bfd_link_hash_new or bfd_link_hash_undefined is
1865 set by an assignment in a linker script in
1866 bfd_elf_record_link_assignment. */
1868 && (h
->root
.type
== bfd_link_hash_new
1869 || h
->root
.type
== bfd_link_hash_undefined
))
1871 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1872 if (require_reloc_pc32
)
1876 tsec
= h
->root
.u
.def
.section
;
1877 toff
= h
->root
.u
.def
.value
;
1884 /* Don't convert GOTPCREL relocation against large section. */
1885 if (elf_section_data (tsec
) != NULL
1886 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1889 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1893 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1895 /* At this stage in linking, no SEC_MERGE symbol has been
1896 adjusted, so all references to such symbols need to be
1897 passed through _bfd_merged_section_offset. (Later, in
1898 relocate_section, all SEC_MERGE symbols *except* for
1899 section symbols have been adjusted.)
1901 gas may reduce relocations against symbols in SEC_MERGE
1902 sections to a relocation against the section symbol when
1903 the original addend was zero. When the reloc is against
1904 a section symbol we should include the addend in the
1905 offset passed to _bfd_merged_section_offset, since the
1906 location of interest is the original symbol. On the
1907 other hand, an access to "sym+addend" where "sym" is not
1908 a section symbol should not include the addend; Such an
1909 access is presumed to be an offset from "sym"; The
1910 location of interest is just "sym". */
1911 if (symtype
== STT_SECTION
)
1914 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1915 elf_section_data (tsec
)->sec_info
,
1918 if (symtype
!= STT_SECTION
)
1924 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1925 if (tsec
->output_section
== sec
->output_section
)
1927 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1932 bfd_signed_vma distance
;
1934 /* At this point, we don't know the load addresses of TSEC
1935 section nor SEC section. We estimate the distrance between
1936 SEC and TSEC. We store the estimated distances in the
1937 compressed_size field of the output section, which is only
1938 used to decompress the compressed input section. */
1939 if (sec
->output_section
->compressed_size
== 0)
1942 bfd_size_type size
= 0;
1943 for (asect
= link_info
->output_bfd
->sections
;
1945 asect
= asect
->next
)
1946 /* Skip debug sections since compressed_size is used to
1947 compress debug sections. */
1948 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1951 for (i
= asect
->map_head
.s
;
1955 size
= align_power (size
, i
->alignment_power
);
1958 asect
->compressed_size
= size
;
1962 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1964 distance
= (tsec
->output_section
->compressed_size
1965 - sec
->output_section
->compressed_size
);
1969 /* Take PT_GNU_RELRO segment into account by adding
1971 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1972 - roff
+ 0x80000000) > 0xffffffff)
1979 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1984 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1986 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1989 /* Convert to "jmp foo nop". */
1992 nop_offset
= irel
->r_offset
+ 3;
1993 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1994 irel
->r_offset
-= 1;
1995 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1999 struct elf_x86_64_link_hash_entry
*eh
2000 = (struct elf_x86_64_link_hash_entry
*) h
;
2002 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2005 /* To support TLS optimization, always use addr32 prefix for
2006 "call *__tls_get_addr@GOTPCREL(%rip)". */
2007 if (eh
&& eh
->tls_get_addr
== 1)
2010 nop_offset
= irel
->r_offset
- 2;
2014 nop
= link_info
->call_nop_byte
;
2015 if (link_info
->call_nop_as_suffix
)
2017 nop_offset
= irel
->r_offset
+ 3;
2018 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2019 irel
->r_offset
-= 1;
2020 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2023 nop_offset
= irel
->r_offset
- 2;
2026 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2027 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2028 r_type
= R_X86_64_PC32
;
2033 unsigned int rex_mask
= REX_R
;
2035 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2036 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2044 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2045 "lea foo(%rip), %reg". */
2047 r_type
= R_X86_64_PC32
;
2051 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2052 "mov $foo, %reg". */
2054 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2055 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2056 if ((rex
& REX_W
) != 0
2057 && ABI_64_P (link_info
->output_bfd
))
2059 /* Keep the REX_W bit in REX byte for LP64. */
2060 r_type
= R_X86_64_32S
;
2061 goto rewrite_modrm_rex
;
2065 /* If the REX_W bit in REX byte isn't needed,
2066 use R_X86_64_32 and clear the W bit to avoid
2067 sign-extend imm32 to imm64. */
2068 r_type
= R_X86_64_32
;
2069 /* Clear the W bit in REX byte. */
2071 goto rewrite_modrm_rex
;
2077 /* R_X86_64_PC32 isn't supported. */
2081 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2084 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2085 "test $foo, %reg". */
2086 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2091 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2092 "binop $foo, %reg". */
2093 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2097 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2098 overflow when sign-extending imm32 to imm64. */
2099 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2102 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2106 /* Move the R bit to the B bit in REX byte. */
2107 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2108 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2111 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2115 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2118 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2125 /* Look through the relocs for a section during the first phase, and
2126 calculate needed space in the global offset table, procedure
2127 linkage table, and dynamic reloc sections. */
2130 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2132 const Elf_Internal_Rela
*relocs
)
2134 struct elf_x86_64_link_hash_table
*htab
;
2135 Elf_Internal_Shdr
*symtab_hdr
;
2136 struct elf_link_hash_entry
**sym_hashes
;
2137 const Elf_Internal_Rela
*rel
;
2138 const Elf_Internal_Rela
*rel_end
;
2141 bfd_boolean use_plt_got
;
2143 if (bfd_link_relocatable (info
))
2146 BFD_ASSERT (is_x86_64_elf (abfd
));
2148 htab
= elf_x86_64_hash_table (info
);
2151 sec
->check_relocs_failed
= 1;
2155 /* Get the section contents. */
2156 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2157 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2158 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2160 sec
->check_relocs_failed
= 1;
2164 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2166 symtab_hdr
= &elf_symtab_hdr (abfd
);
2167 sym_hashes
= elf_sym_hashes (abfd
);
2171 rel_end
= relocs
+ sec
->reloc_count
;
2172 for (rel
= relocs
; rel
< rel_end
; rel
++)
2174 unsigned int r_type
;
2175 unsigned long r_symndx
;
2176 struct elf_link_hash_entry
*h
;
2177 struct elf_x86_64_link_hash_entry
*eh
;
2178 Elf_Internal_Sym
*isym
;
2180 bfd_boolean size_reloc
;
2182 r_symndx
= htab
->r_sym (rel
->r_info
);
2183 r_type
= ELF32_R_TYPE (rel
->r_info
);
2185 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2187 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2192 if (r_symndx
< symtab_hdr
->sh_info
)
2194 /* A local symbol. */
2195 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2200 /* Check relocation against local STT_GNU_IFUNC symbol. */
2201 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2203 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2208 /* Fake a STT_GNU_IFUNC symbol. */
2209 h
->type
= STT_GNU_IFUNC
;
2212 h
->forced_local
= 1;
2213 h
->root
.type
= bfd_link_hash_defined
;
2221 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2222 while (h
->root
.type
== bfd_link_hash_indirect
2223 || h
->root
.type
== bfd_link_hash_warning
)
2224 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2227 /* Check invalid x32 relocations. */
2228 if (!ABI_64_P (abfd
))
2234 case R_X86_64_DTPOFF64
:
2235 case R_X86_64_TPOFF64
:
2237 case R_X86_64_GOTOFF64
:
2238 case R_X86_64_GOT64
:
2239 case R_X86_64_GOTPCREL64
:
2240 case R_X86_64_GOTPC64
:
2241 case R_X86_64_GOTPLT64
:
2242 case R_X86_64_PLTOFF64
:
2245 name
= h
->root
.root
.string
;
2247 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2249 (*_bfd_error_handler
)
2250 (_("%B: relocation %s against symbol `%s' isn't "
2251 "supported in x32 mode"), abfd
,
2252 x86_64_elf_howto_table
[r_type
].name
, name
);
2253 bfd_set_error (bfd_error_bad_value
);
2266 case R_X86_64_PC32_BND
:
2267 case R_X86_64_PLT32_BND
:
2269 case R_X86_64_PLT32
:
2272 /* MPX PLT is supported only if elf_x86_64_arch_bed
2273 is used in 64-bit mode. */
2276 && (get_elf_x86_64_backend_data (abfd
)
2277 == &elf_x86_64_arch_bed
))
2279 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2281 /* Create the second PLT for Intel MPX support. */
2282 if (htab
->plt_bnd
== NULL
)
2284 unsigned int plt_bnd_align
;
2285 const struct elf_backend_data
*bed
;
2287 bed
= get_elf_backend_data (info
->output_bfd
);
2288 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2289 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2290 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2293 if (htab
->elf
.dynobj
== NULL
)
2294 htab
->elf
.dynobj
= abfd
;
2296 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2298 (bed
->dynamic_sec_flags
2303 if (htab
->plt_bnd
== NULL
2304 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2313 case R_X86_64_GOTPCREL
:
2314 case R_X86_64_GOTPCRELX
:
2315 case R_X86_64_REX_GOTPCRELX
:
2316 case R_X86_64_GOTPCREL64
:
2317 if (htab
->elf
.dynobj
== NULL
)
2318 htab
->elf
.dynobj
= abfd
;
2319 /* Create the ifunc sections for static executables. */
2320 if (h
->type
== STT_GNU_IFUNC
2321 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2327 /* It is referenced by a non-shared object. */
2329 h
->root
.non_ir_ref
= 1;
2331 if (h
->type
== STT_GNU_IFUNC
)
2332 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2333 |= elf_gnu_symbol_ifunc
;
2336 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2337 symtab_hdr
, sym_hashes
,
2338 &r_type
, GOT_UNKNOWN
,
2339 rel
, rel_end
, h
, r_symndx
, FALSE
))
2342 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2345 case R_X86_64_TLSLD
:
2346 htab
->tls_ld_got
.refcount
+= 1;
2349 case R_X86_64_TPOFF32
:
2350 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2351 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2352 &x86_64_elf_howto_table
[r_type
]);
2354 eh
->has_got_reloc
= 1;
2357 case R_X86_64_GOTTPOFF
:
2358 if (!bfd_link_executable (info
))
2359 info
->flags
|= DF_STATIC_TLS
;
2362 case R_X86_64_GOT32
:
2363 case R_X86_64_GOTPCREL
:
2364 case R_X86_64_GOTPCRELX
:
2365 case R_X86_64_REX_GOTPCRELX
:
2366 case R_X86_64_TLSGD
:
2367 case R_X86_64_GOT64
:
2368 case R_X86_64_GOTPCREL64
:
2369 case R_X86_64_GOTPLT64
:
2370 case R_X86_64_GOTPC32_TLSDESC
:
2371 case R_X86_64_TLSDESC_CALL
:
2372 /* This symbol requires a global offset table entry. */
2374 int tls_type
, old_tls_type
;
2378 default: tls_type
= GOT_NORMAL
; break;
2379 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2380 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2381 case R_X86_64_GOTPC32_TLSDESC
:
2382 case R_X86_64_TLSDESC_CALL
:
2383 tls_type
= GOT_TLS_GDESC
; break;
2388 h
->got
.refcount
+= 1;
2389 old_tls_type
= eh
->tls_type
;
2393 bfd_signed_vma
*local_got_refcounts
;
2395 /* This is a global offset table entry for a local symbol. */
2396 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2397 if (local_got_refcounts
== NULL
)
2401 size
= symtab_hdr
->sh_info
;
2402 size
*= sizeof (bfd_signed_vma
)
2403 + sizeof (bfd_vma
) + sizeof (char);
2404 local_got_refcounts
= ((bfd_signed_vma
*)
2405 bfd_zalloc (abfd
, size
));
2406 if (local_got_refcounts
== NULL
)
2408 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2409 elf_x86_64_local_tlsdesc_gotent (abfd
)
2410 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2411 elf_x86_64_local_got_tls_type (abfd
)
2412 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2414 local_got_refcounts
[r_symndx
] += 1;
2416 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2419 /* If a TLS symbol is accessed using IE at least once,
2420 there is no point to use dynamic model for it. */
2421 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2422 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2423 || tls_type
!= GOT_TLS_IE
))
2425 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2426 tls_type
= old_tls_type
;
2427 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2428 && GOT_TLS_GD_ANY_P (tls_type
))
2429 tls_type
|= old_tls_type
;
2433 name
= h
->root
.root
.string
;
2435 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2437 (*_bfd_error_handler
)
2438 (_("%B: '%s' accessed both as normal and thread local symbol"),
2440 bfd_set_error (bfd_error_bad_value
);
2445 if (old_tls_type
!= tls_type
)
2448 eh
->tls_type
= tls_type
;
2450 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2455 case R_X86_64_GOTOFF64
:
2456 case R_X86_64_GOTPC32
:
2457 case R_X86_64_GOTPC64
:
2460 eh
->has_got_reloc
= 1;
2461 if (htab
->elf
.sgot
== NULL
)
2463 if (htab
->elf
.dynobj
== NULL
)
2464 htab
->elf
.dynobj
= abfd
;
2465 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2471 case R_X86_64_PLT32
:
2472 case R_X86_64_PLT32_BND
:
2473 /* This symbol requires a procedure linkage table entry. We
2474 actually build the entry in adjust_dynamic_symbol,
2475 because this might be a case of linking PIC code which is
2476 never referenced by a dynamic object, in which case we
2477 don't need to generate a procedure linkage table entry
2480 /* If this is a local symbol, we resolve it directly without
2481 creating a procedure linkage table entry. */
2485 eh
->has_got_reloc
= 1;
2487 h
->plt
.refcount
+= 1;
2490 case R_X86_64_PLTOFF64
:
2491 /* This tries to form the 'address' of a function relative
2492 to GOT. For global symbols we need a PLT entry. */
2496 h
->plt
.refcount
+= 1;
2500 case R_X86_64_SIZE32
:
2501 case R_X86_64_SIZE64
:
2506 if (!ABI_64_P (abfd
))
2511 /* Check relocation overflow as these relocs may lead to
2512 run-time relocation overflow. Don't error out for
2513 sections we don't care about, such as debug sections or
2514 when relocation overflow check is disabled. */
2515 if (!info
->no_reloc_overflow_check
2516 && (bfd_link_pic (info
)
2517 || (bfd_link_executable (info
)
2521 && (sec
->flags
& SEC_READONLY
) == 0))
2522 && (sec
->flags
& SEC_ALLOC
) != 0)
2523 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2524 &x86_64_elf_howto_table
[r_type
]);
2530 case R_X86_64_PC32_BND
:
2534 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2535 eh
->has_non_got_reloc
= 1;
2536 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2537 locally defined and undefined symbol may turn out to be
2538 a STT_GNU_IFUNC symbol later. */
2540 && (bfd_link_executable (info
)
2541 || ((h
->type
== STT_GNU_IFUNC
2542 || h
->root
.type
== bfd_link_hash_undefweak
2543 || h
->root
.type
== bfd_link_hash_undefined
)
2544 && SYMBOLIC_BIND (info
, h
))))
2546 /* If this reloc is in a read-only section, we might
2547 need a copy reloc. We can't check reliably at this
2548 stage whether the section is read-only, as input
2549 sections have not yet been mapped to output sections.
2550 Tentatively set the flag for now, and correct in
2551 adjust_dynamic_symbol. */
2554 /* We may need a .plt entry if the function this reloc
2555 refers to is in a shared lib. */
2556 h
->plt
.refcount
+= 1;
2557 if (r_type
== R_X86_64_PC32
)
2559 /* Since something like ".long foo - ." may be used
2560 as pointer, make sure that PLT is used if foo is
2561 a function defined in a shared library. */
2562 if ((sec
->flags
& SEC_CODE
) == 0)
2563 h
->pointer_equality_needed
= 1;
2565 else if (r_type
!= R_X86_64_PC32_BND
2566 && r_type
!= R_X86_64_PC64
)
2568 h
->pointer_equality_needed
= 1;
2569 /* At run-time, R_X86_64_64 can be resolved for both
2570 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2571 can only be resolved for x32. */
2572 if ((sec
->flags
& SEC_READONLY
) == 0
2573 && (r_type
== R_X86_64_64
2574 || (!ABI_64_P (abfd
)
2575 && (r_type
== R_X86_64_32
2576 || r_type
== R_X86_64_32S
))))
2577 eh
->func_pointer_refcount
+= 1;
2583 /* If we are creating a shared library, and this is a reloc
2584 against a global symbol, or a non PC relative reloc
2585 against a local symbol, then we need to copy the reloc
2586 into the shared library. However, if we are linking with
2587 -Bsymbolic, we do not need to copy a reloc against a
2588 global symbol which is defined in an object we are
2589 including in the link (i.e., DEF_REGULAR is set). At
2590 this point we have not seen all the input files, so it is
2591 possible that DEF_REGULAR is not set now but will be set
2592 later (it is never cleared). In case of a weak definition,
2593 DEF_REGULAR may be cleared later by a strong definition in
2594 a shared library. We account for that possibility below by
2595 storing information in the relocs_copied field of the hash
2596 table entry. A similar situation occurs when creating
2597 shared libraries and symbol visibility changes render the
2600 If on the other hand, we are creating an executable, we
2601 may need to keep relocations for symbols satisfied by a
2602 dynamic library if we manage to avoid copy relocs for the
2604 if ((bfd_link_pic (info
)
2605 && (sec
->flags
& SEC_ALLOC
) != 0
2606 && (! IS_X86_64_PCREL_TYPE (r_type
)
2608 && (! (bfd_link_pie (info
)
2609 || SYMBOLIC_BIND (info
, h
))
2610 || h
->root
.type
== bfd_link_hash_defweak
2611 || !h
->def_regular
))))
2612 || (ELIMINATE_COPY_RELOCS
2613 && !bfd_link_pic (info
)
2614 && (sec
->flags
& SEC_ALLOC
) != 0
2616 && (h
->root
.type
== bfd_link_hash_defweak
2617 || !h
->def_regular
)))
2619 struct elf_dyn_relocs
*p
;
2620 struct elf_dyn_relocs
**head
;
2622 /* We must copy these reloc types into the output file.
2623 Create a reloc section in dynobj and make room for
2627 if (htab
->elf
.dynobj
== NULL
)
2628 htab
->elf
.dynobj
= abfd
;
2630 sreloc
= _bfd_elf_make_dynamic_reloc_section
2631 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2632 abfd
, /*rela?*/ TRUE
);
2638 /* If this is a global symbol, we count the number of
2639 relocations we need for this symbol. */
2641 head
= &eh
->dyn_relocs
;
2644 /* Track dynamic relocs needed for local syms too.
2645 We really need local syms available to do this
2650 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2655 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2659 /* Beware of type punned pointers vs strict aliasing
2661 vpp
= &(elf_section_data (s
)->local_dynrel
);
2662 head
= (struct elf_dyn_relocs
**)vpp
;
2666 if (p
== NULL
|| p
->sec
!= sec
)
2668 bfd_size_type amt
= sizeof *p
;
2670 p
= ((struct elf_dyn_relocs
*)
2671 bfd_alloc (htab
->elf
.dynobj
, amt
));
2682 /* Count size relocation as PC-relative relocation. */
2683 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2688 /* This relocation describes the C++ object vtable hierarchy.
2689 Reconstruct it for later use during GC. */
2690 case R_X86_64_GNU_VTINHERIT
:
2691 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2695 /* This relocation describes which C++ vtable entries are actually
2696 used. Record for later use during GC. */
2697 case R_X86_64_GNU_VTENTRY
:
2698 BFD_ASSERT (h
!= NULL
);
2700 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2710 && h
->plt
.refcount
> 0
2711 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2712 || h
->got
.refcount
> 0)
2713 && htab
->plt_got
== NULL
)
2715 /* Create the GOT procedure linkage table. */
2716 unsigned int plt_got_align
;
2717 const struct elf_backend_data
*bed
;
2719 bed
= get_elf_backend_data (info
->output_bfd
);
2720 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2721 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2722 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2725 if (htab
->elf
.dynobj
== NULL
)
2726 htab
->elf
.dynobj
= abfd
;
2728 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2730 (bed
->dynamic_sec_flags
2735 if (htab
->plt_got
== NULL
2736 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2742 if ((r_type
== R_X86_64_GOTPCREL
2743 || r_type
== R_X86_64_GOTPCRELX
2744 || r_type
== R_X86_64_REX_GOTPCRELX
)
2745 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2746 sec
->need_convert_load
= 1;
2749 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2751 if (!info
->keep_memory
)
2755 /* Cache the section contents for elf_link_input_bfd. */
2756 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2763 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2765 sec
->check_relocs_failed
= 1;
2769 /* Return the section that should be marked against GC for a given
2773 elf_x86_64_gc_mark_hook (asection
*sec
,
2774 struct bfd_link_info
*info
,
2775 Elf_Internal_Rela
*rel
,
2776 struct elf_link_hash_entry
*h
,
2777 Elf_Internal_Sym
*sym
)
2780 switch (ELF32_R_TYPE (rel
->r_info
))
2782 case R_X86_64_GNU_VTINHERIT
:
2783 case R_X86_64_GNU_VTENTRY
:
2787 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2790 /* Remove undefined weak symbol from the dynamic symbol table if it
2791 is resolved to 0. */
2794 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2795 struct elf_link_hash_entry
*h
)
2797 if (h
->dynindx
!= -1
2798 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2799 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2800 elf_x86_64_hash_entry (h
)))
2803 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2809 /* Adjust a symbol defined by a dynamic object and referenced by a
2810 regular object. The current definition is in some section of the
2811 dynamic object, but we're not including those sections. We have to
2812 change the definition to something the rest of the link can
2816 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2817 struct elf_link_hash_entry
*h
)
2819 struct elf_x86_64_link_hash_table
*htab
;
2821 struct elf_x86_64_link_hash_entry
*eh
;
2822 struct elf_dyn_relocs
*p
;
2824 /* STT_GNU_IFUNC symbol must go through PLT. */
2825 if (h
->type
== STT_GNU_IFUNC
)
2827 /* All local STT_GNU_IFUNC references must be treate as local
2828 calls via local PLT. */
2830 && SYMBOL_CALLS_LOCAL (info
, h
))
2832 bfd_size_type pc_count
= 0, count
= 0;
2833 struct elf_dyn_relocs
**pp
;
2835 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2836 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2838 pc_count
+= p
->pc_count
;
2839 p
->count
-= p
->pc_count
;
2848 if (pc_count
|| count
)
2852 if (h
->plt
.refcount
<= 0)
2853 h
->plt
.refcount
= 1;
2855 h
->plt
.refcount
+= 1;
2859 if (h
->plt
.refcount
<= 0)
2861 h
->plt
.offset
= (bfd_vma
) -1;
2867 /* If this is a function, put it in the procedure linkage table. We
2868 will fill in the contents of the procedure linkage table later,
2869 when we know the address of the .got section. */
2870 if (h
->type
== STT_FUNC
2873 if (h
->plt
.refcount
<= 0
2874 || SYMBOL_CALLS_LOCAL (info
, h
)
2875 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2876 && h
->root
.type
== bfd_link_hash_undefweak
))
2878 /* This case can occur if we saw a PLT32 reloc in an input
2879 file, but the symbol was never referred to by a dynamic
2880 object, or if all references were garbage collected. In
2881 such a case, we don't actually need to build a procedure
2882 linkage table, and we can just do a PC32 reloc instead. */
2883 h
->plt
.offset
= (bfd_vma
) -1;
2890 /* It's possible that we incorrectly decided a .plt reloc was
2891 needed for an R_X86_64_PC32 reloc to a non-function sym in
2892 check_relocs. We can't decide accurately between function and
2893 non-function syms in check-relocs; Objects loaded later in
2894 the link may change h->type. So fix it now. */
2895 h
->plt
.offset
= (bfd_vma
) -1;
2897 /* If this is a weak symbol, and there is a real definition, the
2898 processor independent code will have arranged for us to see the
2899 real definition first, and we can just use the same value. */
2900 if (h
->u
.weakdef
!= NULL
)
2902 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2903 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2904 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2905 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2906 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2908 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2909 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2910 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2915 /* This is a reference to a symbol defined by a dynamic object which
2916 is not a function. */
2918 /* If we are creating a shared library, we must presume that the
2919 only references to the symbol are via the global offset table.
2920 For such cases we need not do anything here; the relocations will
2921 be handled correctly by relocate_section. */
2922 if (!bfd_link_executable (info
))
2925 /* If there are no references to this symbol that do not use the
2926 GOT, we don't need to generate a copy reloc. */
2927 if (!h
->non_got_ref
)
2930 /* If -z nocopyreloc was given, we won't generate them either. */
2931 if (info
->nocopyreloc
)
2937 if (ELIMINATE_COPY_RELOCS
)
2939 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2940 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2942 s
= p
->sec
->output_section
;
2943 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2947 /* If we didn't find any dynamic relocs in read-only sections, then
2948 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2956 /* We must allocate the symbol in our .dynbss section, which will
2957 become part of the .bss section of the executable. There will be
2958 an entry for this symbol in the .dynsym section. The dynamic
2959 object will contain position independent code, so all references
2960 from the dynamic object to this symbol will go through the global
2961 offset table. The dynamic linker will use the .dynsym entry to
2962 determine the address it must put in the global offset table, so
2963 both the dynamic object and the regular object will refer to the
2964 same memory location for the variable. */
2966 htab
= elf_x86_64_hash_table (info
);
2970 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2971 to copy the initial value out of the dynamic object and into the
2972 runtime process image. */
2973 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2975 const struct elf_backend_data
*bed
;
2976 bed
= get_elf_backend_data (info
->output_bfd
);
2977 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2983 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2986 /* Allocate space in .plt, .got and associated reloc sections for
2990 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2992 struct bfd_link_info
*info
;
2993 struct elf_x86_64_link_hash_table
*htab
;
2994 struct elf_x86_64_link_hash_entry
*eh
;
2995 struct elf_dyn_relocs
*p
;
2996 const struct elf_backend_data
*bed
;
2997 unsigned int plt_entry_size
;
2998 bfd_boolean resolved_to_zero
;
3000 if (h
->root
.type
== bfd_link_hash_indirect
)
3003 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3005 info
= (struct bfd_link_info
*) inf
;
3006 htab
= elf_x86_64_hash_table (info
);
3009 bed
= get_elf_backend_data (info
->output_bfd
);
3010 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3012 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3016 /* We can't use the GOT PLT if pointer equality is needed since
3017 finish_dynamic_symbol won't clear symbol value and the dynamic
3018 linker won't update the GOT slot. We will get into an infinite
3019 loop at run-time. */
3020 if (htab
->plt_got
!= NULL
3021 && h
->type
!= STT_GNU_IFUNC
3022 && !h
->pointer_equality_needed
3023 && h
->plt
.refcount
> 0
3024 && h
->got
.refcount
> 0)
3026 /* Don't use the regular PLT if there are both GOT and GOTPLT
3028 h
->plt
.offset
= (bfd_vma
) -1;
3030 /* Use the GOT PLT. */
3031 eh
->plt_got
.refcount
= 1;
3034 /* Clear the reference count of function pointer relocations if
3035 symbol isn't a normal function. */
3036 if (h
->type
!= STT_FUNC
)
3037 eh
->func_pointer_refcount
= 0;
3039 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3040 here if it is defined and referenced in a non-shared object. */
3041 if (h
->type
== STT_GNU_IFUNC
3044 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3046 &htab
->readonly_dynrelocs_against_ifunc
,
3051 asection
*s
= htab
->plt_bnd
;
3052 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3054 /* Use the .plt.bnd section if it is created. */
3055 eh
->plt_bnd
.offset
= s
->size
;
3057 /* Make room for this entry in the .plt.bnd section. */
3058 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3066 /* Don't create the PLT entry if there are only function pointer
3067 relocations which can be resolved at run-time. */
3068 else if (htab
->elf
.dynamic_sections_created
3069 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3070 || eh
->plt_got
.refcount
> 0))
3072 bfd_boolean use_plt_got
;
3074 /* Clear the reference count of function pointer relocations
3076 eh
->func_pointer_refcount
= 0;
3078 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3080 /* Don't use the regular PLT for DF_BIND_NOW. */
3081 h
->plt
.offset
= (bfd_vma
) -1;
3083 /* Use the GOT PLT. */
3084 h
->got
.refcount
= 1;
3085 eh
->plt_got
.refcount
= 1;
3088 use_plt_got
= eh
->plt_got
.refcount
> 0;
3090 /* Make sure this symbol is output as a dynamic symbol.
3091 Undefined weak syms won't yet be marked as dynamic. */
3092 if (h
->dynindx
== -1
3094 && !resolved_to_zero
)
3096 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3100 if (bfd_link_pic (info
)
3101 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3103 asection
*s
= htab
->elf
.splt
;
3104 asection
*bnd_s
= htab
->plt_bnd
;
3105 asection
*got_s
= htab
->plt_got
;
3107 /* If this is the first .plt entry, make room for the special
3108 first entry. The .plt section is used by prelink to undo
3109 prelinking for dynamic relocations. */
3111 s
->size
= plt_entry_size
;
3114 eh
->plt_got
.offset
= got_s
->size
;
3117 h
->plt
.offset
= s
->size
;
3119 eh
->plt_bnd
.offset
= bnd_s
->size
;
3122 /* If this symbol is not defined in a regular file, and we are
3123 not generating a shared library, then set the symbol to this
3124 location in the .plt. This is required to make function
3125 pointers compare as equal between the normal executable and
3126 the shared library. */
3127 if (! bfd_link_pic (info
)
3132 /* We need to make a call to the entry of the GOT PLT
3133 instead of regular PLT entry. */
3134 h
->root
.u
.def
.section
= got_s
;
3135 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3141 /* We need to make a call to the entry of the second
3142 PLT instead of regular PLT entry. */
3143 h
->root
.u
.def
.section
= bnd_s
;
3144 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3148 h
->root
.u
.def
.section
= s
;
3149 h
->root
.u
.def
.value
= h
->plt
.offset
;
3154 /* Make room for this entry. */
3156 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3159 s
->size
+= plt_entry_size
;
3161 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3163 /* We also need to make an entry in the .got.plt section,
3164 which will be placed in the .got section by the linker
3166 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3168 /* There should be no PLT relocation against resolved
3169 undefined weak symbol in executable. */
3170 if (!resolved_to_zero
)
3172 /* We also need to make an entry in the .rela.plt
3174 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3175 htab
->elf
.srelplt
->reloc_count
++;
3181 eh
->plt_got
.offset
= (bfd_vma
) -1;
3182 h
->plt
.offset
= (bfd_vma
) -1;
3188 eh
->plt_got
.offset
= (bfd_vma
) -1;
3189 h
->plt
.offset
= (bfd_vma
) -1;
3193 eh
->tlsdesc_got
= (bfd_vma
) -1;
3195 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3196 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3197 if (h
->got
.refcount
> 0
3198 && bfd_link_executable (info
)
3200 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3202 h
->got
.offset
= (bfd_vma
) -1;
3204 else if (h
->got
.refcount
> 0)
3208 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3210 /* Make sure this symbol is output as a dynamic symbol.
3211 Undefined weak syms won't yet be marked as dynamic. */
3212 if (h
->dynindx
== -1
3214 && !resolved_to_zero
)
3216 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3220 if (GOT_TLS_GDESC_P (tls_type
))
3222 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3223 - elf_x86_64_compute_jump_table_size (htab
);
3224 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3225 h
->got
.offset
= (bfd_vma
) -2;
3227 if (! GOT_TLS_GDESC_P (tls_type
)
3228 || GOT_TLS_GD_P (tls_type
))
3231 h
->got
.offset
= s
->size
;
3232 s
->size
+= GOT_ENTRY_SIZE
;
3233 if (GOT_TLS_GD_P (tls_type
))
3234 s
->size
+= GOT_ENTRY_SIZE
;
3236 dyn
= htab
->elf
.dynamic_sections_created
;
3237 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3238 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3239 relocation. No dynamic relocation against resolved undefined
3240 weak symbol in executable. */
3241 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3242 || tls_type
== GOT_TLS_IE
)
3243 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3244 else if (GOT_TLS_GD_P (tls_type
))
3245 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3246 else if (! GOT_TLS_GDESC_P (tls_type
)
3247 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3248 && !resolved_to_zero
)
3249 || h
->root
.type
!= bfd_link_hash_undefweak
)
3250 && (bfd_link_pic (info
)
3251 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3252 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3253 if (GOT_TLS_GDESC_P (tls_type
))
3255 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3256 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3260 h
->got
.offset
= (bfd_vma
) -1;
3262 if (eh
->dyn_relocs
== NULL
)
3265 /* In the shared -Bsymbolic case, discard space allocated for
3266 dynamic pc-relative relocs against symbols which turn out to be
3267 defined in regular objects. For the normal shared case, discard
3268 space for pc-relative relocs that have become local due to symbol
3269 visibility changes. */
3271 if (bfd_link_pic (info
))
3273 /* Relocs that use pc_count are those that appear on a call
3274 insn, or certain REL relocs that can generated via assembly.
3275 We want calls to protected symbols to resolve directly to the
3276 function rather than going via the plt. If people want
3277 function pointer comparisons to work as expected then they
3278 should avoid writing weird assembly. */
3279 if (SYMBOL_CALLS_LOCAL (info
, h
))
3281 struct elf_dyn_relocs
**pp
;
3283 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3285 p
->count
-= p
->pc_count
;
3294 /* Also discard relocs on undefined weak syms with non-default
3295 visibility or in PIE. */
3296 if (eh
->dyn_relocs
!= NULL
)
3298 if (h
->root
.type
== bfd_link_hash_undefweak
)
3300 /* Undefined weak symbol is never bound locally in shared
3302 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3303 || resolved_to_zero
)
3304 eh
->dyn_relocs
= NULL
;
3305 else if (h
->dynindx
== -1
3306 && ! h
->forced_local
3307 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3310 /* For PIE, discard space for pc-relative relocs against
3311 symbols which turn out to need copy relocs. */
3312 else if (bfd_link_executable (info
)
3313 && (h
->needs_copy
|| eh
->needs_copy
)
3317 struct elf_dyn_relocs
**pp
;
3319 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3321 if (p
->pc_count
!= 0)
3329 else if (ELIMINATE_COPY_RELOCS
)
3331 /* For the non-shared case, discard space for relocs against
3332 symbols which turn out to need copy relocs or are not
3333 dynamic. Keep dynamic relocations for run-time function
3334 pointer initialization. */
3336 if ((!h
->non_got_ref
3337 || eh
->func_pointer_refcount
> 0
3338 || (h
->root
.type
== bfd_link_hash_undefweak
3339 && !resolved_to_zero
))
3342 || (htab
->elf
.dynamic_sections_created
3343 && (h
->root
.type
== bfd_link_hash_undefweak
3344 || h
->root
.type
== bfd_link_hash_undefined
))))
3346 /* Make sure this symbol is output as a dynamic symbol.
3347 Undefined weak syms won't yet be marked as dynamic. */
3348 if (h
->dynindx
== -1
3349 && ! h
->forced_local
3350 && ! resolved_to_zero
3351 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3354 /* If that succeeded, we know we'll be keeping all the
3356 if (h
->dynindx
!= -1)
3360 eh
->dyn_relocs
= NULL
;
3361 eh
->func_pointer_refcount
= 0;
3366 /* Finally, allocate space. */
3367 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3371 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3373 BFD_ASSERT (sreloc
!= NULL
);
3375 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3381 /* Allocate space in .plt, .got and associated reloc sections for
3382 local dynamic relocs. */
3385 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3387 struct elf_link_hash_entry
*h
3388 = (struct elf_link_hash_entry
*) *slot
;
3390 if (h
->type
!= STT_GNU_IFUNC
3394 || h
->root
.type
!= bfd_link_hash_defined
)
3397 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3400 /* Find any dynamic relocs that apply to read-only sections. */
3403 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3406 struct elf_x86_64_link_hash_entry
*eh
;
3407 struct elf_dyn_relocs
*p
;
3409 /* Skip local IFUNC symbols. */
3410 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3413 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3414 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3416 asection
*s
= p
->sec
->output_section
;
3418 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3420 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3422 info
->flags
|= DF_TEXTREL
;
3424 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3425 || info
->error_textrel
)
3426 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3427 p
->sec
->owner
, h
->root
.root
.string
,
3430 /* Not an error, just cut short the traversal. */
3437 /* Convert load via the GOT slot to load immediate. */
3440 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3441 struct bfd_link_info
*link_info
)
3443 Elf_Internal_Shdr
*symtab_hdr
;
3444 Elf_Internal_Rela
*internal_relocs
;
3445 Elf_Internal_Rela
*irel
, *irelend
;
3447 struct elf_x86_64_link_hash_table
*htab
;
3448 bfd_boolean changed
;
3449 bfd_signed_vma
*local_got_refcounts
;
3451 /* Don't even try to convert non-ELF outputs. */
3452 if (!is_elf_hash_table (link_info
->hash
))
3455 /* Nothing to do if there is no need or no output. */
3456 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3457 || sec
->need_convert_load
== 0
3458 || bfd_is_abs_section (sec
->output_section
))
3461 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3463 /* Load the relocations for this section. */
3464 internal_relocs
= (_bfd_elf_link_read_relocs
3465 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3466 link_info
->keep_memory
));
3467 if (internal_relocs
== NULL
)
3471 htab
= elf_x86_64_hash_table (link_info
);
3472 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3474 /* Get the section contents. */
3475 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3476 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3479 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3483 irelend
= internal_relocs
+ sec
->reloc_count
;
3484 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3486 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3487 unsigned int r_symndx
;
3488 struct elf_link_hash_entry
*h
;
3489 bfd_boolean converted
;
3491 if (r_type
!= R_X86_64_GOTPCRELX
3492 && r_type
!= R_X86_64_REX_GOTPCRELX
3493 && r_type
!= R_X86_64_GOTPCREL
)
3496 r_symndx
= htab
->r_sym (irel
->r_info
);
3497 if (r_symndx
< symtab_hdr
->sh_info
)
3498 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3499 (const Elf_Internal_Rela
*) irel
,
3503 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3504 while (h
->root
.type
== bfd_link_hash_indirect
3505 || h
->root
.type
== bfd_link_hash_warning
)
3506 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3509 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3510 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3514 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3515 &converted
, link_info
))
3520 changed
= converted
;
3523 if (h
->got
.refcount
> 0)
3524 h
->got
.refcount
-= 1;
3528 if (local_got_refcounts
!= NULL
3529 && local_got_refcounts
[r_symndx
] > 0)
3530 local_got_refcounts
[r_symndx
] -= 1;
3535 if (contents
!= NULL
3536 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3538 if (!changed
&& !link_info
->keep_memory
)
3542 /* Cache the section contents for elf_link_input_bfd. */
3543 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3547 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3550 free (internal_relocs
);
3552 elf_section_data (sec
)->relocs
= internal_relocs
;
3558 if (contents
!= NULL
3559 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3561 if (internal_relocs
!= NULL
3562 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3563 free (internal_relocs
);
3567 /* Set the sizes of the dynamic sections. */
3570 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3571 struct bfd_link_info
*info
)
3573 struct elf_x86_64_link_hash_table
*htab
;
3578 const struct elf_backend_data
*bed
;
3580 htab
= elf_x86_64_hash_table (info
);
3583 bed
= get_elf_backend_data (output_bfd
);
3585 dynobj
= htab
->elf
.dynobj
;
3589 /* Set up .got offsets for local syms, and space for local dynamic
3591 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3593 bfd_signed_vma
*local_got
;
3594 bfd_signed_vma
*end_local_got
;
3595 char *local_tls_type
;
3596 bfd_vma
*local_tlsdesc_gotent
;
3597 bfd_size_type locsymcount
;
3598 Elf_Internal_Shdr
*symtab_hdr
;
3601 if (! is_x86_64_elf (ibfd
))
3604 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3606 struct elf_dyn_relocs
*p
;
3608 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3611 for (p
= (struct elf_dyn_relocs
*)
3612 (elf_section_data (s
)->local_dynrel
);
3616 if (!bfd_is_abs_section (p
->sec
)
3617 && bfd_is_abs_section (p
->sec
->output_section
))
3619 /* Input section has been discarded, either because
3620 it is a copy of a linkonce section or due to
3621 linker script /DISCARD/, so we'll be discarding
3624 else if (p
->count
!= 0)
3626 srel
= elf_section_data (p
->sec
)->sreloc
;
3627 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3628 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3629 && (info
->flags
& DF_TEXTREL
) == 0)
3631 info
->flags
|= DF_TEXTREL
;
3632 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3633 || info
->error_textrel
)
3634 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3635 p
->sec
->owner
, p
->sec
);
3641 local_got
= elf_local_got_refcounts (ibfd
);
3645 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3646 locsymcount
= symtab_hdr
->sh_info
;
3647 end_local_got
= local_got
+ locsymcount
;
3648 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3649 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3651 srel
= htab
->elf
.srelgot
;
3652 for (; local_got
< end_local_got
;
3653 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3655 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3658 if (GOT_TLS_GDESC_P (*local_tls_type
))
3660 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3661 - elf_x86_64_compute_jump_table_size (htab
);
3662 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3663 *local_got
= (bfd_vma
) -2;
3665 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3666 || GOT_TLS_GD_P (*local_tls_type
))
3668 *local_got
= s
->size
;
3669 s
->size
+= GOT_ENTRY_SIZE
;
3670 if (GOT_TLS_GD_P (*local_tls_type
))
3671 s
->size
+= GOT_ENTRY_SIZE
;
3673 if (bfd_link_pic (info
)
3674 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3675 || *local_tls_type
== GOT_TLS_IE
)
3677 if (GOT_TLS_GDESC_P (*local_tls_type
))
3679 htab
->elf
.srelplt
->size
3680 += bed
->s
->sizeof_rela
;
3681 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3683 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3684 || GOT_TLS_GD_P (*local_tls_type
))
3685 srel
->size
+= bed
->s
->sizeof_rela
;
3689 *local_got
= (bfd_vma
) -1;
3693 if (htab
->tls_ld_got
.refcount
> 0)
3695 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3697 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3698 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3699 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3702 htab
->tls_ld_got
.offset
= -1;
3704 /* Allocate global sym .plt and .got entries, and space for global
3705 sym dynamic relocs. */
3706 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3709 /* Allocate .plt and .got entries, and space for local symbols. */
3710 htab_traverse (htab
->loc_hash_table
,
3711 elf_x86_64_allocate_local_dynrelocs
,
3714 /* For every jump slot reserved in the sgotplt, reloc_count is
3715 incremented. However, when we reserve space for TLS descriptors,
3716 it's not incremented, so in order to compute the space reserved
3717 for them, it suffices to multiply the reloc count by the jump
3720 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3721 so that R_X86_64_IRELATIVE entries come last. */
3722 if (htab
->elf
.srelplt
)
3724 htab
->sgotplt_jump_table_size
3725 = elf_x86_64_compute_jump_table_size (htab
);
3726 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3728 else if (htab
->elf
.irelplt
)
3729 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3731 if (htab
->tlsdesc_plt
)
3733 /* If we're not using lazy TLS relocations, don't generate the
3734 PLT and GOT entries they require. */
3735 if ((info
->flags
& DF_BIND_NOW
))
3736 htab
->tlsdesc_plt
= 0;
3739 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3740 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3741 /* Reserve room for the initial entry.
3742 FIXME: we could probably do away with it in this case. */
3743 if (htab
->elf
.splt
->size
== 0)
3744 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3745 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3746 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3750 if (htab
->elf
.sgotplt
)
3752 /* Don't allocate .got.plt section if there are no GOT nor PLT
3753 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3754 if ((htab
->elf
.hgot
== NULL
3755 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3756 && (htab
->elf
.sgotplt
->size
3757 == get_elf_backend_data (output_bfd
)->got_header_size
)
3758 && (htab
->elf
.splt
== NULL
3759 || htab
->elf
.splt
->size
== 0)
3760 && (htab
->elf
.sgot
== NULL
3761 || htab
->elf
.sgot
->size
== 0)
3762 && (htab
->elf
.iplt
== NULL
3763 || htab
->elf
.iplt
->size
== 0)
3764 && (htab
->elf
.igotplt
== NULL
3765 || htab
->elf
.igotplt
->size
== 0))
3766 htab
->elf
.sgotplt
->size
= 0;
3769 if (htab
->plt_eh_frame
!= NULL
3770 && htab
->elf
.splt
!= NULL
3771 && htab
->elf
.splt
->size
!= 0
3772 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3773 && _bfd_elf_eh_frame_present (info
))
3775 const struct elf_x86_64_backend_data
*arch_data
3776 = get_elf_x86_64_arch_data (bed
);
3777 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3780 /* We now have determined the sizes of the various dynamic sections.
3781 Allocate memory for them. */
3783 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3785 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3788 if (s
== htab
->elf
.splt
3789 || s
== htab
->elf
.sgot
3790 || s
== htab
->elf
.sgotplt
3791 || s
== htab
->elf
.iplt
3792 || s
== htab
->elf
.igotplt
3793 || s
== htab
->plt_bnd
3794 || s
== htab
->plt_got
3795 || s
== htab
->plt_eh_frame
3796 || s
== htab
->sdynbss
)
3798 /* Strip this section if we don't need it; see the
3801 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3803 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3806 /* We use the reloc_count field as a counter if we need
3807 to copy relocs into the output file. */
3808 if (s
!= htab
->elf
.srelplt
)
3813 /* It's not one of our sections, so don't allocate space. */
3819 /* If we don't need this section, strip it from the
3820 output file. This is mostly to handle .rela.bss and
3821 .rela.plt. We must create both sections in
3822 create_dynamic_sections, because they must be created
3823 before the linker maps input sections to output
3824 sections. The linker does that before
3825 adjust_dynamic_symbol is called, and it is that
3826 function which decides whether anything needs to go
3827 into these sections. */
3829 s
->flags
|= SEC_EXCLUDE
;
3833 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3836 /* Allocate memory for the section contents. We use bfd_zalloc
3837 here in case unused entries are not reclaimed before the
3838 section's contents are written out. This should not happen,
3839 but this way if it does, we get a R_X86_64_NONE reloc instead
3841 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3842 if (s
->contents
== NULL
)
3846 if (htab
->plt_eh_frame
!= NULL
3847 && htab
->plt_eh_frame
->contents
!= NULL
)
3849 const struct elf_x86_64_backend_data
*arch_data
3850 = get_elf_x86_64_arch_data (bed
);
3852 memcpy (htab
->plt_eh_frame
->contents
,
3853 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3854 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3855 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3858 if (htab
->elf
.dynamic_sections_created
)
3860 /* Add some entries to the .dynamic section. We fill in the
3861 values later, in elf_x86_64_finish_dynamic_sections, but we
3862 must add the entries now so that we get the correct size for
3863 the .dynamic section. The DT_DEBUG entry is filled in by the
3864 dynamic linker and used by the debugger. */
3865 #define add_dynamic_entry(TAG, VAL) \
3866 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3868 if (bfd_link_executable (info
))
3870 if (!add_dynamic_entry (DT_DEBUG
, 0))
3874 if (htab
->elf
.splt
->size
!= 0)
3876 /* DT_PLTGOT is used by prelink even if there is no PLT
3878 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3881 if (htab
->elf
.srelplt
->size
!= 0)
3883 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3884 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3885 || !add_dynamic_entry (DT_JMPREL
, 0))
3889 if (htab
->tlsdesc_plt
3890 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3891 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3897 if (!add_dynamic_entry (DT_RELA
, 0)
3898 || !add_dynamic_entry (DT_RELASZ
, 0)
3899 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3902 /* If any dynamic relocs apply to a read-only section,
3903 then we need a DT_TEXTREL entry. */
3904 if ((info
->flags
& DF_TEXTREL
) == 0)
3905 elf_link_hash_traverse (&htab
->elf
,
3906 elf_x86_64_readonly_dynrelocs
,
3909 if ((info
->flags
& DF_TEXTREL
) != 0)
3911 if (htab
->readonly_dynrelocs_against_ifunc
)
3913 info
->callbacks
->einfo
3914 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3915 bfd_set_error (bfd_error_bad_value
);
3919 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3924 #undef add_dynamic_entry
3930 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3931 struct bfd_link_info
*info
)
3933 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3937 struct elf_link_hash_entry
*tlsbase
;
3939 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3940 "_TLS_MODULE_BASE_",
3941 FALSE
, FALSE
, FALSE
);
3943 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3945 struct elf_x86_64_link_hash_table
*htab
;
3946 struct bfd_link_hash_entry
*bh
= NULL
;
3947 const struct elf_backend_data
*bed
3948 = get_elf_backend_data (output_bfd
);
3950 htab
= elf_x86_64_hash_table (info
);
3954 if (!(_bfd_generic_link_add_one_symbol
3955 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3956 tls_sec
, 0, NULL
, FALSE
,
3957 bed
->collect
, &bh
)))
3960 htab
->tls_module_base
= bh
;
3962 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3963 tlsbase
->def_regular
= 1;
3964 tlsbase
->other
= STV_HIDDEN
;
3965 tlsbase
->root
.linker_def
= 1;
3966 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3973 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3974 executables. Rather than setting it to the beginning of the TLS
3975 section, we have to set it to the end. This function may be called
3976 multiple times, it is idempotent. */
3979 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3981 struct elf_x86_64_link_hash_table
*htab
;
3982 struct bfd_link_hash_entry
*base
;
3984 if (!bfd_link_executable (info
))
3987 htab
= elf_x86_64_hash_table (info
);
3991 base
= htab
->tls_module_base
;
3995 base
->u
.def
.value
= htab
->elf
.tls_size
;
3998 /* Return the base VMA address which should be subtracted from real addresses
3999 when resolving @dtpoff relocation.
4000 This is PT_TLS segment p_vaddr. */
4003 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4005 /* If tls_sec is NULL, we should have signalled an error already. */
4006 if (elf_hash_table (info
)->tls_sec
== NULL
)
4008 return elf_hash_table (info
)->tls_sec
->vma
;
4011 /* Return the relocation value for @tpoff relocation
4012 if STT_TLS virtual address is ADDRESS. */
4015 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4017 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4018 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4019 bfd_vma static_tls_size
;
4021 /* If tls_segment is NULL, we should have signalled an error already. */
4022 if (htab
->tls_sec
== NULL
)
4025 /* Consider special static TLS alignment requirements. */
4026 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4027 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4030 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4034 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4036 /* Opcode Instruction
4039 0x0f 0x8x conditional jump */
4041 && (contents
[offset
- 1] == 0xe8
4042 || contents
[offset
- 1] == 0xe9))
4044 && contents
[offset
- 2] == 0x0f
4045 && (contents
[offset
- 1] & 0xf0) == 0x80));
4048 /* Relocate an x86_64 ELF section. */
4051 elf_x86_64_relocate_section (bfd
*output_bfd
,
4052 struct bfd_link_info
*info
,
4054 asection
*input_section
,
4056 Elf_Internal_Rela
*relocs
,
4057 Elf_Internal_Sym
*local_syms
,
4058 asection
**local_sections
)
4060 struct elf_x86_64_link_hash_table
*htab
;
4061 Elf_Internal_Shdr
*symtab_hdr
;
4062 struct elf_link_hash_entry
**sym_hashes
;
4063 bfd_vma
*local_got_offsets
;
4064 bfd_vma
*local_tlsdesc_gotents
;
4065 Elf_Internal_Rela
*rel
;
4066 Elf_Internal_Rela
*wrel
;
4067 Elf_Internal_Rela
*relend
;
4068 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4070 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4072 /* Skip if check_relocs failed. */
4073 if (input_section
->check_relocs_failed
)
4076 htab
= elf_x86_64_hash_table (info
);
4079 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4080 sym_hashes
= elf_sym_hashes (input_bfd
);
4081 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4082 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4084 elf_x86_64_set_tls_module_base (info
);
4086 rel
= wrel
= relocs
;
4087 relend
= relocs
+ input_section
->reloc_count
;
4088 for (; rel
< relend
; wrel
++, rel
++)
4090 unsigned int r_type
;
4091 reloc_howto_type
*howto
;
4092 unsigned long r_symndx
;
4093 struct elf_link_hash_entry
*h
;
4094 struct elf_x86_64_link_hash_entry
*eh
;
4095 Elf_Internal_Sym
*sym
;
4097 bfd_vma off
, offplt
, plt_offset
;
4099 bfd_boolean unresolved_reloc
;
4100 bfd_reloc_status_type r
;
4102 asection
*base_got
, *resolved_plt
;
4104 bfd_boolean resolved_to_zero
;
4106 r_type
= ELF32_R_TYPE (rel
->r_info
);
4107 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4108 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4115 if (r_type
>= (int) R_X86_64_standard
)
4117 (*_bfd_error_handler
)
4118 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4119 input_bfd
, input_section
, r_type
);
4120 bfd_set_error (bfd_error_bad_value
);
4124 if (r_type
!= (int) R_X86_64_32
4125 || ABI_64_P (output_bfd
))
4126 howto
= x86_64_elf_howto_table
+ r_type
;
4128 howto
= (x86_64_elf_howto_table
4129 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4130 r_symndx
= htab
->r_sym (rel
->r_info
);
4134 unresolved_reloc
= FALSE
;
4135 if (r_symndx
< symtab_hdr
->sh_info
)
4137 sym
= local_syms
+ r_symndx
;
4138 sec
= local_sections
[r_symndx
];
4140 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4142 st_size
= sym
->st_size
;
4144 /* Relocate against local STT_GNU_IFUNC symbol. */
4145 if (!bfd_link_relocatable (info
)
4146 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4148 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4153 /* Set STT_GNU_IFUNC symbol value. */
4154 h
->root
.u
.def
.value
= sym
->st_value
;
4155 h
->root
.u
.def
.section
= sec
;
4160 bfd_boolean warned ATTRIBUTE_UNUSED
;
4161 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4163 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4164 r_symndx
, symtab_hdr
, sym_hashes
,
4166 unresolved_reloc
, warned
, ignored
);
4170 if (sec
!= NULL
&& discarded_section (sec
))
4172 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4173 contents
+ rel
->r_offset
);
4174 wrel
->r_offset
= rel
->r_offset
;
4178 /* For ld -r, remove relocations in debug sections against
4179 sections defined in discarded sections. Not done for
4180 eh_frame editing code expects to be present. */
4181 if (bfd_link_relocatable (info
)
4182 && (input_section
->flags
& SEC_DEBUGGING
))
4188 if (bfd_link_relocatable (info
))
4195 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4197 if (r_type
== R_X86_64_64
)
4199 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4200 zero-extend it to 64bit if addend is zero. */
4201 r_type
= R_X86_64_32
;
4202 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4204 else if (r_type
== R_X86_64_SIZE64
)
4206 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4207 zero-extend it to 64bit if addend is zero. */
4208 r_type
= R_X86_64_SIZE32
;
4209 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4213 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4215 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4216 it here if it is defined in a non-shared object. */
4218 && h
->type
== STT_GNU_IFUNC
4224 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4226 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4227 sections because such sections are not SEC_ALLOC and
4228 thus ld.so will not process them. */
4229 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4233 else if (h
->plt
.offset
== (bfd_vma
) -1)
4236 /* STT_GNU_IFUNC symbol must go through PLT. */
4237 if (htab
->elf
.splt
!= NULL
)
4239 if (htab
->plt_bnd
!= NULL
)
4241 resolved_plt
= htab
->plt_bnd
;
4242 plt_offset
= eh
->plt_bnd
.offset
;
4246 resolved_plt
= htab
->elf
.splt
;
4247 plt_offset
= h
->plt
.offset
;
4252 resolved_plt
= htab
->elf
.iplt
;
4253 plt_offset
= h
->plt
.offset
;
4256 relocation
= (resolved_plt
->output_section
->vma
4257 + resolved_plt
->output_offset
+ plt_offset
);
4262 if (h
->root
.root
.string
)
4263 name
= h
->root
.root
.string
;
4265 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4267 (*_bfd_error_handler
)
4268 (_("%B: relocation %s against STT_GNU_IFUNC "
4269 "symbol `%s' isn't handled by %s"), input_bfd
,
4270 howto
->name
, name
, __FUNCTION__
);
4271 bfd_set_error (bfd_error_bad_value
);
4275 if (bfd_link_pic (info
))
4280 if (ABI_64_P (output_bfd
))
4284 if (rel
->r_addend
!= 0)
4286 if (h
->root
.root
.string
)
4287 name
= h
->root
.root
.string
;
4289 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4291 (*_bfd_error_handler
)
4292 (_("%B: relocation %s against STT_GNU_IFUNC "
4293 "symbol `%s' has non-zero addend: %d"),
4294 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4295 bfd_set_error (bfd_error_bad_value
);
4299 /* Generate dynamic relcoation only when there is a
4300 non-GOT reference in a shared object. */
4301 if (bfd_link_pic (info
) && h
->non_got_ref
)
4303 Elf_Internal_Rela outrel
;
4306 /* Need a dynamic relocation to get the real function
4308 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4312 if (outrel
.r_offset
== (bfd_vma
) -1
4313 || outrel
.r_offset
== (bfd_vma
) -2)
4316 outrel
.r_offset
+= (input_section
->output_section
->vma
4317 + input_section
->output_offset
);
4319 if (h
->dynindx
== -1
4321 || bfd_link_executable (info
))
4323 /* This symbol is resolved locally. */
4324 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4325 outrel
.r_addend
= (h
->root
.u
.def
.value
4326 + h
->root
.u
.def
.section
->output_section
->vma
4327 + h
->root
.u
.def
.section
->output_offset
);
4331 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4332 outrel
.r_addend
= 0;
4335 sreloc
= htab
->elf
.irelifunc
;
4336 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4338 /* If this reloc is against an external symbol, we
4339 do not want to fiddle with the addend. Otherwise,
4340 we need to include the symbol value so that it
4341 becomes an addend for the dynamic reloc. For an
4342 internal symbol, we have updated addend. */
4347 case R_X86_64_PC32_BND
:
4349 case R_X86_64_PLT32
:
4350 case R_X86_64_PLT32_BND
:
4353 case R_X86_64_GOTPCREL
:
4354 case R_X86_64_GOTPCRELX
:
4355 case R_X86_64_REX_GOTPCRELX
:
4356 case R_X86_64_GOTPCREL64
:
4357 base_got
= htab
->elf
.sgot
;
4358 off
= h
->got
.offset
;
4360 if (base_got
== NULL
)
4363 if (off
== (bfd_vma
) -1)
4365 /* We can't use h->got.offset here to save state, or
4366 even just remember the offset, as finish_dynamic_symbol
4367 would use that as offset into .got. */
4369 if (htab
->elf
.splt
!= NULL
)
4371 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4372 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4373 base_got
= htab
->elf
.sgotplt
;
4377 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4378 off
= plt_index
* GOT_ENTRY_SIZE
;
4379 base_got
= htab
->elf
.igotplt
;
4382 if (h
->dynindx
== -1
4386 /* This references the local defitionion. We must
4387 initialize this entry in the global offset table.
4388 Since the offset must always be a multiple of 8,
4389 we use the least significant bit to record
4390 whether we have initialized it already.
4392 When doing a dynamic link, we create a .rela.got
4393 relocation entry to initialize the value. This
4394 is done in the finish_dynamic_symbol routine. */
4399 bfd_put_64 (output_bfd
, relocation
,
4400 base_got
->contents
+ off
);
4401 /* Note that this is harmless for the GOTPLT64
4402 case, as -1 | 1 still is -1. */
4408 relocation
= (base_got
->output_section
->vma
4409 + base_got
->output_offset
+ off
);
4415 resolved_to_zero
= (eh
!= NULL
4416 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4420 /* When generating a shared object, the relocations handled here are
4421 copied into the output file to be resolved at run time. */
4424 case R_X86_64_GOT32
:
4425 case R_X86_64_GOT64
:
4426 /* Relocation is to the entry for this symbol in the global
4428 case R_X86_64_GOTPCREL
:
4429 case R_X86_64_GOTPCRELX
:
4430 case R_X86_64_REX_GOTPCRELX
:
4431 case R_X86_64_GOTPCREL64
:
4432 /* Use global offset table entry as symbol value. */
4433 case R_X86_64_GOTPLT64
:
4434 /* This is obsolete and treated the the same as GOT64. */
4435 base_got
= htab
->elf
.sgot
;
4437 if (htab
->elf
.sgot
== NULL
)
4444 off
= h
->got
.offset
;
4446 && h
->plt
.offset
!= (bfd_vma
)-1
4447 && off
== (bfd_vma
)-1)
4449 /* We can't use h->got.offset here to save
4450 state, or even just remember the offset, as
4451 finish_dynamic_symbol would use that as offset into
4453 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4454 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4455 base_got
= htab
->elf
.sgotplt
;
4458 dyn
= htab
->elf
.dynamic_sections_created
;
4460 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4461 || (bfd_link_pic (info
)
4462 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4463 || (ELF_ST_VISIBILITY (h
->other
)
4464 && h
->root
.type
== bfd_link_hash_undefweak
))
4466 /* This is actually a static link, or it is a -Bsymbolic
4467 link and the symbol is defined locally, or the symbol
4468 was forced to be local because of a version file. We
4469 must initialize this entry in the global offset table.
4470 Since the offset must always be a multiple of 8, we
4471 use the least significant bit to record whether we
4472 have initialized it already.
4474 When doing a dynamic link, we create a .rela.got
4475 relocation entry to initialize the value. This is
4476 done in the finish_dynamic_symbol routine. */
4481 bfd_put_64 (output_bfd
, relocation
,
4482 base_got
->contents
+ off
);
4483 /* Note that this is harmless for the GOTPLT64 case,
4484 as -1 | 1 still is -1. */
4489 unresolved_reloc
= FALSE
;
4493 if (local_got_offsets
== NULL
)
4496 off
= local_got_offsets
[r_symndx
];
4498 /* The offset must always be a multiple of 8. We use
4499 the least significant bit to record whether we have
4500 already generated the necessary reloc. */
4505 bfd_put_64 (output_bfd
, relocation
,
4506 base_got
->contents
+ off
);
4508 if (bfd_link_pic (info
))
4511 Elf_Internal_Rela outrel
;
4513 /* We need to generate a R_X86_64_RELATIVE reloc
4514 for the dynamic linker. */
4515 s
= htab
->elf
.srelgot
;
4519 outrel
.r_offset
= (base_got
->output_section
->vma
4520 + base_got
->output_offset
4522 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4523 outrel
.r_addend
= relocation
;
4524 elf_append_rela (output_bfd
, s
, &outrel
);
4527 local_got_offsets
[r_symndx
] |= 1;
4531 if (off
>= (bfd_vma
) -2)
4534 relocation
= base_got
->output_section
->vma
4535 + base_got
->output_offset
+ off
;
4536 if (r_type
!= R_X86_64_GOTPCREL
4537 && r_type
!= R_X86_64_GOTPCRELX
4538 && r_type
!= R_X86_64_REX_GOTPCRELX
4539 && r_type
!= R_X86_64_GOTPCREL64
)
4540 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4541 - htab
->elf
.sgotplt
->output_offset
;
4545 case R_X86_64_GOTOFF64
:
4546 /* Relocation is relative to the start of the global offset
4549 /* Check to make sure it isn't a protected function or data
4550 symbol for shared library since it may not be local when
4551 used as function address or with copy relocation. We also
4552 need to make sure that a symbol is referenced locally. */
4553 if (bfd_link_pic (info
) && h
)
4555 if (!h
->def_regular
)
4559 switch (ELF_ST_VISIBILITY (h
->other
))
4562 v
= _("hidden symbol");
4565 v
= _("internal symbol");
4568 v
= _("protected symbol");
4575 (*_bfd_error_handler
)
4576 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4577 input_bfd
, v
, h
->root
.root
.string
);
4578 bfd_set_error (bfd_error_bad_value
);
4581 else if (!bfd_link_executable (info
)
4582 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4583 && (h
->type
== STT_FUNC
4584 || h
->type
== STT_OBJECT
)
4585 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4587 (*_bfd_error_handler
)
4588 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4590 h
->type
== STT_FUNC
? "function" : "data",
4591 h
->root
.root
.string
);
4592 bfd_set_error (bfd_error_bad_value
);
4597 /* Note that sgot is not involved in this
4598 calculation. We always want the start of .got.plt. If we
4599 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4600 permitted by the ABI, we might have to change this
4602 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4603 + htab
->elf
.sgotplt
->output_offset
;
4606 case R_X86_64_GOTPC32
:
4607 case R_X86_64_GOTPC64
:
4608 /* Use global offset table as symbol value. */
4609 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4610 + htab
->elf
.sgotplt
->output_offset
;
4611 unresolved_reloc
= FALSE
;
4614 case R_X86_64_PLTOFF64
:
4615 /* Relocation is PLT entry relative to GOT. For local
4616 symbols it's the symbol itself relative to GOT. */
4618 /* See PLT32 handling. */
4619 && h
->plt
.offset
!= (bfd_vma
) -1
4620 && htab
->elf
.splt
!= NULL
)
4622 if (htab
->plt_bnd
!= NULL
)
4624 resolved_plt
= htab
->plt_bnd
;
4625 plt_offset
= eh
->plt_bnd
.offset
;
4629 resolved_plt
= htab
->elf
.splt
;
4630 plt_offset
= h
->plt
.offset
;
4633 relocation
= (resolved_plt
->output_section
->vma
4634 + resolved_plt
->output_offset
4636 unresolved_reloc
= FALSE
;
4639 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4640 + htab
->elf
.sgotplt
->output_offset
;
4643 case R_X86_64_PLT32
:
4644 case R_X86_64_PLT32_BND
:
4645 /* Relocation is to the entry for this symbol in the
4646 procedure linkage table. */
4648 /* Resolve a PLT32 reloc against a local symbol directly,
4649 without using the procedure linkage table. */
4653 if ((h
->plt
.offset
== (bfd_vma
) -1
4654 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4655 || htab
->elf
.splt
== NULL
)
4657 /* We didn't make a PLT entry for this symbol. This
4658 happens when statically linking PIC code, or when
4659 using -Bsymbolic. */
4663 if (h
->plt
.offset
!= (bfd_vma
) -1)
4665 if (htab
->plt_bnd
!= NULL
)
4667 resolved_plt
= htab
->plt_bnd
;
4668 plt_offset
= eh
->plt_bnd
.offset
;
4672 resolved_plt
= htab
->elf
.splt
;
4673 plt_offset
= h
->plt
.offset
;
4678 /* Use the GOT PLT. */
4679 resolved_plt
= htab
->plt_got
;
4680 plt_offset
= eh
->plt_got
.offset
;
4683 relocation
= (resolved_plt
->output_section
->vma
4684 + resolved_plt
->output_offset
4686 unresolved_reloc
= FALSE
;
4689 case R_X86_64_SIZE32
:
4690 case R_X86_64_SIZE64
:
4691 /* Set to symbol size. */
4692 relocation
= st_size
;
4698 case R_X86_64_PC32_BND
:
4699 /* Don't complain about -fPIC if the symbol is undefined when
4700 building executable unless it is unresolved weak symbol. */
4701 if ((input_section
->flags
& SEC_ALLOC
) != 0
4702 && (input_section
->flags
& SEC_READONLY
) != 0
4704 && ((bfd_link_executable (info
)
4705 && h
->root
.type
== bfd_link_hash_undefweak
4706 && !resolved_to_zero
)
4707 || (bfd_link_pic (info
)
4708 && !(bfd_link_pie (info
)
4709 && h
->root
.type
== bfd_link_hash_undefined
))))
4711 bfd_boolean fail
= FALSE
;
4713 = ((r_type
== R_X86_64_PC32
4714 || r_type
== R_X86_64_PC32_BND
)
4715 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4717 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4719 /* Symbol is referenced locally. Make sure it is
4720 defined locally or for a branch. */
4721 fail
= !h
->def_regular
&& !branch
;
4723 else if (!(bfd_link_pie (info
)
4724 && (h
->needs_copy
|| eh
->needs_copy
)))
4726 /* Symbol doesn't need copy reloc and isn't referenced
4727 locally. We only allow branch to symbol with
4728 non-default visibility. */
4730 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4734 return elf_x86_64_need_pic (input_bfd
, input_section
,
4735 h
, NULL
, NULL
, howto
);
4744 /* FIXME: The ABI says the linker should make sure the value is
4745 the same when it's zeroextended to 64 bit. */
4748 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4751 /* Don't copy a pc-relative relocation into the output file
4752 if the symbol needs copy reloc or the symbol is undefined
4753 when building executable. Copy dynamic function pointer
4754 relocations. Don't generate dynamic relocations against
4755 resolved undefined weak symbols in PIE. */
4756 if ((bfd_link_pic (info
)
4757 && !(bfd_link_pie (info
)
4761 || h
->root
.type
== bfd_link_hash_undefined
)
4762 && IS_X86_64_PCREL_TYPE (r_type
))
4764 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4765 && !resolved_to_zero
)
4766 || h
->root
.type
!= bfd_link_hash_undefweak
))
4767 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4768 && r_type
!= R_X86_64_SIZE32
4769 && r_type
!= R_X86_64_SIZE64
)
4770 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4771 || (ELIMINATE_COPY_RELOCS
4772 && !bfd_link_pic (info
)
4776 || eh
->func_pointer_refcount
> 0
4777 || (h
->root
.type
== bfd_link_hash_undefweak
4778 && !resolved_to_zero
))
4779 && ((h
->def_dynamic
&& !h
->def_regular
)
4780 /* Undefined weak symbol is bound locally when
4782 || h
->root
.type
== bfd_link_hash_undefined
)))
4784 Elf_Internal_Rela outrel
;
4785 bfd_boolean skip
, relocate
;
4788 /* When generating a shared object, these relocations
4789 are copied into the output file to be resolved at run
4795 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4797 if (outrel
.r_offset
== (bfd_vma
) -1)
4799 else if (outrel
.r_offset
== (bfd_vma
) -2)
4800 skip
= TRUE
, relocate
= TRUE
;
4802 outrel
.r_offset
+= (input_section
->output_section
->vma
4803 + input_section
->output_offset
);
4806 memset (&outrel
, 0, sizeof outrel
);
4808 /* h->dynindx may be -1 if this symbol was marked to
4812 && (IS_X86_64_PCREL_TYPE (r_type
)
4813 || !(bfd_link_executable (info
)
4814 || SYMBOLIC_BIND (info
, h
))
4815 || ! h
->def_regular
))
4817 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4818 outrel
.r_addend
= rel
->r_addend
;
4822 /* This symbol is local, or marked to become local.
4823 When relocation overflow check is disabled, we
4824 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4825 if (r_type
== htab
->pointer_r_type
4826 || (r_type
== R_X86_64_32
4827 && info
->no_reloc_overflow_check
))
4830 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4831 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4833 else if (r_type
== R_X86_64_64
4834 && !ABI_64_P (output_bfd
))
4837 outrel
.r_info
= htab
->r_info (0,
4838 R_X86_64_RELATIVE64
);
4839 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4840 /* Check addend overflow. */
4841 if ((outrel
.r_addend
& 0x80000000)
4842 != (rel
->r_addend
& 0x80000000))
4845 int addend
= rel
->r_addend
;
4846 if (h
&& h
->root
.root
.string
)
4847 name
= h
->root
.root
.string
;
4849 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4852 (*_bfd_error_handler
)
4853 (_("%B: addend -0x%x in relocation %s against "
4854 "symbol `%s' at 0x%lx in section `%A' is "
4856 input_bfd
, input_section
, addend
,
4858 (unsigned long) rel
->r_offset
);
4860 (*_bfd_error_handler
)
4861 (_("%B: addend 0x%x in relocation %s against "
4862 "symbol `%s' at 0x%lx in section `%A' is "
4864 input_bfd
, input_section
, addend
,
4866 (unsigned long) rel
->r_offset
);
4867 bfd_set_error (bfd_error_bad_value
);
4875 if (bfd_is_abs_section (sec
))
4877 else if (sec
== NULL
|| sec
->owner
== NULL
)
4879 bfd_set_error (bfd_error_bad_value
);
4886 /* We are turning this relocation into one
4887 against a section symbol. It would be
4888 proper to subtract the symbol's value,
4889 osec->vma, from the emitted reloc addend,
4890 but ld.so expects buggy relocs. */
4891 osec
= sec
->output_section
;
4892 sindx
= elf_section_data (osec
)->dynindx
;
4895 asection
*oi
= htab
->elf
.text_index_section
;
4896 sindx
= elf_section_data (oi
)->dynindx
;
4898 BFD_ASSERT (sindx
!= 0);
4901 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4902 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4906 sreloc
= elf_section_data (input_section
)->sreloc
;
4908 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4910 r
= bfd_reloc_notsupported
;
4911 goto check_relocation_error
;
4914 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4916 /* If this reloc is against an external symbol, we do
4917 not want to fiddle with the addend. Otherwise, we
4918 need to include the symbol value so that it becomes
4919 an addend for the dynamic reloc. */
4926 case R_X86_64_TLSGD
:
4927 case R_X86_64_GOTPC32_TLSDESC
:
4928 case R_X86_64_TLSDESC_CALL
:
4929 case R_X86_64_GOTTPOFF
:
4930 tls_type
= GOT_UNKNOWN
;
4931 if (h
== NULL
&& local_got_offsets
)
4932 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4934 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4936 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4937 input_section
, contents
,
4938 symtab_hdr
, sym_hashes
,
4939 &r_type
, tls_type
, rel
,
4940 relend
, h
, r_symndx
, TRUE
))
4943 if (r_type
== R_X86_64_TPOFF32
)
4945 bfd_vma roff
= rel
->r_offset
;
4947 BFD_ASSERT (! unresolved_reloc
);
4949 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4951 /* GD->LE transition. For 64bit, change
4952 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4953 .word 0x6666; rex64; call __tls_get_addr@PLT
4955 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4957 call *__tls_get_addr@GOTPCREL(%rip)
4958 which may be converted to
4959 addr32 call __tls_get_addr
4962 leaq foo@tpoff(%rax), %rax
4964 leaq foo@tlsgd(%rip), %rdi
4965 .word 0x6666; rex64; call __tls_get_addr@PLT
4967 leaq foo@tlsgd(%rip), %rdi
4969 call *__tls_get_addr@GOTPCREL(%rip)
4970 which may be converted to
4971 addr32 call __tls_get_addr
4974 leaq foo@tpoff(%rax), %rax
4975 For largepic, change:
4976 leaq foo@tlsgd(%rip), %rdi
4977 movabsq $__tls_get_addr@pltoff, %rax
4982 leaq foo@tpoff(%rax), %rax
4983 nopw 0x0(%rax,%rax,1) */
4985 if (ABI_64_P (output_bfd
))
4987 if (contents
[roff
+ 5] == 0xb8)
4989 memcpy (contents
+ roff
- 3,
4990 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4991 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4995 memcpy (contents
+ roff
- 4,
4996 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5000 memcpy (contents
+ roff
- 3,
5001 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5003 bfd_put_32 (output_bfd
,
5004 elf_x86_64_tpoff (info
, relocation
),
5005 contents
+ roff
+ 8 + largepic
);
5006 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5007 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5012 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5014 /* GDesc -> LE transition.
5015 It's originally something like:
5016 leaq x@tlsdesc(%rip), %rax
5019 movl $x@tpoff, %rax. */
5021 unsigned int val
, type
;
5023 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5024 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5025 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5026 contents
+ roff
- 3);
5027 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5028 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5029 contents
+ roff
- 1);
5030 bfd_put_32 (output_bfd
,
5031 elf_x86_64_tpoff (info
, relocation
),
5035 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5037 /* GDesc -> LE transition.
5042 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5043 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5046 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5048 /* IE->LE transition:
5049 For 64bit, originally it can be one of:
5050 movq foo@gottpoff(%rip), %reg
5051 addq foo@gottpoff(%rip), %reg
5054 leaq foo(%reg), %reg
5056 For 32bit, originally it can be one of:
5057 movq foo@gottpoff(%rip), %reg
5058 addl foo@gottpoff(%rip), %reg
5061 leal foo(%reg), %reg
5064 unsigned int val
, type
, reg
;
5067 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5070 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5071 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5077 bfd_put_8 (output_bfd
, 0x49,
5078 contents
+ roff
- 3);
5079 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5080 bfd_put_8 (output_bfd
, 0x41,
5081 contents
+ roff
- 3);
5082 bfd_put_8 (output_bfd
, 0xc7,
5083 contents
+ roff
- 2);
5084 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5085 contents
+ roff
- 1);
5089 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5092 bfd_put_8 (output_bfd
, 0x49,
5093 contents
+ roff
- 3);
5094 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5095 bfd_put_8 (output_bfd
, 0x41,
5096 contents
+ roff
- 3);
5097 bfd_put_8 (output_bfd
, 0x81,
5098 contents
+ roff
- 2);
5099 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5100 contents
+ roff
- 1);
5104 /* addq/addl -> leaq/leal */
5106 bfd_put_8 (output_bfd
, 0x4d,
5107 contents
+ roff
- 3);
5108 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5109 bfd_put_8 (output_bfd
, 0x45,
5110 contents
+ roff
- 3);
5111 bfd_put_8 (output_bfd
, 0x8d,
5112 contents
+ roff
- 2);
5113 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5114 contents
+ roff
- 1);
5116 bfd_put_32 (output_bfd
,
5117 elf_x86_64_tpoff (info
, relocation
),
5125 if (htab
->elf
.sgot
== NULL
)
5130 off
= h
->got
.offset
;
5131 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5135 if (local_got_offsets
== NULL
)
5138 off
= local_got_offsets
[r_symndx
];
5139 offplt
= local_tlsdesc_gotents
[r_symndx
];
5146 Elf_Internal_Rela outrel
;
5150 if (htab
->elf
.srelgot
== NULL
)
5153 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5155 if (GOT_TLS_GDESC_P (tls_type
))
5157 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5158 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5159 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5160 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5161 + htab
->elf
.sgotplt
->output_offset
5163 + htab
->sgotplt_jump_table_size
);
5164 sreloc
= htab
->elf
.srelplt
;
5166 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5168 outrel
.r_addend
= 0;
5169 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5172 sreloc
= htab
->elf
.srelgot
;
5174 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5175 + htab
->elf
.sgot
->output_offset
+ off
);
5177 if (GOT_TLS_GD_P (tls_type
))
5178 dr_type
= R_X86_64_DTPMOD64
;
5179 else if (GOT_TLS_GDESC_P (tls_type
))
5182 dr_type
= R_X86_64_TPOFF64
;
5184 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5185 outrel
.r_addend
= 0;
5186 if ((dr_type
== R_X86_64_TPOFF64
5187 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5188 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5189 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5191 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5193 if (GOT_TLS_GD_P (tls_type
))
5197 BFD_ASSERT (! unresolved_reloc
);
5198 bfd_put_64 (output_bfd
,
5199 relocation
- elf_x86_64_dtpoff_base (info
),
5200 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5204 bfd_put_64 (output_bfd
, 0,
5205 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5206 outrel
.r_info
= htab
->r_info (indx
,
5208 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5209 elf_append_rela (output_bfd
, sreloc
,
5218 local_got_offsets
[r_symndx
] |= 1;
5221 if (off
>= (bfd_vma
) -2
5222 && ! GOT_TLS_GDESC_P (tls_type
))
5224 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5226 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5227 || r_type
== R_X86_64_TLSDESC_CALL
)
5228 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5229 + htab
->elf
.sgotplt
->output_offset
5230 + offplt
+ htab
->sgotplt_jump_table_size
;
5232 relocation
= htab
->elf
.sgot
->output_section
->vma
5233 + htab
->elf
.sgot
->output_offset
+ off
;
5234 unresolved_reloc
= FALSE
;
5238 bfd_vma roff
= rel
->r_offset
;
5240 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5242 /* GD->IE transition. For 64bit, change
5243 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5244 .word 0x6666; rex64; call __tls_get_addr@PLT
5246 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5248 call *__tls_get_addr@GOTPCREL(%rip
5249 which may be converted to
5250 addr32 call __tls_get_addr
5253 addq foo@gottpoff(%rip), %rax
5255 leaq foo@tlsgd(%rip), %rdi
5256 .word 0x6666; rex64; call __tls_get_addr@PLT
5258 leaq foo@tlsgd(%rip), %rdi
5260 call *__tls_get_addr@GOTPCREL(%rip)
5261 which may be converted to
5262 addr32 call __tls_get_addr
5265 addq foo@gottpoff(%rip), %rax
5266 For largepic, change:
5267 leaq foo@tlsgd(%rip), %rdi
5268 movabsq $__tls_get_addr@pltoff, %rax
5273 addq foo@gottpoff(%rax), %rax
5274 nopw 0x0(%rax,%rax,1) */
5276 if (ABI_64_P (output_bfd
))
5278 if (contents
[roff
+ 5] == 0xb8)
5280 memcpy (contents
+ roff
- 3,
5281 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5282 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5286 memcpy (contents
+ roff
- 4,
5287 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5291 memcpy (contents
+ roff
- 3,
5292 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5295 relocation
= (htab
->elf
.sgot
->output_section
->vma
5296 + htab
->elf
.sgot
->output_offset
+ off
5299 - input_section
->output_section
->vma
5300 - input_section
->output_offset
5302 bfd_put_32 (output_bfd
, relocation
,
5303 contents
+ roff
+ 8 + largepic
);
5304 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5309 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5311 /* GDesc -> IE transition.
5312 It's originally something like:
5313 leaq x@tlsdesc(%rip), %rax
5316 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5318 /* Now modify the instruction as appropriate. To
5319 turn a leaq into a movq in the form we use it, it
5320 suffices to change the second byte from 0x8d to
5322 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5324 bfd_put_32 (output_bfd
,
5325 htab
->elf
.sgot
->output_section
->vma
5326 + htab
->elf
.sgot
->output_offset
+ off
5328 - input_section
->output_section
->vma
5329 - input_section
->output_offset
5334 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5336 /* GDesc -> IE transition.
5343 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5344 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5352 case R_X86_64_TLSLD
:
5353 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5354 input_section
, contents
,
5355 symtab_hdr
, sym_hashes
,
5356 &r_type
, GOT_UNKNOWN
, rel
,
5357 relend
, h
, r_symndx
, TRUE
))
5360 if (r_type
!= R_X86_64_TLSLD
)
5362 /* LD->LE transition:
5363 leaq foo@tlsld(%rip), %rdi
5364 call __tls_get_addr@PLT
5365 For 64bit, we change it into:
5366 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5367 For 32bit, we change it into:
5368 nopl 0x0(%rax); movl %fs:0, %eax
5370 leaq foo@tlsld(%rip), %rdi;
5371 call *__tls_get_addr@GOTPCREL(%rip)
5372 which may be converted to
5373 addr32 call __tls_get_addr
5374 For 64bit, we change it into:
5375 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5376 For 32bit, we change it into:
5377 nopw 0x0(%rax); movl %fs:0, %eax
5378 For largepic, change:
5379 leaq foo@tlsgd(%rip), %rdi
5380 movabsq $__tls_get_addr@pltoff, %rax
5384 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5387 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5388 if (ABI_64_P (output_bfd
))
5390 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5391 memcpy (contents
+ rel
->r_offset
- 3,
5392 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5393 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5394 else if (contents
[rel
->r_offset
+ 4] == 0xff
5395 || contents
[rel
->r_offset
+ 4] == 0x67)
5396 memcpy (contents
+ rel
->r_offset
- 3,
5397 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5400 memcpy (contents
+ rel
->r_offset
- 3,
5401 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5405 if (contents
[rel
->r_offset
+ 4] == 0xff)
5406 memcpy (contents
+ rel
->r_offset
- 3,
5407 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5410 memcpy (contents
+ rel
->r_offset
- 3,
5411 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5413 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5414 and R_X86_64_PLTOFF64. */
5420 if (htab
->elf
.sgot
== NULL
)
5423 off
= htab
->tls_ld_got
.offset
;
5428 Elf_Internal_Rela outrel
;
5430 if (htab
->elf
.srelgot
== NULL
)
5433 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5434 + htab
->elf
.sgot
->output_offset
+ off
);
5436 bfd_put_64 (output_bfd
, 0,
5437 htab
->elf
.sgot
->contents
+ off
);
5438 bfd_put_64 (output_bfd
, 0,
5439 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5440 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5441 outrel
.r_addend
= 0;
5442 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5444 htab
->tls_ld_got
.offset
|= 1;
5446 relocation
= htab
->elf
.sgot
->output_section
->vma
5447 + htab
->elf
.sgot
->output_offset
+ off
;
5448 unresolved_reloc
= FALSE
;
5451 case R_X86_64_DTPOFF32
:
5452 if (!bfd_link_executable (info
)
5453 || (input_section
->flags
& SEC_CODE
) == 0)
5454 relocation
-= elf_x86_64_dtpoff_base (info
);
5456 relocation
= elf_x86_64_tpoff (info
, relocation
);
5459 case R_X86_64_TPOFF32
:
5460 case R_X86_64_TPOFF64
:
5461 BFD_ASSERT (bfd_link_executable (info
));
5462 relocation
= elf_x86_64_tpoff (info
, relocation
);
5465 case R_X86_64_DTPOFF64
:
5466 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5467 relocation
-= elf_x86_64_dtpoff_base (info
);
5474 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5475 because such sections are not SEC_ALLOC and thus ld.so will
5476 not process them. */
5477 if (unresolved_reloc
5478 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5480 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5481 rel
->r_offset
) != (bfd_vma
) -1)
5483 (*_bfd_error_handler
)
5484 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5487 (long) rel
->r_offset
,
5489 h
->root
.root
.string
);
5494 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5495 contents
, rel
->r_offset
,
5496 relocation
, rel
->r_addend
);
5498 check_relocation_error
:
5499 if (r
!= bfd_reloc_ok
)
5504 name
= h
->root
.root
.string
;
5507 name
= bfd_elf_string_from_elf_section (input_bfd
,
5508 symtab_hdr
->sh_link
,
5513 name
= bfd_section_name (input_bfd
, sec
);
5516 if (r
== bfd_reloc_overflow
)
5517 (*info
->callbacks
->reloc_overflow
)
5518 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5519 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5522 (*_bfd_error_handler
)
5523 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5524 input_bfd
, input_section
,
5525 (long) rel
->r_offset
, name
, (int) r
);
5536 Elf_Internal_Shdr
*rel_hdr
;
5537 size_t deleted
= rel
- wrel
;
5539 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5540 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5541 if (rel_hdr
->sh_size
== 0)
5543 /* It is too late to remove an empty reloc section. Leave
5545 ??? What is wrong with an empty section??? */
5546 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5549 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5550 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5551 input_section
->reloc_count
-= deleted
;
5557 /* Finish up dynamic symbol handling. We set the contents of various
5558 dynamic sections here. */
5561 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5562 struct bfd_link_info
*info
,
5563 struct elf_link_hash_entry
*h
,
5564 Elf_Internal_Sym
*sym
)
5566 struct elf_x86_64_link_hash_table
*htab
;
5567 const struct elf_x86_64_backend_data
*abed
;
5568 bfd_boolean use_plt_bnd
;
5569 struct elf_x86_64_link_hash_entry
*eh
;
5570 bfd_boolean local_undefweak
;
5572 htab
= elf_x86_64_hash_table (info
);
5576 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5577 section only if there is .plt section. */
5578 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5580 ? &elf_x86_64_bnd_arch_bed
5581 : get_elf_x86_64_backend_data (output_bfd
));
5583 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5585 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5586 resolved undefined weak symbols in executable so that their
5587 references have value 0 at run-time. */
5588 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5592 if (h
->plt
.offset
!= (bfd_vma
) -1)
5595 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5596 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5597 Elf_Internal_Rela rela
;
5599 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5600 const struct elf_backend_data
*bed
;
5601 bfd_vma plt_got_pcrel_offset
;
5603 /* When building a static executable, use .iplt, .igot.plt and
5604 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5605 if (htab
->elf
.splt
!= NULL
)
5607 plt
= htab
->elf
.splt
;
5608 gotplt
= htab
->elf
.sgotplt
;
5609 relplt
= htab
->elf
.srelplt
;
5613 plt
= htab
->elf
.iplt
;
5614 gotplt
= htab
->elf
.igotplt
;
5615 relplt
= htab
->elf
.irelplt
;
5618 /* This symbol has an entry in the procedure linkage table. Set
5620 if ((h
->dynindx
== -1
5622 && !((h
->forced_local
|| bfd_link_executable (info
))
5624 && h
->type
== STT_GNU_IFUNC
))
5630 /* Get the index in the procedure linkage table which
5631 corresponds to this symbol. This is the index of this symbol
5632 in all the symbols for which we are making plt entries. The
5633 first entry in the procedure linkage table is reserved.
5635 Get the offset into the .got table of the entry that
5636 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5637 bytes. The first three are reserved for the dynamic linker.
5639 For static executables, we don't reserve anything. */
5641 if (plt
== htab
->elf
.splt
)
5643 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5644 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5648 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5649 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5652 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5653 plt_plt_offset
= abed
->plt_plt_offset
;
5654 plt_got_insn_size
= abed
->plt_got_insn_size
;
5655 plt_got_offset
= abed
->plt_got_offset
;
5658 /* Use the second PLT with BND relocations. */
5659 const bfd_byte
*plt_entry
, *plt2_entry
;
5661 if (eh
->has_bnd_reloc
)
5663 plt_entry
= elf_x86_64_bnd_plt_entry
;
5664 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5668 plt_entry
= elf_x86_64_legacy_plt_entry
;
5669 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5671 /* Subtract 1 since there is no BND prefix. */
5672 plt_plt_insn_end
-= 1;
5673 plt_plt_offset
-= 1;
5674 plt_got_insn_size
-= 1;
5675 plt_got_offset
-= 1;
5678 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5679 == sizeof (elf_x86_64_legacy_plt_entry
));
5681 /* Fill in the entry in the procedure linkage table. */
5682 memcpy (plt
->contents
+ h
->plt
.offset
,
5683 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5684 /* Fill in the entry in the second PLT. */
5685 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5686 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5688 resolved_plt
= htab
->plt_bnd
;
5689 plt_offset
= eh
->plt_bnd
.offset
;
5693 /* Fill in the entry in the procedure linkage table. */
5694 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5695 abed
->plt_entry_size
);
5698 plt_offset
= h
->plt
.offset
;
5701 /* Insert the relocation positions of the plt section. */
5703 /* Put offset the PC-relative instruction referring to the GOT entry,
5704 subtracting the size of that instruction. */
5705 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5706 + gotplt
->output_offset
5708 - resolved_plt
->output_section
->vma
5709 - resolved_plt
->output_offset
5711 - plt_got_insn_size
);
5713 /* Check PC-relative offset overflow in PLT entry. */
5714 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5715 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5716 output_bfd
, h
->root
.root
.string
);
5718 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5719 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5721 /* Fill in the entry in the global offset table, initially this
5722 points to the second part of the PLT entry. Leave the entry
5723 as zero for undefined weak symbol in PIE. No PLT relocation
5724 against undefined weak symbol in PIE. */
5725 if (!local_undefweak
)
5727 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5728 + plt
->output_offset
5730 + abed
->plt_lazy_offset
),
5731 gotplt
->contents
+ got_offset
);
5733 /* Fill in the entry in the .rela.plt section. */
5734 rela
.r_offset
= (gotplt
->output_section
->vma
5735 + gotplt
->output_offset
5737 if (h
->dynindx
== -1
5738 || ((bfd_link_executable (info
)
5739 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5741 && h
->type
== STT_GNU_IFUNC
))
5743 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5744 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5745 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5746 rela
.r_addend
= (h
->root
.u
.def
.value
5747 + h
->root
.u
.def
.section
->output_section
->vma
5748 + h
->root
.u
.def
.section
->output_offset
);
5749 /* R_X86_64_IRELATIVE comes last. */
5750 plt_index
= htab
->next_irelative_index
--;
5754 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5756 plt_index
= htab
->next_jump_slot_index
++;
5759 /* Don't fill PLT entry for static executables. */
5760 if (plt
== htab
->elf
.splt
)
5762 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5764 /* Put relocation index. */
5765 bfd_put_32 (output_bfd
, plt_index
,
5766 (plt
->contents
+ h
->plt
.offset
5767 + abed
->plt_reloc_offset
));
5769 /* Put offset for jmp .PLT0 and check for overflow. We don't
5770 check relocation index for overflow since branch displacement
5771 will overflow first. */
5772 if (plt0_offset
> 0x80000000)
5773 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5774 output_bfd
, h
->root
.root
.string
);
5775 bfd_put_32 (output_bfd
, - plt0_offset
,
5776 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5779 bed
= get_elf_backend_data (output_bfd
);
5780 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5781 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5784 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5786 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5787 asection
*plt
, *got
;
5788 bfd_boolean got_after_plt
;
5789 int32_t got_pcrel_offset
;
5790 const bfd_byte
*got_plt_entry
;
5792 /* Set the entry in the GOT procedure linkage table. */
5793 plt
= htab
->plt_got
;
5794 got
= htab
->elf
.sgot
;
5795 got_offset
= h
->got
.offset
;
5797 if (got_offset
== (bfd_vma
) -1
5798 || h
->type
== STT_GNU_IFUNC
5803 /* Use the second PLT entry template for the GOT PLT since they
5804 are the identical. */
5805 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5806 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5807 if (eh
->has_bnd_reloc
)
5808 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5811 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5813 /* Subtract 1 since there is no BND prefix. */
5814 plt_got_insn_size
-= 1;
5815 plt_got_offset
-= 1;
5818 /* Fill in the entry in the GOT procedure linkage table. */
5819 plt_offset
= eh
->plt_got
.offset
;
5820 memcpy (plt
->contents
+ plt_offset
,
5821 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5823 /* Put offset the PC-relative instruction referring to the GOT
5824 entry, subtracting the size of that instruction. */
5825 got_pcrel_offset
= (got
->output_section
->vma
5826 + got
->output_offset
5828 - plt
->output_section
->vma
5829 - plt
->output_offset
5831 - plt_got_insn_size
);
5833 /* Check PC-relative offset overflow in GOT PLT entry. */
5834 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5835 if ((got_after_plt
&& got_pcrel_offset
< 0)
5836 || (!got_after_plt
&& got_pcrel_offset
> 0))
5837 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5838 output_bfd
, h
->root
.root
.string
);
5840 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5841 plt
->contents
+ plt_offset
+ plt_got_offset
);
5844 if (!local_undefweak
5846 && (h
->plt
.offset
!= (bfd_vma
) -1
5847 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5849 /* Mark the symbol as undefined, rather than as defined in
5850 the .plt section. Leave the value if there were any
5851 relocations where pointer equality matters (this is a clue
5852 for the dynamic linker, to make function pointer
5853 comparisons work between an application and shared
5854 library), otherwise set it to zero. If a function is only
5855 called from a binary, there is no need to slow down
5856 shared libraries because of that. */
5857 sym
->st_shndx
= SHN_UNDEF
;
5858 if (!h
->pointer_equality_needed
)
5862 /* Don't generate dynamic GOT relocation against undefined weak
5863 symbol in executable. */
5864 if (h
->got
.offset
!= (bfd_vma
) -1
5865 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5866 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5867 && !local_undefweak
)
5869 Elf_Internal_Rela rela
;
5871 /* This symbol has an entry in the global offset table. Set it
5873 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5876 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5877 + htab
->elf
.sgot
->output_offset
5878 + (h
->got
.offset
&~ (bfd_vma
) 1));
5880 /* If this is a static link, or it is a -Bsymbolic link and the
5881 symbol is defined locally or was forced to be local because
5882 of a version file, we just want to emit a RELATIVE reloc.
5883 The entry in the global offset table will already have been
5884 initialized in the relocate_section function. */
5886 && h
->type
== STT_GNU_IFUNC
)
5888 if (bfd_link_pic (info
))
5890 /* Generate R_X86_64_GLOB_DAT. */
5897 if (!h
->pointer_equality_needed
)
5900 /* For non-shared object, we can't use .got.plt, which
5901 contains the real function addres if we need pointer
5902 equality. We load the GOT entry with the PLT entry. */
5903 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5904 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5905 + plt
->output_offset
5907 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5911 else if (bfd_link_pic (info
)
5912 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5914 if (!h
->def_regular
)
5916 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5917 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5918 rela
.r_addend
= (h
->root
.u
.def
.value
5919 + h
->root
.u
.def
.section
->output_section
->vma
5920 + h
->root
.u
.def
.section
->output_offset
);
5924 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5926 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5927 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5928 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5932 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5937 Elf_Internal_Rela rela
;
5939 /* This symbol needs a copy reloc. Set it up. */
5941 if (h
->dynindx
== -1
5942 || (h
->root
.type
!= bfd_link_hash_defined
5943 && h
->root
.type
!= bfd_link_hash_defweak
)
5944 || htab
->srelbss
== NULL
)
5947 rela
.r_offset
= (h
->root
.u
.def
.value
5948 + h
->root
.u
.def
.section
->output_section
->vma
5949 + h
->root
.u
.def
.section
->output_offset
);
5950 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5952 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5958 /* Finish up local dynamic symbol handling. We set the contents of
5959 various dynamic sections here. */
5962 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5964 struct elf_link_hash_entry
*h
5965 = (struct elf_link_hash_entry
*) *slot
;
5966 struct bfd_link_info
*info
5967 = (struct bfd_link_info
*) inf
;
5969 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5973 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5974 here since undefined weak symbol may not be dynamic and may not be
5975 called for elf_x86_64_finish_dynamic_symbol. */
5978 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5981 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5982 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5984 if (h
->root
.type
!= bfd_link_hash_undefweak
5985 || h
->dynindx
!= -1)
5988 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5992 /* Used to decide how to sort relocs in an optimal manner for the
5993 dynamic linker, before writing them out. */
5995 static enum elf_reloc_type_class
5996 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5997 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5998 const Elf_Internal_Rela
*rela
)
6000 bfd
*abfd
= info
->output_bfd
;
6001 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6002 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6004 if (htab
->elf
.dynsym
!= NULL
6005 && htab
->elf
.dynsym
->contents
!= NULL
)
6007 /* Check relocation against STT_GNU_IFUNC symbol if there are
6009 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6010 Elf_Internal_Sym sym
;
6011 if (!bed
->s
->swap_symbol_in (abfd
,
6012 (htab
->elf
.dynsym
->contents
6013 + r_symndx
* bed
->s
->sizeof_sym
),
6017 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6018 return reloc_class_ifunc
;
6021 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6023 case R_X86_64_RELATIVE
:
6024 case R_X86_64_RELATIVE64
:
6025 return reloc_class_relative
;
6026 case R_X86_64_JUMP_SLOT
:
6027 return reloc_class_plt
;
6029 return reloc_class_copy
;
6031 return reloc_class_normal
;
6035 /* Finish up the dynamic sections. */
6038 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6039 struct bfd_link_info
*info
)
6041 struct elf_x86_64_link_hash_table
*htab
;
6044 const struct elf_x86_64_backend_data
*abed
;
6046 htab
= elf_x86_64_hash_table (info
);
6050 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6051 section only if there is .plt section. */
6052 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6053 ? &elf_x86_64_bnd_arch_bed
6054 : get_elf_x86_64_backend_data (output_bfd
));
6056 dynobj
= htab
->elf
.dynobj
;
6057 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6059 if (htab
->elf
.dynamic_sections_created
)
6061 bfd_byte
*dyncon
, *dynconend
;
6062 const struct elf_backend_data
*bed
;
6063 bfd_size_type sizeof_dyn
;
6065 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6068 bed
= get_elf_backend_data (dynobj
);
6069 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6070 dyncon
= sdyn
->contents
;
6071 dynconend
= sdyn
->contents
+ sdyn
->size
;
6072 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6074 Elf_Internal_Dyn dyn
;
6077 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6085 s
= htab
->elf
.sgotplt
;
6086 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6090 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6094 s
= htab
->elf
.srelplt
->output_section
;
6095 dyn
.d_un
.d_val
= s
->size
;
6099 /* The procedure linkage table relocs (DT_JMPREL) should
6100 not be included in the overall relocs (DT_RELA).
6101 Therefore, we override the DT_RELASZ entry here to
6102 make it not include the JMPREL relocs. Since the
6103 linker script arranges for .rela.plt to follow all
6104 other relocation sections, we don't have to worry
6105 about changing the DT_RELA entry. */
6106 if (htab
->elf
.srelplt
!= NULL
)
6108 s
= htab
->elf
.srelplt
->output_section
;
6109 dyn
.d_un
.d_val
-= s
->size
;
6113 case DT_TLSDESC_PLT
:
6115 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6116 + htab
->tlsdesc_plt
;
6119 case DT_TLSDESC_GOT
:
6121 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6122 + htab
->tlsdesc_got
;
6126 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6129 /* Fill in the special first entry in the procedure linkage table. */
6130 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6132 /* Fill in the first entry in the procedure linkage table. */
6133 memcpy (htab
->elf
.splt
->contents
,
6134 abed
->plt0_entry
, abed
->plt_entry_size
);
6135 /* Add offset for pushq GOT+8(%rip), since the instruction
6136 uses 6 bytes subtract this value. */
6137 bfd_put_32 (output_bfd
,
6138 (htab
->elf
.sgotplt
->output_section
->vma
6139 + htab
->elf
.sgotplt
->output_offset
6141 - htab
->elf
.splt
->output_section
->vma
6142 - htab
->elf
.splt
->output_offset
6144 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6145 /* Add offset for the PC-relative instruction accessing GOT+16,
6146 subtracting the offset to the end of that instruction. */
6147 bfd_put_32 (output_bfd
,
6148 (htab
->elf
.sgotplt
->output_section
->vma
6149 + htab
->elf
.sgotplt
->output_offset
6151 - htab
->elf
.splt
->output_section
->vma
6152 - htab
->elf
.splt
->output_offset
6153 - abed
->plt0_got2_insn_end
),
6154 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6156 elf_section_data (htab
->elf
.splt
->output_section
)
6157 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6159 if (htab
->tlsdesc_plt
)
6161 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6162 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6164 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6165 abed
->plt0_entry
, abed
->plt_entry_size
);
6167 /* Add offset for pushq GOT+8(%rip), since the
6168 instruction uses 6 bytes subtract this value. */
6169 bfd_put_32 (output_bfd
,
6170 (htab
->elf
.sgotplt
->output_section
->vma
6171 + htab
->elf
.sgotplt
->output_offset
6173 - htab
->elf
.splt
->output_section
->vma
6174 - htab
->elf
.splt
->output_offset
6177 htab
->elf
.splt
->contents
6178 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6179 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6180 where TGD stands for htab->tlsdesc_got, subtracting the offset
6181 to the end of that instruction. */
6182 bfd_put_32 (output_bfd
,
6183 (htab
->elf
.sgot
->output_section
->vma
6184 + htab
->elf
.sgot
->output_offset
6186 - htab
->elf
.splt
->output_section
->vma
6187 - htab
->elf
.splt
->output_offset
6189 - abed
->plt0_got2_insn_end
),
6190 htab
->elf
.splt
->contents
6191 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6196 if (htab
->plt_bnd
!= NULL
)
6197 elf_section_data (htab
->plt_bnd
->output_section
)
6198 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6200 if (htab
->elf
.sgotplt
)
6202 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6204 (*_bfd_error_handler
)
6205 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6209 /* Fill in the first three entries in the global offset table. */
6210 if (htab
->elf
.sgotplt
->size
> 0)
6212 /* Set the first entry in the global offset table to the address of
6213 the dynamic section. */
6215 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6217 bfd_put_64 (output_bfd
,
6218 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6219 htab
->elf
.sgotplt
->contents
);
6220 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6221 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6222 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6225 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6229 /* Adjust .eh_frame for .plt section. */
6230 if (htab
->plt_eh_frame
!= NULL
6231 && htab
->plt_eh_frame
->contents
!= NULL
)
6233 if (htab
->elf
.splt
!= NULL
6234 && htab
->elf
.splt
->size
!= 0
6235 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6236 && htab
->elf
.splt
->output_section
!= NULL
6237 && htab
->plt_eh_frame
->output_section
!= NULL
)
6239 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6240 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6241 + htab
->plt_eh_frame
->output_offset
6242 + PLT_FDE_START_OFFSET
;
6243 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6244 htab
->plt_eh_frame
->contents
6245 + PLT_FDE_START_OFFSET
);
6247 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6249 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6251 htab
->plt_eh_frame
->contents
))
6256 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6257 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6260 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6261 htab_traverse (htab
->loc_hash_table
,
6262 elf_x86_64_finish_local_dynamic_symbol
,
6265 /* Fill PLT entries for undefined weak symbols in PIE. */
6266 if (bfd_link_pie (info
))
6267 bfd_hash_traverse (&info
->hash
->table
,
6268 elf_x86_64_pie_finish_undefweak_symbol
,
6274 /* Return an array of PLT entry symbol values. */
6277 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6280 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6283 bfd_vma
*plt_sym_val
;
6285 bfd_byte
*plt_contents
;
6286 const struct elf_x86_64_backend_data
*bed
;
6287 Elf_Internal_Shdr
*hdr
;
6290 /* Get the .plt section contents. PLT passed down may point to the
6291 .plt.bnd section. Make sure that PLT always points to the .plt
6293 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6298 plt
= bfd_get_section_by_name (abfd
, ".plt");
6301 bed
= &elf_x86_64_bnd_arch_bed
;
6304 bed
= get_elf_x86_64_backend_data (abfd
);
6306 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6307 if (plt_contents
== NULL
)
6309 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6310 plt_contents
, 0, plt
->size
))
6313 free (plt_contents
);
6317 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6318 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6321 hdr
= &elf_section_data (relplt
)->this_hdr
;
6322 count
= relplt
->size
/ hdr
->sh_entsize
;
6324 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6325 if (plt_sym_val
== NULL
)
6328 for (i
= 0; i
< count
; i
++)
6329 plt_sym_val
[i
] = -1;
6331 plt_offset
= bed
->plt_entry_size
;
6332 p
= relplt
->relocation
;
6333 for (i
= 0; i
< count
; i
++, p
++)
6337 /* Skip unknown relocation. */
6338 if (p
->howto
== NULL
)
6341 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6342 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6345 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6346 + bed
->plt_reloc_offset
));
6347 if (reloc_index
< count
)
6351 /* This is the index in .plt section. */
6352 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6353 /* Store VMA + the offset in .plt.bnd section. */
6354 plt_sym_val
[reloc_index
] =
6356 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6359 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6361 plt_offset
+= bed
->plt_entry_size
;
6363 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6365 if (plt_offset
>= plt
->size
)
6369 free (plt_contents
);
6374 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6378 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6385 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6386 as PLT if it exists. */
6387 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6389 plt
= bfd_get_section_by_name (abfd
, ".plt");
6390 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6391 dynsymcount
, dynsyms
, ret
,
6393 elf_x86_64_get_plt_sym_val
);
6396 /* Handle an x86-64 specific section when reading an object file. This
6397 is called when elfcode.h finds a section with an unknown type. */
6400 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6401 const char *name
, int shindex
)
6403 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6406 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6412 /* Hook called by the linker routine which adds symbols from an object
6413 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6417 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6418 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6419 Elf_Internal_Sym
*sym
,
6420 const char **namep ATTRIBUTE_UNUSED
,
6421 flagword
*flagsp ATTRIBUTE_UNUSED
,
6427 switch (sym
->st_shndx
)
6429 case SHN_X86_64_LCOMMON
:
6430 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6433 lcomm
= bfd_make_section_with_flags (abfd
,
6437 | SEC_LINKER_CREATED
));
6440 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6443 *valp
= sym
->st_size
;
6451 /* Given a BFD section, try to locate the corresponding ELF section
6455 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6456 asection
*sec
, int *index_return
)
6458 if (sec
== &_bfd_elf_large_com_section
)
6460 *index_return
= SHN_X86_64_LCOMMON
;
6466 /* Process a symbol. */
6469 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6472 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6474 switch (elfsym
->internal_elf_sym
.st_shndx
)
6476 case SHN_X86_64_LCOMMON
:
6477 asym
->section
= &_bfd_elf_large_com_section
;
6478 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6479 /* Common symbol doesn't set BSF_GLOBAL. */
6480 asym
->flags
&= ~BSF_GLOBAL
;
6486 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6488 return (sym
->st_shndx
== SHN_COMMON
6489 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6493 elf_x86_64_common_section_index (asection
*sec
)
6495 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6498 return SHN_X86_64_LCOMMON
;
6502 elf_x86_64_common_section (asection
*sec
)
6504 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6505 return bfd_com_section_ptr
;
6507 return &_bfd_elf_large_com_section
;
6511 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6512 const Elf_Internal_Sym
*sym
,
6517 const asection
*oldsec
)
6519 /* A normal common symbol and a large common symbol result in a
6520 normal common symbol. We turn the large common symbol into a
6523 && h
->root
.type
== bfd_link_hash_common
6525 && bfd_is_com_section (*psec
)
6528 if (sym
->st_shndx
== SHN_COMMON
6529 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6531 h
->root
.u
.c
.p
->section
6532 = bfd_make_section_old_way (oldbfd
, "COMMON");
6533 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6535 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6536 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6537 *psec
= bfd_com_section_ptr
;
6544 elf_x86_64_additional_program_headers (bfd
*abfd
,
6545 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6550 /* Check to see if we need a large readonly segment. */
6551 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6552 if (s
&& (s
->flags
& SEC_LOAD
))
6555 /* Check to see if we need a large data segment. Since .lbss sections
6556 is placed right after the .bss section, there should be no need for
6557 a large data segment just because of .lbss. */
6558 s
= bfd_get_section_by_name (abfd
, ".ldata");
6559 if (s
&& (s
->flags
& SEC_LOAD
))
6565 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6568 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6570 if (h
->plt
.offset
!= (bfd_vma
) -1
6572 && !h
->pointer_equality_needed
)
6575 return _bfd_elf_hash_symbol (h
);
6578 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6581 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6582 const bfd_target
*output
)
6584 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6585 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6586 && _bfd_elf_relocs_compatible (input
, output
));
6589 static const struct bfd_elf_special_section
6590 elf_x86_64_special_sections
[]=
6592 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6593 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6594 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6595 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6596 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6597 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6598 { NULL
, 0, 0, 0, 0 }
6601 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6602 #define TARGET_LITTLE_NAME "elf64-x86-64"
6603 #define ELF_ARCH bfd_arch_i386
6604 #define ELF_TARGET_ID X86_64_ELF_DATA
6605 #define ELF_MACHINE_CODE EM_X86_64
6606 #define ELF_MAXPAGESIZE 0x200000
6607 #define ELF_MINPAGESIZE 0x1000
6608 #define ELF_COMMONPAGESIZE 0x1000
6610 #define elf_backend_can_gc_sections 1
6611 #define elf_backend_can_refcount 1
6612 #define elf_backend_want_got_plt 1
6613 #define elf_backend_plt_readonly 1
6614 #define elf_backend_want_plt_sym 0
6615 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6616 #define elf_backend_rela_normal 1
6617 #define elf_backend_plt_alignment 4
6618 #define elf_backend_extern_protected_data 1
6619 #define elf_backend_caches_rawsize 1
6621 #define elf_info_to_howto elf_x86_64_info_to_howto
6623 #define bfd_elf64_bfd_link_hash_table_create \
6624 elf_x86_64_link_hash_table_create
6625 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6626 #define bfd_elf64_bfd_reloc_name_lookup \
6627 elf_x86_64_reloc_name_lookup
6629 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6630 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6631 #define elf_backend_check_relocs elf_x86_64_check_relocs
6632 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6633 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6634 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6635 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6636 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6637 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6638 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6640 #define elf_backend_write_core_note elf_x86_64_write_core_note
6642 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6643 #define elf_backend_relocate_section elf_x86_64_relocate_section
6644 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6645 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6646 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6647 #define elf_backend_object_p elf64_x86_64_elf_object_p
6648 #define bfd_elf64_mkobject elf_x86_64_mkobject
6649 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6651 #define elf_backend_section_from_shdr \
6652 elf_x86_64_section_from_shdr
6654 #define elf_backend_section_from_bfd_section \
6655 elf_x86_64_elf_section_from_bfd_section
6656 #define elf_backend_add_symbol_hook \
6657 elf_x86_64_add_symbol_hook
6658 #define elf_backend_symbol_processing \
6659 elf_x86_64_symbol_processing
6660 #define elf_backend_common_section_index \
6661 elf_x86_64_common_section_index
6662 #define elf_backend_common_section \
6663 elf_x86_64_common_section
6664 #define elf_backend_common_definition \
6665 elf_x86_64_common_definition
6666 #define elf_backend_merge_symbol \
6667 elf_x86_64_merge_symbol
6668 #define elf_backend_special_sections \
6669 elf_x86_64_special_sections
6670 #define elf_backend_additional_program_headers \
6671 elf_x86_64_additional_program_headers
6672 #define elf_backend_hash_symbol \
6673 elf_x86_64_hash_symbol
6674 #define elf_backend_omit_section_dynsym \
6675 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6676 #define elf_backend_fixup_symbol \
6677 elf_x86_64_fixup_symbol
6679 #include "elf64-target.h"
6681 /* CloudABI support. */
6683 #undef TARGET_LITTLE_SYM
6684 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6685 #undef TARGET_LITTLE_NAME
6686 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6689 #define ELF_OSABI ELFOSABI_CLOUDABI
6692 #define elf64_bed elf64_x86_64_cloudabi_bed
6694 #include "elf64-target.h"
6696 /* FreeBSD support. */
6698 #undef TARGET_LITTLE_SYM
6699 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6700 #undef TARGET_LITTLE_NAME
6701 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6704 #define ELF_OSABI ELFOSABI_FREEBSD
6707 #define elf64_bed elf64_x86_64_fbsd_bed
6709 #include "elf64-target.h"
6711 /* Solaris 2 support. */
6713 #undef TARGET_LITTLE_SYM
6714 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6715 #undef TARGET_LITTLE_NAME
6716 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6718 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6719 objects won't be recognized. */
6723 #define elf64_bed elf64_x86_64_sol2_bed
6725 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6727 #undef elf_backend_static_tls_alignment
6728 #define elf_backend_static_tls_alignment 16
6730 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6732 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6734 #undef elf_backend_want_plt_sym
6735 #define elf_backend_want_plt_sym 1
6737 #undef elf_backend_strtab_flags
6738 #define elf_backend_strtab_flags SHF_STRINGS
6741 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6742 bfd
*obfd ATTRIBUTE_UNUSED
,
6743 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6744 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6746 /* PR 19938: FIXME: Need to add code for setting the sh_info
6747 and sh_link fields of Solaris specific section types. */
6751 #undef elf_backend_copy_special_section_fields
6752 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6754 #include "elf64-target.h"
6756 /* Native Client support. */
6759 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6761 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6762 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6766 #undef TARGET_LITTLE_SYM
6767 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6768 #undef TARGET_LITTLE_NAME
6769 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6771 #define elf64_bed elf64_x86_64_nacl_bed
6773 #undef ELF_MAXPAGESIZE
6774 #undef ELF_MINPAGESIZE
6775 #undef ELF_COMMONPAGESIZE
6776 #define ELF_MAXPAGESIZE 0x10000
6777 #define ELF_MINPAGESIZE 0x10000
6778 #define ELF_COMMONPAGESIZE 0x10000
6780 /* Restore defaults. */
6782 #undef elf_backend_static_tls_alignment
6783 #undef elf_backend_want_plt_sym
6784 #define elf_backend_want_plt_sym 0
6785 #undef elf_backend_strtab_flags
6786 #undef elf_backend_copy_special_section_fields
6788 /* NaCl uses substantially different PLT entries for the same effects. */
6790 #undef elf_backend_plt_alignment
6791 #define elf_backend_plt_alignment 5
6792 #define NACL_PLT_ENTRY_SIZE 64
6793 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6795 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6797 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6798 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6799 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6800 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6801 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6803 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6804 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6806 /* 32 bytes of nop to pad out to the standard size. */
6807 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6808 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6809 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6810 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6811 0x66, /* excess data16 prefix */
6815 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6817 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6818 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6819 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6820 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6822 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6823 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6824 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6826 /* Lazy GOT entries point here (32-byte aligned). */
6827 0x68, /* pushq immediate */
6828 0, 0, 0, 0, /* replaced with index into relocation table. */
6829 0xe9, /* jmp relative */
6830 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6832 /* 22 bytes of nop to pad out to the standard size. */
6833 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6834 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6835 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6838 /* .eh_frame covering the .plt section. */
6840 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6842 #if (PLT_CIE_LENGTH != 20 \
6843 || PLT_FDE_LENGTH != 36 \
6844 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6845 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6846 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6848 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6849 0, 0, 0, 0, /* CIE ID */
6850 1, /* CIE version */
6851 'z', 'R', 0, /* Augmentation string */
6852 1, /* Code alignment factor */
6853 0x78, /* Data alignment factor */
6854 16, /* Return address column */
6855 1, /* Augmentation size */
6856 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6857 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6858 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6859 DW_CFA_nop
, DW_CFA_nop
,
6861 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6862 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6863 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6864 0, 0, 0, 0, /* .plt size goes here */
6865 0, /* Augmentation size */
6866 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6867 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6868 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6869 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6870 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6871 13, /* Block length */
6872 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6873 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6874 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6875 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6876 DW_CFA_nop
, DW_CFA_nop
6879 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6881 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6882 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6883 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6884 2, /* plt0_got1_offset */
6885 9, /* plt0_got2_offset */
6886 13, /* plt0_got2_insn_end */
6887 3, /* plt_got_offset */
6888 33, /* plt_reloc_offset */
6889 38, /* plt_plt_offset */
6890 7, /* plt_got_insn_size */
6891 42, /* plt_plt_insn_end */
6892 32, /* plt_lazy_offset */
6893 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6894 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6897 #undef elf_backend_arch_data
6898 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6900 #undef elf_backend_object_p
6901 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6902 #undef elf_backend_modify_segment_map
6903 #define elf_backend_modify_segment_map nacl_modify_segment_map
6904 #undef elf_backend_modify_program_headers
6905 #define elf_backend_modify_program_headers nacl_modify_program_headers
6906 #undef elf_backend_final_write_processing
6907 #define elf_backend_final_write_processing nacl_final_write_processing
6909 #include "elf64-target.h"
6911 /* Native Client x32 support. */
6914 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6916 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6917 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6921 #undef TARGET_LITTLE_SYM
6922 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6923 #undef TARGET_LITTLE_NAME
6924 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6926 #define elf32_bed elf32_x86_64_nacl_bed
6928 #define bfd_elf32_bfd_link_hash_table_create \
6929 elf_x86_64_link_hash_table_create
6930 #define bfd_elf32_bfd_reloc_type_lookup \
6931 elf_x86_64_reloc_type_lookup
6932 #define bfd_elf32_bfd_reloc_name_lookup \
6933 elf_x86_64_reloc_name_lookup
6934 #define bfd_elf32_mkobject \
6936 #define bfd_elf32_get_synthetic_symtab \
6937 elf_x86_64_get_synthetic_symtab
6939 #undef elf_backend_object_p
6940 #define elf_backend_object_p \
6941 elf32_x86_64_nacl_elf_object_p
6943 #undef elf_backend_bfd_from_remote_memory
6944 #define elf_backend_bfd_from_remote_memory \
6945 _bfd_elf32_bfd_from_remote_memory
6947 #undef elf_backend_size_info
6948 #define elf_backend_size_info \
6949 _bfd_elf32_size_info
6951 #include "elf32-target.h"
6953 /* Restore defaults. */
6954 #undef elf_backend_object_p
6955 #define elf_backend_object_p elf64_x86_64_elf_object_p
6956 #undef elf_backend_bfd_from_remote_memory
6957 #undef elf_backend_size_info
6958 #undef elf_backend_modify_segment_map
6959 #undef elf_backend_modify_program_headers
6960 #undef elf_backend_final_write_processing
6962 /* Intel L1OM support. */
6965 elf64_l1om_elf_object_p (bfd
*abfd
)
6967 /* Set the right machine number for an L1OM elf64 file. */
6968 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6972 #undef TARGET_LITTLE_SYM
6973 #define TARGET_LITTLE_SYM l1om_elf64_vec
6974 #undef TARGET_LITTLE_NAME
6975 #define TARGET_LITTLE_NAME "elf64-l1om"
6977 #define ELF_ARCH bfd_arch_l1om
6979 #undef ELF_MACHINE_CODE
6980 #define ELF_MACHINE_CODE EM_L1OM
6985 #define elf64_bed elf64_l1om_bed
6987 #undef elf_backend_object_p
6988 #define elf_backend_object_p elf64_l1om_elf_object_p
6990 /* Restore defaults. */
6991 #undef ELF_MAXPAGESIZE
6992 #undef ELF_MINPAGESIZE
6993 #undef ELF_COMMONPAGESIZE
6994 #define ELF_MAXPAGESIZE 0x200000
6995 #define ELF_MINPAGESIZE 0x1000
6996 #define ELF_COMMONPAGESIZE 0x1000
6997 #undef elf_backend_plt_alignment
6998 #define elf_backend_plt_alignment 4
6999 #undef elf_backend_arch_data
7000 #define elf_backend_arch_data &elf_x86_64_arch_bed
7002 #include "elf64-target.h"
7004 /* FreeBSD L1OM support. */
7006 #undef TARGET_LITTLE_SYM
7007 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7008 #undef TARGET_LITTLE_NAME
7009 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7012 #define ELF_OSABI ELFOSABI_FREEBSD
7015 #define elf64_bed elf64_l1om_fbsd_bed
7017 #include "elf64-target.h"
7019 /* Intel K1OM support. */
7022 elf64_k1om_elf_object_p (bfd
*abfd
)
7024 /* Set the right machine number for an K1OM elf64 file. */
7025 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7029 #undef TARGET_LITTLE_SYM
7030 #define TARGET_LITTLE_SYM k1om_elf64_vec
7031 #undef TARGET_LITTLE_NAME
7032 #define TARGET_LITTLE_NAME "elf64-k1om"
7034 #define ELF_ARCH bfd_arch_k1om
7036 #undef ELF_MACHINE_CODE
7037 #define ELF_MACHINE_CODE EM_K1OM
7042 #define elf64_bed elf64_k1om_bed
7044 #undef elf_backend_object_p
7045 #define elf_backend_object_p elf64_k1om_elf_object_p
7047 #undef elf_backend_static_tls_alignment
7049 #undef elf_backend_want_plt_sym
7050 #define elf_backend_want_plt_sym 0
7052 #include "elf64-target.h"
7054 /* FreeBSD K1OM support. */
7056 #undef TARGET_LITTLE_SYM
7057 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7058 #undef TARGET_LITTLE_NAME
7059 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7062 #define ELF_OSABI ELFOSABI_FREEBSD
7065 #define elf64_bed elf64_k1om_fbsd_bed
7067 #include "elf64-target.h"
7069 /* 32bit x86-64 support. */
7071 #undef TARGET_LITTLE_SYM
7072 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7073 #undef TARGET_LITTLE_NAME
7074 #define TARGET_LITTLE_NAME "elf32-x86-64"
7078 #define ELF_ARCH bfd_arch_i386
7080 #undef ELF_MACHINE_CODE
7081 #define ELF_MACHINE_CODE EM_X86_64
7085 #undef elf_backend_object_p
7086 #define elf_backend_object_p \
7087 elf32_x86_64_elf_object_p
7089 #undef elf_backend_bfd_from_remote_memory
7090 #define elf_backend_bfd_from_remote_memory \
7091 _bfd_elf32_bfd_from_remote_memory
7093 #undef elf_backend_size_info
7094 #define elf_backend_size_info \
7095 _bfd_elf32_size_info
7097 #include "elf32-target.h"