1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
905 /* Get the x86-64 ELF linker hash table from a link_info structure. */
907 #define elf_x86_64_hash_table(p) \
908 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
909 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
911 #define elf_x86_64_compute_jump_table_size(htab) \
912 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
914 /* Create an entry in an x86-64 ELF linker hash table. */
916 static struct bfd_hash_entry
*
917 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
918 struct bfd_hash_table
*table
,
921 /* Allocate the structure if it has not already been allocated by a
925 entry
= (struct bfd_hash_entry
*)
926 bfd_hash_allocate (table
,
927 sizeof (struct elf_x86_64_link_hash_entry
));
932 /* Call the allocation method of the superclass. */
933 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
936 struct elf_x86_64_link_hash_entry
*eh
;
938 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
939 eh
->dyn_relocs
= NULL
;
940 eh
->tls_type
= GOT_UNKNOWN
;
942 eh
->has_bnd_reloc
= 0;
943 eh
->has_got_reloc
= 0;
944 eh
->has_non_got_reloc
= 0;
945 eh
->func_pointer_refcount
= 0;
946 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
947 eh
->plt_got
.offset
= (bfd_vma
) -1;
948 eh
->tlsdesc_got
= (bfd_vma
) -1;
954 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
955 for local symbol so that we can handle local STT_GNU_IFUNC symbols
956 as global symbol. We reuse indx and dynstr_index for local symbol
957 hash since they aren't used by global symbols in this backend. */
960 elf_x86_64_local_htab_hash (const void *ptr
)
962 struct elf_link_hash_entry
*h
963 = (struct elf_link_hash_entry
*) ptr
;
964 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
967 /* Compare local hash entries. */
970 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
972 struct elf_link_hash_entry
*h1
973 = (struct elf_link_hash_entry
*) ptr1
;
974 struct elf_link_hash_entry
*h2
975 = (struct elf_link_hash_entry
*) ptr2
;
977 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
980 /* Find and/or create a hash entry for local symbol. */
982 static struct elf_link_hash_entry
*
983 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
984 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
987 struct elf_x86_64_link_hash_entry e
, *ret
;
988 asection
*sec
= abfd
->sections
;
989 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
990 htab
->r_sym (rel
->r_info
));
993 e
.elf
.indx
= sec
->id
;
994 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
995 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
996 create
? INSERT
: NO_INSERT
);
1003 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1007 ret
= (struct elf_x86_64_link_hash_entry
*)
1008 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1009 sizeof (struct elf_x86_64_link_hash_entry
));
1012 memset (ret
, 0, sizeof (*ret
));
1013 ret
->elf
.indx
= sec
->id
;
1014 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1015 ret
->elf
.dynindx
= -1;
1016 ret
->func_pointer_refcount
= 0;
1017 ret
->plt_got
.offset
= (bfd_vma
) -1;
1023 /* Destroy an X86-64 ELF linker hash table. */
1026 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1028 struct elf_x86_64_link_hash_table
*htab
1029 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1031 if (htab
->loc_hash_table
)
1032 htab_delete (htab
->loc_hash_table
);
1033 if (htab
->loc_hash_memory
)
1034 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1035 _bfd_elf_link_hash_table_free (obfd
);
1038 /* Create an X86-64 ELF linker hash table. */
1040 static struct bfd_link_hash_table
*
1041 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1043 struct elf_x86_64_link_hash_table
*ret
;
1044 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1046 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1050 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1051 elf_x86_64_link_hash_newfunc
,
1052 sizeof (struct elf_x86_64_link_hash_entry
),
1059 if (ABI_64_P (abfd
))
1061 ret
->r_info
= elf64_r_info
;
1062 ret
->r_sym
= elf64_r_sym
;
1063 ret
->pointer_r_type
= R_X86_64_64
;
1064 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1065 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->r_info
= elf32_r_info
;
1070 ret
->r_sym
= elf32_r_sym
;
1071 ret
->pointer_r_type
= R_X86_64_32
;
1072 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1073 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1076 ret
->loc_hash_table
= htab_try_create (1024,
1077 elf_x86_64_local_htab_hash
,
1078 elf_x86_64_local_htab_eq
,
1080 ret
->loc_hash_memory
= objalloc_create ();
1081 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1083 elf_x86_64_link_hash_table_free (abfd
);
1086 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1088 return &ret
->elf
.root
;
1091 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1092 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1096 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1097 struct bfd_link_info
*info
)
1099 struct elf_x86_64_link_hash_table
*htab
;
1101 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1104 htab
= elf_x86_64_hash_table (info
);
1108 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1112 if (bfd_link_executable (info
))
1114 /* Always allow copy relocs for building executables. */
1115 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1118 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1119 s
= bfd_make_section_anyway_with_flags (dynobj
,
1121 (bed
->dynamic_sec_flags
1124 || ! bfd_set_section_alignment (dynobj
, s
,
1125 bed
->s
->log_file_align
))
1131 if (!info
->no_ld_generated_unwind_info
1132 && htab
->plt_eh_frame
== NULL
1133 && htab
->elf
.splt
!= NULL
)
1135 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1136 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1137 | SEC_LINKER_CREATED
);
1139 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1140 if (htab
->plt_eh_frame
== NULL
1141 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1147 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1150 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1151 struct elf_link_hash_entry
*dir
,
1152 struct elf_link_hash_entry
*ind
)
1154 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1156 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1157 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1159 if (!edir
->has_bnd_reloc
)
1160 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1162 if (!edir
->has_got_reloc
)
1163 edir
->has_got_reloc
= eind
->has_got_reloc
;
1165 if (!edir
->has_non_got_reloc
)
1166 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1168 if (eind
->dyn_relocs
!= NULL
)
1170 if (edir
->dyn_relocs
!= NULL
)
1172 struct elf_dyn_relocs
**pp
;
1173 struct elf_dyn_relocs
*p
;
1175 /* Add reloc counts against the indirect sym to the direct sym
1176 list. Merge any entries against the same section. */
1177 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1179 struct elf_dyn_relocs
*q
;
1181 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1182 if (q
->sec
== p
->sec
)
1184 q
->pc_count
+= p
->pc_count
;
1185 q
->count
+= p
->count
;
1192 *pp
= edir
->dyn_relocs
;
1195 edir
->dyn_relocs
= eind
->dyn_relocs
;
1196 eind
->dyn_relocs
= NULL
;
1199 if (ind
->root
.type
== bfd_link_hash_indirect
1200 && dir
->got
.refcount
<= 0)
1202 edir
->tls_type
= eind
->tls_type
;
1203 eind
->tls_type
= GOT_UNKNOWN
;
1206 if (ELIMINATE_COPY_RELOCS
1207 && ind
->root
.type
!= bfd_link_hash_indirect
1208 && dir
->dynamic_adjusted
)
1210 /* If called to transfer flags for a weakdef during processing
1211 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1212 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1213 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1214 dir
->ref_regular
|= ind
->ref_regular
;
1215 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1216 dir
->needs_plt
|= ind
->needs_plt
;
1217 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1221 if (eind
->func_pointer_refcount
> 0)
1223 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1224 eind
->func_pointer_refcount
= 0;
1227 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1232 elf64_x86_64_elf_object_p (bfd
*abfd
)
1234 /* Set the right machine number for an x86-64 elf64 file. */
1235 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1240 elf32_x86_64_elf_object_p (bfd
*abfd
)
1242 /* Set the right machine number for an x86-64 elf32 file. */
1243 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1247 /* Return TRUE if the TLS access code sequence support transition
1251 elf_x86_64_check_tls_transition (bfd
*abfd
,
1252 struct bfd_link_info
*info
,
1255 Elf_Internal_Shdr
*symtab_hdr
,
1256 struct elf_link_hash_entry
**sym_hashes
,
1257 unsigned int r_type
,
1258 const Elf_Internal_Rela
*rel
,
1259 const Elf_Internal_Rela
*relend
)
1262 unsigned long r_symndx
;
1263 bfd_boolean largepic
= FALSE
;
1264 struct elf_link_hash_entry
*h
;
1266 struct elf_x86_64_link_hash_table
*htab
;
1268 /* Get the section contents. */
1269 if (contents
== NULL
)
1271 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1272 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1275 /* FIXME: How to better handle error condition? */
1276 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1279 /* Cache the section contents for elf_link_input_bfd. */
1280 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1284 htab
= elf_x86_64_hash_table (info
);
1285 offset
= rel
->r_offset
;
1288 case R_X86_64_TLSGD
:
1289 case R_X86_64_TLSLD
:
1290 if ((rel
+ 1) >= relend
)
1293 if (r_type
== R_X86_64_TLSGD
)
1295 /* Check transition from GD access model. For 64bit, only
1296 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1297 .word 0x6666; rex64; call __tls_get_addr
1298 can transit to different access model. For 32bit, only
1299 leaq foo@tlsgd(%rip), %rdi
1300 .word 0x6666; rex64; call __tls_get_addr
1301 can transit to different access model. For largepic
1303 leaq foo@tlsgd(%rip), %rdi
1304 movabsq $__tls_get_addr@pltoff, %rax
1308 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1309 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1311 if ((offset
+ 12) > sec
->size
)
1314 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1316 if (!ABI_64_P (abfd
)
1317 || (offset
+ 19) > sec
->size
1319 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1320 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1321 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1326 else if (ABI_64_P (abfd
))
1329 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1335 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1341 /* Check transition from LD access model. Only
1342 leaq foo@tlsld(%rip), %rdi;
1344 can transit to different access model. For largepic
1346 leaq foo@tlsld(%rip), %rdi
1347 movabsq $__tls_get_addr@pltoff, %rax
1351 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1353 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1356 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1359 if (0xe8 != *(contents
+ offset
+ 4))
1361 if (!ABI_64_P (abfd
)
1362 || (offset
+ 19) > sec
->size
1363 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1364 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1371 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1372 if (r_symndx
< symtab_hdr
->sh_info
)
1375 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1376 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1377 may be versioned. */
1379 && h
->root
.root
.string
!= NULL
1381 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1382 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1383 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1384 && (strncmp (h
->root
.root
.string
,
1385 "__tls_get_addr", 14) == 0));
1387 case R_X86_64_GOTTPOFF
:
1388 /* Check transition from IE access model:
1389 mov foo@gottpoff(%rip), %reg
1390 add foo@gottpoff(%rip), %reg
1393 /* Check REX prefix first. */
1394 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1396 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1397 if (val
!= 0x48 && val
!= 0x4c)
1399 /* X32 may have 0x44 REX prefix or no REX prefix. */
1400 if (ABI_64_P (abfd
))
1406 /* X32 may not have any REX prefix. */
1407 if (ABI_64_P (abfd
))
1409 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1413 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1414 if (val
!= 0x8b && val
!= 0x03)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1418 return (val
& 0xc7) == 5;
1420 case R_X86_64_GOTPC32_TLSDESC
:
1421 /* Check transition from GDesc access model:
1422 leaq x@tlsdesc(%rip), %rax
1424 Make sure it's a leaq adding rip to a 32-bit offset
1425 into any register, although it's probably almost always
1428 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1431 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1432 if ((val
& 0xfb) != 0x48)
1435 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1438 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1439 return (val
& 0xc7) == 0x05;
1441 case R_X86_64_TLSDESC_CALL
:
1442 /* Check transition from GDesc access model:
1443 call *x@tlsdesc(%rax)
1445 if (offset
+ 2 <= sec
->size
)
1447 /* Make sure that it's a call *x@tlsdesc(%rax). */
1448 static const unsigned char call
[] = { 0xff, 0x10 };
1449 return memcmp (contents
+ offset
, call
, 2) == 0;
1459 /* Return TRUE if the TLS access transition is OK or no transition
1460 will be performed. Update R_TYPE if there is a transition. */
1463 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1464 asection
*sec
, bfd_byte
*contents
,
1465 Elf_Internal_Shdr
*symtab_hdr
,
1466 struct elf_link_hash_entry
**sym_hashes
,
1467 unsigned int *r_type
, int tls_type
,
1468 const Elf_Internal_Rela
*rel
,
1469 const Elf_Internal_Rela
*relend
,
1470 struct elf_link_hash_entry
*h
,
1471 unsigned long r_symndx
)
1473 unsigned int from_type
= *r_type
;
1474 unsigned int to_type
= from_type
;
1475 bfd_boolean check
= TRUE
;
1477 /* Skip TLS transition for functions. */
1479 && (h
->type
== STT_FUNC
1480 || h
->type
== STT_GNU_IFUNC
))
1485 case R_X86_64_TLSGD
:
1486 case R_X86_64_GOTPC32_TLSDESC
:
1487 case R_X86_64_TLSDESC_CALL
:
1488 case R_X86_64_GOTTPOFF
:
1489 if (bfd_link_executable (info
))
1492 to_type
= R_X86_64_TPOFF32
;
1494 to_type
= R_X86_64_GOTTPOFF
;
1497 /* When we are called from elf_x86_64_relocate_section,
1498 CONTENTS isn't NULL and there may be additional transitions
1499 based on TLS_TYPE. */
1500 if (contents
!= NULL
)
1502 unsigned int new_to_type
= to_type
;
1504 if (bfd_link_executable (info
)
1507 && tls_type
== GOT_TLS_IE
)
1508 new_to_type
= R_X86_64_TPOFF32
;
1510 if (to_type
== R_X86_64_TLSGD
1511 || to_type
== R_X86_64_GOTPC32_TLSDESC
1512 || to_type
== R_X86_64_TLSDESC_CALL
)
1514 if (tls_type
== GOT_TLS_IE
)
1515 new_to_type
= R_X86_64_GOTTPOFF
;
1518 /* We checked the transition before when we were called from
1519 elf_x86_64_check_relocs. We only want to check the new
1520 transition which hasn't been checked before. */
1521 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1522 to_type
= new_to_type
;
1527 case R_X86_64_TLSLD
:
1528 if (bfd_link_executable (info
))
1529 to_type
= R_X86_64_TPOFF32
;
1536 /* Return TRUE if there is no transition. */
1537 if (from_type
== to_type
)
1540 /* Check if the transition can be performed. */
1542 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1543 symtab_hdr
, sym_hashes
,
1544 from_type
, rel
, relend
))
1546 reloc_howto_type
*from
, *to
;
1549 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1550 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1553 name
= h
->root
.root
.string
;
1556 struct elf_x86_64_link_hash_table
*htab
;
1558 htab
= elf_x86_64_hash_table (info
);
1563 Elf_Internal_Sym
*isym
;
1565 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1567 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1571 (*_bfd_error_handler
)
1572 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1573 "in section `%A' failed"),
1574 abfd
, sec
, from
->name
, to
->name
, name
,
1575 (unsigned long) rel
->r_offset
);
1576 bfd_set_error (bfd_error_bad_value
);
1584 /* Rename some of the generic section flags to better document how they
1586 #define need_convert_load sec_flg0
1588 /* Look through the relocs for a section during the first phase, and
1589 calculate needed space in the global offset table, procedure
1590 linkage table, and dynamic reloc sections. */
1593 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1595 const Elf_Internal_Rela
*relocs
)
1597 struct elf_x86_64_link_hash_table
*htab
;
1598 Elf_Internal_Shdr
*symtab_hdr
;
1599 struct elf_link_hash_entry
**sym_hashes
;
1600 const Elf_Internal_Rela
*rel
;
1601 const Elf_Internal_Rela
*rel_end
;
1603 bfd_boolean use_plt_got
;
1605 if (bfd_link_relocatable (info
))
1608 BFD_ASSERT (is_x86_64_elf (abfd
));
1610 htab
= elf_x86_64_hash_table (info
);
1614 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1616 symtab_hdr
= &elf_symtab_hdr (abfd
);
1617 sym_hashes
= elf_sym_hashes (abfd
);
1621 rel_end
= relocs
+ sec
->reloc_count
;
1622 for (rel
= relocs
; rel
< rel_end
; rel
++)
1624 unsigned int r_type
;
1625 unsigned long r_symndx
;
1626 struct elf_link_hash_entry
*h
;
1627 struct elf_x86_64_link_hash_entry
*eh
;
1628 Elf_Internal_Sym
*isym
;
1630 bfd_boolean size_reloc
;
1632 r_symndx
= htab
->r_sym (rel
->r_info
);
1633 r_type
= ELF32_R_TYPE (rel
->r_info
);
1635 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1637 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1642 if (r_symndx
< symtab_hdr
->sh_info
)
1644 /* A local symbol. */
1645 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1650 /* Check relocation against local STT_GNU_IFUNC symbol. */
1651 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1653 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1658 /* Fake a STT_GNU_IFUNC symbol. */
1659 h
->type
= STT_GNU_IFUNC
;
1662 h
->forced_local
= 1;
1663 h
->root
.type
= bfd_link_hash_defined
;
1671 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1672 while (h
->root
.type
== bfd_link_hash_indirect
1673 || h
->root
.type
== bfd_link_hash_warning
)
1674 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1677 /* Check invalid x32 relocations. */
1678 if (!ABI_64_P (abfd
))
1684 case R_X86_64_DTPOFF64
:
1685 case R_X86_64_TPOFF64
:
1687 case R_X86_64_GOTOFF64
:
1688 case R_X86_64_GOT64
:
1689 case R_X86_64_GOTPCREL64
:
1690 case R_X86_64_GOTPC64
:
1691 case R_X86_64_GOTPLT64
:
1692 case R_X86_64_PLTOFF64
:
1695 name
= h
->root
.root
.string
;
1697 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1699 (*_bfd_error_handler
)
1700 (_("%B: relocation %s against symbol `%s' isn't "
1701 "supported in x32 mode"), abfd
,
1702 x86_64_elf_howto_table
[r_type
].name
, name
);
1703 bfd_set_error (bfd_error_bad_value
);
1711 /* Create the ifunc sections for static executables. If we
1712 never see an indirect function symbol nor we are building
1713 a static executable, those sections will be empty and
1714 won't appear in output. */
1720 case R_X86_64_PC32_BND
:
1721 case R_X86_64_PLT32_BND
:
1723 case R_X86_64_PLT32
:
1726 /* MPX PLT is supported only if elf_x86_64_arch_bed
1727 is used in 64-bit mode. */
1730 && (get_elf_x86_64_backend_data (abfd
)
1731 == &elf_x86_64_arch_bed
))
1733 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1735 /* Create the second PLT for Intel MPX support. */
1736 if (htab
->plt_bnd
== NULL
)
1738 unsigned int plt_bnd_align
;
1739 const struct elf_backend_data
*bed
;
1741 bed
= get_elf_backend_data (info
->output_bfd
);
1742 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1743 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1744 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1747 if (htab
->elf
.dynobj
== NULL
)
1748 htab
->elf
.dynobj
= abfd
;
1750 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1752 (bed
->dynamic_sec_flags
1757 if (htab
->plt_bnd
== NULL
1758 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1767 case R_X86_64_GOTPCREL
:
1768 case R_X86_64_GOTPCRELX
:
1769 case R_X86_64_REX_GOTPCRELX
:
1770 case R_X86_64_GOTPCREL64
:
1771 if (htab
->elf
.dynobj
== NULL
)
1772 htab
->elf
.dynobj
= abfd
;
1773 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1778 /* It is referenced by a non-shared object. */
1780 h
->root
.non_ir_ref
= 1;
1782 if (h
->type
== STT_GNU_IFUNC
)
1783 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1784 |= elf_gnu_symbol_ifunc
;
1787 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1788 symtab_hdr
, sym_hashes
,
1789 &r_type
, GOT_UNKNOWN
,
1790 rel
, rel_end
, h
, r_symndx
))
1793 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1796 case R_X86_64_TLSLD
:
1797 htab
->tls_ld_got
.refcount
+= 1;
1800 case R_X86_64_TPOFF32
:
1801 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1804 name
= h
->root
.root
.string
;
1806 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1808 (*_bfd_error_handler
)
1809 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1811 x86_64_elf_howto_table
[r_type
].name
, name
);
1812 bfd_set_error (bfd_error_bad_value
);
1816 eh
->has_got_reloc
= 1;
1819 case R_X86_64_GOTTPOFF
:
1820 if (!bfd_link_executable (info
))
1821 info
->flags
|= DF_STATIC_TLS
;
1824 case R_X86_64_GOT32
:
1825 case R_X86_64_GOTPCREL
:
1826 case R_X86_64_GOTPCRELX
:
1827 case R_X86_64_REX_GOTPCRELX
:
1828 case R_X86_64_TLSGD
:
1829 case R_X86_64_GOT64
:
1830 case R_X86_64_GOTPCREL64
:
1831 case R_X86_64_GOTPLT64
:
1832 case R_X86_64_GOTPC32_TLSDESC
:
1833 case R_X86_64_TLSDESC_CALL
:
1834 /* This symbol requires a global offset table entry. */
1836 int tls_type
, old_tls_type
;
1840 default: tls_type
= GOT_NORMAL
; break;
1841 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1842 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1843 case R_X86_64_GOTPC32_TLSDESC
:
1844 case R_X86_64_TLSDESC_CALL
:
1845 tls_type
= GOT_TLS_GDESC
; break;
1850 h
->got
.refcount
+= 1;
1851 old_tls_type
= eh
->tls_type
;
1855 bfd_signed_vma
*local_got_refcounts
;
1857 /* This is a global offset table entry for a local symbol. */
1858 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1859 if (local_got_refcounts
== NULL
)
1863 size
= symtab_hdr
->sh_info
;
1864 size
*= sizeof (bfd_signed_vma
)
1865 + sizeof (bfd_vma
) + sizeof (char);
1866 local_got_refcounts
= ((bfd_signed_vma
*)
1867 bfd_zalloc (abfd
, size
));
1868 if (local_got_refcounts
== NULL
)
1870 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1871 elf_x86_64_local_tlsdesc_gotent (abfd
)
1872 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1873 elf_x86_64_local_got_tls_type (abfd
)
1874 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1876 local_got_refcounts
[r_symndx
] += 1;
1878 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1881 /* If a TLS symbol is accessed using IE at least once,
1882 there is no point to use dynamic model for it. */
1883 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1884 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1885 || tls_type
!= GOT_TLS_IE
))
1887 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1888 tls_type
= old_tls_type
;
1889 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1890 && GOT_TLS_GD_ANY_P (tls_type
))
1891 tls_type
|= old_tls_type
;
1895 name
= h
->root
.root
.string
;
1897 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1899 (*_bfd_error_handler
)
1900 (_("%B: '%s' accessed both as normal and thread local symbol"),
1902 bfd_set_error (bfd_error_bad_value
);
1907 if (old_tls_type
!= tls_type
)
1910 eh
->tls_type
= tls_type
;
1912 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1917 case R_X86_64_GOTOFF64
:
1918 case R_X86_64_GOTPC32
:
1919 case R_X86_64_GOTPC64
:
1922 eh
->has_got_reloc
= 1;
1923 if (htab
->elf
.sgot
== NULL
)
1925 if (htab
->elf
.dynobj
== NULL
)
1926 htab
->elf
.dynobj
= abfd
;
1927 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1933 case R_X86_64_PLT32
:
1934 case R_X86_64_PLT32_BND
:
1935 /* This symbol requires a procedure linkage table entry. We
1936 actually build the entry in adjust_dynamic_symbol,
1937 because this might be a case of linking PIC code which is
1938 never referenced by a dynamic object, in which case we
1939 don't need to generate a procedure linkage table entry
1942 /* If this is a local symbol, we resolve it directly without
1943 creating a procedure linkage table entry. */
1947 eh
->has_got_reloc
= 1;
1949 h
->plt
.refcount
+= 1;
1952 case R_X86_64_PLTOFF64
:
1953 /* This tries to form the 'address' of a function relative
1954 to GOT. For global symbols we need a PLT entry. */
1958 h
->plt
.refcount
+= 1;
1962 case R_X86_64_SIZE32
:
1963 case R_X86_64_SIZE64
:
1968 if (!ABI_64_P (abfd
))
1973 /* Let's help debug shared library creation. These relocs
1974 cannot be used in shared libs. Don't error out for
1975 sections we don't care about, such as debug sections or
1976 non-constant sections. */
1977 if (bfd_link_pic (info
)
1978 && (sec
->flags
& SEC_ALLOC
) != 0
1979 && (sec
->flags
& SEC_READONLY
) != 0)
1982 name
= h
->root
.root
.string
;
1984 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1985 (*_bfd_error_handler
)
1986 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1987 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1988 bfd_set_error (bfd_error_bad_value
);
1996 case R_X86_64_PC32_BND
:
2000 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2001 eh
->has_non_got_reloc
= 1;
2002 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2003 locally defined and undefined symbol may turn out to be
2004 a STT_GNU_IFUNC symbol later. */
2006 && (bfd_link_executable (info
)
2007 || ((h
->type
== STT_GNU_IFUNC
2008 || h
->root
.type
== bfd_link_hash_undefweak
2009 || h
->root
.type
== bfd_link_hash_undefined
)
2010 && SYMBOLIC_BIND (info
, h
))))
2012 /* If this reloc is in a read-only section, we might
2013 need a copy reloc. We can't check reliably at this
2014 stage whether the section is read-only, as input
2015 sections have not yet been mapped to output sections.
2016 Tentatively set the flag for now, and correct in
2017 adjust_dynamic_symbol. */
2020 /* We may need a .plt entry if the function this reloc
2021 refers to is in a shared lib. */
2022 h
->plt
.refcount
+= 1;
2023 if (r_type
== R_X86_64_PC32
)
2025 /* Since something like ".long foo - ." may be used
2026 as pointer, make sure that PLT is used if foo is
2027 a function defined in a shared library. */
2028 if ((sec
->flags
& SEC_CODE
) == 0)
2029 h
->pointer_equality_needed
= 1;
2031 else if (r_type
!= R_X86_64_PC32_BND
2032 && r_type
!= R_X86_64_PC64
)
2034 h
->pointer_equality_needed
= 1;
2035 /* At run-time, R_X86_64_64 can be resolved for both
2036 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2037 can only be resolved for x32. */
2038 if ((sec
->flags
& SEC_READONLY
) == 0
2039 && (r_type
== R_X86_64_64
2040 || (!ABI_64_P (abfd
)
2041 && (r_type
== R_X86_64_32
2042 || r_type
== R_X86_64_32S
))))
2043 eh
->func_pointer_refcount
+= 1;
2049 /* If we are creating a shared library, and this is a reloc
2050 against a global symbol, or a non PC relative reloc
2051 against a local symbol, then we need to copy the reloc
2052 into the shared library. However, if we are linking with
2053 -Bsymbolic, we do not need to copy a reloc against a
2054 global symbol which is defined in an object we are
2055 including in the link (i.e., DEF_REGULAR is set). At
2056 this point we have not seen all the input files, so it is
2057 possible that DEF_REGULAR is not set now but will be set
2058 later (it is never cleared). In case of a weak definition,
2059 DEF_REGULAR may be cleared later by a strong definition in
2060 a shared library. We account for that possibility below by
2061 storing information in the relocs_copied field of the hash
2062 table entry. A similar situation occurs when creating
2063 shared libraries and symbol visibility changes render the
2066 If on the other hand, we are creating an executable, we
2067 may need to keep relocations for symbols satisfied by a
2068 dynamic library if we manage to avoid copy relocs for the
2070 if ((bfd_link_pic (info
)
2071 && (sec
->flags
& SEC_ALLOC
) != 0
2072 && (! IS_X86_64_PCREL_TYPE (r_type
)
2074 && (! SYMBOLIC_BIND (info
, h
)
2075 || h
->root
.type
== bfd_link_hash_defweak
2076 || !h
->def_regular
))))
2077 || (ELIMINATE_COPY_RELOCS
2078 && !bfd_link_pic (info
)
2079 && (sec
->flags
& SEC_ALLOC
) != 0
2081 && (h
->root
.type
== bfd_link_hash_defweak
2082 || !h
->def_regular
)))
2084 struct elf_dyn_relocs
*p
;
2085 struct elf_dyn_relocs
**head
;
2087 /* We must copy these reloc types into the output file.
2088 Create a reloc section in dynobj and make room for
2092 if (htab
->elf
.dynobj
== NULL
)
2093 htab
->elf
.dynobj
= abfd
;
2095 sreloc
= _bfd_elf_make_dynamic_reloc_section
2096 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2097 abfd
, /*rela?*/ TRUE
);
2103 /* If this is a global symbol, we count the number of
2104 relocations we need for this symbol. */
2106 head
= &eh
->dyn_relocs
;
2109 /* Track dynamic relocs needed for local syms too.
2110 We really need local syms available to do this
2115 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2120 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2124 /* Beware of type punned pointers vs strict aliasing
2126 vpp
= &(elf_section_data (s
)->local_dynrel
);
2127 head
= (struct elf_dyn_relocs
**)vpp
;
2131 if (p
== NULL
|| p
->sec
!= sec
)
2133 bfd_size_type amt
= sizeof *p
;
2135 p
= ((struct elf_dyn_relocs
*)
2136 bfd_alloc (htab
->elf
.dynobj
, amt
));
2147 /* Count size relocation as PC-relative relocation. */
2148 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2153 /* This relocation describes the C++ object vtable hierarchy.
2154 Reconstruct it for later use during GC. */
2155 case R_X86_64_GNU_VTINHERIT
:
2156 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2160 /* This relocation describes which C++ vtable entries are actually
2161 used. Record for later use during GC. */
2162 case R_X86_64_GNU_VTENTRY
:
2163 BFD_ASSERT (h
!= NULL
);
2165 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2175 && h
->plt
.refcount
> 0
2176 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2177 || h
->got
.refcount
> 0)
2178 && htab
->plt_got
== NULL
)
2180 /* Create the GOT procedure linkage table. */
2181 unsigned int plt_got_align
;
2182 const struct elf_backend_data
*bed
;
2184 bed
= get_elf_backend_data (info
->output_bfd
);
2185 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2186 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2187 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2190 if (htab
->elf
.dynobj
== NULL
)
2191 htab
->elf
.dynobj
= abfd
;
2193 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2195 (bed
->dynamic_sec_flags
2200 if (htab
->plt_got
== NULL
2201 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2207 if ((r_type
== R_X86_64_GOTPCREL
2208 || r_type
== R_X86_64_GOTPCRELX
2209 || r_type
== R_X86_64_REX_GOTPCRELX
)
2210 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2211 sec
->need_convert_load
= 1;
2217 /* Return the section that should be marked against GC for a given
2221 elf_x86_64_gc_mark_hook (asection
*sec
,
2222 struct bfd_link_info
*info
,
2223 Elf_Internal_Rela
*rel
,
2224 struct elf_link_hash_entry
*h
,
2225 Elf_Internal_Sym
*sym
)
2228 switch (ELF32_R_TYPE (rel
->r_info
))
2230 case R_X86_64_GNU_VTINHERIT
:
2231 case R_X86_64_GNU_VTENTRY
:
2235 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2238 /* Update the got entry reference counts for the section being removed. */
2241 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2243 const Elf_Internal_Rela
*relocs
)
2245 struct elf_x86_64_link_hash_table
*htab
;
2246 Elf_Internal_Shdr
*symtab_hdr
;
2247 struct elf_link_hash_entry
**sym_hashes
;
2248 bfd_signed_vma
*local_got_refcounts
;
2249 const Elf_Internal_Rela
*rel
, *relend
;
2251 if (bfd_link_relocatable (info
))
2254 htab
= elf_x86_64_hash_table (info
);
2258 elf_section_data (sec
)->local_dynrel
= NULL
;
2260 symtab_hdr
= &elf_symtab_hdr (abfd
);
2261 sym_hashes
= elf_sym_hashes (abfd
);
2262 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2264 htab
= elf_x86_64_hash_table (info
);
2265 relend
= relocs
+ sec
->reloc_count
;
2266 for (rel
= relocs
; rel
< relend
; rel
++)
2268 unsigned long r_symndx
;
2269 unsigned int r_type
;
2270 struct elf_link_hash_entry
*h
= NULL
;
2271 bfd_boolean pointer_reloc
;
2273 r_symndx
= htab
->r_sym (rel
->r_info
);
2274 if (r_symndx
>= symtab_hdr
->sh_info
)
2276 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2277 while (h
->root
.type
== bfd_link_hash_indirect
2278 || h
->root
.type
== bfd_link_hash_warning
)
2279 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2283 /* A local symbol. */
2284 Elf_Internal_Sym
*isym
;
2286 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2289 /* Check relocation against local STT_GNU_IFUNC symbol. */
2291 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2293 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2301 struct elf_x86_64_link_hash_entry
*eh
;
2302 struct elf_dyn_relocs
**pp
;
2303 struct elf_dyn_relocs
*p
;
2305 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2307 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2310 /* Everything must go for SEC. */
2316 r_type
= ELF32_R_TYPE (rel
->r_info
);
2317 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2318 symtab_hdr
, sym_hashes
,
2319 &r_type
, GOT_UNKNOWN
,
2320 rel
, relend
, h
, r_symndx
))
2323 pointer_reloc
= FALSE
;
2326 case R_X86_64_TLSLD
:
2327 if (htab
->tls_ld_got
.refcount
> 0)
2328 htab
->tls_ld_got
.refcount
-= 1;
2331 case R_X86_64_TLSGD
:
2332 case R_X86_64_GOTPC32_TLSDESC
:
2333 case R_X86_64_TLSDESC_CALL
:
2334 case R_X86_64_GOTTPOFF
:
2335 case R_X86_64_GOT32
:
2336 case R_X86_64_GOTPCREL
:
2337 case R_X86_64_GOTPCRELX
:
2338 case R_X86_64_REX_GOTPCRELX
:
2339 case R_X86_64_GOT64
:
2340 case R_X86_64_GOTPCREL64
:
2341 case R_X86_64_GOTPLT64
:
2344 if (h
->got
.refcount
> 0)
2345 h
->got
.refcount
-= 1;
2346 if (h
->type
== STT_GNU_IFUNC
)
2348 if (h
->plt
.refcount
> 0)
2349 h
->plt
.refcount
-= 1;
2352 else if (local_got_refcounts
!= NULL
)
2354 if (local_got_refcounts
[r_symndx
] > 0)
2355 local_got_refcounts
[r_symndx
] -= 1;
2361 pointer_reloc
= !ABI_64_P (abfd
);
2365 pointer_reloc
= TRUE
;
2371 case R_X86_64_PC32_BND
:
2373 case R_X86_64_SIZE32
:
2374 case R_X86_64_SIZE64
:
2376 if (bfd_link_pic (info
)
2377 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2381 case R_X86_64_PLT32
:
2382 case R_X86_64_PLT32_BND
:
2383 case R_X86_64_PLTOFF64
:
2386 if (h
->plt
.refcount
> 0)
2387 h
->plt
.refcount
-= 1;
2388 if (pointer_reloc
&& (sec
->flags
& SEC_READONLY
) == 0)
2390 struct elf_x86_64_link_hash_entry
*eh
2391 = (struct elf_x86_64_link_hash_entry
*) h
;
2392 if (eh
->func_pointer_refcount
> 0)
2393 eh
->func_pointer_refcount
-= 1;
2406 /* Remove undefined weak symbol from the dynamic symbol table if it
2407 is resolved to 0. */
2410 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2411 struct elf_link_hash_entry
*h
)
2413 if (h
->dynindx
!= -1
2414 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2415 elf_x86_64_hash_entry (h
)))
2418 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2424 /* Adjust a symbol defined by a dynamic object and referenced by a
2425 regular object. The current definition is in some section of the
2426 dynamic object, but we're not including those sections. We have to
2427 change the definition to something the rest of the link can
2431 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2432 struct elf_link_hash_entry
*h
)
2434 struct elf_x86_64_link_hash_table
*htab
;
2436 struct elf_x86_64_link_hash_entry
*eh
;
2437 struct elf_dyn_relocs
*p
;
2439 /* STT_GNU_IFUNC symbol must go through PLT. */
2440 if (h
->type
== STT_GNU_IFUNC
)
2442 /* All local STT_GNU_IFUNC references must be treate as local
2443 calls via local PLT. */
2445 && SYMBOL_CALLS_LOCAL (info
, h
))
2447 bfd_size_type pc_count
= 0, count
= 0;
2448 struct elf_dyn_relocs
**pp
;
2450 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2451 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2453 pc_count
+= p
->pc_count
;
2454 p
->count
-= p
->pc_count
;
2463 if (pc_count
|| count
)
2467 if (h
->plt
.refcount
<= 0)
2468 h
->plt
.refcount
= 1;
2470 h
->plt
.refcount
+= 1;
2474 if (h
->plt
.refcount
<= 0)
2476 h
->plt
.offset
= (bfd_vma
) -1;
2482 /* If this is a function, put it in the procedure linkage table. We
2483 will fill in the contents of the procedure linkage table later,
2484 when we know the address of the .got section. */
2485 if (h
->type
== STT_FUNC
2488 if (h
->plt
.refcount
<= 0
2489 || SYMBOL_CALLS_LOCAL (info
, h
)
2490 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2491 && h
->root
.type
== bfd_link_hash_undefweak
))
2493 /* This case can occur if we saw a PLT32 reloc in an input
2494 file, but the symbol was never referred to by a dynamic
2495 object, or if all references were garbage collected. In
2496 such a case, we don't actually need to build a procedure
2497 linkage table, and we can just do a PC32 reloc instead. */
2498 h
->plt
.offset
= (bfd_vma
) -1;
2505 /* It's possible that we incorrectly decided a .plt reloc was
2506 needed for an R_X86_64_PC32 reloc to a non-function sym in
2507 check_relocs. We can't decide accurately between function and
2508 non-function syms in check-relocs; Objects loaded later in
2509 the link may change h->type. So fix it now. */
2510 h
->plt
.offset
= (bfd_vma
) -1;
2512 /* If this is a weak symbol, and there is a real definition, the
2513 processor independent code will have arranged for us to see the
2514 real definition first, and we can just use the same value. */
2515 if (h
->u
.weakdef
!= NULL
)
2517 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2518 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2519 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2520 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2521 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2523 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2524 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2525 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2530 /* This is a reference to a symbol defined by a dynamic object which
2531 is not a function. */
2533 /* If we are creating a shared library, we must presume that the
2534 only references to the symbol are via the global offset table.
2535 For such cases we need not do anything here; the relocations will
2536 be handled correctly by relocate_section. */
2537 if (!bfd_link_executable (info
))
2540 /* If there are no references to this symbol that do not use the
2541 GOT, we don't need to generate a copy reloc. */
2542 if (!h
->non_got_ref
)
2545 /* If -z nocopyreloc was given, we won't generate them either. */
2546 if (info
->nocopyreloc
)
2552 if (ELIMINATE_COPY_RELOCS
)
2554 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2555 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2557 s
= p
->sec
->output_section
;
2558 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2562 /* If we didn't find any dynamic relocs in read-only sections, then
2563 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2571 /* We must allocate the symbol in our .dynbss section, which will
2572 become part of the .bss section of the executable. There will be
2573 an entry for this symbol in the .dynsym section. The dynamic
2574 object will contain position independent code, so all references
2575 from the dynamic object to this symbol will go through the global
2576 offset table. The dynamic linker will use the .dynsym entry to
2577 determine the address it must put in the global offset table, so
2578 both the dynamic object and the regular object will refer to the
2579 same memory location for the variable. */
2581 htab
= elf_x86_64_hash_table (info
);
2585 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2586 to copy the initial value out of the dynamic object and into the
2587 runtime process image. */
2588 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2590 const struct elf_backend_data
*bed
;
2591 bed
= get_elf_backend_data (info
->output_bfd
);
2592 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2598 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2601 /* Allocate space in .plt, .got and associated reloc sections for
2605 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2607 struct bfd_link_info
*info
;
2608 struct elf_x86_64_link_hash_table
*htab
;
2609 struct elf_x86_64_link_hash_entry
*eh
;
2610 struct elf_dyn_relocs
*p
;
2611 const struct elf_backend_data
*bed
;
2612 unsigned int plt_entry_size
;
2613 bfd_boolean resolved_to_zero
;
2615 if (h
->root
.type
== bfd_link_hash_indirect
)
2618 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2620 info
= (struct bfd_link_info
*) inf
;
2621 htab
= elf_x86_64_hash_table (info
);
2624 bed
= get_elf_backend_data (info
->output_bfd
);
2625 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2627 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2629 /* We can't use the GOT PLT if pointer equality is needed since
2630 finish_dynamic_symbol won't clear symbol value and the dynamic
2631 linker won't update the GOT slot. We will get into an infinite
2632 loop at run-time. */
2633 if (htab
->plt_got
!= NULL
2634 && h
->type
!= STT_GNU_IFUNC
2635 && !h
->pointer_equality_needed
2636 && h
->plt
.refcount
> 0
2637 && h
->got
.refcount
> 0)
2639 /* Don't use the regular PLT if there are both GOT and GOTPLT
2641 h
->plt
.offset
= (bfd_vma
) -1;
2643 /* Use the GOT PLT. */
2644 eh
->plt_got
.refcount
= 1;
2647 /* Clear the reference count of function pointer relocations if
2648 symbol isn't a normal function. */
2649 if (h
->type
!= STT_FUNC
)
2650 eh
->func_pointer_refcount
= 0;
2652 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2653 here if it is defined and referenced in a non-shared object. */
2654 if (h
->type
== STT_GNU_IFUNC
2657 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2663 asection
*s
= htab
->plt_bnd
;
2664 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2666 /* Use the .plt.bnd section if it is created. */
2667 eh
->plt_bnd
.offset
= s
->size
;
2669 /* Make room for this entry in the .plt.bnd section. */
2670 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2678 /* Don't create the PLT entry if there are only function pointer
2679 relocations which can be resolved at run-time. */
2680 else if (htab
->elf
.dynamic_sections_created
2681 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2682 || eh
->plt_got
.refcount
> 0))
2684 bfd_boolean use_plt_got
;
2686 /* Clear the reference count of function pointer relocations
2688 eh
->func_pointer_refcount
= 0;
2690 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2692 /* Don't use the regular PLT for DF_BIND_NOW. */
2693 h
->plt
.offset
= (bfd_vma
) -1;
2695 /* Use the GOT PLT. */
2696 h
->got
.refcount
= 1;
2697 eh
->plt_got
.refcount
= 1;
2700 use_plt_got
= eh
->plt_got
.refcount
> 0;
2702 /* Make sure this symbol is output as a dynamic symbol.
2703 Undefined weak syms won't yet be marked as dynamic. */
2704 if (h
->dynindx
== -1
2706 && !resolved_to_zero
)
2708 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2712 if (bfd_link_pic (info
)
2713 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2715 asection
*s
= htab
->elf
.splt
;
2716 asection
*bnd_s
= htab
->plt_bnd
;
2717 asection
*got_s
= htab
->plt_got
;
2719 /* If this is the first .plt entry, make room for the special
2720 first entry. The .plt section is used by prelink to undo
2721 prelinking for dynamic relocations. */
2723 s
->size
= plt_entry_size
;
2726 eh
->plt_got
.offset
= got_s
->size
;
2729 h
->plt
.offset
= s
->size
;
2731 eh
->plt_bnd
.offset
= bnd_s
->size
;
2734 /* If this symbol is not defined in a regular file, and we are
2735 not generating a shared library, then set the symbol to this
2736 location in the .plt. This is required to make function
2737 pointers compare as equal between the normal executable and
2738 the shared library. */
2739 if (! bfd_link_pic (info
)
2744 /* We need to make a call to the entry of the GOT PLT
2745 instead of regular PLT entry. */
2746 h
->root
.u
.def
.section
= got_s
;
2747 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2753 /* We need to make a call to the entry of the second
2754 PLT instead of regular PLT entry. */
2755 h
->root
.u
.def
.section
= bnd_s
;
2756 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2760 h
->root
.u
.def
.section
= s
;
2761 h
->root
.u
.def
.value
= h
->plt
.offset
;
2766 /* Make room for this entry. */
2768 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2771 s
->size
+= plt_entry_size
;
2773 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2775 /* We also need to make an entry in the .got.plt section,
2776 which will be placed in the .got section by the linker
2778 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2780 /* There should be no PLT relocation against resolved
2781 undefined weak symbol in executable. */
2782 if (!resolved_to_zero
)
2784 /* We also need to make an entry in the .rela.plt
2786 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2787 htab
->elf
.srelplt
->reloc_count
++;
2793 eh
->plt_got
.offset
= (bfd_vma
) -1;
2794 h
->plt
.offset
= (bfd_vma
) -1;
2800 eh
->plt_got
.offset
= (bfd_vma
) -1;
2801 h
->plt
.offset
= (bfd_vma
) -1;
2805 eh
->tlsdesc_got
= (bfd_vma
) -1;
2807 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2808 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2809 if (h
->got
.refcount
> 0
2810 && bfd_link_executable (info
)
2812 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2814 h
->got
.offset
= (bfd_vma
) -1;
2816 else if (h
->got
.refcount
> 0)
2820 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2822 /* Make sure this symbol is output as a dynamic symbol.
2823 Undefined weak syms won't yet be marked as dynamic. */
2824 if (h
->dynindx
== -1
2826 && !resolved_to_zero
)
2828 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2832 if (GOT_TLS_GDESC_P (tls_type
))
2834 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2835 - elf_x86_64_compute_jump_table_size (htab
);
2836 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2837 h
->got
.offset
= (bfd_vma
) -2;
2839 if (! GOT_TLS_GDESC_P (tls_type
)
2840 || GOT_TLS_GD_P (tls_type
))
2843 h
->got
.offset
= s
->size
;
2844 s
->size
+= GOT_ENTRY_SIZE
;
2845 if (GOT_TLS_GD_P (tls_type
))
2846 s
->size
+= GOT_ENTRY_SIZE
;
2848 dyn
= htab
->elf
.dynamic_sections_created
;
2849 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2850 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2851 relocation. No dynamic relocation against resolved undefined
2852 weak symbol in executable. */
2853 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2854 || tls_type
== GOT_TLS_IE
)
2855 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2856 else if (GOT_TLS_GD_P (tls_type
))
2857 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2858 else if (! GOT_TLS_GDESC_P (tls_type
)
2859 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2860 && !resolved_to_zero
)
2861 || h
->root
.type
!= bfd_link_hash_undefweak
)
2862 && (bfd_link_pic (info
)
2863 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2864 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2865 if (GOT_TLS_GDESC_P (tls_type
))
2867 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2868 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2872 h
->got
.offset
= (bfd_vma
) -1;
2874 if (eh
->dyn_relocs
== NULL
)
2877 /* In the shared -Bsymbolic case, discard space allocated for
2878 dynamic pc-relative relocs against symbols which turn out to be
2879 defined in regular objects. For the normal shared case, discard
2880 space for pc-relative relocs that have become local due to symbol
2881 visibility changes. */
2883 if (bfd_link_pic (info
))
2885 /* Relocs that use pc_count are those that appear on a call
2886 insn, or certain REL relocs that can generated via assembly.
2887 We want calls to protected symbols to resolve directly to the
2888 function rather than going via the plt. If people want
2889 function pointer comparisons to work as expected then they
2890 should avoid writing weird assembly. */
2891 if (SYMBOL_CALLS_LOCAL (info
, h
))
2893 struct elf_dyn_relocs
**pp
;
2895 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2897 p
->count
-= p
->pc_count
;
2906 /* Also discard relocs on undefined weak syms with non-default
2907 visibility or in PIE. */
2908 if (eh
->dyn_relocs
!= NULL
)
2910 if (h
->root
.type
== bfd_link_hash_undefweak
)
2912 /* Undefined weak symbol is never bound locally in shared
2914 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2915 || resolved_to_zero
)
2916 eh
->dyn_relocs
= NULL
;
2917 else if (h
->dynindx
== -1
2918 && ! h
->forced_local
2919 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2922 /* For PIE, discard space for pc-relative relocs against
2923 symbols which turn out to need copy relocs. */
2924 else if (bfd_link_executable (info
)
2925 && (h
->needs_copy
|| eh
->needs_copy
)
2929 struct elf_dyn_relocs
**pp
;
2931 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2933 if (p
->pc_count
!= 0)
2941 else if (ELIMINATE_COPY_RELOCS
)
2943 /* For the non-shared case, discard space for relocs against
2944 symbols which turn out to need copy relocs or are not
2945 dynamic. Keep dynamic relocations for run-time function
2946 pointer initialization. */
2948 if ((!h
->non_got_ref
2949 || eh
->func_pointer_refcount
> 0
2950 || (h
->root
.type
== bfd_link_hash_undefweak
2951 && !resolved_to_zero
))
2954 || (htab
->elf
.dynamic_sections_created
2955 && (h
->root
.type
== bfd_link_hash_undefweak
2956 || h
->root
.type
== bfd_link_hash_undefined
))))
2958 /* Make sure this symbol is output as a dynamic symbol.
2959 Undefined weak syms won't yet be marked as dynamic. */
2960 if (h
->dynindx
== -1
2961 && ! h
->forced_local
2962 && ! resolved_to_zero
2963 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2966 /* If that succeeded, we know we'll be keeping all the
2968 if (h
->dynindx
!= -1)
2972 eh
->dyn_relocs
= NULL
;
2973 eh
->func_pointer_refcount
= 0;
2978 /* Finally, allocate space. */
2979 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2983 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2985 BFD_ASSERT (sreloc
!= NULL
);
2987 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2993 /* Allocate space in .plt, .got and associated reloc sections for
2994 local dynamic relocs. */
2997 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2999 struct elf_link_hash_entry
*h
3000 = (struct elf_link_hash_entry
*) *slot
;
3002 if (h
->type
!= STT_GNU_IFUNC
3006 || h
->root
.type
!= bfd_link_hash_defined
)
3009 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3012 /* Find any dynamic relocs that apply to read-only sections. */
3015 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3018 struct elf_x86_64_link_hash_entry
*eh
;
3019 struct elf_dyn_relocs
*p
;
3021 /* Skip local IFUNC symbols. */
3022 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3025 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3026 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3028 asection
*s
= p
->sec
->output_section
;
3030 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3032 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3034 info
->flags
|= DF_TEXTREL
;
3036 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3037 || info
->error_textrel
)
3038 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3039 p
->sec
->owner
, h
->root
.root
.string
,
3042 /* Not an error, just cut short the traversal. */
3049 /* With the local symbol, foo, we convert
3050 mov foo@GOTPCREL(%rip), %reg
3054 call/jmp *foo@GOTPCREL(%rip)
3056 nop call foo/jmp foo nop
3057 When PIC is false, convert
3058 test %reg, foo@GOTPCREL(%rip)
3062 binop foo@GOTPCREL(%rip), %reg
3065 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
3069 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3070 struct bfd_link_info
*link_info
)
3072 Elf_Internal_Shdr
*symtab_hdr
;
3073 Elf_Internal_Rela
*internal_relocs
;
3074 Elf_Internal_Rela
*irel
, *irelend
;
3076 struct elf_x86_64_link_hash_table
*htab
;
3077 bfd_boolean changed_contents
;
3078 bfd_boolean changed_relocs
;
3079 bfd_signed_vma
*local_got_refcounts
;
3080 bfd_vma maxpagesize
;
3082 bfd_boolean require_reloc_pc32
;
3084 /* Don't even try to convert non-ELF outputs. */
3085 if (!is_elf_hash_table (link_info
->hash
))
3088 /* Nothing to do if there is no need or no output. */
3089 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3090 || sec
->need_convert_load
== 0
3091 || bfd_is_abs_section (sec
->output_section
))
3094 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3096 /* Load the relocations for this section. */
3097 internal_relocs
= (_bfd_elf_link_read_relocs
3098 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3099 link_info
->keep_memory
));
3100 if (internal_relocs
== NULL
)
3103 htab
= elf_x86_64_hash_table (link_info
);
3104 changed_contents
= FALSE
;
3105 changed_relocs
= FALSE
;
3106 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3107 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3109 /* Get the section contents. */
3110 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3111 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3114 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3118 is_pic
= bfd_link_pic (link_info
);
3120 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3123 = link_info
->disable_target_specific_optimizations
> 1;
3125 irelend
= internal_relocs
+ sec
->reloc_count
;
3126 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3128 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3129 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3131 struct elf_link_hash_entry
*h
;
3135 bfd_signed_vma raddend
;
3136 unsigned int opcode
;
3139 bfd_boolean to_reloc_pc32
;
3141 relocx
= (r_type
== R_X86_64_GOTPCRELX
3142 || r_type
== R_X86_64_REX_GOTPCRELX
);
3143 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3146 roff
= irel
->r_offset
;
3147 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3150 raddend
= irel
->r_addend
;
3151 /* Addend for 32-bit PC-relative relocation must be -4. */
3155 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3157 /* Convert mov to lea since it has been done for a while. */
3160 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3161 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3162 test, xor instructions. */
3167 /* We convert only to R_X86_64_PC32:
3169 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3170 3. require_reloc_pc32 is true.
3173 to_reloc_pc32
= (opcode
== 0xff
3175 || require_reloc_pc32
3178 /* Get the symbol referred to by the reloc. */
3179 if (r_symndx
< symtab_hdr
->sh_info
)
3181 Elf_Internal_Sym
*isym
;
3183 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3186 symtype
= ELF_ST_TYPE (isym
->st_info
);
3188 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3189 relocation against undefined symbols. */
3190 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3193 if (isym
->st_shndx
== SHN_ABS
)
3194 tsec
= bfd_abs_section_ptr
;
3195 else if (isym
->st_shndx
== SHN_COMMON
)
3196 tsec
= bfd_com_section_ptr
;
3197 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3198 tsec
= &_bfd_elf_large_com_section
;
3200 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3203 toff
= isym
->st_value
;
3207 indx
= r_symndx
- symtab_hdr
->sh_info
;
3208 h
= elf_sym_hashes (abfd
)[indx
];
3209 BFD_ASSERT (h
!= NULL
);
3211 while (h
->root
.type
== bfd_link_hash_indirect
3212 || h
->root
.type
== bfd_link_hash_warning
)
3213 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3215 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3216 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3217 since ld.so may use its link-time address. */
3218 if (h
->type
== STT_GNU_IFUNC
)
3221 /* Undefined weak symbol is only bound locally in executable
3222 and its reference is resolved as 0 without relocation
3223 overflow. We can only perform this optimization for
3224 GOTPCRELX relocations since we need to modify REX byte.
3225 It is OK convert mov with R_X86_64_GOTPCREL to
3227 if ((relocx
|| opcode
== 0x8b)
3228 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3229 elf_x86_64_hash_entry (h
)))
3233 /* Skip for branch instructions since R_X86_64_PC32
3235 if (require_reloc_pc32
)
3240 /* For non-branch instructions, we can convert to
3241 R_X86_64_32/R_X86_64_32S since we know if there
3243 to_reloc_pc32
= FALSE
;
3246 /* Since we don't know the current PC when PIC is true,
3247 we can't convert to R_X86_64_PC32. */
3248 if (to_reloc_pc32
&& is_pic
)
3253 else if ((h
->def_regular
3254 || h
->root
.type
== bfd_link_hash_defined
3255 || h
->root
.type
== bfd_link_hash_defweak
)
3256 && h
!= htab
->elf
.hdynamic
3257 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3259 /* bfd_link_hash_new or bfd_link_hash_undefined is
3260 set by an assignment in a linker script in
3261 bfd_elf_record_link_assignment. */
3263 && (h
->root
.type
== bfd_link_hash_new
3264 || h
->root
.type
== bfd_link_hash_undefined
))
3266 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3267 if (require_reloc_pc32
)
3271 tsec
= h
->root
.u
.def
.section
;
3272 toff
= h
->root
.u
.def
.value
;
3279 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3283 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3285 /* At this stage in linking, no SEC_MERGE symbol has been
3286 adjusted, so all references to such symbols need to be
3287 passed through _bfd_merged_section_offset. (Later, in
3288 relocate_section, all SEC_MERGE symbols *except* for
3289 section symbols have been adjusted.)
3291 gas may reduce relocations against symbols in SEC_MERGE
3292 sections to a relocation against the section symbol when
3293 the original addend was zero. When the reloc is against
3294 a section symbol we should include the addend in the
3295 offset passed to _bfd_merged_section_offset, since the
3296 location of interest is the original symbol. On the
3297 other hand, an access to "sym+addend" where "sym" is not
3298 a section symbol should not include the addend; Such an
3299 access is presumed to be an offset from "sym"; The
3300 location of interest is just "sym". */
3301 if (symtype
== STT_SECTION
)
3304 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3305 elf_section_data (tsec
)->sec_info
,
3308 if (symtype
!= STT_SECTION
)
3314 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3315 if (tsec
->output_section
== sec
->output_section
)
3317 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3322 bfd_signed_vma distance
;
3324 /* At this point, we don't know the load addresses of TSEC
3325 section nor SEC section. We estimate the distrance between
3326 SEC and TSEC. We store the estimated distances in the
3327 compressed_size field of the output section, which is only
3328 used to decompress the compressed input section. */
3329 if (sec
->output_section
->compressed_size
== 0)
3332 bfd_size_type size
= 0;
3333 for (asect
= link_info
->output_bfd
->sections
;
3335 asect
= asect
->next
)
3338 for (i
= asect
->map_head
.s
;
3342 size
= align_power (size
, i
->alignment_power
);
3345 asect
->compressed_size
= size
;
3349 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3351 distance
= (tsec
->output_section
->compressed_size
3352 - sec
->output_section
->compressed_size
);
3356 /* Take PT_GNU_RELRO segment into account by adding
3358 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3366 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3371 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3373 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3376 /* Convert to "jmp foo nop". */
3379 nop_offset
= irel
->r_offset
+ 3;
3380 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3381 irel
->r_offset
-= 1;
3382 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3386 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3389 nop
= link_info
->call_nop_byte
;
3390 if (link_info
->call_nop_as_suffix
)
3392 nop_offset
= irel
->r_offset
+ 3;
3393 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3394 irel
->r_offset
-= 1;
3395 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3398 nop_offset
= irel
->r_offset
- 2;
3400 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3401 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3402 r_type
= R_X86_64_PC32
;
3407 unsigned int rex_mask
= REX_R
;
3409 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3410 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3418 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3419 "lea foo(%rip), %reg". */
3421 r_type
= R_X86_64_PC32
;
3425 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3426 "mov $foo, %reg". */
3428 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3429 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3430 if ((rex
& REX_W
) != 0
3431 && ABI_64_P (link_info
->output_bfd
))
3433 /* Keep the REX_W bit in REX byte for LP64. */
3434 r_type
= R_X86_64_32S
;
3435 goto rewrite_modrm_rex
;
3439 /* If the REX_W bit in REX byte isn't needed,
3440 use R_X86_64_32 and clear the W bit to avoid
3441 sign-extend imm32 to imm64. */
3442 r_type
= R_X86_64_32
;
3443 /* Clear the W bit in REX byte. */
3445 goto rewrite_modrm_rex
;
3451 /* R_X86_64_PC32 isn't supported. */
3455 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3458 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3459 "test $foo, %reg". */
3460 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3465 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3466 "binop $foo, %reg". */
3467 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3471 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3472 overflow when sign-extending imm32 to imm64. */
3473 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3476 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3480 /* Move the R bit to the B bit in REX byte. */
3481 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3482 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3485 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3489 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3492 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3493 changed_contents
= TRUE
;
3494 changed_relocs
= TRUE
;
3498 if (h
->got
.refcount
> 0)
3499 h
->got
.refcount
-= 1;
3503 if (local_got_refcounts
!= NULL
3504 && local_got_refcounts
[r_symndx
] > 0)
3505 local_got_refcounts
[r_symndx
] -= 1;
3509 if (contents
!= NULL
3510 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3512 if (!changed_contents
&& !link_info
->keep_memory
)
3516 /* Cache the section contents for elf_link_input_bfd. */
3517 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3521 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3523 if (!changed_relocs
)
3524 free (internal_relocs
);
3526 elf_section_data (sec
)->relocs
= internal_relocs
;
3532 if (contents
!= NULL
3533 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3535 if (internal_relocs
!= NULL
3536 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3537 free (internal_relocs
);
3541 /* Set the sizes of the dynamic sections. */
3544 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3545 struct bfd_link_info
*info
)
3547 struct elf_x86_64_link_hash_table
*htab
;
3552 const struct elf_backend_data
*bed
;
3554 htab
= elf_x86_64_hash_table (info
);
3557 bed
= get_elf_backend_data (output_bfd
);
3559 dynobj
= htab
->elf
.dynobj
;
3563 if (htab
->elf
.dynamic_sections_created
)
3565 /* Set the contents of the .interp section to the interpreter. */
3566 if (bfd_link_executable (info
) && !info
->nointerp
)
3568 s
= bfd_get_linker_section (dynobj
, ".interp");
3571 s
->size
= htab
->dynamic_interpreter_size
;
3572 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3577 /* Set up .got offsets for local syms, and space for local dynamic
3579 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3581 bfd_signed_vma
*local_got
;
3582 bfd_signed_vma
*end_local_got
;
3583 char *local_tls_type
;
3584 bfd_vma
*local_tlsdesc_gotent
;
3585 bfd_size_type locsymcount
;
3586 Elf_Internal_Shdr
*symtab_hdr
;
3589 if (! is_x86_64_elf (ibfd
))
3592 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3594 struct elf_dyn_relocs
*p
;
3596 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3599 for (p
= (struct elf_dyn_relocs
*)
3600 (elf_section_data (s
)->local_dynrel
);
3604 if (!bfd_is_abs_section (p
->sec
)
3605 && bfd_is_abs_section (p
->sec
->output_section
))
3607 /* Input section has been discarded, either because
3608 it is a copy of a linkonce section or due to
3609 linker script /DISCARD/, so we'll be discarding
3612 else if (p
->count
!= 0)
3614 srel
= elf_section_data (p
->sec
)->sreloc
;
3615 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3616 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3617 && (info
->flags
& DF_TEXTREL
) == 0)
3619 info
->flags
|= DF_TEXTREL
;
3620 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3621 || info
->error_textrel
)
3622 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3623 p
->sec
->owner
, p
->sec
);
3629 local_got
= elf_local_got_refcounts (ibfd
);
3633 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3634 locsymcount
= symtab_hdr
->sh_info
;
3635 end_local_got
= local_got
+ locsymcount
;
3636 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3637 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3639 srel
= htab
->elf
.srelgot
;
3640 for (; local_got
< end_local_got
;
3641 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3643 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3646 if (GOT_TLS_GDESC_P (*local_tls_type
))
3648 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3649 - elf_x86_64_compute_jump_table_size (htab
);
3650 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3651 *local_got
= (bfd_vma
) -2;
3653 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3654 || GOT_TLS_GD_P (*local_tls_type
))
3656 *local_got
= s
->size
;
3657 s
->size
+= GOT_ENTRY_SIZE
;
3658 if (GOT_TLS_GD_P (*local_tls_type
))
3659 s
->size
+= GOT_ENTRY_SIZE
;
3661 if (bfd_link_pic (info
)
3662 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3663 || *local_tls_type
== GOT_TLS_IE
)
3665 if (GOT_TLS_GDESC_P (*local_tls_type
))
3667 htab
->elf
.srelplt
->size
3668 += bed
->s
->sizeof_rela
;
3669 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3671 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3672 || GOT_TLS_GD_P (*local_tls_type
))
3673 srel
->size
+= bed
->s
->sizeof_rela
;
3677 *local_got
= (bfd_vma
) -1;
3681 if (htab
->tls_ld_got
.refcount
> 0)
3683 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3685 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3686 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3687 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3690 htab
->tls_ld_got
.offset
= -1;
3692 /* Allocate global sym .plt and .got entries, and space for global
3693 sym dynamic relocs. */
3694 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3697 /* Allocate .plt and .got entries, and space for local symbols. */
3698 htab_traverse (htab
->loc_hash_table
,
3699 elf_x86_64_allocate_local_dynrelocs
,
3702 /* For every jump slot reserved in the sgotplt, reloc_count is
3703 incremented. However, when we reserve space for TLS descriptors,
3704 it's not incremented, so in order to compute the space reserved
3705 for them, it suffices to multiply the reloc count by the jump
3708 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3709 so that R_X86_64_IRELATIVE entries come last. */
3710 if (htab
->elf
.srelplt
)
3712 htab
->sgotplt_jump_table_size
3713 = elf_x86_64_compute_jump_table_size (htab
);
3714 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3716 else if (htab
->elf
.irelplt
)
3717 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3719 if (htab
->tlsdesc_plt
)
3721 /* If we're not using lazy TLS relocations, don't generate the
3722 PLT and GOT entries they require. */
3723 if ((info
->flags
& DF_BIND_NOW
))
3724 htab
->tlsdesc_plt
= 0;
3727 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3728 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3729 /* Reserve room for the initial entry.
3730 FIXME: we could probably do away with it in this case. */
3731 if (htab
->elf
.splt
->size
== 0)
3732 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3733 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3734 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3738 if (htab
->elf
.sgotplt
)
3740 /* Don't allocate .got.plt section if there are no GOT nor PLT
3741 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3742 if ((htab
->elf
.hgot
== NULL
3743 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3744 && (htab
->elf
.sgotplt
->size
3745 == get_elf_backend_data (output_bfd
)->got_header_size
)
3746 && (htab
->elf
.splt
== NULL
3747 || htab
->elf
.splt
->size
== 0)
3748 && (htab
->elf
.sgot
== NULL
3749 || htab
->elf
.sgot
->size
== 0)
3750 && (htab
->elf
.iplt
== NULL
3751 || htab
->elf
.iplt
->size
== 0)
3752 && (htab
->elf
.igotplt
== NULL
3753 || htab
->elf
.igotplt
->size
== 0))
3754 htab
->elf
.sgotplt
->size
= 0;
3757 if (htab
->plt_eh_frame
!= NULL
3758 && htab
->elf
.splt
!= NULL
3759 && htab
->elf
.splt
->size
!= 0
3760 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3761 && _bfd_elf_eh_frame_present (info
))
3763 const struct elf_x86_64_backend_data
*arch_data
3764 = get_elf_x86_64_arch_data (bed
);
3765 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3768 /* We now have determined the sizes of the various dynamic sections.
3769 Allocate memory for them. */
3771 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3773 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3776 if (s
== htab
->elf
.splt
3777 || s
== htab
->elf
.sgot
3778 || s
== htab
->elf
.sgotplt
3779 || s
== htab
->elf
.iplt
3780 || s
== htab
->elf
.igotplt
3781 || s
== htab
->plt_bnd
3782 || s
== htab
->plt_got
3783 || s
== htab
->plt_eh_frame
3784 || s
== htab
->sdynbss
)
3786 /* Strip this section if we don't need it; see the
3789 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3791 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3794 /* We use the reloc_count field as a counter if we need
3795 to copy relocs into the output file. */
3796 if (s
!= htab
->elf
.srelplt
)
3801 /* It's not one of our sections, so don't allocate space. */
3807 /* If we don't need this section, strip it from the
3808 output file. This is mostly to handle .rela.bss and
3809 .rela.plt. We must create both sections in
3810 create_dynamic_sections, because they must be created
3811 before the linker maps input sections to output
3812 sections. The linker does that before
3813 adjust_dynamic_symbol is called, and it is that
3814 function which decides whether anything needs to go
3815 into these sections. */
3817 s
->flags
|= SEC_EXCLUDE
;
3821 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3824 /* Allocate memory for the section contents. We use bfd_zalloc
3825 here in case unused entries are not reclaimed before the
3826 section's contents are written out. This should not happen,
3827 but this way if it does, we get a R_X86_64_NONE reloc instead
3829 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3830 if (s
->contents
== NULL
)
3834 if (htab
->plt_eh_frame
!= NULL
3835 && htab
->plt_eh_frame
->contents
!= NULL
)
3837 const struct elf_x86_64_backend_data
*arch_data
3838 = get_elf_x86_64_arch_data (bed
);
3840 memcpy (htab
->plt_eh_frame
->contents
,
3841 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3842 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3843 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3846 if (htab
->elf
.dynamic_sections_created
)
3848 /* Add some entries to the .dynamic section. We fill in the
3849 values later, in elf_x86_64_finish_dynamic_sections, but we
3850 must add the entries now so that we get the correct size for
3851 the .dynamic section. The DT_DEBUG entry is filled in by the
3852 dynamic linker and used by the debugger. */
3853 #define add_dynamic_entry(TAG, VAL) \
3854 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3856 if (bfd_link_executable (info
))
3858 if (!add_dynamic_entry (DT_DEBUG
, 0))
3862 if (htab
->elf
.splt
->size
!= 0)
3864 /* DT_PLTGOT is used by prelink even if there is no PLT
3866 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3869 if (htab
->elf
.srelplt
->size
!= 0)
3871 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3872 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3873 || !add_dynamic_entry (DT_JMPREL
, 0))
3877 if (htab
->tlsdesc_plt
3878 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3879 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3885 if (!add_dynamic_entry (DT_RELA
, 0)
3886 || !add_dynamic_entry (DT_RELASZ
, 0)
3887 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3890 /* If any dynamic relocs apply to a read-only section,
3891 then we need a DT_TEXTREL entry. */
3892 if ((info
->flags
& DF_TEXTREL
) == 0)
3893 elf_link_hash_traverse (&htab
->elf
,
3894 elf_x86_64_readonly_dynrelocs
,
3897 if ((info
->flags
& DF_TEXTREL
) != 0)
3899 if ((elf_tdata (output_bfd
)->has_gnu_symbols
3900 & elf_gnu_symbol_ifunc
) == elf_gnu_symbol_ifunc
)
3902 info
->callbacks
->einfo
3903 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3904 bfd_set_error (bfd_error_bad_value
);
3908 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3913 #undef add_dynamic_entry
3919 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3920 struct bfd_link_info
*info
)
3922 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3926 struct elf_link_hash_entry
*tlsbase
;
3928 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3929 "_TLS_MODULE_BASE_",
3930 FALSE
, FALSE
, FALSE
);
3932 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3934 struct elf_x86_64_link_hash_table
*htab
;
3935 struct bfd_link_hash_entry
*bh
= NULL
;
3936 const struct elf_backend_data
*bed
3937 = get_elf_backend_data (output_bfd
);
3939 htab
= elf_x86_64_hash_table (info
);
3943 if (!(_bfd_generic_link_add_one_symbol
3944 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3945 tls_sec
, 0, NULL
, FALSE
,
3946 bed
->collect
, &bh
)))
3949 htab
->tls_module_base
= bh
;
3951 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3952 tlsbase
->def_regular
= 1;
3953 tlsbase
->other
= STV_HIDDEN
;
3954 tlsbase
->root
.linker_def
= 1;
3955 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3962 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3963 executables. Rather than setting it to the beginning of the TLS
3964 section, we have to set it to the end. This function may be called
3965 multiple times, it is idempotent. */
3968 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3970 struct elf_x86_64_link_hash_table
*htab
;
3971 struct bfd_link_hash_entry
*base
;
3973 if (!bfd_link_executable (info
))
3976 htab
= elf_x86_64_hash_table (info
);
3980 base
= htab
->tls_module_base
;
3984 base
->u
.def
.value
= htab
->elf
.tls_size
;
3987 /* Return the base VMA address which should be subtracted from real addresses
3988 when resolving @dtpoff relocation.
3989 This is PT_TLS segment p_vaddr. */
3992 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3994 /* If tls_sec is NULL, we should have signalled an error already. */
3995 if (elf_hash_table (info
)->tls_sec
== NULL
)
3997 return elf_hash_table (info
)->tls_sec
->vma
;
4000 /* Return the relocation value for @tpoff relocation
4001 if STT_TLS virtual address is ADDRESS. */
4004 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4006 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4007 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4008 bfd_vma static_tls_size
;
4010 /* If tls_segment is NULL, we should have signalled an error already. */
4011 if (htab
->tls_sec
== NULL
)
4014 /* Consider special static TLS alignment requirements. */
4015 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4016 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4019 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4023 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4025 /* Opcode Instruction
4028 0x0f 0x8x conditional jump */
4030 && (contents
[offset
- 1] == 0xe8
4031 || contents
[offset
- 1] == 0xe9))
4033 && contents
[offset
- 2] == 0x0f
4034 && (contents
[offset
- 1] & 0xf0) == 0x80));
4038 elf_x86_64_need_pic (bfd
*input_bfd
, struct elf_link_hash_entry
*h
,
4039 reloc_howto_type
*howto
)
4043 const char *pic
= "";
4045 switch (ELF_ST_VISIBILITY (h
->other
))
4048 v
= _("hidden symbol");
4051 v
= _("internal symbol");
4054 v
= _("protected symbol");
4058 pic
= _("; recompile with -fPIC");
4063 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4065 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4067 (*_bfd_error_handler
) (fmt
, input_bfd
, howto
->name
,
4068 v
, h
->root
.root
.string
, pic
);
4069 bfd_set_error (bfd_error_bad_value
);
4073 /* Relocate an x86_64 ELF section. */
4076 elf_x86_64_relocate_section (bfd
*output_bfd
,
4077 struct bfd_link_info
*info
,
4079 asection
*input_section
,
4081 Elf_Internal_Rela
*relocs
,
4082 Elf_Internal_Sym
*local_syms
,
4083 asection
**local_sections
)
4085 struct elf_x86_64_link_hash_table
*htab
;
4086 Elf_Internal_Shdr
*symtab_hdr
;
4087 struct elf_link_hash_entry
**sym_hashes
;
4088 bfd_vma
*local_got_offsets
;
4089 bfd_vma
*local_tlsdesc_gotents
;
4090 Elf_Internal_Rela
*rel
;
4091 Elf_Internal_Rela
*wrel
;
4092 Elf_Internal_Rela
*relend
;
4093 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4095 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4097 htab
= elf_x86_64_hash_table (info
);
4100 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4101 sym_hashes
= elf_sym_hashes (input_bfd
);
4102 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4103 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4105 elf_x86_64_set_tls_module_base (info
);
4107 rel
= wrel
= relocs
;
4108 relend
= relocs
+ input_section
->reloc_count
;
4109 for (; rel
< relend
; wrel
++, rel
++)
4111 unsigned int r_type
;
4112 reloc_howto_type
*howto
;
4113 unsigned long r_symndx
;
4114 struct elf_link_hash_entry
*h
;
4115 struct elf_x86_64_link_hash_entry
*eh
;
4116 Elf_Internal_Sym
*sym
;
4118 bfd_vma off
, offplt
, plt_offset
;
4120 bfd_boolean unresolved_reloc
;
4121 bfd_reloc_status_type r
;
4123 asection
*base_got
, *resolved_plt
;
4125 bfd_boolean resolved_to_zero
;
4127 r_type
= ELF32_R_TYPE (rel
->r_info
);
4128 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4129 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4136 if (r_type
>= (int) R_X86_64_standard
)
4138 (*_bfd_error_handler
)
4139 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4140 input_bfd
, input_section
, r_type
);
4141 bfd_set_error (bfd_error_bad_value
);
4145 if (r_type
!= (int) R_X86_64_32
4146 || ABI_64_P (output_bfd
))
4147 howto
= x86_64_elf_howto_table
+ r_type
;
4149 howto
= (x86_64_elf_howto_table
4150 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4151 r_symndx
= htab
->r_sym (rel
->r_info
);
4155 unresolved_reloc
= FALSE
;
4156 if (r_symndx
< symtab_hdr
->sh_info
)
4158 sym
= local_syms
+ r_symndx
;
4159 sec
= local_sections
[r_symndx
];
4161 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4163 st_size
= sym
->st_size
;
4165 /* Relocate against local STT_GNU_IFUNC symbol. */
4166 if (!bfd_link_relocatable (info
)
4167 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4169 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4174 /* Set STT_GNU_IFUNC symbol value. */
4175 h
->root
.u
.def
.value
= sym
->st_value
;
4176 h
->root
.u
.def
.section
= sec
;
4181 bfd_boolean warned ATTRIBUTE_UNUSED
;
4182 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4184 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4185 r_symndx
, symtab_hdr
, sym_hashes
,
4187 unresolved_reloc
, warned
, ignored
);
4191 if (sec
!= NULL
&& discarded_section (sec
))
4193 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4194 contents
+ rel
->r_offset
);
4195 wrel
->r_offset
= rel
->r_offset
;
4199 /* For ld -r, remove relocations in debug sections against
4200 sections defined in discarded sections. Not done for
4201 eh_frame editing code expects to be present. */
4202 if (bfd_link_relocatable (info
)
4203 && (input_section
->flags
& SEC_DEBUGGING
))
4209 if (bfd_link_relocatable (info
))
4216 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4218 if (r_type
== R_X86_64_64
)
4220 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4221 zero-extend it to 64bit if addend is zero. */
4222 r_type
= R_X86_64_32
;
4223 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4225 else if (r_type
== R_X86_64_SIZE64
)
4227 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4228 zero-extend it to 64bit if addend is zero. */
4229 r_type
= R_X86_64_SIZE32
;
4230 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4234 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4236 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4237 it here if it is defined in a non-shared object. */
4239 && h
->type
== STT_GNU_IFUNC
4245 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4247 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4248 sections because such sections are not SEC_ALLOC and
4249 thus ld.so will not process them. */
4250 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4254 else if (h
->plt
.offset
== (bfd_vma
) -1)
4257 /* STT_GNU_IFUNC symbol must go through PLT. */
4258 if (htab
->elf
.splt
!= NULL
)
4260 if (htab
->plt_bnd
!= NULL
)
4262 resolved_plt
= htab
->plt_bnd
;
4263 plt_offset
= eh
->plt_bnd
.offset
;
4267 resolved_plt
= htab
->elf
.splt
;
4268 plt_offset
= h
->plt
.offset
;
4273 resolved_plt
= htab
->elf
.iplt
;
4274 plt_offset
= h
->plt
.offset
;
4277 relocation
= (resolved_plt
->output_section
->vma
4278 + resolved_plt
->output_offset
+ plt_offset
);
4283 if (h
->root
.root
.string
)
4284 name
= h
->root
.root
.string
;
4286 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4288 (*_bfd_error_handler
)
4289 (_("%B: relocation %s against STT_GNU_IFUNC "
4290 "symbol `%s' isn't handled by %s"), input_bfd
,
4291 howto
->name
, name
, __FUNCTION__
);
4292 bfd_set_error (bfd_error_bad_value
);
4296 if (bfd_link_pic (info
))
4301 if (ABI_64_P (output_bfd
))
4305 if (rel
->r_addend
!= 0)
4307 if (h
->root
.root
.string
)
4308 name
= h
->root
.root
.string
;
4310 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4312 (*_bfd_error_handler
)
4313 (_("%B: relocation %s against STT_GNU_IFUNC "
4314 "symbol `%s' has non-zero addend: %d"),
4315 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4316 bfd_set_error (bfd_error_bad_value
);
4320 /* Generate dynamic relcoation only when there is a
4321 non-GOT reference in a shared object. */
4322 if (bfd_link_pic (info
) && h
->non_got_ref
)
4324 Elf_Internal_Rela outrel
;
4327 /* Need a dynamic relocation to get the real function
4329 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4333 if (outrel
.r_offset
== (bfd_vma
) -1
4334 || outrel
.r_offset
== (bfd_vma
) -2)
4337 outrel
.r_offset
+= (input_section
->output_section
->vma
4338 + input_section
->output_offset
);
4340 if (h
->dynindx
== -1
4342 || bfd_link_executable (info
))
4344 /* This symbol is resolved locally. */
4345 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4346 outrel
.r_addend
= (h
->root
.u
.def
.value
4347 + h
->root
.u
.def
.section
->output_section
->vma
4348 + h
->root
.u
.def
.section
->output_offset
);
4352 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4353 outrel
.r_addend
= 0;
4356 sreloc
= htab
->elf
.irelifunc
;
4357 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4359 /* If this reloc is against an external symbol, we
4360 do not want to fiddle with the addend. Otherwise,
4361 we need to include the symbol value so that it
4362 becomes an addend for the dynamic reloc. For an
4363 internal symbol, we have updated addend. */
4368 case R_X86_64_PC32_BND
:
4370 case R_X86_64_PLT32
:
4371 case R_X86_64_PLT32_BND
:
4374 case R_X86_64_GOTPCREL
:
4375 case R_X86_64_GOTPCRELX
:
4376 case R_X86_64_REX_GOTPCRELX
:
4377 case R_X86_64_GOTPCREL64
:
4378 base_got
= htab
->elf
.sgot
;
4379 off
= h
->got
.offset
;
4381 if (base_got
== NULL
)
4384 if (off
== (bfd_vma
) -1)
4386 /* We can't use h->got.offset here to save state, or
4387 even just remember the offset, as finish_dynamic_symbol
4388 would use that as offset into .got. */
4390 if (htab
->elf
.splt
!= NULL
)
4392 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4393 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4394 base_got
= htab
->elf
.sgotplt
;
4398 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4399 off
= plt_index
* GOT_ENTRY_SIZE
;
4400 base_got
= htab
->elf
.igotplt
;
4403 if (h
->dynindx
== -1
4407 /* This references the local defitionion. We must
4408 initialize this entry in the global offset table.
4409 Since the offset must always be a multiple of 8,
4410 we use the least significant bit to record
4411 whether we have initialized it already.
4413 When doing a dynamic link, we create a .rela.got
4414 relocation entry to initialize the value. This
4415 is done in the finish_dynamic_symbol routine. */
4420 bfd_put_64 (output_bfd
, relocation
,
4421 base_got
->contents
+ off
);
4422 /* Note that this is harmless for the GOTPLT64
4423 case, as -1 | 1 still is -1. */
4429 relocation
= (base_got
->output_section
->vma
4430 + base_got
->output_offset
+ off
);
4436 resolved_to_zero
= (eh
!= NULL
4437 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4439 /* When generating a shared object, the relocations handled here are
4440 copied into the output file to be resolved at run time. */
4443 case R_X86_64_GOT32
:
4444 case R_X86_64_GOT64
:
4445 /* Relocation is to the entry for this symbol in the global
4447 case R_X86_64_GOTPCREL
:
4448 case R_X86_64_GOTPCRELX
:
4449 case R_X86_64_REX_GOTPCRELX
:
4450 case R_X86_64_GOTPCREL64
:
4451 /* Use global offset table entry as symbol value. */
4452 case R_X86_64_GOTPLT64
:
4453 /* This is obsolete and treated the the same as GOT64. */
4454 base_got
= htab
->elf
.sgot
;
4456 if (htab
->elf
.sgot
== NULL
)
4463 off
= h
->got
.offset
;
4465 && h
->plt
.offset
!= (bfd_vma
)-1
4466 && off
== (bfd_vma
)-1)
4468 /* We can't use h->got.offset here to save
4469 state, or even just remember the offset, as
4470 finish_dynamic_symbol would use that as offset into
4472 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4473 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4474 base_got
= htab
->elf
.sgotplt
;
4477 dyn
= htab
->elf
.dynamic_sections_created
;
4479 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4480 || (bfd_link_pic (info
)
4481 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4482 || (ELF_ST_VISIBILITY (h
->other
)
4483 && h
->root
.type
== bfd_link_hash_undefweak
))
4485 /* This is actually a static link, or it is a -Bsymbolic
4486 link and the symbol is defined locally, or the symbol
4487 was forced to be local because of a version file. We
4488 must initialize this entry in the global offset table.
4489 Since the offset must always be a multiple of 8, we
4490 use the least significant bit to record whether we
4491 have initialized it already.
4493 When doing a dynamic link, we create a .rela.got
4494 relocation entry to initialize the value. This is
4495 done in the finish_dynamic_symbol routine. */
4500 bfd_put_64 (output_bfd
, relocation
,
4501 base_got
->contents
+ off
);
4502 /* Note that this is harmless for the GOTPLT64 case,
4503 as -1 | 1 still is -1. */
4508 unresolved_reloc
= FALSE
;
4512 if (local_got_offsets
== NULL
)
4515 off
= local_got_offsets
[r_symndx
];
4517 /* The offset must always be a multiple of 8. We use
4518 the least significant bit to record whether we have
4519 already generated the necessary reloc. */
4524 bfd_put_64 (output_bfd
, relocation
,
4525 base_got
->contents
+ off
);
4527 if (bfd_link_pic (info
))
4530 Elf_Internal_Rela outrel
;
4532 /* We need to generate a R_X86_64_RELATIVE reloc
4533 for the dynamic linker. */
4534 s
= htab
->elf
.srelgot
;
4538 outrel
.r_offset
= (base_got
->output_section
->vma
4539 + base_got
->output_offset
4541 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4542 outrel
.r_addend
= relocation
;
4543 elf_append_rela (output_bfd
, s
, &outrel
);
4546 local_got_offsets
[r_symndx
] |= 1;
4550 if (off
>= (bfd_vma
) -2)
4553 relocation
= base_got
->output_section
->vma
4554 + base_got
->output_offset
+ off
;
4555 if (r_type
!= R_X86_64_GOTPCREL
4556 && r_type
!= R_X86_64_GOTPCRELX
4557 && r_type
!= R_X86_64_REX_GOTPCRELX
4558 && r_type
!= R_X86_64_GOTPCREL64
)
4559 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4560 - htab
->elf
.sgotplt
->output_offset
;
4564 case R_X86_64_GOTOFF64
:
4565 /* Relocation is relative to the start of the global offset
4568 /* Check to make sure it isn't a protected function or data
4569 symbol for shared library since it may not be local when
4570 used as function address or with copy relocation. We also
4571 need to make sure that a symbol is referenced locally. */
4572 if (bfd_link_pic (info
) && h
)
4574 if (!h
->def_regular
)
4578 switch (ELF_ST_VISIBILITY (h
->other
))
4581 v
= _("hidden symbol");
4584 v
= _("internal symbol");
4587 v
= _("protected symbol");
4594 (*_bfd_error_handler
)
4595 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4596 input_bfd
, v
, h
->root
.root
.string
);
4597 bfd_set_error (bfd_error_bad_value
);
4600 else if (!bfd_link_executable (info
)
4601 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4602 && (h
->type
== STT_FUNC
4603 || h
->type
== STT_OBJECT
)
4604 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4606 (*_bfd_error_handler
)
4607 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4609 h
->type
== STT_FUNC
? "function" : "data",
4610 h
->root
.root
.string
);
4611 bfd_set_error (bfd_error_bad_value
);
4616 /* Note that sgot is not involved in this
4617 calculation. We always want the start of .got.plt. If we
4618 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4619 permitted by the ABI, we might have to change this
4621 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4622 + htab
->elf
.sgotplt
->output_offset
;
4625 case R_X86_64_GOTPC32
:
4626 case R_X86_64_GOTPC64
:
4627 /* Use global offset table as symbol value. */
4628 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4629 + htab
->elf
.sgotplt
->output_offset
;
4630 unresolved_reloc
= FALSE
;
4633 case R_X86_64_PLTOFF64
:
4634 /* Relocation is PLT entry relative to GOT. For local
4635 symbols it's the symbol itself relative to GOT. */
4637 /* See PLT32 handling. */
4638 && h
->plt
.offset
!= (bfd_vma
) -1
4639 && htab
->elf
.splt
!= NULL
)
4641 if (htab
->plt_bnd
!= NULL
)
4643 resolved_plt
= htab
->plt_bnd
;
4644 plt_offset
= eh
->plt_bnd
.offset
;
4648 resolved_plt
= htab
->elf
.splt
;
4649 plt_offset
= h
->plt
.offset
;
4652 relocation
= (resolved_plt
->output_section
->vma
4653 + resolved_plt
->output_offset
4655 unresolved_reloc
= FALSE
;
4658 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4659 + htab
->elf
.sgotplt
->output_offset
;
4662 case R_X86_64_PLT32
:
4663 case R_X86_64_PLT32_BND
:
4664 /* Relocation is to the entry for this symbol in the
4665 procedure linkage table. */
4667 /* Resolve a PLT32 reloc against a local symbol directly,
4668 without using the procedure linkage table. */
4672 if ((h
->plt
.offset
== (bfd_vma
) -1
4673 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4674 || htab
->elf
.splt
== NULL
)
4676 /* We didn't make a PLT entry for this symbol. This
4677 happens when statically linking PIC code, or when
4678 using -Bsymbolic. */
4682 if (h
->plt
.offset
!= (bfd_vma
) -1)
4684 if (htab
->plt_bnd
!= NULL
)
4686 resolved_plt
= htab
->plt_bnd
;
4687 plt_offset
= eh
->plt_bnd
.offset
;
4691 resolved_plt
= htab
->elf
.splt
;
4692 plt_offset
= h
->plt
.offset
;
4697 /* Use the GOT PLT. */
4698 resolved_plt
= htab
->plt_got
;
4699 plt_offset
= eh
->plt_got
.offset
;
4702 relocation
= (resolved_plt
->output_section
->vma
4703 + resolved_plt
->output_offset
4705 unresolved_reloc
= FALSE
;
4708 case R_X86_64_SIZE32
:
4709 case R_X86_64_SIZE64
:
4710 /* Set to symbol size. */
4711 relocation
= st_size
;
4717 case R_X86_64_PC32_BND
:
4718 /* Don't complain about -fPIC if the symbol is undefined when
4719 building executable unless it is unresolved weak symbol. */
4720 if ((input_section
->flags
& SEC_ALLOC
) != 0
4721 && (input_section
->flags
& SEC_READONLY
) != 0
4723 && ((bfd_link_executable (info
)
4724 && h
->root
.type
== bfd_link_hash_undefweak
4725 && !resolved_to_zero
)
4726 || (bfd_link_pic (info
)
4727 && !(bfd_link_pie (info
)
4728 && h
->root
.type
== bfd_link_hash_undefined
))))
4730 bfd_boolean fail
= FALSE
;
4732 = ((r_type
== R_X86_64_PC32
4733 || r_type
== R_X86_64_PC32_BND
)
4734 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4736 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4738 /* Symbol is referenced locally. Make sure it is
4739 defined locally or for a branch. */
4740 fail
= !h
->def_regular
&& !branch
;
4742 else if (!(bfd_link_pie (info
)
4743 && (h
->needs_copy
|| eh
->needs_copy
)))
4745 /* Symbol doesn't need copy reloc and isn't referenced
4746 locally. We only allow branch to symbol with
4747 non-default visibility. */
4749 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4753 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4762 /* FIXME: The ABI says the linker should make sure the value is
4763 the same when it's zeroextended to 64 bit. */
4766 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4769 /* Don't copy a pc-relative relocation into the output file
4770 if the symbol needs copy reloc or the symbol is undefined
4771 when building executable. Copy dynamic function pointer
4772 relocations. Don't generate dynamic relocations against
4773 resolved undefined weak symbols in PIE. */
4774 if ((bfd_link_pic (info
)
4775 && !(bfd_link_pie (info
)
4779 || h
->root
.type
== bfd_link_hash_undefined
)
4780 && IS_X86_64_PCREL_TYPE (r_type
))
4782 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4783 && !resolved_to_zero
)
4784 || h
->root
.type
!= bfd_link_hash_undefweak
))
4785 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4786 && r_type
!= R_X86_64_SIZE32
4787 && r_type
!= R_X86_64_SIZE64
)
4788 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4789 || (ELIMINATE_COPY_RELOCS
4790 && !bfd_link_pic (info
)
4794 || eh
->func_pointer_refcount
> 0
4795 || (h
->root
.type
== bfd_link_hash_undefweak
4796 && !resolved_to_zero
))
4797 && ((h
->def_dynamic
&& !h
->def_regular
)
4798 /* Undefined weak symbol is bound locally when
4800 || h
->root
.type
== bfd_link_hash_undefined
)))
4802 Elf_Internal_Rela outrel
;
4803 bfd_boolean skip
, relocate
;
4806 /* When generating a shared object, these relocations
4807 are copied into the output file to be resolved at run
4813 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4815 if (outrel
.r_offset
== (bfd_vma
) -1)
4817 else if (outrel
.r_offset
== (bfd_vma
) -2)
4818 skip
= TRUE
, relocate
= TRUE
;
4820 outrel
.r_offset
+= (input_section
->output_section
->vma
4821 + input_section
->output_offset
);
4824 memset (&outrel
, 0, sizeof outrel
);
4826 /* h->dynindx may be -1 if this symbol was marked to
4830 && (IS_X86_64_PCREL_TYPE (r_type
)
4831 || ! bfd_link_pic (info
)
4832 || ! SYMBOLIC_BIND (info
, h
)
4833 || ! h
->def_regular
))
4835 if ((r_type
!= R_X86_64_PC64
&& r_type
!= R_X86_64_64
)
4836 && bfd_link_executable (info
)
4837 && h
->root
.type
== bfd_link_hash_undefweak
4838 && !resolved_to_zero
)
4839 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4840 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4841 outrel
.r_addend
= rel
->r_addend
;
4845 /* This symbol is local, or marked to become local. */
4846 if (r_type
== htab
->pointer_r_type
)
4849 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4850 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4852 else if (r_type
== R_X86_64_64
4853 && !ABI_64_P (output_bfd
))
4856 outrel
.r_info
= htab
->r_info (0,
4857 R_X86_64_RELATIVE64
);
4858 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4859 /* Check addend overflow. */
4860 if ((outrel
.r_addend
& 0x80000000)
4861 != (rel
->r_addend
& 0x80000000))
4864 int addend
= rel
->r_addend
;
4865 if (h
&& h
->root
.root
.string
)
4866 name
= h
->root
.root
.string
;
4868 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4871 (*_bfd_error_handler
)
4872 (_("%B: addend -0x%x in relocation %s against "
4873 "symbol `%s' at 0x%lx in section `%A' is "
4875 input_bfd
, input_section
, addend
,
4877 (unsigned long) rel
->r_offset
);
4879 (*_bfd_error_handler
)
4880 (_("%B: addend 0x%x in relocation %s against "
4881 "symbol `%s' at 0x%lx in section `%A' is "
4883 input_bfd
, input_section
, addend
,
4885 (unsigned long) rel
->r_offset
);
4886 bfd_set_error (bfd_error_bad_value
);
4894 if (bfd_is_abs_section (sec
))
4896 else if (sec
== NULL
|| sec
->owner
== NULL
)
4898 bfd_set_error (bfd_error_bad_value
);
4905 /* We are turning this relocation into one
4906 against a section symbol. It would be
4907 proper to subtract the symbol's value,
4908 osec->vma, from the emitted reloc addend,
4909 but ld.so expects buggy relocs. */
4910 osec
= sec
->output_section
;
4911 sindx
= elf_section_data (osec
)->dynindx
;
4914 asection
*oi
= htab
->elf
.text_index_section
;
4915 sindx
= elf_section_data (oi
)->dynindx
;
4917 BFD_ASSERT (sindx
!= 0);
4920 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4921 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4925 sreloc
= elf_section_data (input_section
)->sreloc
;
4927 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4929 r
= bfd_reloc_notsupported
;
4930 goto check_relocation_error
;
4933 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4935 /* If this reloc is against an external symbol, we do
4936 not want to fiddle with the addend. Otherwise, we
4937 need to include the symbol value so that it becomes
4938 an addend for the dynamic reloc. */
4945 case R_X86_64_TLSGD
:
4946 case R_X86_64_GOTPC32_TLSDESC
:
4947 case R_X86_64_TLSDESC_CALL
:
4948 case R_X86_64_GOTTPOFF
:
4949 tls_type
= GOT_UNKNOWN
;
4950 if (h
== NULL
&& local_got_offsets
)
4951 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4953 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4955 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4956 input_section
, contents
,
4957 symtab_hdr
, sym_hashes
,
4958 &r_type
, tls_type
, rel
,
4959 relend
, h
, r_symndx
))
4962 if (r_type
== R_X86_64_TPOFF32
)
4964 bfd_vma roff
= rel
->r_offset
;
4966 BFD_ASSERT (! unresolved_reloc
);
4968 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4970 /* GD->LE transition. For 64bit, change
4971 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4972 .word 0x6666; rex64; call __tls_get_addr
4975 leaq foo@tpoff(%rax), %rax
4977 leaq foo@tlsgd(%rip), %rdi
4978 .word 0x6666; rex64; call __tls_get_addr
4981 leaq foo@tpoff(%rax), %rax
4982 For largepic, change:
4983 leaq foo@tlsgd(%rip), %rdi
4984 movabsq $__tls_get_addr@pltoff, %rax
4989 leaq foo@tpoff(%rax), %rax
4990 nopw 0x0(%rax,%rax,1) */
4992 if (ABI_64_P (output_bfd
)
4993 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4995 memcpy (contents
+ roff
- 3,
4996 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4997 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5000 else if (ABI_64_P (output_bfd
))
5001 memcpy (contents
+ roff
- 4,
5002 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5005 memcpy (contents
+ roff
- 3,
5006 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5008 bfd_put_32 (output_bfd
,
5009 elf_x86_64_tpoff (info
, relocation
),
5010 contents
+ roff
+ 8 + largepic
);
5011 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5016 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5018 /* GDesc -> LE transition.
5019 It's originally something like:
5020 leaq x@tlsdesc(%rip), %rax
5023 movl $x@tpoff, %rax. */
5025 unsigned int val
, type
;
5027 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5028 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5029 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5030 contents
+ roff
- 3);
5031 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5032 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5033 contents
+ roff
- 1);
5034 bfd_put_32 (output_bfd
,
5035 elf_x86_64_tpoff (info
, relocation
),
5039 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5041 /* GDesc -> LE transition.
5046 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5047 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5050 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5052 /* IE->LE transition:
5053 For 64bit, originally it can be one of:
5054 movq foo@gottpoff(%rip), %reg
5055 addq foo@gottpoff(%rip), %reg
5058 leaq foo(%reg), %reg
5060 For 32bit, originally it can be one of:
5061 movq foo@gottpoff(%rip), %reg
5062 addl foo@gottpoff(%rip), %reg
5065 leal foo(%reg), %reg
5068 unsigned int val
, type
, reg
;
5071 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5074 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5075 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5081 bfd_put_8 (output_bfd
, 0x49,
5082 contents
+ roff
- 3);
5083 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5084 bfd_put_8 (output_bfd
, 0x41,
5085 contents
+ roff
- 3);
5086 bfd_put_8 (output_bfd
, 0xc7,
5087 contents
+ roff
- 2);
5088 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5089 contents
+ roff
- 1);
5093 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5096 bfd_put_8 (output_bfd
, 0x49,
5097 contents
+ roff
- 3);
5098 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5099 bfd_put_8 (output_bfd
, 0x41,
5100 contents
+ roff
- 3);
5101 bfd_put_8 (output_bfd
, 0x81,
5102 contents
+ roff
- 2);
5103 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5104 contents
+ roff
- 1);
5108 /* addq/addl -> leaq/leal */
5110 bfd_put_8 (output_bfd
, 0x4d,
5111 contents
+ roff
- 3);
5112 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5113 bfd_put_8 (output_bfd
, 0x45,
5114 contents
+ roff
- 3);
5115 bfd_put_8 (output_bfd
, 0x8d,
5116 contents
+ roff
- 2);
5117 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5118 contents
+ roff
- 1);
5120 bfd_put_32 (output_bfd
,
5121 elf_x86_64_tpoff (info
, relocation
),
5129 if (htab
->elf
.sgot
== NULL
)
5134 off
= h
->got
.offset
;
5135 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5139 if (local_got_offsets
== NULL
)
5142 off
= local_got_offsets
[r_symndx
];
5143 offplt
= local_tlsdesc_gotents
[r_symndx
];
5150 Elf_Internal_Rela outrel
;
5154 if (htab
->elf
.srelgot
== NULL
)
5157 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5159 if (GOT_TLS_GDESC_P (tls_type
))
5161 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5162 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5163 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5164 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5165 + htab
->elf
.sgotplt
->output_offset
5167 + htab
->sgotplt_jump_table_size
);
5168 sreloc
= htab
->elf
.srelplt
;
5170 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5172 outrel
.r_addend
= 0;
5173 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5176 sreloc
= htab
->elf
.srelgot
;
5178 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5179 + htab
->elf
.sgot
->output_offset
+ off
);
5181 if (GOT_TLS_GD_P (tls_type
))
5182 dr_type
= R_X86_64_DTPMOD64
;
5183 else if (GOT_TLS_GDESC_P (tls_type
))
5186 dr_type
= R_X86_64_TPOFF64
;
5188 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5189 outrel
.r_addend
= 0;
5190 if ((dr_type
== R_X86_64_TPOFF64
5191 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5192 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5193 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5195 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5197 if (GOT_TLS_GD_P (tls_type
))
5201 BFD_ASSERT (! unresolved_reloc
);
5202 bfd_put_64 (output_bfd
,
5203 relocation
- elf_x86_64_dtpoff_base (info
),
5204 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5208 bfd_put_64 (output_bfd
, 0,
5209 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5210 outrel
.r_info
= htab
->r_info (indx
,
5212 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5213 elf_append_rela (output_bfd
, sreloc
,
5222 local_got_offsets
[r_symndx
] |= 1;
5225 if (off
>= (bfd_vma
) -2
5226 && ! GOT_TLS_GDESC_P (tls_type
))
5228 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5230 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5231 || r_type
== R_X86_64_TLSDESC_CALL
)
5232 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5233 + htab
->elf
.sgotplt
->output_offset
5234 + offplt
+ htab
->sgotplt_jump_table_size
;
5236 relocation
= htab
->elf
.sgot
->output_section
->vma
5237 + htab
->elf
.sgot
->output_offset
+ off
;
5238 unresolved_reloc
= FALSE
;
5242 bfd_vma roff
= rel
->r_offset
;
5244 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5246 /* GD->IE transition. For 64bit, change
5247 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5248 .word 0x6666; rex64; call __tls_get_addr@plt
5251 addq foo@gottpoff(%rip), %rax
5253 leaq foo@tlsgd(%rip), %rdi
5254 .word 0x6666; rex64; call __tls_get_addr@plt
5257 addq foo@gottpoff(%rip), %rax
5258 For largepic, change:
5259 leaq foo@tlsgd(%rip), %rdi
5260 movabsq $__tls_get_addr@pltoff, %rax
5265 addq foo@gottpoff(%rax), %rax
5266 nopw 0x0(%rax,%rax,1) */
5268 if (ABI_64_P (output_bfd
)
5269 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5271 memcpy (contents
+ roff
- 3,
5272 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5273 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5276 else if (ABI_64_P (output_bfd
))
5277 memcpy (contents
+ roff
- 4,
5278 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5281 memcpy (contents
+ roff
- 3,
5282 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5285 relocation
= (htab
->elf
.sgot
->output_section
->vma
5286 + htab
->elf
.sgot
->output_offset
+ off
5289 - input_section
->output_section
->vma
5290 - input_section
->output_offset
5292 bfd_put_32 (output_bfd
, relocation
,
5293 contents
+ roff
+ 8 + largepic
);
5294 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5299 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5301 /* GDesc -> IE transition.
5302 It's originally something like:
5303 leaq x@tlsdesc(%rip), %rax
5306 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5308 /* Now modify the instruction as appropriate. To
5309 turn a leaq into a movq in the form we use it, it
5310 suffices to change the second byte from 0x8d to
5312 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5314 bfd_put_32 (output_bfd
,
5315 htab
->elf
.sgot
->output_section
->vma
5316 + htab
->elf
.sgot
->output_offset
+ off
5318 - input_section
->output_section
->vma
5319 - input_section
->output_offset
5324 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5326 /* GDesc -> IE transition.
5333 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5334 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5342 case R_X86_64_TLSLD
:
5343 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5344 input_section
, contents
,
5345 symtab_hdr
, sym_hashes
,
5346 &r_type
, GOT_UNKNOWN
,
5347 rel
, relend
, h
, r_symndx
))
5350 if (r_type
!= R_X86_64_TLSLD
)
5352 /* LD->LE transition:
5353 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5354 For 64bit, we change it into:
5355 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5356 For 32bit, we change it into:
5357 nopl 0x0(%rax); movl %fs:0, %eax.
5358 For largepic, change:
5359 leaq foo@tlsgd(%rip), %rdi
5360 movabsq $__tls_get_addr@pltoff, %rax
5364 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5367 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5368 if (ABI_64_P (output_bfd
)
5369 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5370 memcpy (contents
+ rel
->r_offset
- 3,
5371 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5372 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5373 else if (ABI_64_P (output_bfd
))
5374 memcpy (contents
+ rel
->r_offset
- 3,
5375 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5377 memcpy (contents
+ rel
->r_offset
- 3,
5378 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5379 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5385 if (htab
->elf
.sgot
== NULL
)
5388 off
= htab
->tls_ld_got
.offset
;
5393 Elf_Internal_Rela outrel
;
5395 if (htab
->elf
.srelgot
== NULL
)
5398 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5399 + htab
->elf
.sgot
->output_offset
+ off
);
5401 bfd_put_64 (output_bfd
, 0,
5402 htab
->elf
.sgot
->contents
+ off
);
5403 bfd_put_64 (output_bfd
, 0,
5404 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5405 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5406 outrel
.r_addend
= 0;
5407 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5409 htab
->tls_ld_got
.offset
|= 1;
5411 relocation
= htab
->elf
.sgot
->output_section
->vma
5412 + htab
->elf
.sgot
->output_offset
+ off
;
5413 unresolved_reloc
= FALSE
;
5416 case R_X86_64_DTPOFF32
:
5417 if (!bfd_link_executable (info
)
5418 || (input_section
->flags
& SEC_CODE
) == 0)
5419 relocation
-= elf_x86_64_dtpoff_base (info
);
5421 relocation
= elf_x86_64_tpoff (info
, relocation
);
5424 case R_X86_64_TPOFF32
:
5425 case R_X86_64_TPOFF64
:
5426 BFD_ASSERT (bfd_link_executable (info
));
5427 relocation
= elf_x86_64_tpoff (info
, relocation
);
5430 case R_X86_64_DTPOFF64
:
5431 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5432 relocation
-= elf_x86_64_dtpoff_base (info
);
5439 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5440 because such sections are not SEC_ALLOC and thus ld.so will
5441 not process them. */
5442 if (unresolved_reloc
5443 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5445 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5446 rel
->r_offset
) != (bfd_vma
) -1)
5448 (*_bfd_error_handler
)
5449 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5452 (long) rel
->r_offset
,
5454 h
->root
.root
.string
);
5459 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5460 contents
, rel
->r_offset
,
5461 relocation
, rel
->r_addend
);
5463 check_relocation_error
:
5464 if (r
!= bfd_reloc_ok
)
5469 name
= h
->root
.root
.string
;
5472 name
= bfd_elf_string_from_elf_section (input_bfd
,
5473 symtab_hdr
->sh_link
,
5478 name
= bfd_section_name (input_bfd
, sec
);
5481 if (r
== bfd_reloc_overflow
)
5483 if (! ((*info
->callbacks
->reloc_overflow
)
5484 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5485 (bfd_vma
) 0, input_bfd
, input_section
,
5491 (*_bfd_error_handler
)
5492 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5493 input_bfd
, input_section
,
5494 (long) rel
->r_offset
, name
, (int) r
);
5505 Elf_Internal_Shdr
*rel_hdr
;
5506 size_t deleted
= rel
- wrel
;
5508 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5509 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5510 if (rel_hdr
->sh_size
== 0)
5512 /* It is too late to remove an empty reloc section. Leave
5514 ??? What is wrong with an empty section??? */
5515 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5518 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5519 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5520 input_section
->reloc_count
-= deleted
;
5526 /* Finish up dynamic symbol handling. We set the contents of various
5527 dynamic sections here. */
5530 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5531 struct bfd_link_info
*info
,
5532 struct elf_link_hash_entry
*h
,
5533 Elf_Internal_Sym
*sym
)
5535 struct elf_x86_64_link_hash_table
*htab
;
5536 const struct elf_x86_64_backend_data
*abed
;
5537 bfd_boolean use_plt_bnd
;
5538 struct elf_x86_64_link_hash_entry
*eh
;
5539 bfd_boolean local_undefweak
;
5541 htab
= elf_x86_64_hash_table (info
);
5545 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5546 section only if there is .plt section. */
5547 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5549 ? &elf_x86_64_bnd_arch_bed
5550 : get_elf_x86_64_backend_data (output_bfd
));
5552 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5554 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5555 resolved undefined weak symbols in executable so that their
5556 references have value 0 at run-time. */
5557 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5559 if (h
->plt
.offset
!= (bfd_vma
) -1)
5562 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5563 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5564 Elf_Internal_Rela rela
;
5566 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5567 const struct elf_backend_data
*bed
;
5568 bfd_vma plt_got_pcrel_offset
;
5570 /* When building a static executable, use .iplt, .igot.plt and
5571 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5572 if (htab
->elf
.splt
!= NULL
)
5574 plt
= htab
->elf
.splt
;
5575 gotplt
= htab
->elf
.sgotplt
;
5576 relplt
= htab
->elf
.srelplt
;
5580 plt
= htab
->elf
.iplt
;
5581 gotplt
= htab
->elf
.igotplt
;
5582 relplt
= htab
->elf
.irelplt
;
5585 /* This symbol has an entry in the procedure linkage table. Set
5587 if ((h
->dynindx
== -1
5589 && !((h
->forced_local
|| bfd_link_executable (info
))
5591 && h
->type
== STT_GNU_IFUNC
))
5597 /* Get the index in the procedure linkage table which
5598 corresponds to this symbol. This is the index of this symbol
5599 in all the symbols for which we are making plt entries. The
5600 first entry in the procedure linkage table is reserved.
5602 Get the offset into the .got table of the entry that
5603 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5604 bytes. The first three are reserved for the dynamic linker.
5606 For static executables, we don't reserve anything. */
5608 if (plt
== htab
->elf
.splt
)
5610 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5611 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5615 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5616 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5619 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5620 plt_plt_offset
= abed
->plt_plt_offset
;
5621 plt_got_insn_size
= abed
->plt_got_insn_size
;
5622 plt_got_offset
= abed
->plt_got_offset
;
5625 /* Use the second PLT with BND relocations. */
5626 const bfd_byte
*plt_entry
, *plt2_entry
;
5628 if (eh
->has_bnd_reloc
)
5630 plt_entry
= elf_x86_64_bnd_plt_entry
;
5631 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5635 plt_entry
= elf_x86_64_legacy_plt_entry
;
5636 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5638 /* Subtract 1 since there is no BND prefix. */
5639 plt_plt_insn_end
-= 1;
5640 plt_plt_offset
-= 1;
5641 plt_got_insn_size
-= 1;
5642 plt_got_offset
-= 1;
5645 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5646 == sizeof (elf_x86_64_legacy_plt_entry
));
5648 /* Fill in the entry in the procedure linkage table. */
5649 memcpy (plt
->contents
+ h
->plt
.offset
,
5650 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5651 /* Fill in the entry in the second PLT. */
5652 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5653 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5655 resolved_plt
= htab
->plt_bnd
;
5656 plt_offset
= eh
->plt_bnd
.offset
;
5660 /* Fill in the entry in the procedure linkage table. */
5661 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5662 abed
->plt_entry_size
);
5665 plt_offset
= h
->plt
.offset
;
5668 /* Insert the relocation positions of the plt section. */
5670 /* Put offset the PC-relative instruction referring to the GOT entry,
5671 subtracting the size of that instruction. */
5672 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5673 + gotplt
->output_offset
5675 - resolved_plt
->output_section
->vma
5676 - resolved_plt
->output_offset
5678 - plt_got_insn_size
);
5680 /* Check PC-relative offset overflow in PLT entry. */
5681 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5682 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5683 output_bfd
, h
->root
.root
.string
);
5685 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5686 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5688 /* Fill in the entry in the global offset table, initially this
5689 points to the second part of the PLT entry. Leave the entry
5690 as zero for undefined weak symbol in PIE. No PLT relocation
5691 against undefined weak symbol in PIE. */
5692 if (!local_undefweak
)
5694 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5695 + plt
->output_offset
5697 + abed
->plt_lazy_offset
),
5698 gotplt
->contents
+ got_offset
);
5700 /* Fill in the entry in the .rela.plt section. */
5701 rela
.r_offset
= (gotplt
->output_section
->vma
5702 + gotplt
->output_offset
5704 if (h
->dynindx
== -1
5705 || ((bfd_link_executable (info
)
5706 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5708 && h
->type
== STT_GNU_IFUNC
))
5710 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5711 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5712 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5713 rela
.r_addend
= (h
->root
.u
.def
.value
5714 + h
->root
.u
.def
.section
->output_section
->vma
5715 + h
->root
.u
.def
.section
->output_offset
);
5716 /* R_X86_64_IRELATIVE comes last. */
5717 plt_index
= htab
->next_irelative_index
--;
5721 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5723 plt_index
= htab
->next_jump_slot_index
++;
5726 /* Don't fill PLT entry for static executables. */
5727 if (plt
== htab
->elf
.splt
)
5729 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5731 /* Put relocation index. */
5732 bfd_put_32 (output_bfd
, plt_index
,
5733 (plt
->contents
+ h
->plt
.offset
5734 + abed
->plt_reloc_offset
));
5736 /* Put offset for jmp .PLT0 and check for overflow. We don't
5737 check relocation index for overflow since branch displacement
5738 will overflow first. */
5739 if (plt0_offset
> 0x80000000)
5740 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5741 output_bfd
, h
->root
.root
.string
);
5742 bfd_put_32 (output_bfd
, - plt0_offset
,
5743 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5746 bed
= get_elf_backend_data (output_bfd
);
5747 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5748 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5751 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5753 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5754 asection
*plt
, *got
;
5755 bfd_boolean got_after_plt
;
5756 int32_t got_pcrel_offset
;
5757 const bfd_byte
*got_plt_entry
;
5759 /* Set the entry in the GOT procedure linkage table. */
5760 plt
= htab
->plt_got
;
5761 got
= htab
->elf
.sgot
;
5762 got_offset
= h
->got
.offset
;
5764 if (got_offset
== (bfd_vma
) -1
5765 || h
->type
== STT_GNU_IFUNC
5770 /* Use the second PLT entry template for the GOT PLT since they
5771 are the identical. */
5772 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5773 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5774 if (eh
->has_bnd_reloc
)
5775 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5778 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5780 /* Subtract 1 since there is no BND prefix. */
5781 plt_got_insn_size
-= 1;
5782 plt_got_offset
-= 1;
5785 /* Fill in the entry in the GOT procedure linkage table. */
5786 plt_offset
= eh
->plt_got
.offset
;
5787 memcpy (plt
->contents
+ plt_offset
,
5788 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5790 /* Put offset the PC-relative instruction referring to the GOT
5791 entry, subtracting the size of that instruction. */
5792 got_pcrel_offset
= (got
->output_section
->vma
5793 + got
->output_offset
5795 - plt
->output_section
->vma
5796 - plt
->output_offset
5798 - plt_got_insn_size
);
5800 /* Check PC-relative offset overflow in GOT PLT entry. */
5801 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5802 if ((got_after_plt
&& got_pcrel_offset
< 0)
5803 || (!got_after_plt
&& got_pcrel_offset
> 0))
5804 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5805 output_bfd
, h
->root
.root
.string
);
5807 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5808 plt
->contents
+ plt_offset
+ plt_got_offset
);
5811 if (!local_undefweak
5813 && (h
->plt
.offset
!= (bfd_vma
) -1
5814 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5816 /* Mark the symbol as undefined, rather than as defined in
5817 the .plt section. Leave the value if there were any
5818 relocations where pointer equality matters (this is a clue
5819 for the dynamic linker, to make function pointer
5820 comparisons work between an application and shared
5821 library), otherwise set it to zero. If a function is only
5822 called from a binary, there is no need to slow down
5823 shared libraries because of that. */
5824 sym
->st_shndx
= SHN_UNDEF
;
5825 if (!h
->pointer_equality_needed
)
5829 /* Don't generate dynamic GOT relocation against undefined weak
5830 symbol in executable. */
5831 if (h
->got
.offset
!= (bfd_vma
) -1
5832 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5833 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5834 && !local_undefweak
)
5836 Elf_Internal_Rela rela
;
5838 /* This symbol has an entry in the global offset table. Set it
5840 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5843 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5844 + htab
->elf
.sgot
->output_offset
5845 + (h
->got
.offset
&~ (bfd_vma
) 1));
5847 /* If this is a static link, or it is a -Bsymbolic link and the
5848 symbol is defined locally or was forced to be local because
5849 of a version file, we just want to emit a RELATIVE reloc.
5850 The entry in the global offset table will already have been
5851 initialized in the relocate_section function. */
5853 && h
->type
== STT_GNU_IFUNC
)
5855 if (bfd_link_pic (info
))
5857 /* Generate R_X86_64_GLOB_DAT. */
5864 if (!h
->pointer_equality_needed
)
5867 /* For non-shared object, we can't use .got.plt, which
5868 contains the real function addres if we need pointer
5869 equality. We load the GOT entry with the PLT entry. */
5870 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5871 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5872 + plt
->output_offset
5874 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5878 else if (bfd_link_pic (info
)
5879 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5881 if (!h
->def_regular
)
5883 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5884 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5885 rela
.r_addend
= (h
->root
.u
.def
.value
5886 + h
->root
.u
.def
.section
->output_section
->vma
5887 + h
->root
.u
.def
.section
->output_offset
);
5891 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5893 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5894 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5895 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5899 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5904 Elf_Internal_Rela rela
;
5906 /* This symbol needs a copy reloc. Set it up. */
5908 if (h
->dynindx
== -1
5909 || (h
->root
.type
!= bfd_link_hash_defined
5910 && h
->root
.type
!= bfd_link_hash_defweak
)
5911 || htab
->srelbss
== NULL
)
5914 rela
.r_offset
= (h
->root
.u
.def
.value
5915 + h
->root
.u
.def
.section
->output_section
->vma
5916 + h
->root
.u
.def
.section
->output_offset
);
5917 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5919 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5925 /* Finish up local dynamic symbol handling. We set the contents of
5926 various dynamic sections here. */
5929 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5931 struct elf_link_hash_entry
*h
5932 = (struct elf_link_hash_entry
*) *slot
;
5933 struct bfd_link_info
*info
5934 = (struct bfd_link_info
*) inf
;
5936 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5940 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5941 here since undefined weak symbol may not be dynamic and may not be
5942 called for elf_x86_64_finish_dynamic_symbol. */
5945 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5948 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5949 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5951 if (h
->root
.type
!= bfd_link_hash_undefweak
5952 || h
->dynindx
!= -1)
5955 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5959 /* Used to decide how to sort relocs in an optimal manner for the
5960 dynamic linker, before writing them out. */
5962 static enum elf_reloc_type_class
5963 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5964 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5965 const Elf_Internal_Rela
*rela
)
5967 bfd
*abfd
= info
->output_bfd
;
5968 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5969 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5971 if (htab
->elf
.dynsym
!= NULL
5972 && htab
->elf
.dynsym
->contents
!= NULL
)
5974 /* Check relocation against STT_GNU_IFUNC symbol if there are
5976 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5977 Elf_Internal_Sym sym
;
5978 if (!bed
->s
->swap_symbol_in (abfd
,
5979 (htab
->elf
.dynsym
->contents
5980 + r_symndx
* bed
->s
->sizeof_sym
),
5984 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5985 return reloc_class_ifunc
;
5988 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5990 case R_X86_64_RELATIVE
:
5991 case R_X86_64_RELATIVE64
:
5992 return reloc_class_relative
;
5993 case R_X86_64_JUMP_SLOT
:
5994 return reloc_class_plt
;
5996 return reloc_class_copy
;
5998 return reloc_class_normal
;
6002 /* Finish up the dynamic sections. */
6005 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6006 struct bfd_link_info
*info
)
6008 struct elf_x86_64_link_hash_table
*htab
;
6011 const struct elf_x86_64_backend_data
*abed
;
6013 htab
= elf_x86_64_hash_table (info
);
6017 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6018 section only if there is .plt section. */
6019 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6020 ? &elf_x86_64_bnd_arch_bed
6021 : get_elf_x86_64_backend_data (output_bfd
));
6023 dynobj
= htab
->elf
.dynobj
;
6024 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6026 if (htab
->elf
.dynamic_sections_created
)
6028 bfd_byte
*dyncon
, *dynconend
;
6029 const struct elf_backend_data
*bed
;
6030 bfd_size_type sizeof_dyn
;
6032 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6035 bed
= get_elf_backend_data (dynobj
);
6036 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6037 dyncon
= sdyn
->contents
;
6038 dynconend
= sdyn
->contents
+ sdyn
->size
;
6039 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6041 Elf_Internal_Dyn dyn
;
6044 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6052 s
= htab
->elf
.sgotplt
;
6053 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6057 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6061 s
= htab
->elf
.srelplt
->output_section
;
6062 dyn
.d_un
.d_val
= s
->size
;
6066 /* The procedure linkage table relocs (DT_JMPREL) should
6067 not be included in the overall relocs (DT_RELA).
6068 Therefore, we override the DT_RELASZ entry here to
6069 make it not include the JMPREL relocs. Since the
6070 linker script arranges for .rela.plt to follow all
6071 other relocation sections, we don't have to worry
6072 about changing the DT_RELA entry. */
6073 if (htab
->elf
.srelplt
!= NULL
)
6075 s
= htab
->elf
.srelplt
->output_section
;
6076 dyn
.d_un
.d_val
-= s
->size
;
6080 case DT_TLSDESC_PLT
:
6082 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6083 + htab
->tlsdesc_plt
;
6086 case DT_TLSDESC_GOT
:
6088 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6089 + htab
->tlsdesc_got
;
6093 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6096 /* Fill in the special first entry in the procedure linkage table. */
6097 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6099 /* Fill in the first entry in the procedure linkage table. */
6100 memcpy (htab
->elf
.splt
->contents
,
6101 abed
->plt0_entry
, abed
->plt_entry_size
);
6102 /* Add offset for pushq GOT+8(%rip), since the instruction
6103 uses 6 bytes subtract this value. */
6104 bfd_put_32 (output_bfd
,
6105 (htab
->elf
.sgotplt
->output_section
->vma
6106 + htab
->elf
.sgotplt
->output_offset
6108 - htab
->elf
.splt
->output_section
->vma
6109 - htab
->elf
.splt
->output_offset
6111 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6112 /* Add offset for the PC-relative instruction accessing GOT+16,
6113 subtracting the offset to the end of that instruction. */
6114 bfd_put_32 (output_bfd
,
6115 (htab
->elf
.sgotplt
->output_section
->vma
6116 + htab
->elf
.sgotplt
->output_offset
6118 - htab
->elf
.splt
->output_section
->vma
6119 - htab
->elf
.splt
->output_offset
6120 - abed
->plt0_got2_insn_end
),
6121 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6123 elf_section_data (htab
->elf
.splt
->output_section
)
6124 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6126 if (htab
->tlsdesc_plt
)
6128 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6129 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6131 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6132 abed
->plt0_entry
, abed
->plt_entry_size
);
6134 /* Add offset for pushq GOT+8(%rip), since the
6135 instruction uses 6 bytes subtract this value. */
6136 bfd_put_32 (output_bfd
,
6137 (htab
->elf
.sgotplt
->output_section
->vma
6138 + htab
->elf
.sgotplt
->output_offset
6140 - htab
->elf
.splt
->output_section
->vma
6141 - htab
->elf
.splt
->output_offset
6144 htab
->elf
.splt
->contents
6145 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6146 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6147 where TGD stands for htab->tlsdesc_got, subtracting the offset
6148 to the end of that instruction. */
6149 bfd_put_32 (output_bfd
,
6150 (htab
->elf
.sgot
->output_section
->vma
6151 + htab
->elf
.sgot
->output_offset
6153 - htab
->elf
.splt
->output_section
->vma
6154 - htab
->elf
.splt
->output_offset
6156 - abed
->plt0_got2_insn_end
),
6157 htab
->elf
.splt
->contents
6158 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6163 if (htab
->plt_bnd
!= NULL
)
6164 elf_section_data (htab
->plt_bnd
->output_section
)
6165 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6167 if (htab
->elf
.sgotplt
)
6169 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6171 (*_bfd_error_handler
)
6172 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6176 /* Fill in the first three entries in the global offset table. */
6177 if (htab
->elf
.sgotplt
->size
> 0)
6179 /* Set the first entry in the global offset table to the address of
6180 the dynamic section. */
6182 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6184 bfd_put_64 (output_bfd
,
6185 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6186 htab
->elf
.sgotplt
->contents
);
6187 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6188 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6189 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6192 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6196 /* Adjust .eh_frame for .plt section. */
6197 if (htab
->plt_eh_frame
!= NULL
6198 && htab
->plt_eh_frame
->contents
!= NULL
)
6200 if (htab
->elf
.splt
!= NULL
6201 && htab
->elf
.splt
->size
!= 0
6202 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6203 && htab
->elf
.splt
->output_section
!= NULL
6204 && htab
->plt_eh_frame
->output_section
!= NULL
)
6206 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6207 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6208 + htab
->plt_eh_frame
->output_offset
6209 + PLT_FDE_START_OFFSET
;
6210 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6211 htab
->plt_eh_frame
->contents
6212 + PLT_FDE_START_OFFSET
);
6214 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6216 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6218 htab
->plt_eh_frame
->contents
))
6223 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6224 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6227 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6228 htab_traverse (htab
->loc_hash_table
,
6229 elf_x86_64_finish_local_dynamic_symbol
,
6232 /* Fill PLT entries for undefined weak symbols in PIE. */
6233 if (bfd_link_pie (info
))
6234 bfd_hash_traverse (&info
->hash
->table
,
6235 elf_x86_64_pie_finish_undefweak_symbol
,
6241 /* Return an array of PLT entry symbol values. */
6244 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6247 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6250 bfd_vma
*plt_sym_val
;
6252 bfd_byte
*plt_contents
;
6253 const struct elf_x86_64_backend_data
*bed
;
6254 Elf_Internal_Shdr
*hdr
;
6257 /* Get the .plt section contents. PLT passed down may point to the
6258 .plt.bnd section. Make sure that PLT always points to the .plt
6260 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6265 plt
= bfd_get_section_by_name (abfd
, ".plt");
6268 bed
= &elf_x86_64_bnd_arch_bed
;
6271 bed
= get_elf_x86_64_backend_data (abfd
);
6273 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6274 if (plt_contents
== NULL
)
6276 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6277 plt_contents
, 0, plt
->size
))
6280 free (plt_contents
);
6284 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6285 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6288 hdr
= &elf_section_data (relplt
)->this_hdr
;
6289 count
= relplt
->size
/ hdr
->sh_entsize
;
6291 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6292 if (plt_sym_val
== NULL
)
6295 for (i
= 0; i
< count
; i
++)
6296 plt_sym_val
[i
] = -1;
6298 plt_offset
= bed
->plt_entry_size
;
6299 p
= relplt
->relocation
;
6300 for (i
= 0; i
< count
; i
++, p
++)
6304 /* Skip unknown relocation. */
6305 if (p
->howto
== NULL
)
6308 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6309 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6312 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6313 + bed
->plt_reloc_offset
));
6314 if (reloc_index
< count
)
6318 /* This is the index in .plt section. */
6319 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6320 /* Store VMA + the offset in .plt.bnd section. */
6321 plt_sym_val
[reloc_index
] =
6323 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6326 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6328 plt_offset
+= bed
->plt_entry_size
;
6330 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6332 if (plt_offset
>= plt
->size
)
6336 free (plt_contents
);
6341 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6345 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6352 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6353 as PLT if it exists. */
6354 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6356 plt
= bfd_get_section_by_name (abfd
, ".plt");
6357 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6358 dynsymcount
, dynsyms
, ret
,
6360 elf_x86_64_get_plt_sym_val
);
6363 /* Handle an x86-64 specific section when reading an object file. This
6364 is called when elfcode.h finds a section with an unknown type. */
6367 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6368 const char *name
, int shindex
)
6370 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6373 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6379 /* Hook called by the linker routine which adds symbols from an object
6380 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6384 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6385 struct bfd_link_info
*info
,
6386 Elf_Internal_Sym
*sym
,
6387 const char **namep ATTRIBUTE_UNUSED
,
6388 flagword
*flagsp ATTRIBUTE_UNUSED
,
6394 switch (sym
->st_shndx
)
6396 case SHN_X86_64_LCOMMON
:
6397 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6400 lcomm
= bfd_make_section_with_flags (abfd
,
6404 | SEC_LINKER_CREATED
));
6407 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6410 *valp
= sym
->st_size
;
6414 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6415 && (abfd
->flags
& DYNAMIC
) == 0
6416 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6417 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6418 |= elf_gnu_symbol_unique
;
6424 /* Given a BFD section, try to locate the corresponding ELF section
6428 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6429 asection
*sec
, int *index_return
)
6431 if (sec
== &_bfd_elf_large_com_section
)
6433 *index_return
= SHN_X86_64_LCOMMON
;
6439 /* Process a symbol. */
6442 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6445 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6447 switch (elfsym
->internal_elf_sym
.st_shndx
)
6449 case SHN_X86_64_LCOMMON
:
6450 asym
->section
= &_bfd_elf_large_com_section
;
6451 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6452 /* Common symbol doesn't set BSF_GLOBAL. */
6453 asym
->flags
&= ~BSF_GLOBAL
;
6459 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6461 return (sym
->st_shndx
== SHN_COMMON
6462 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6466 elf_x86_64_common_section_index (asection
*sec
)
6468 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6471 return SHN_X86_64_LCOMMON
;
6475 elf_x86_64_common_section (asection
*sec
)
6477 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6478 return bfd_com_section_ptr
;
6480 return &_bfd_elf_large_com_section
;
6484 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6485 const Elf_Internal_Sym
*sym
,
6490 const asection
*oldsec
)
6492 /* A normal common symbol and a large common symbol result in a
6493 normal common symbol. We turn the large common symbol into a
6496 && h
->root
.type
== bfd_link_hash_common
6498 && bfd_is_com_section (*psec
)
6501 if (sym
->st_shndx
== SHN_COMMON
6502 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6504 h
->root
.u
.c
.p
->section
6505 = bfd_make_section_old_way (oldbfd
, "COMMON");
6506 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6508 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6509 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6510 *psec
= bfd_com_section_ptr
;
6517 elf_x86_64_additional_program_headers (bfd
*abfd
,
6518 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6523 /* Check to see if we need a large readonly segment. */
6524 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6525 if (s
&& (s
->flags
& SEC_LOAD
))
6528 /* Check to see if we need a large data segment. Since .lbss sections
6529 is placed right after the .bss section, there should be no need for
6530 a large data segment just because of .lbss. */
6531 s
= bfd_get_section_by_name (abfd
, ".ldata");
6532 if (s
&& (s
->flags
& SEC_LOAD
))
6538 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6541 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6543 if (h
->plt
.offset
!= (bfd_vma
) -1
6545 && !h
->pointer_equality_needed
)
6548 return _bfd_elf_hash_symbol (h
);
6551 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6554 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6555 const bfd_target
*output
)
6557 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6558 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6559 && _bfd_elf_relocs_compatible (input
, output
));
6562 static const struct bfd_elf_special_section
6563 elf_x86_64_special_sections
[]=
6565 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6566 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6567 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6568 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6569 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6570 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6571 { NULL
, 0, 0, 0, 0 }
6574 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6575 #define TARGET_LITTLE_NAME "elf64-x86-64"
6576 #define ELF_ARCH bfd_arch_i386
6577 #define ELF_TARGET_ID X86_64_ELF_DATA
6578 #define ELF_MACHINE_CODE EM_X86_64
6579 #define ELF_MAXPAGESIZE 0x200000
6580 #define ELF_MINPAGESIZE 0x1000
6581 #define ELF_COMMONPAGESIZE 0x1000
6583 #define elf_backend_can_gc_sections 1
6584 #define elf_backend_can_refcount 1
6585 #define elf_backend_want_got_plt 1
6586 #define elf_backend_plt_readonly 1
6587 #define elf_backend_want_plt_sym 0
6588 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6589 #define elf_backend_rela_normal 1
6590 #define elf_backend_plt_alignment 4
6591 #define elf_backend_extern_protected_data 1
6593 #define elf_info_to_howto elf_x86_64_info_to_howto
6595 #define bfd_elf64_bfd_link_hash_table_create \
6596 elf_x86_64_link_hash_table_create
6597 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6598 #define bfd_elf64_bfd_reloc_name_lookup \
6599 elf_x86_64_reloc_name_lookup
6601 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6602 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6603 #define elf_backend_check_relocs elf_x86_64_check_relocs
6604 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6605 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6606 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6607 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6608 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6609 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6610 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6611 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6613 #define elf_backend_write_core_note elf_x86_64_write_core_note
6615 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6616 #define elf_backend_relocate_section elf_x86_64_relocate_section
6617 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6618 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6619 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6620 #define elf_backend_object_p elf64_x86_64_elf_object_p
6621 #define bfd_elf64_mkobject elf_x86_64_mkobject
6622 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6624 #define elf_backend_section_from_shdr \
6625 elf_x86_64_section_from_shdr
6627 #define elf_backend_section_from_bfd_section \
6628 elf_x86_64_elf_section_from_bfd_section
6629 #define elf_backend_add_symbol_hook \
6630 elf_x86_64_add_symbol_hook
6631 #define elf_backend_symbol_processing \
6632 elf_x86_64_symbol_processing
6633 #define elf_backend_common_section_index \
6634 elf_x86_64_common_section_index
6635 #define elf_backend_common_section \
6636 elf_x86_64_common_section
6637 #define elf_backend_common_definition \
6638 elf_x86_64_common_definition
6639 #define elf_backend_merge_symbol \
6640 elf_x86_64_merge_symbol
6641 #define elf_backend_special_sections \
6642 elf_x86_64_special_sections
6643 #define elf_backend_additional_program_headers \
6644 elf_x86_64_additional_program_headers
6645 #define elf_backend_hash_symbol \
6646 elf_x86_64_hash_symbol
6647 #define elf_backend_omit_section_dynsym \
6648 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6649 #define elf_backend_fixup_symbol \
6650 elf_x86_64_fixup_symbol
6652 #include "elf64-target.h"
6654 /* CloudABI support. */
6656 #undef TARGET_LITTLE_SYM
6657 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6658 #undef TARGET_LITTLE_NAME
6659 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6662 #define ELF_OSABI ELFOSABI_CLOUDABI
6665 #define elf64_bed elf64_x86_64_cloudabi_bed
6667 #include "elf64-target.h"
6669 /* FreeBSD support. */
6671 #undef TARGET_LITTLE_SYM
6672 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6673 #undef TARGET_LITTLE_NAME
6674 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6677 #define ELF_OSABI ELFOSABI_FREEBSD
6680 #define elf64_bed elf64_x86_64_fbsd_bed
6682 #include "elf64-target.h"
6684 /* Solaris 2 support. */
6686 #undef TARGET_LITTLE_SYM
6687 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6688 #undef TARGET_LITTLE_NAME
6689 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6691 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6692 objects won't be recognized. */
6696 #define elf64_bed elf64_x86_64_sol2_bed
6698 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6700 #undef elf_backend_static_tls_alignment
6701 #define elf_backend_static_tls_alignment 16
6703 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6705 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6707 #undef elf_backend_want_plt_sym
6708 #define elf_backend_want_plt_sym 1
6710 #include "elf64-target.h"
6712 /* Native Client support. */
6715 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6717 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6718 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6722 #undef TARGET_LITTLE_SYM
6723 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6724 #undef TARGET_LITTLE_NAME
6725 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6727 #define elf64_bed elf64_x86_64_nacl_bed
6729 #undef ELF_MAXPAGESIZE
6730 #undef ELF_MINPAGESIZE
6731 #undef ELF_COMMONPAGESIZE
6732 #define ELF_MAXPAGESIZE 0x10000
6733 #define ELF_MINPAGESIZE 0x10000
6734 #define ELF_COMMONPAGESIZE 0x10000
6736 /* Restore defaults. */
6738 #undef elf_backend_static_tls_alignment
6739 #undef elf_backend_want_plt_sym
6740 #define elf_backend_want_plt_sym 0
6742 /* NaCl uses substantially different PLT entries for the same effects. */
6744 #undef elf_backend_plt_alignment
6745 #define elf_backend_plt_alignment 5
6746 #define NACL_PLT_ENTRY_SIZE 64
6747 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6749 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6751 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6752 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6753 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6754 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6755 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6757 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6758 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6760 /* 32 bytes of nop to pad out to the standard size. */
6761 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6762 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6763 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6764 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6765 0x66, /* excess data32 prefix */
6769 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6771 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6772 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6773 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6774 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6776 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6777 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6778 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6780 /* Lazy GOT entries point here (32-byte aligned). */
6781 0x68, /* pushq immediate */
6782 0, 0, 0, 0, /* replaced with index into relocation table. */
6783 0xe9, /* jmp relative */
6784 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6786 /* 22 bytes of nop to pad out to the standard size. */
6787 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6788 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6789 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6792 /* .eh_frame covering the .plt section. */
6794 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6796 #if (PLT_CIE_LENGTH != 20 \
6797 || PLT_FDE_LENGTH != 36 \
6798 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6799 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6800 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6802 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6803 0, 0, 0, 0, /* CIE ID */
6804 1, /* CIE version */
6805 'z', 'R', 0, /* Augmentation string */
6806 1, /* Code alignment factor */
6807 0x78, /* Data alignment factor */
6808 16, /* Return address column */
6809 1, /* Augmentation size */
6810 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6811 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6812 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6813 DW_CFA_nop
, DW_CFA_nop
,
6815 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6816 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6817 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6818 0, 0, 0, 0, /* .plt size goes here */
6819 0, /* Augmentation size */
6820 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6821 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6822 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6823 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6824 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6825 13, /* Block length */
6826 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6827 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6828 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6829 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6830 DW_CFA_nop
, DW_CFA_nop
6833 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6835 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6836 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6837 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6838 2, /* plt0_got1_offset */
6839 9, /* plt0_got2_offset */
6840 13, /* plt0_got2_insn_end */
6841 3, /* plt_got_offset */
6842 33, /* plt_reloc_offset */
6843 38, /* plt_plt_offset */
6844 7, /* plt_got_insn_size */
6845 42, /* plt_plt_insn_end */
6846 32, /* plt_lazy_offset */
6847 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6848 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6851 #undef elf_backend_arch_data
6852 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6854 #undef elf_backend_object_p
6855 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6856 #undef elf_backend_modify_segment_map
6857 #define elf_backend_modify_segment_map nacl_modify_segment_map
6858 #undef elf_backend_modify_program_headers
6859 #define elf_backend_modify_program_headers nacl_modify_program_headers
6860 #undef elf_backend_final_write_processing
6861 #define elf_backend_final_write_processing nacl_final_write_processing
6863 #include "elf64-target.h"
6865 /* Native Client x32 support. */
6868 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6870 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6871 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6875 #undef TARGET_LITTLE_SYM
6876 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6877 #undef TARGET_LITTLE_NAME
6878 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6880 #define elf32_bed elf32_x86_64_nacl_bed
6882 #define bfd_elf32_bfd_link_hash_table_create \
6883 elf_x86_64_link_hash_table_create
6884 #define bfd_elf32_bfd_reloc_type_lookup \
6885 elf_x86_64_reloc_type_lookup
6886 #define bfd_elf32_bfd_reloc_name_lookup \
6887 elf_x86_64_reloc_name_lookup
6888 #define bfd_elf32_mkobject \
6890 #define bfd_elf32_get_synthetic_symtab \
6891 elf_x86_64_get_synthetic_symtab
6893 #undef elf_backend_object_p
6894 #define elf_backend_object_p \
6895 elf32_x86_64_nacl_elf_object_p
6897 #undef elf_backend_bfd_from_remote_memory
6898 #define elf_backend_bfd_from_remote_memory \
6899 _bfd_elf32_bfd_from_remote_memory
6901 #undef elf_backend_size_info
6902 #define elf_backend_size_info \
6903 _bfd_elf32_size_info
6905 #include "elf32-target.h"
6907 /* Restore defaults. */
6908 #undef elf_backend_object_p
6909 #define elf_backend_object_p elf64_x86_64_elf_object_p
6910 #undef elf_backend_bfd_from_remote_memory
6911 #undef elf_backend_size_info
6912 #undef elf_backend_modify_segment_map
6913 #undef elf_backend_modify_program_headers
6914 #undef elf_backend_final_write_processing
6916 /* Intel L1OM support. */
6919 elf64_l1om_elf_object_p (bfd
*abfd
)
6921 /* Set the right machine number for an L1OM elf64 file. */
6922 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6926 #undef TARGET_LITTLE_SYM
6927 #define TARGET_LITTLE_SYM l1om_elf64_vec
6928 #undef TARGET_LITTLE_NAME
6929 #define TARGET_LITTLE_NAME "elf64-l1om"
6931 #define ELF_ARCH bfd_arch_l1om
6933 #undef ELF_MACHINE_CODE
6934 #define ELF_MACHINE_CODE EM_L1OM
6939 #define elf64_bed elf64_l1om_bed
6941 #undef elf_backend_object_p
6942 #define elf_backend_object_p elf64_l1om_elf_object_p
6944 /* Restore defaults. */
6945 #undef ELF_MAXPAGESIZE
6946 #undef ELF_MINPAGESIZE
6947 #undef ELF_COMMONPAGESIZE
6948 #define ELF_MAXPAGESIZE 0x200000
6949 #define ELF_MINPAGESIZE 0x1000
6950 #define ELF_COMMONPAGESIZE 0x1000
6951 #undef elf_backend_plt_alignment
6952 #define elf_backend_plt_alignment 4
6953 #undef elf_backend_arch_data
6954 #define elf_backend_arch_data &elf_x86_64_arch_bed
6956 #include "elf64-target.h"
6958 /* FreeBSD L1OM support. */
6960 #undef TARGET_LITTLE_SYM
6961 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6962 #undef TARGET_LITTLE_NAME
6963 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6966 #define ELF_OSABI ELFOSABI_FREEBSD
6969 #define elf64_bed elf64_l1om_fbsd_bed
6971 #include "elf64-target.h"
6973 /* Intel K1OM support. */
6976 elf64_k1om_elf_object_p (bfd
*abfd
)
6978 /* Set the right machine number for an K1OM elf64 file. */
6979 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6983 #undef TARGET_LITTLE_SYM
6984 #define TARGET_LITTLE_SYM k1om_elf64_vec
6985 #undef TARGET_LITTLE_NAME
6986 #define TARGET_LITTLE_NAME "elf64-k1om"
6988 #define ELF_ARCH bfd_arch_k1om
6990 #undef ELF_MACHINE_CODE
6991 #define ELF_MACHINE_CODE EM_K1OM
6996 #define elf64_bed elf64_k1om_bed
6998 #undef elf_backend_object_p
6999 #define elf_backend_object_p elf64_k1om_elf_object_p
7001 #undef elf_backend_static_tls_alignment
7003 #undef elf_backend_want_plt_sym
7004 #define elf_backend_want_plt_sym 0
7006 #include "elf64-target.h"
7008 /* FreeBSD K1OM support. */
7010 #undef TARGET_LITTLE_SYM
7011 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7012 #undef TARGET_LITTLE_NAME
7013 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7016 #define ELF_OSABI ELFOSABI_FREEBSD
7019 #define elf64_bed elf64_k1om_fbsd_bed
7021 #include "elf64-target.h"
7023 /* 32bit x86-64 support. */
7025 #undef TARGET_LITTLE_SYM
7026 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7027 #undef TARGET_LITTLE_NAME
7028 #define TARGET_LITTLE_NAME "elf32-x86-64"
7032 #define ELF_ARCH bfd_arch_i386
7034 #undef ELF_MACHINE_CODE
7035 #define ELF_MACHINE_CODE EM_X86_64
7039 #undef elf_backend_object_p
7040 #define elf_backend_object_p \
7041 elf32_x86_64_elf_object_p
7043 #undef elf_backend_bfd_from_remote_memory
7044 #define elf_backend_bfd_from_remote_memory \
7045 _bfd_elf32_bfd_from_remote_memory
7047 #undef elf_backend_size_info
7048 #define elf_backend_size_info \
7049 _bfd_elf32_size_info
7051 #include "elf32-target.h"