1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2017 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 /* xgettext:c-format */
289 _bfd_error_handler (_("%B: invalid relocation type %d"),
291 r_type
= R_X86_64_NONE
;
296 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
297 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
298 return &x86_64_elf_howto_table
[i
];
301 /* Given a BFD reloc type, return a HOWTO structure. */
302 static reloc_howto_type
*
303 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
304 bfd_reloc_code_real_type code
)
308 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
311 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
312 return elf_x86_64_rtype_to_howto (abfd
,
313 x86_64_reloc_map
[i
].elf_reloc_val
);
318 static reloc_howto_type
*
319 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
324 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
326 /* Get x32 R_X86_64_32. */
327 reloc_howto_type
*reloc
328 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
329 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
333 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
334 if (x86_64_elf_howto_table
[i
].name
!= NULL
335 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
336 return &x86_64_elf_howto_table
[i
];
341 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
344 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
345 Elf_Internal_Rela
*dst
)
349 r_type
= ELF32_R_TYPE (dst
->r_info
);
350 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
351 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
354 /* Support for core dump NOTE sections. */
356 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
361 switch (note
->descsz
)
366 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
368 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
371 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
379 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
381 elf_tdata (abfd
)->core
->signal
382 = bfd_get_16 (abfd
, note
->descdata
+ 12);
385 elf_tdata (abfd
)->core
->lwpid
386 = bfd_get_32 (abfd
, note
->descdata
+ 32);
395 /* Make a ".reg/999" section. */
396 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
397 size
, note
->descpos
+ offset
);
401 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
403 switch (note
->descsz
)
408 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
409 elf_tdata (abfd
)->core
->pid
410 = bfd_get_32 (abfd
, note
->descdata
+ 12);
411 elf_tdata (abfd
)->core
->program
412 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
413 elf_tdata (abfd
)->core
->command
414 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
417 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
418 elf_tdata (abfd
)->core
->pid
419 = bfd_get_32 (abfd
, note
->descdata
+ 24);
420 elf_tdata (abfd
)->core
->program
421 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
422 elf_tdata (abfd
)->core
->command
423 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
426 /* Note that for some reason, a spurious space is tacked
427 onto the end of the args in some (at least one anyway)
428 implementations, so strip it off if it exists. */
431 char *command
= elf_tdata (abfd
)->core
->command
;
432 int n
= strlen (command
);
434 if (0 < n
&& command
[n
- 1] == ' ')
435 command
[n
- 1] = '\0';
443 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
446 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
448 const char *fname
, *psargs
;
459 va_start (ap
, note_type
);
460 fname
= va_arg (ap
, const char *);
461 psargs
= va_arg (ap
, const char *);
464 if (bed
->s
->elfclass
== ELFCLASS32
)
467 memset (&data
, 0, sizeof (data
));
468 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
469 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
470 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
471 &data
, sizeof (data
));
476 memset (&data
, 0, sizeof (data
));
477 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
478 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
479 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
480 &data
, sizeof (data
));
485 va_start (ap
, note_type
);
486 pid
= va_arg (ap
, long);
487 cursig
= va_arg (ap
, int);
488 gregs
= va_arg (ap
, const void *);
491 if (bed
->s
->elfclass
== ELFCLASS32
)
493 if (bed
->elf_machine_code
== EM_X86_64
)
495 prstatusx32_t prstat
;
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
506 memset (&prstat
, 0, sizeof (prstat
));
508 prstat
.pr_cursig
= cursig
;
509 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
510 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
511 &prstat
, sizeof (prstat
));
517 memset (&prstat
, 0, sizeof (prstat
));
519 prstat
.pr_cursig
= cursig
;
520 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
521 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
522 &prstat
, sizeof (prstat
));
529 /* Functions for the x86-64 ELF linker. */
531 /* The name of the dynamic interpreter. This is put in the .interp
534 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
535 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the global offset table. */
545 #define GOT_ENTRY_SIZE 8
547 /* The size in bytes of an entry in the lazy procedure linkage table. */
549 #define LAZY_PLT_ENTRY_SIZE 16
551 /* The size in bytes of an entry in the non-lazy procedure linkage
554 #define NON_LAZY_PLT_ENTRY_SIZE 8
556 /* The first entry in a lazy procedure linkage table looks like this.
557 See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
560 static const bfd_byte elf_x86_64_lazy_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
562 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
563 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
564 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
567 /* Subsequent entries in a lazy procedure linkage table look like this. */
569 static const bfd_byte elf_x86_64_lazy_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
571 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
572 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
573 0x68, /* pushq immediate */
574 0, 0, 0, 0, /* replaced with index into relocation table. */
575 0xe9, /* jmp relative */
576 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
579 /* The first entry in a lazy procedure linkage table with BND prefix
582 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
584 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
585 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
586 0x0f, 0x1f, 0 /* nopl (%rax) */
589 /* Subsequent entries for branches with BND prefx in a lazy procedure
590 linkage table look like this. */
592 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
594 0x68, 0, 0, 0, 0, /* pushq immediate */
595 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
596 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
599 /* Entries in the non-lazey procedure linkage table look like this. */
601 static const bfd_byte elf_x86_64_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
603 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
604 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
605 0x66, 0x90 /* xchg %ax,%ax */
608 /* Entries for branches with BND prefix in the non-lazey procedure
609 linkage table look like this. */
611 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
613 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
614 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
618 /* .eh_frame covering the lazy .plt section. */
620 static const bfd_byte elf_x86_64_eh_frame_lazy_plt
[] =
622 #define PLT_CIE_LENGTH 20
623 #define PLT_FDE_LENGTH 36
624 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
625 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
626 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
627 0, 0, 0, 0, /* CIE ID */
629 'z', 'R', 0, /* Augmentation string */
630 1, /* Code alignment factor */
631 0x78, /* Data alignment factor */
632 16, /* Return address column */
633 1, /* Augmentation size */
634 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
635 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
636 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
637 DW_CFA_nop
, DW_CFA_nop
,
639 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
640 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
641 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
642 0, 0, 0, 0, /* .plt size goes here */
643 0, /* Augmentation size */
644 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
645 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
646 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
647 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
648 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
649 11, /* Block length */
650 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
651 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
652 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
653 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
654 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
657 /* .eh_frame covering the lazy BND .plt section. */
659 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt
[] =
661 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
662 0, 0, 0, 0, /* CIE ID */
664 'z', 'R', 0, /* Augmentation string */
665 1, /* Code alignment factor */
666 0x78, /* Data alignment factor */
667 16, /* Return address column */
668 1, /* Augmentation size */
669 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
670 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
671 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
672 DW_CFA_nop
, DW_CFA_nop
,
674 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
675 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
676 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
677 0, 0, 0, 0, /* .plt size goes here */
678 0, /* Augmentation size */
679 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
680 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
681 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
682 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
683 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
684 11, /* Block length */
685 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
686 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
687 DW_OP_lit15
, DW_OP_and
, DW_OP_lit5
, DW_OP_ge
,
688 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
689 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
692 /* .eh_frame covering the non-lazy .plt section. */
694 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt
[] =
696 #define PLT_GOT_FDE_LENGTH 20
697 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
698 0, 0, 0, 0, /* CIE ID */
700 'z', 'R', 0, /* Augmentation string */
701 1, /* Code alignment factor */
702 0x78, /* Data alignment factor */
703 16, /* Return address column */
704 1, /* Augmentation size */
705 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
706 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
707 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
708 DW_CFA_nop
, DW_CFA_nop
,
710 PLT_GOT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
711 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
712 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
713 0, 0, 0, 0, /* non-lazy .plt size goes here */
714 0, /* Augmentation size */
715 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
,
716 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
719 struct elf_x86_64_lazy_plt_layout
721 /* Templates for the initial PLT entry and for subsequent entries. */
722 const bfd_byte
*plt0_entry
;
723 const bfd_byte
*plt_entry
;
724 unsigned int plt_entry_size
; /* Size of each PLT entry. */
726 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
727 unsigned int plt0_got1_offset
;
728 unsigned int plt0_got2_offset
;
730 /* Offset of the end of the PC-relative instruction containing
732 unsigned int plt0_got2_insn_end
;
734 /* Offsets into plt_entry that are to be replaced with... */
735 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
736 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
737 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
739 /* Length of the PC-relative instruction containing plt_got_offset. */
740 unsigned int plt_got_insn_size
;
742 /* Offset of the end of the PC-relative jump to plt0_entry. */
743 unsigned int plt_plt_insn_end
;
745 /* Offset into plt_entry where the initial value of the GOT entry points. */
746 unsigned int plt_lazy_offset
;
748 /* .eh_frame covering the lazy .plt section. */
749 const bfd_byte
*eh_frame_plt
;
750 unsigned int eh_frame_plt_size
;
753 struct elf_x86_64_non_lazy_plt_layout
755 /* Template for the lazy PLT entries. */
756 const bfd_byte
*plt_entry
;
757 unsigned int plt_entry_size
; /* Size of each PLT entry. */
759 /* Offsets into plt_entry that are to be replaced with... */
760 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
762 /* Length of the PC-relative instruction containing plt_got_offset. */
763 unsigned int plt_got_insn_size
;
765 /* .eh_frame covering the non-lazy .plt section. */
766 const bfd_byte
*eh_frame_plt
;
767 unsigned int eh_frame_plt_size
;
770 struct elf_x86_64_plt_layout
772 /* Template for the PLT entries. */
773 const bfd_byte
*plt_entry
;
774 unsigned int plt_entry_size
; /* Size of each PLT entry. */
777 unsigned int has_plt0
;
779 /* Offsets into plt_entry that are to be replaced with... */
780 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
782 /* Length of the PC-relative instruction containing plt_got_offset. */
783 unsigned int plt_got_insn_size
;
785 /* .eh_frame covering the .plt section. */
786 const bfd_byte
*eh_frame_plt
;
787 unsigned int eh_frame_plt_size
;
790 /* Architecture-specific backend data for x86-64. */
792 struct elf_x86_64_backend_data
802 #define get_elf_x86_64_arch_data(bed) \
803 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
805 #define get_elf_x86_64_backend_data(abfd) \
806 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
808 /* These are the standard parameters. */
809 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_plt
=
811 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
812 elf_x86_64_lazy_plt_entry
, /* plt_entry */
813 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
814 2, /* plt0_got1_offset */
815 8, /* plt0_got2_offset */
816 12, /* plt0_got2_insn_end */
817 2, /* plt_got_offset */
818 7, /* plt_reloc_offset */
819 12, /* plt_plt_offset */
820 6, /* plt_got_insn_size */
821 LAZY_PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
822 6, /* plt_lazy_offset */
823 elf_x86_64_eh_frame_lazy_plt
, /* eh_frame_plt */
824 sizeof (elf_x86_64_eh_frame_lazy_plt
) /* eh_frame_plt_size */
827 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_plt
=
829 elf_x86_64_non_lazy_plt_entry
, /* plt_entry */
830 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
831 2, /* plt_got_offset */
832 6, /* plt_got_insn_size */
833 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
834 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
837 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_bnd_plt
=
839 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
840 elf_x86_64_lazy_bnd_plt_entry
, /* plt_entry */
841 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
842 2, /* plt0_got1_offset */
843 1+8, /* plt0_got2_offset */
844 1+12, /* plt0_got2_insn_end */
845 1+2, /* plt_got_offset */
846 1, /* plt_reloc_offset */
847 7, /* plt_plt_offset */
848 1+6, /* plt_got_insn_size */
849 11, /* plt_plt_insn_end */
850 0, /* plt_lazy_offset */
851 elf_x86_64_eh_frame_lazy_bnd_plt
, /* eh_frame_plt */
852 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt
) /* eh_frame_plt_size */
855 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt
=
857 elf_x86_64_non_lazy_bnd_plt_entry
, /* plt_entry */
858 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
859 1+2, /* plt_got_offset */
860 1+6, /* plt_got_insn_size */
861 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
862 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
865 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
870 #define elf_backend_arch_data &elf_x86_64_arch_bed
872 /* Is a undefined weak symbol which is resolved to 0. Reference to an
873 undefined weak symbol is resolved to 0 when building executable if
875 1. Has non-GOT/non-PLT relocations in text section. Or
876 2. Has no GOT/PLT relocation.
878 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
879 ((EH)->elf.root.type == bfd_link_hash_undefweak \
880 && bfd_link_executable (INFO) \
881 && (elf_x86_64_hash_table (INFO)->interp == NULL \
883 || (EH)->has_non_got_reloc \
884 || !(INFO)->dynamic_undefined_weak))
886 /* x86-64 ELF linker hash entry. */
888 struct elf_x86_64_link_hash_entry
890 struct elf_link_hash_entry elf
;
892 /* Track dynamic relocs copied for this symbol. */
893 struct elf_dyn_relocs
*dyn_relocs
;
895 #define GOT_UNKNOWN 0
899 #define GOT_TLS_GDESC 4
900 #define GOT_TLS_GD_BOTH_P(type) \
901 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
902 #define GOT_TLS_GD_P(type) \
903 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
904 #define GOT_TLS_GDESC_P(type) \
905 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
906 #define GOT_TLS_GD_ANY_P(type) \
907 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
908 unsigned char tls_type
;
910 /* TRUE if a weak symbol with a real definition needs a copy reloc.
911 When there is a weak symbol with a real definition, the processor
912 independent code will have arranged for us to see the real
913 definition first. We need to copy the needs_copy bit from the
914 real definition and check it when allowing copy reloc in PIE. */
915 unsigned int needs_copy
: 1;
917 /* TRUE if symbol has GOT or PLT relocations. */
918 unsigned int has_got_reloc
: 1;
920 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
921 unsigned int has_non_got_reloc
: 1;
923 /* Don't call finish_dynamic_symbol on this symbol. */
924 unsigned int no_finish_dynamic_symbol
: 1;
926 /* 0: symbol isn't __tls_get_addr.
927 1: symbol is __tls_get_addr.
928 2: symbol is unknown. */
929 unsigned int tls_get_addr
: 2;
931 /* Reference count of C/C++ function pointer relocations in read-write
932 section which can be resolved at run-time. */
933 bfd_signed_vma func_pointer_refcount
;
935 /* Information about the GOT PLT entry. Filled when there are both
936 GOT and PLT relocations against the same function. */
937 union gotplt_union plt_got
;
939 /* Information about the second PLT entry. */
940 union gotplt_union plt_second
;
942 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
943 starting at the end of the jump table. */
947 #define elf_x86_64_hash_entry(ent) \
948 ((struct elf_x86_64_link_hash_entry *)(ent))
950 struct elf_x86_64_obj_tdata
952 struct elf_obj_tdata root
;
954 /* tls_type for each local got entry. */
955 char *local_got_tls_type
;
957 /* GOTPLT entries for TLS descriptors. */
958 bfd_vma
*local_tlsdesc_gotent
;
961 #define elf_x86_64_tdata(abfd) \
962 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
964 #define elf_x86_64_local_got_tls_type(abfd) \
965 (elf_x86_64_tdata (abfd)->local_got_tls_type)
967 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
968 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
970 #define is_x86_64_elf(bfd) \
971 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
972 && elf_tdata (bfd) != NULL \
973 && elf_object_id (bfd) == X86_64_ELF_DATA)
976 elf_x86_64_mkobject (bfd
*abfd
)
978 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
982 /* x86-64 ELF linker hash table. */
984 struct elf_x86_64_link_hash_table
986 struct elf_link_hash_table elf
;
988 /* Short-cuts to get to dynamic linker sections. */
990 asection
*plt_eh_frame
;
991 asection
*plt_second
;
992 asection
*plt_second_eh_frame
;
994 asection
*plt_got_eh_frame
;
996 /* Parameters describing PLT generation, lazy or non-lazy. */
997 struct elf_x86_64_plt_layout plt
;
999 /* Parameters describing lazy PLT generation. */
1000 const struct elf_x86_64_lazy_plt_layout
*lazy_plt
;
1002 /* Parameters describing non-lazy PLT generation. */
1003 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_plt
;
1007 bfd_signed_vma refcount
;
1011 /* The amount of space used by the jump slots in the GOT. */
1012 bfd_vma sgotplt_jump_table_size
;
1014 /* Small local sym cache. */
1015 struct sym_cache sym_cache
;
1017 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
1018 bfd_vma (*r_sym
) (bfd_vma
);
1019 unsigned int pointer_r_type
;
1020 const char *dynamic_interpreter
;
1021 int dynamic_interpreter_size
;
1023 /* _TLS_MODULE_BASE_ symbol. */
1024 struct bfd_link_hash_entry
*tls_module_base
;
1026 /* Used by local STT_GNU_IFUNC symbols. */
1027 htab_t loc_hash_table
;
1028 void * loc_hash_memory
;
1030 /* The offset into splt of the PLT entry for the TLS descriptor
1031 resolver. Special values are 0, if not necessary (or not found
1032 to be necessary yet), and -1 if needed but not determined
1034 bfd_vma tlsdesc_plt
;
1035 /* The offset into sgot of the GOT entry used by the PLT entry
1037 bfd_vma tlsdesc_got
;
1039 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
1040 bfd_vma next_jump_slot_index
;
1041 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
1042 bfd_vma next_irelative_index
;
1044 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
1045 to read-only sections. */
1046 bfd_boolean readonly_dynrelocs_against_ifunc
;
1049 /* Get the x86-64 ELF linker hash table from a link_info structure. */
1051 #define elf_x86_64_hash_table(p) \
1052 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1053 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
1055 #define elf_x86_64_compute_jump_table_size(htab) \
1056 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
1058 /* Create an entry in an x86-64 ELF linker hash table. */
1060 static struct bfd_hash_entry
*
1061 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1062 struct bfd_hash_table
*table
,
1065 /* Allocate the structure if it has not already been allocated by a
1069 entry
= (struct bfd_hash_entry
*)
1070 bfd_hash_allocate (table
,
1071 sizeof (struct elf_x86_64_link_hash_entry
));
1076 /* Call the allocation method of the superclass. */
1077 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
1080 struct elf_x86_64_link_hash_entry
*eh
;
1082 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
1083 eh
->dyn_relocs
= NULL
;
1084 eh
->tls_type
= GOT_UNKNOWN
;
1086 eh
->has_got_reloc
= 0;
1087 eh
->has_non_got_reloc
= 0;
1088 eh
->no_finish_dynamic_symbol
= 0;
1089 eh
->tls_get_addr
= 2;
1090 eh
->func_pointer_refcount
= 0;
1091 eh
->plt_second
.offset
= (bfd_vma
) -1;
1092 eh
->plt_got
.offset
= (bfd_vma
) -1;
1093 eh
->tlsdesc_got
= (bfd_vma
) -1;
1099 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
1100 for local symbol so that we can handle local STT_GNU_IFUNC symbols
1101 as global symbol. We reuse indx and dynstr_index for local symbol
1102 hash since they aren't used by global symbols in this backend. */
1105 elf_x86_64_local_htab_hash (const void *ptr
)
1107 struct elf_link_hash_entry
*h
1108 = (struct elf_link_hash_entry
*) ptr
;
1109 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
1112 /* Compare local hash entries. */
1115 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1117 struct elf_link_hash_entry
*h1
1118 = (struct elf_link_hash_entry
*) ptr1
;
1119 struct elf_link_hash_entry
*h2
1120 = (struct elf_link_hash_entry
*) ptr2
;
1122 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
1125 /* Find and/or create a hash entry for local symbol. */
1127 static struct elf_link_hash_entry
*
1128 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
1129 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1132 struct elf_x86_64_link_hash_entry e
, *ret
;
1133 asection
*sec
= abfd
->sections
;
1134 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1135 htab
->r_sym (rel
->r_info
));
1138 e
.elf
.indx
= sec
->id
;
1139 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1140 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1141 create
? INSERT
: NO_INSERT
);
1148 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1152 ret
= (struct elf_x86_64_link_hash_entry
*)
1153 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1154 sizeof (struct elf_x86_64_link_hash_entry
));
1157 memset (ret
, 0, sizeof (*ret
));
1158 ret
->elf
.indx
= sec
->id
;
1159 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1160 ret
->elf
.dynindx
= -1;
1161 ret
->func_pointer_refcount
= 0;
1162 ret
->plt_got
.offset
= (bfd_vma
) -1;
1168 /* Destroy an X86-64 ELF linker hash table. */
1171 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1173 struct elf_x86_64_link_hash_table
*htab
1174 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1176 if (htab
->loc_hash_table
)
1177 htab_delete (htab
->loc_hash_table
);
1178 if (htab
->loc_hash_memory
)
1179 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1180 _bfd_elf_link_hash_table_free (obfd
);
1183 /* Create an X86-64 ELF linker hash table. */
1185 static struct bfd_link_hash_table
*
1186 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1188 struct elf_x86_64_link_hash_table
*ret
;
1189 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1191 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1195 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1196 elf_x86_64_link_hash_newfunc
,
1197 sizeof (struct elf_x86_64_link_hash_entry
),
1204 if (ABI_64_P (abfd
))
1206 ret
->r_info
= elf64_r_info
;
1207 ret
->r_sym
= elf64_r_sym
;
1208 ret
->pointer_r_type
= R_X86_64_64
;
1209 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1210 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1214 ret
->r_info
= elf32_r_info
;
1215 ret
->r_sym
= elf32_r_sym
;
1216 ret
->pointer_r_type
= R_X86_64_32
;
1217 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1218 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1221 ret
->loc_hash_table
= htab_try_create (1024,
1222 elf_x86_64_local_htab_hash
,
1223 elf_x86_64_local_htab_eq
,
1225 ret
->loc_hash_memory
= objalloc_create ();
1226 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1228 elf_x86_64_link_hash_table_free (abfd
);
1231 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1233 return &ret
->elf
.root
;
1236 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1239 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1240 struct elf_link_hash_entry
*dir
,
1241 struct elf_link_hash_entry
*ind
)
1243 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1245 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1246 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1248 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1249 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1251 if (eind
->dyn_relocs
!= NULL
)
1253 if (edir
->dyn_relocs
!= NULL
)
1255 struct elf_dyn_relocs
**pp
;
1256 struct elf_dyn_relocs
*p
;
1258 /* Add reloc counts against the indirect sym to the direct sym
1259 list. Merge any entries against the same section. */
1260 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1262 struct elf_dyn_relocs
*q
;
1264 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1265 if (q
->sec
== p
->sec
)
1267 q
->pc_count
+= p
->pc_count
;
1268 q
->count
+= p
->count
;
1275 *pp
= edir
->dyn_relocs
;
1278 edir
->dyn_relocs
= eind
->dyn_relocs
;
1279 eind
->dyn_relocs
= NULL
;
1282 if (ind
->root
.type
== bfd_link_hash_indirect
1283 && dir
->got
.refcount
<= 0)
1285 edir
->tls_type
= eind
->tls_type
;
1286 eind
->tls_type
= GOT_UNKNOWN
;
1289 if (ELIMINATE_COPY_RELOCS
1290 && ind
->root
.type
!= bfd_link_hash_indirect
1291 && dir
->dynamic_adjusted
)
1293 /* If called to transfer flags for a weakdef during processing
1294 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1295 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1296 if (dir
->versioned
!= versioned_hidden
)
1297 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1298 dir
->ref_regular
|= ind
->ref_regular
;
1299 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1300 dir
->needs_plt
|= ind
->needs_plt
;
1301 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1305 if (eind
->func_pointer_refcount
> 0)
1307 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1308 eind
->func_pointer_refcount
= 0;
1311 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1316 elf64_x86_64_elf_object_p (bfd
*abfd
)
1318 /* Set the right machine number for an x86-64 elf64 file. */
1319 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1324 elf32_x86_64_elf_object_p (bfd
*abfd
)
1326 /* Set the right machine number for an x86-64 elf32 file. */
1327 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1331 /* Return TRUE if the TLS access code sequence support transition
1335 elf_x86_64_check_tls_transition (bfd
*abfd
,
1336 struct bfd_link_info
*info
,
1339 Elf_Internal_Shdr
*symtab_hdr
,
1340 struct elf_link_hash_entry
**sym_hashes
,
1341 unsigned int r_type
,
1342 const Elf_Internal_Rela
*rel
,
1343 const Elf_Internal_Rela
*relend
)
1346 unsigned long r_symndx
;
1347 bfd_boolean largepic
= FALSE
;
1348 struct elf_link_hash_entry
*h
;
1350 struct elf_x86_64_link_hash_table
*htab
;
1352 bfd_boolean indirect_call
, tls_get_addr
;
1354 htab
= elf_x86_64_hash_table (info
);
1355 offset
= rel
->r_offset
;
1358 case R_X86_64_TLSGD
:
1359 case R_X86_64_TLSLD
:
1360 if ((rel
+ 1) >= relend
)
1363 if (r_type
== R_X86_64_TLSGD
)
1365 /* Check transition from GD access model. For 64bit, only
1366 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1367 .word 0x6666; rex64; call __tls_get_addr@PLT
1369 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1371 call *__tls_get_addr@GOTPCREL(%rip)
1372 which may be converted to
1373 addr32 call __tls_get_addr
1374 can transit to different access model. For 32bit, only
1375 leaq foo@tlsgd(%rip), %rdi
1376 .word 0x6666; rex64; call __tls_get_addr@PLT
1378 leaq foo@tlsgd(%rip), %rdi
1380 call *__tls_get_addr@GOTPCREL(%rip)
1381 which may be converted to
1382 addr32 call __tls_get_addr
1383 can transit to different access model. For largepic,
1385 leaq foo@tlsgd(%rip), %rdi
1386 movabsq $__tls_get_addr@pltoff, %rax
1390 leaq foo@tlsgd(%rip), %rdi
1391 movabsq $__tls_get_addr@pltoff, %rax
1395 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1397 if ((offset
+ 12) > sec
->size
)
1400 call
= contents
+ offset
+ 4;
1402 || !((call
[1] == 0x48
1410 && call
[3] == 0xe8)))
1412 if (!ABI_64_P (abfd
)
1413 || (offset
+ 19) > sec
->size
1415 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1416 || memcmp (call
, "\x48\xb8", 2) != 0
1420 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1421 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1425 else if (ABI_64_P (abfd
))
1428 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1434 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1437 indirect_call
= call
[2] == 0xff;
1441 /* Check transition from LD access model. Only
1442 leaq foo@tlsld(%rip), %rdi;
1443 call __tls_get_addr@PLT
1445 leaq foo@tlsld(%rip), %rdi;
1446 call *__tls_get_addr@GOTPCREL(%rip)
1447 which may be converted to
1448 addr32 call __tls_get_addr
1449 can transit to different access model. For largepic
1451 leaq foo@tlsld(%rip), %rdi
1452 movabsq $__tls_get_addr@pltoff, %rax
1456 leaq foo@tlsld(%rip), %rdi
1457 movabsq $__tls_get_addr@pltoff, %rax
1461 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1463 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1466 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1469 call
= contents
+ offset
+ 4;
1470 if (!(call
[0] == 0xe8
1471 || (call
[0] == 0xff && call
[1] == 0x15)
1472 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1474 if (!ABI_64_P (abfd
)
1475 || (offset
+ 19) > sec
->size
1476 || memcmp (call
, "\x48\xb8", 2) != 0
1480 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1481 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1485 indirect_call
= call
[0] == 0xff;
1488 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1489 if (r_symndx
< symtab_hdr
->sh_info
)
1492 tls_get_addr
= FALSE
;
1493 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1494 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1496 struct elf_x86_64_link_hash_entry
*eh
1497 = (struct elf_x86_64_link_hash_entry
*) h
;
1498 tls_get_addr
= eh
->tls_get_addr
== 1;
1499 if (eh
->tls_get_addr
> 1)
1501 /* Use strncmp to check __tls_get_addr since
1502 __tls_get_addr may be versioned. */
1503 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1506 eh
->tls_get_addr
= 1;
1507 tls_get_addr
= TRUE
;
1510 eh
->tls_get_addr
= 0;
1517 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1518 else if (indirect_call
)
1519 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1521 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1522 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1524 case R_X86_64_GOTTPOFF
:
1525 /* Check transition from IE access model:
1526 mov foo@gottpoff(%rip), %reg
1527 add foo@gottpoff(%rip), %reg
1530 /* Check REX prefix first. */
1531 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1533 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1534 if (val
!= 0x48 && val
!= 0x4c)
1536 /* X32 may have 0x44 REX prefix or no REX prefix. */
1537 if (ABI_64_P (abfd
))
1543 /* X32 may not have any REX prefix. */
1544 if (ABI_64_P (abfd
))
1546 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1550 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1551 if (val
!= 0x8b && val
!= 0x03)
1554 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1555 return (val
& 0xc7) == 5;
1557 case R_X86_64_GOTPC32_TLSDESC
:
1558 /* Check transition from GDesc access model:
1559 leaq x@tlsdesc(%rip), %rax
1561 Make sure it's a leaq adding rip to a 32-bit offset
1562 into any register, although it's probably almost always
1565 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1568 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1569 if ((val
& 0xfb) != 0x48)
1572 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1575 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1576 return (val
& 0xc7) == 0x05;
1578 case R_X86_64_TLSDESC_CALL
:
1579 /* Check transition from GDesc access model:
1580 call *x@tlsdesc(%rax)
1582 if (offset
+ 2 <= sec
->size
)
1584 /* Make sure that it's a call *x@tlsdesc(%rax). */
1585 call
= contents
+ offset
;
1586 return call
[0] == 0xff && call
[1] == 0x10;
1596 /* Return TRUE if the TLS access transition is OK or no transition
1597 will be performed. Update R_TYPE if there is a transition. */
1600 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1601 asection
*sec
, bfd_byte
*contents
,
1602 Elf_Internal_Shdr
*symtab_hdr
,
1603 struct elf_link_hash_entry
**sym_hashes
,
1604 unsigned int *r_type
, int tls_type
,
1605 const Elf_Internal_Rela
*rel
,
1606 const Elf_Internal_Rela
*relend
,
1607 struct elf_link_hash_entry
*h
,
1608 unsigned long r_symndx
,
1609 bfd_boolean from_relocate_section
)
1611 unsigned int from_type
= *r_type
;
1612 unsigned int to_type
= from_type
;
1613 bfd_boolean check
= TRUE
;
1615 /* Skip TLS transition for functions. */
1617 && (h
->type
== STT_FUNC
1618 || h
->type
== STT_GNU_IFUNC
))
1623 case R_X86_64_TLSGD
:
1624 case R_X86_64_GOTPC32_TLSDESC
:
1625 case R_X86_64_TLSDESC_CALL
:
1626 case R_X86_64_GOTTPOFF
:
1627 if (bfd_link_executable (info
))
1630 to_type
= R_X86_64_TPOFF32
;
1632 to_type
= R_X86_64_GOTTPOFF
;
1635 /* When we are called from elf_x86_64_relocate_section, there may
1636 be additional transitions based on TLS_TYPE. */
1637 if (from_relocate_section
)
1639 unsigned int new_to_type
= to_type
;
1641 if (bfd_link_executable (info
)
1644 && tls_type
== GOT_TLS_IE
)
1645 new_to_type
= R_X86_64_TPOFF32
;
1647 if (to_type
== R_X86_64_TLSGD
1648 || to_type
== R_X86_64_GOTPC32_TLSDESC
1649 || to_type
== R_X86_64_TLSDESC_CALL
)
1651 if (tls_type
== GOT_TLS_IE
)
1652 new_to_type
= R_X86_64_GOTTPOFF
;
1655 /* We checked the transition before when we were called from
1656 elf_x86_64_check_relocs. We only want to check the new
1657 transition which hasn't been checked before. */
1658 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1659 to_type
= new_to_type
;
1664 case R_X86_64_TLSLD
:
1665 if (bfd_link_executable (info
))
1666 to_type
= R_X86_64_TPOFF32
;
1673 /* Return TRUE if there is no transition. */
1674 if (from_type
== to_type
)
1677 /* Check if the transition can be performed. */
1679 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1680 symtab_hdr
, sym_hashes
,
1681 from_type
, rel
, relend
))
1683 reloc_howto_type
*from
, *to
;
1686 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1687 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1690 name
= h
->root
.root
.string
;
1693 struct elf_x86_64_link_hash_table
*htab
;
1695 htab
= elf_x86_64_hash_table (info
);
1700 Elf_Internal_Sym
*isym
;
1702 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1704 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1709 /* xgettext:c-format */
1710 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1711 "in section `%A' failed"),
1712 abfd
, from
->name
, to
->name
, name
,
1713 (unsigned long) rel
->r_offset
, sec
);
1714 bfd_set_error (bfd_error_bad_value
);
1722 /* Rename some of the generic section flags to better document how they
1724 #define need_convert_load sec_flg0
1725 #define check_relocs_failed sec_flg1
1728 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1729 struct elf_link_hash_entry
*h
,
1730 Elf_Internal_Shdr
*symtab_hdr
,
1731 Elf_Internal_Sym
*isym
,
1732 reloc_howto_type
*howto
)
1735 const char *und
= "";
1736 const char *pic
= "";
1741 name
= h
->root
.root
.string
;
1742 switch (ELF_ST_VISIBILITY (h
->other
))
1745 v
= _("hidden symbol ");
1748 v
= _("internal symbol ");
1751 v
= _("protected symbol ");
1755 pic
= _("; recompile with -fPIC");
1759 if (!h
->def_regular
&& !h
->def_dynamic
)
1760 und
= _("undefined ");
1764 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1765 pic
= _("; recompile with -fPIC");
1768 /* xgettext:c-format */
1769 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1770 "not be used when making a shared object%s"),
1771 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1772 bfd_set_error (bfd_error_bad_value
);
1773 sec
->check_relocs_failed
= 1;
1777 /* With the local symbol, foo, we convert
1778 mov foo@GOTPCREL(%rip), %reg
1782 call/jmp *foo@GOTPCREL(%rip)
1784 nop call foo/jmp foo nop
1785 When PIC is false, convert
1786 test %reg, foo@GOTPCREL(%rip)
1790 binop foo@GOTPCREL(%rip), %reg
1793 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1797 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1799 Elf_Internal_Rela
*irel
,
1800 struct elf_link_hash_entry
*h
,
1801 bfd_boolean
*converted
,
1802 struct bfd_link_info
*link_info
)
1804 struct elf_x86_64_link_hash_table
*htab
;
1806 bfd_boolean require_reloc_pc32
;
1808 bfd_boolean to_reloc_pc32
;
1811 bfd_signed_vma raddend
;
1812 unsigned int opcode
;
1814 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1815 unsigned int r_symndx
;
1817 bfd_vma roff
= irel
->r_offset
;
1819 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1822 raddend
= irel
->r_addend
;
1823 /* Addend for 32-bit PC-relative relocation must be -4. */
1827 htab
= elf_x86_64_hash_table (link_info
);
1828 is_pic
= bfd_link_pic (link_info
);
1830 relocx
= (r_type
== R_X86_64_GOTPCRELX
1831 || r_type
== R_X86_64_REX_GOTPCRELX
);
1833 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1836 = link_info
->disable_target_specific_optimizations
> 1;
1838 r_symndx
= htab
->r_sym (irel
->r_info
);
1840 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1842 /* Convert mov to lea since it has been done for a while. */
1845 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1846 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1847 test, xor instructions. */
1852 /* We convert only to R_X86_64_PC32:
1854 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1855 3. require_reloc_pc32 is true.
1858 to_reloc_pc32
= (opcode
== 0xff
1860 || require_reloc_pc32
1863 /* Get the symbol referred to by the reloc. */
1866 Elf_Internal_Sym
*isym
1867 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1869 /* Skip relocation against undefined symbols. */
1870 if (isym
->st_shndx
== SHN_UNDEF
)
1873 symtype
= ELF_ST_TYPE (isym
->st_info
);
1875 if (isym
->st_shndx
== SHN_ABS
)
1876 tsec
= bfd_abs_section_ptr
;
1877 else if (isym
->st_shndx
== SHN_COMMON
)
1878 tsec
= bfd_com_section_ptr
;
1879 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1880 tsec
= &_bfd_elf_large_com_section
;
1882 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1884 toff
= isym
->st_value
;
1888 /* Undefined weak symbol is only bound locally in executable
1889 and its reference is resolved as 0 without relocation
1890 overflow. We can only perform this optimization for
1891 GOTPCRELX relocations since we need to modify REX byte.
1892 It is OK convert mov with R_X86_64_GOTPCREL to
1894 if ((relocx
|| opcode
== 0x8b)
1895 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1897 elf_x86_64_hash_entry (h
)))
1901 /* Skip for branch instructions since R_X86_64_PC32
1903 if (require_reloc_pc32
)
1908 /* For non-branch instructions, we can convert to
1909 R_X86_64_32/R_X86_64_32S since we know if there
1911 to_reloc_pc32
= FALSE
;
1914 /* Since we don't know the current PC when PIC is true,
1915 we can't convert to R_X86_64_PC32. */
1916 if (to_reloc_pc32
&& is_pic
)
1921 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1922 ld.so may use its link-time address. */
1923 else if ((h
->def_regular
1924 || h
->root
.type
== bfd_link_hash_defined
1925 || h
->root
.type
== bfd_link_hash_defweak
)
1926 && h
!= htab
->elf
.hdynamic
1927 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1929 /* bfd_link_hash_new or bfd_link_hash_undefined is
1930 set by an assignment in a linker script in
1931 bfd_elf_record_link_assignment. */
1933 && (h
->root
.type
== bfd_link_hash_new
1934 || h
->root
.type
== bfd_link_hash_undefined
1935 || ((h
->root
.type
== bfd_link_hash_defined
1936 || h
->root
.type
== bfd_link_hash_defweak
)
1937 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)))
1939 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1940 if (require_reloc_pc32
)
1944 tsec
= h
->root
.u
.def
.section
;
1945 toff
= h
->root
.u
.def
.value
;
1952 /* Don't convert GOTPCREL relocation against large section. */
1953 if (elf_section_data (tsec
) != NULL
1954 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1957 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1961 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1963 /* At this stage in linking, no SEC_MERGE symbol has been
1964 adjusted, so all references to such symbols need to be
1965 passed through _bfd_merged_section_offset. (Later, in
1966 relocate_section, all SEC_MERGE symbols *except* for
1967 section symbols have been adjusted.)
1969 gas may reduce relocations against symbols in SEC_MERGE
1970 sections to a relocation against the section symbol when
1971 the original addend was zero. When the reloc is against
1972 a section symbol we should include the addend in the
1973 offset passed to _bfd_merged_section_offset, since the
1974 location of interest is the original symbol. On the
1975 other hand, an access to "sym+addend" where "sym" is not
1976 a section symbol should not include the addend; Such an
1977 access is presumed to be an offset from "sym"; The
1978 location of interest is just "sym". */
1979 if (symtype
== STT_SECTION
)
1982 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1983 elf_section_data (tsec
)->sec_info
,
1986 if (symtype
!= STT_SECTION
)
1992 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1993 if (tsec
->output_section
== sec
->output_section
)
1995 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
2000 bfd_signed_vma distance
;
2002 /* At this point, we don't know the load addresses of TSEC
2003 section nor SEC section. We estimate the distrance between
2004 SEC and TSEC. We store the estimated distances in the
2005 compressed_size field of the output section, which is only
2006 used to decompress the compressed input section. */
2007 if (sec
->output_section
->compressed_size
== 0)
2010 bfd_size_type size
= 0;
2011 for (asect
= link_info
->output_bfd
->sections
;
2013 asect
= asect
->next
)
2014 /* Skip debug sections since compressed_size is used to
2015 compress debug sections. */
2016 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
2019 for (i
= asect
->map_head
.s
;
2023 size
= align_power (size
, i
->alignment_power
);
2026 asect
->compressed_size
= size
;
2030 /* Don't convert GOTPCREL relocations if TSEC isn't placed
2032 distance
= (tsec
->output_section
->compressed_size
2033 - sec
->output_section
->compressed_size
);
2037 /* Take PT_GNU_RELRO segment into account by adding
2039 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
2040 - roff
+ 0x80000000) > 0xffffffff)
2047 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
2052 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
2054 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2057 /* Convert to "jmp foo nop". */
2060 nop_offset
= irel
->r_offset
+ 3;
2061 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2062 irel
->r_offset
-= 1;
2063 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2067 struct elf_x86_64_link_hash_entry
*eh
2068 = (struct elf_x86_64_link_hash_entry
*) h
;
2070 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2073 /* To support TLS optimization, always use addr32 prefix for
2074 "call *__tls_get_addr@GOTPCREL(%rip)". */
2075 if (eh
&& eh
->tls_get_addr
== 1)
2078 nop_offset
= irel
->r_offset
- 2;
2082 nop
= link_info
->call_nop_byte
;
2083 if (link_info
->call_nop_as_suffix
)
2085 nop_offset
= irel
->r_offset
+ 3;
2086 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2087 irel
->r_offset
-= 1;
2088 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2091 nop_offset
= irel
->r_offset
- 2;
2094 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2095 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2096 r_type
= R_X86_64_PC32
;
2101 unsigned int rex_mask
= REX_R
;
2103 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2104 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2112 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2113 "lea foo(%rip), %reg". */
2115 r_type
= R_X86_64_PC32
;
2119 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2120 "mov $foo, %reg". */
2122 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2123 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2124 if ((rex
& REX_W
) != 0
2125 && ABI_64_P (link_info
->output_bfd
))
2127 /* Keep the REX_W bit in REX byte for LP64. */
2128 r_type
= R_X86_64_32S
;
2129 goto rewrite_modrm_rex
;
2133 /* If the REX_W bit in REX byte isn't needed,
2134 use R_X86_64_32 and clear the W bit to avoid
2135 sign-extend imm32 to imm64. */
2136 r_type
= R_X86_64_32
;
2137 /* Clear the W bit in REX byte. */
2139 goto rewrite_modrm_rex
;
2145 /* R_X86_64_PC32 isn't supported. */
2149 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2152 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2153 "test $foo, %reg". */
2154 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2159 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2160 "binop $foo, %reg". */
2161 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2165 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2166 overflow when sign-extending imm32 to imm64. */
2167 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2170 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2174 /* Move the R bit to the B bit in REX byte. */
2175 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2176 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2179 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2183 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2186 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2193 /* Look through the relocs for a section during the first phase, and
2194 calculate needed space in the global offset table, procedure
2195 linkage table, and dynamic reloc sections. */
2198 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2200 const Elf_Internal_Rela
*relocs
)
2202 struct elf_x86_64_link_hash_table
*htab
;
2203 Elf_Internal_Shdr
*symtab_hdr
;
2204 struct elf_link_hash_entry
**sym_hashes
;
2205 const Elf_Internal_Rela
*rel
;
2206 const Elf_Internal_Rela
*rel_end
;
2210 if (bfd_link_relocatable (info
))
2213 /* Don't do anything special with non-loaded, non-alloced sections.
2214 In particular, any relocs in such sections should not affect GOT
2215 and PLT reference counting (ie. we don't allow them to create GOT
2216 or PLT entries), there's no possibility or desire to optimize TLS
2217 relocs, and there's not much point in propagating relocs to shared
2218 libs that the dynamic linker won't relocate. */
2219 if ((sec
->flags
& SEC_ALLOC
) == 0)
2222 BFD_ASSERT (is_x86_64_elf (abfd
));
2224 htab
= elf_x86_64_hash_table (info
);
2227 sec
->check_relocs_failed
= 1;
2231 /* Get the section contents. */
2232 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2233 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2234 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2236 sec
->check_relocs_failed
= 1;
2240 symtab_hdr
= &elf_symtab_hdr (abfd
);
2241 sym_hashes
= elf_sym_hashes (abfd
);
2245 rel_end
= relocs
+ sec
->reloc_count
;
2246 for (rel
= relocs
; rel
< rel_end
; rel
++)
2248 unsigned int r_type
;
2249 unsigned long r_symndx
;
2250 struct elf_link_hash_entry
*h
;
2251 struct elf_x86_64_link_hash_entry
*eh
;
2252 Elf_Internal_Sym
*isym
;
2254 bfd_boolean size_reloc
;
2256 r_symndx
= htab
->r_sym (rel
->r_info
);
2257 r_type
= ELF32_R_TYPE (rel
->r_info
);
2259 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2261 /* xgettext:c-format */
2262 _bfd_error_handler (_("%B: bad symbol index: %d"),
2267 if (r_symndx
< symtab_hdr
->sh_info
)
2269 /* A local symbol. */
2270 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2275 /* Check relocation against local STT_GNU_IFUNC symbol. */
2276 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2278 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2283 /* Fake a STT_GNU_IFUNC symbol. */
2284 h
->type
= STT_GNU_IFUNC
;
2287 h
->forced_local
= 1;
2288 h
->root
.type
= bfd_link_hash_defined
;
2296 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2297 while (h
->root
.type
== bfd_link_hash_indirect
2298 || h
->root
.type
== bfd_link_hash_warning
)
2299 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2302 /* Check invalid x32 relocations. */
2303 if (!ABI_64_P (abfd
))
2309 case R_X86_64_DTPOFF64
:
2310 case R_X86_64_TPOFF64
:
2312 case R_X86_64_GOTOFF64
:
2313 case R_X86_64_GOT64
:
2314 case R_X86_64_GOTPCREL64
:
2315 case R_X86_64_GOTPC64
:
2316 case R_X86_64_GOTPLT64
:
2317 case R_X86_64_PLTOFF64
:
2320 name
= h
->root
.root
.string
;
2322 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2325 /* xgettext:c-format */
2326 (_("%B: relocation %s against symbol `%s' isn't "
2327 "supported in x32 mode"), abfd
,
2328 x86_64_elf_howto_table
[r_type
].name
, name
);
2329 bfd_set_error (bfd_error_bad_value
);
2337 /* It is referenced by a non-shared object. */
2339 h
->root
.non_ir_ref
= 1;
2341 if (h
->type
== STT_GNU_IFUNC
)
2342 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2343 |= elf_gnu_symbol_ifunc
;
2346 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2347 symtab_hdr
, sym_hashes
,
2348 &r_type
, GOT_UNKNOWN
,
2349 rel
, rel_end
, h
, r_symndx
, FALSE
))
2352 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2355 case R_X86_64_TLSLD
:
2356 htab
->tls_ld_got
.refcount
+= 1;
2359 case R_X86_64_TPOFF32
:
2360 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2361 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2362 &x86_64_elf_howto_table
[r_type
]);
2364 eh
->has_got_reloc
= 1;
2367 case R_X86_64_GOTTPOFF
:
2368 if (!bfd_link_executable (info
))
2369 info
->flags
|= DF_STATIC_TLS
;
2372 case R_X86_64_GOT32
:
2373 case R_X86_64_GOTPCREL
:
2374 case R_X86_64_GOTPCRELX
:
2375 case R_X86_64_REX_GOTPCRELX
:
2376 case R_X86_64_TLSGD
:
2377 case R_X86_64_GOT64
:
2378 case R_X86_64_GOTPCREL64
:
2379 case R_X86_64_GOTPLT64
:
2380 case R_X86_64_GOTPC32_TLSDESC
:
2381 case R_X86_64_TLSDESC_CALL
:
2382 /* This symbol requires a global offset table entry. */
2384 int tls_type
, old_tls_type
;
2388 default: tls_type
= GOT_NORMAL
; break;
2389 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2390 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2391 case R_X86_64_GOTPC32_TLSDESC
:
2392 case R_X86_64_TLSDESC_CALL
:
2393 tls_type
= GOT_TLS_GDESC
; break;
2398 h
->got
.refcount
+= 1;
2399 old_tls_type
= eh
->tls_type
;
2403 bfd_signed_vma
*local_got_refcounts
;
2405 /* This is a global offset table entry for a local symbol. */
2406 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2407 if (local_got_refcounts
== NULL
)
2411 size
= symtab_hdr
->sh_info
;
2412 size
*= sizeof (bfd_signed_vma
)
2413 + sizeof (bfd_vma
) + sizeof (char);
2414 local_got_refcounts
= ((bfd_signed_vma
*)
2415 bfd_zalloc (abfd
, size
));
2416 if (local_got_refcounts
== NULL
)
2418 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2419 elf_x86_64_local_tlsdesc_gotent (abfd
)
2420 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2421 elf_x86_64_local_got_tls_type (abfd
)
2422 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2424 local_got_refcounts
[r_symndx
] += 1;
2426 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2429 /* If a TLS symbol is accessed using IE at least once,
2430 there is no point to use dynamic model for it. */
2431 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2432 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2433 || tls_type
!= GOT_TLS_IE
))
2435 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2436 tls_type
= old_tls_type
;
2437 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2438 && GOT_TLS_GD_ANY_P (tls_type
))
2439 tls_type
|= old_tls_type
;
2443 name
= h
->root
.root
.string
;
2445 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2448 /* xgettext:c-format */
2449 (_("%B: '%s' accessed both as normal and"
2450 " thread local symbol"),
2452 bfd_set_error (bfd_error_bad_value
);
2457 if (old_tls_type
!= tls_type
)
2460 eh
->tls_type
= tls_type
;
2462 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2467 case R_X86_64_GOTOFF64
:
2468 case R_X86_64_GOTPC32
:
2469 case R_X86_64_GOTPC64
:
2472 eh
->has_got_reloc
= 1;
2475 case R_X86_64_PLT32
:
2476 case R_X86_64_PLT32_BND
:
2477 /* This symbol requires a procedure linkage table entry. We
2478 actually build the entry in adjust_dynamic_symbol,
2479 because this might be a case of linking PIC code which is
2480 never referenced by a dynamic object, in which case we
2481 don't need to generate a procedure linkage table entry
2484 /* If this is a local symbol, we resolve it directly without
2485 creating a procedure linkage table entry. */
2489 eh
->has_got_reloc
= 1;
2491 h
->plt
.refcount
+= 1;
2494 case R_X86_64_PLTOFF64
:
2495 /* This tries to form the 'address' of a function relative
2496 to GOT. For global symbols we need a PLT entry. */
2500 h
->plt
.refcount
+= 1;
2504 case R_X86_64_SIZE32
:
2505 case R_X86_64_SIZE64
:
2510 if (!ABI_64_P (abfd
))
2516 /* Check relocation overflow as these relocs may lead to
2517 run-time relocation overflow. Don't error out for
2518 sections we don't care about, such as debug sections or
2519 when relocation overflow check is disabled. */
2520 if (!info
->no_reloc_overflow_check
2521 && (bfd_link_pic (info
)
2522 || (bfd_link_executable (info
)
2526 && (sec
->flags
& SEC_READONLY
) == 0)))
2527 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2528 &x86_64_elf_howto_table
[r_type
]);
2534 case R_X86_64_PC32_BND
:
2538 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2539 eh
->has_non_got_reloc
= 1;
2540 /* We are called after all symbols have been resolved. Only
2541 relocation against STT_GNU_IFUNC symbol must go through
2544 && (bfd_link_executable (info
)
2545 || h
->type
== STT_GNU_IFUNC
))
2547 /* If this reloc is in a read-only section, we might
2548 need a copy reloc. We can't check reliably at this
2549 stage whether the section is read-only, as input
2550 sections have not yet been mapped to output sections.
2551 Tentatively set the flag for now, and correct in
2552 adjust_dynamic_symbol. */
2555 /* We may need a .plt entry if the symbol is a function
2556 defined in a shared lib or is a STT_GNU_IFUNC function
2557 referenced from the code or read-only section. */
2559 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2560 h
->plt
.refcount
+= 1;
2562 if (r_type
== R_X86_64_PC32
)
2564 /* Since something like ".long foo - ." may be used
2565 as pointer, make sure that PLT is used if foo is
2566 a function defined in a shared library. */
2567 if ((sec
->flags
& SEC_CODE
) == 0)
2568 h
->pointer_equality_needed
= 1;
2570 else if (r_type
!= R_X86_64_PC32_BND
2571 && r_type
!= R_X86_64_PC64
)
2573 h
->pointer_equality_needed
= 1;
2574 /* At run-time, R_X86_64_64 can be resolved for both
2575 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2576 can only be resolved for x32. */
2577 if ((sec
->flags
& SEC_READONLY
) == 0
2578 && (r_type
== R_X86_64_64
2579 || (!ABI_64_P (abfd
)
2580 && (r_type
== R_X86_64_32
2581 || r_type
== R_X86_64_32S
))))
2582 eh
->func_pointer_refcount
+= 1;
2588 /* If we are creating a shared library, and this is a reloc
2589 against a global symbol, or a non PC relative reloc
2590 against a local symbol, then we need to copy the reloc
2591 into the shared library. However, if we are linking with
2592 -Bsymbolic, we do not need to copy a reloc against a
2593 global symbol which is defined in an object we are
2594 including in the link (i.e., DEF_REGULAR is set). At
2595 this point we have not seen all the input files, so it is
2596 possible that DEF_REGULAR is not set now but will be set
2597 later (it is never cleared). In case of a weak definition,
2598 DEF_REGULAR may be cleared later by a strong definition in
2599 a shared library. We account for that possibility below by
2600 storing information in the relocs_copied field of the hash
2601 table entry. A similar situation occurs when creating
2602 shared libraries and symbol visibility changes render the
2605 If on the other hand, we are creating an executable, we
2606 may need to keep relocations for symbols satisfied by a
2607 dynamic library if we manage to avoid copy relocs for the
2610 Generate dynamic pointer relocation against STT_GNU_IFUNC
2611 symbol in the non-code section. */
2612 if ((bfd_link_pic (info
)
2613 && (! IS_X86_64_PCREL_TYPE (r_type
)
2615 && (! (bfd_link_pie (info
)
2616 || SYMBOLIC_BIND (info
, h
))
2617 || h
->root
.type
== bfd_link_hash_defweak
2618 || !h
->def_regular
))))
2620 && h
->type
== STT_GNU_IFUNC
2621 && r_type
== htab
->pointer_r_type
2622 && (sec
->flags
& SEC_CODE
) == 0)
2623 || (ELIMINATE_COPY_RELOCS
2624 && !bfd_link_pic (info
)
2626 && (h
->root
.type
== bfd_link_hash_defweak
2627 || !h
->def_regular
)))
2629 struct elf_dyn_relocs
*p
;
2630 struct elf_dyn_relocs
**head
;
2632 /* We must copy these reloc types into the output file.
2633 Create a reloc section in dynobj and make room for
2637 sreloc
= _bfd_elf_make_dynamic_reloc_section
2638 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2639 abfd
, /*rela?*/ TRUE
);
2645 /* If this is a global symbol, we count the number of
2646 relocations we need for this symbol. */
2648 head
= &eh
->dyn_relocs
;
2651 /* Track dynamic relocs needed for local syms too.
2652 We really need local syms available to do this
2657 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2662 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2666 /* Beware of type punned pointers vs strict aliasing
2668 vpp
= &(elf_section_data (s
)->local_dynrel
);
2669 head
= (struct elf_dyn_relocs
**)vpp
;
2673 if (p
== NULL
|| p
->sec
!= sec
)
2675 bfd_size_type amt
= sizeof *p
;
2677 p
= ((struct elf_dyn_relocs
*)
2678 bfd_alloc (htab
->elf
.dynobj
, amt
));
2689 /* Count size relocation as PC-relative relocation. */
2690 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2695 /* This relocation describes the C++ object vtable hierarchy.
2696 Reconstruct it for later use during GC. */
2697 case R_X86_64_GNU_VTINHERIT
:
2698 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2702 /* This relocation describes which C++ vtable entries are actually
2703 used. Record for later use during GC. */
2704 case R_X86_64_GNU_VTENTRY
:
2705 BFD_ASSERT (h
!= NULL
);
2707 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2715 if ((r_type
== R_X86_64_GOTPCREL
2716 || r_type
== R_X86_64_GOTPCRELX
2717 || r_type
== R_X86_64_REX_GOTPCRELX
)
2718 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2719 sec
->need_convert_load
= 1;
2722 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2724 if (!info
->keep_memory
)
2728 /* Cache the section contents for elf_link_input_bfd. */
2729 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2736 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2738 sec
->check_relocs_failed
= 1;
2742 /* Return the section that should be marked against GC for a given
2746 elf_x86_64_gc_mark_hook (asection
*sec
,
2747 struct bfd_link_info
*info
,
2748 Elf_Internal_Rela
*rel
,
2749 struct elf_link_hash_entry
*h
,
2750 Elf_Internal_Sym
*sym
)
2753 switch (ELF32_R_TYPE (rel
->r_info
))
2755 case R_X86_64_GNU_VTINHERIT
:
2756 case R_X86_64_GNU_VTENTRY
:
2760 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2763 /* Remove undefined weak symbol from the dynamic symbol table if it
2764 is resolved to 0. */
2767 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2768 struct elf_link_hash_entry
*h
)
2770 if (h
->dynindx
!= -1
2771 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2772 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2773 elf_x86_64_hash_entry (h
)))
2776 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2782 /* Adjust a symbol defined by a dynamic object and referenced by a
2783 regular object. The current definition is in some section of the
2784 dynamic object, but we're not including those sections. We have to
2785 change the definition to something the rest of the link can
2789 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2790 struct elf_link_hash_entry
*h
)
2792 struct elf_x86_64_link_hash_table
*htab
;
2794 struct elf_x86_64_link_hash_entry
*eh
;
2795 struct elf_dyn_relocs
*p
;
2797 /* STT_GNU_IFUNC symbol must go through PLT. */
2798 if (h
->type
== STT_GNU_IFUNC
)
2800 /* All local STT_GNU_IFUNC references must be treate as local
2801 calls via local PLT. */
2803 && SYMBOL_CALLS_LOCAL (info
, h
))
2805 bfd_size_type pc_count
= 0, count
= 0;
2806 struct elf_dyn_relocs
**pp
;
2808 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2809 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2811 pc_count
+= p
->pc_count
;
2812 p
->count
-= p
->pc_count
;
2821 if (pc_count
|| count
)
2826 /* Increment PLT reference count only for PC-relative
2829 if (h
->plt
.refcount
<= 0)
2830 h
->plt
.refcount
= 1;
2832 h
->plt
.refcount
+= 1;
2837 if (h
->plt
.refcount
<= 0)
2839 h
->plt
.offset
= (bfd_vma
) -1;
2845 /* If this is a function, put it in the procedure linkage table. We
2846 will fill in the contents of the procedure linkage table later,
2847 when we know the address of the .got section. */
2848 if (h
->type
== STT_FUNC
2851 if (h
->plt
.refcount
<= 0
2852 || SYMBOL_CALLS_LOCAL (info
, h
)
2853 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2854 && h
->root
.type
== bfd_link_hash_undefweak
))
2856 /* This case can occur if we saw a PLT32 reloc in an input
2857 file, but the symbol was never referred to by a dynamic
2858 object, or if all references were garbage collected. In
2859 such a case, we don't actually need to build a procedure
2860 linkage table, and we can just do a PC32 reloc instead. */
2861 h
->plt
.offset
= (bfd_vma
) -1;
2868 /* It's possible that we incorrectly decided a .plt reloc was
2869 needed for an R_X86_64_PC32 reloc to a non-function sym in
2870 check_relocs. We can't decide accurately between function and
2871 non-function syms in check-relocs; Objects loaded later in
2872 the link may change h->type. So fix it now. */
2873 h
->plt
.offset
= (bfd_vma
) -1;
2875 /* If this is a weak symbol, and there is a real definition, the
2876 processor independent code will have arranged for us to see the
2877 real definition first, and we can just use the same value. */
2878 if (h
->u
.weakdef
!= NULL
)
2880 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2881 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2882 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2883 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2884 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2886 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2887 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2888 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2893 /* This is a reference to a symbol defined by a dynamic object which
2894 is not a function. */
2896 /* If we are creating a shared library, we must presume that the
2897 only references to the symbol are via the global offset table.
2898 For such cases we need not do anything here; the relocations will
2899 be handled correctly by relocate_section. */
2900 if (!bfd_link_executable (info
))
2903 /* If there are no references to this symbol that do not use the
2904 GOT, we don't need to generate a copy reloc. */
2905 if (!h
->non_got_ref
)
2908 /* If -z nocopyreloc was given, we won't generate them either. */
2909 if (info
->nocopyreloc
)
2915 if (ELIMINATE_COPY_RELOCS
)
2917 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2918 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2920 s
= p
->sec
->output_section
;
2921 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2925 /* If we didn't find any dynamic relocs in read-only sections, then
2926 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2934 /* We must allocate the symbol in our .dynbss section, which will
2935 become part of the .bss section of the executable. There will be
2936 an entry for this symbol in the .dynsym section. The dynamic
2937 object will contain position independent code, so all references
2938 from the dynamic object to this symbol will go through the global
2939 offset table. The dynamic linker will use the .dynsym entry to
2940 determine the address it must put in the global offset table, so
2941 both the dynamic object and the regular object will refer to the
2942 same memory location for the variable. */
2944 htab
= elf_x86_64_hash_table (info
);
2948 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2949 to copy the initial value out of the dynamic object and into the
2950 runtime process image. */
2951 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2953 s
= htab
->elf
.sdynrelro
;
2954 srel
= htab
->elf
.sreldynrelro
;
2958 s
= htab
->elf
.sdynbss
;
2959 srel
= htab
->elf
.srelbss
;
2961 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2963 const struct elf_backend_data
*bed
;
2964 bed
= get_elf_backend_data (info
->output_bfd
);
2965 srel
->size
+= bed
->s
->sizeof_rela
;
2969 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2972 /* Allocate space in .plt, .got and associated reloc sections for
2976 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2978 struct bfd_link_info
*info
;
2979 struct elf_x86_64_link_hash_table
*htab
;
2980 struct elf_x86_64_link_hash_entry
*eh
;
2981 struct elf_dyn_relocs
*p
;
2982 const struct elf_backend_data
*bed
;
2983 unsigned int plt_entry_size
;
2984 bfd_boolean resolved_to_zero
;
2986 if (h
->root
.type
== bfd_link_hash_indirect
)
2989 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2991 info
= (struct bfd_link_info
*) inf
;
2992 htab
= elf_x86_64_hash_table (info
);
2995 bed
= get_elf_backend_data (info
->output_bfd
);
2996 plt_entry_size
= htab
->plt
.plt_entry_size
;
2998 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3002 /* We can't use the GOT PLT if pointer equality is needed since
3003 finish_dynamic_symbol won't clear symbol value and the dynamic
3004 linker won't update the GOT slot. We will get into an infinite
3005 loop at run-time. */
3006 if (htab
->plt_got
!= NULL
3007 && h
->type
!= STT_GNU_IFUNC
3008 && !h
->pointer_equality_needed
3009 && h
->plt
.refcount
> 0
3010 && h
->got
.refcount
> 0)
3012 /* Don't use the regular PLT if there are both GOT and GOTPLT
3014 h
->plt
.offset
= (bfd_vma
) -1;
3016 /* Use the GOT PLT. */
3017 eh
->plt_got
.refcount
= 1;
3020 /* Clear the reference count of function pointer relocations if
3021 symbol isn't a normal function. */
3022 if (h
->type
!= STT_FUNC
)
3023 eh
->func_pointer_refcount
= 0;
3025 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3026 here if it is defined and referenced in a non-shared object. */
3027 if (h
->type
== STT_GNU_IFUNC
3030 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3032 &htab
->readonly_dynrelocs_against_ifunc
,
3036 GOT_ENTRY_SIZE
, TRUE
))
3038 asection
*s
= htab
->plt_second
;
3039 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3041 /* Use the second PLT section if it is created. */
3042 eh
->plt_second
.offset
= s
->size
;
3044 /* Make room for this entry in the second PLT section. */
3045 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3053 /* Don't create the PLT entry if there are only function pointer
3054 relocations which can be resolved at run-time. */
3055 else if (htab
->elf
.dynamic_sections_created
3056 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3057 || eh
->plt_got
.refcount
> 0))
3059 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
3061 /* Clear the reference count of function pointer relocations
3063 eh
->func_pointer_refcount
= 0;
3065 /* Make sure this symbol is output as a dynamic symbol.
3066 Undefined weak syms won't yet be marked as dynamic. */
3067 if (h
->dynindx
== -1
3069 && !resolved_to_zero
3070 && h
->root
.type
== bfd_link_hash_undefweak
)
3072 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3076 if (bfd_link_pic (info
)
3077 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3079 asection
*s
= htab
->elf
.splt
;
3080 asection
*second_s
= htab
->plt_second
;
3081 asection
*got_s
= htab
->plt_got
;
3083 /* If this is the first .plt entry, make room for the special
3084 first entry. The .plt section is used by prelink to undo
3085 prelinking for dynamic relocations. */
3087 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
3090 eh
->plt_got
.offset
= got_s
->size
;
3093 h
->plt
.offset
= s
->size
;
3095 eh
->plt_second
.offset
= second_s
->size
;
3098 /* If this symbol is not defined in a regular file, and we are
3099 not generating a shared library, then set the symbol to this
3100 location in the .plt. This is required to make function
3101 pointers compare as equal between the normal executable and
3102 the shared library. */
3103 if (! bfd_link_pic (info
)
3108 /* We need to make a call to the entry of the GOT PLT
3109 instead of regular PLT entry. */
3110 h
->root
.u
.def
.section
= got_s
;
3111 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3117 /* We need to make a call to the entry of the
3118 second PLT instead of regular PLT entry. */
3119 h
->root
.u
.def
.section
= second_s
;
3120 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
3124 h
->root
.u
.def
.section
= s
;
3125 h
->root
.u
.def
.value
= h
->plt
.offset
;
3130 /* Make room for this entry. */
3132 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3135 s
->size
+= plt_entry_size
;
3137 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3139 /* We also need to make an entry in the .got.plt section,
3140 which will be placed in the .got section by the linker
3142 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3144 /* There should be no PLT relocation against resolved
3145 undefined weak symbol in executable. */
3146 if (!resolved_to_zero
)
3148 /* We also need to make an entry in the .rela.plt
3150 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3151 htab
->elf
.srelplt
->reloc_count
++;
3157 eh
->plt_got
.offset
= (bfd_vma
) -1;
3158 h
->plt
.offset
= (bfd_vma
) -1;
3164 eh
->plt_got
.offset
= (bfd_vma
) -1;
3165 h
->plt
.offset
= (bfd_vma
) -1;
3169 eh
->tlsdesc_got
= (bfd_vma
) -1;
3171 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3172 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3173 if (h
->got
.refcount
> 0
3174 && bfd_link_executable (info
)
3176 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3178 h
->got
.offset
= (bfd_vma
) -1;
3180 else if (h
->got
.refcount
> 0)
3184 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3186 /* Make sure this symbol is output as a dynamic symbol.
3187 Undefined weak syms won't yet be marked as dynamic. */
3188 if (h
->dynindx
== -1
3190 && !resolved_to_zero
3191 && h
->root
.type
== bfd_link_hash_undefweak
)
3193 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3197 if (GOT_TLS_GDESC_P (tls_type
))
3199 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3200 - elf_x86_64_compute_jump_table_size (htab
);
3201 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3202 h
->got
.offset
= (bfd_vma
) -2;
3204 if (! GOT_TLS_GDESC_P (tls_type
)
3205 || GOT_TLS_GD_P (tls_type
))
3208 h
->got
.offset
= s
->size
;
3209 s
->size
+= GOT_ENTRY_SIZE
;
3210 if (GOT_TLS_GD_P (tls_type
))
3211 s
->size
+= GOT_ENTRY_SIZE
;
3213 dyn
= htab
->elf
.dynamic_sections_created
;
3214 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3215 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3216 relocation. No dynamic relocation against resolved undefined
3217 weak symbol in executable. */
3218 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3219 || tls_type
== GOT_TLS_IE
)
3220 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3221 else if (GOT_TLS_GD_P (tls_type
))
3222 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3223 else if (! GOT_TLS_GDESC_P (tls_type
)
3224 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3225 && !resolved_to_zero
)
3226 || h
->root
.type
!= bfd_link_hash_undefweak
)
3227 && (bfd_link_pic (info
)
3228 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3229 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3230 if (GOT_TLS_GDESC_P (tls_type
))
3232 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3233 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3237 h
->got
.offset
= (bfd_vma
) -1;
3239 if (eh
->dyn_relocs
== NULL
)
3242 /* In the shared -Bsymbolic case, discard space allocated for
3243 dynamic pc-relative relocs against symbols which turn out to be
3244 defined in regular objects. For the normal shared case, discard
3245 space for pc-relative relocs that have become local due to symbol
3246 visibility changes. */
3248 if (bfd_link_pic (info
))
3250 /* Relocs that use pc_count are those that appear on a call
3251 insn, or certain REL relocs that can generated via assembly.
3252 We want calls to protected symbols to resolve directly to the
3253 function rather than going via the plt. If people want
3254 function pointer comparisons to work as expected then they
3255 should avoid writing weird assembly. */
3256 if (SYMBOL_CALLS_LOCAL (info
, h
))
3258 struct elf_dyn_relocs
**pp
;
3260 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3262 p
->count
-= p
->pc_count
;
3271 /* Also discard relocs on undefined weak syms with non-default
3272 visibility or in PIE. */
3273 if (eh
->dyn_relocs
!= NULL
)
3275 if (h
->root
.type
== bfd_link_hash_undefweak
)
3277 /* Undefined weak symbol is never bound locally in shared
3279 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3280 || resolved_to_zero
)
3281 eh
->dyn_relocs
= NULL
;
3282 else if (h
->dynindx
== -1
3283 && ! h
->forced_local
3284 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3287 /* For PIE, discard space for pc-relative relocs against
3288 symbols which turn out to need copy relocs. */
3289 else if (bfd_link_executable (info
)
3290 && (h
->needs_copy
|| eh
->needs_copy
)
3294 struct elf_dyn_relocs
**pp
;
3296 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3298 if (p
->pc_count
!= 0)
3306 else if (ELIMINATE_COPY_RELOCS
)
3308 /* For the non-shared case, discard space for relocs against
3309 symbols which turn out to need copy relocs or are not
3310 dynamic. Keep dynamic relocations for run-time function
3311 pointer initialization. */
3313 if ((!h
->non_got_ref
3314 || eh
->func_pointer_refcount
> 0
3315 || (h
->root
.type
== bfd_link_hash_undefweak
3316 && !resolved_to_zero
))
3319 || (htab
->elf
.dynamic_sections_created
3320 && (h
->root
.type
== bfd_link_hash_undefweak
3321 || h
->root
.type
== bfd_link_hash_undefined
))))
3323 /* Make sure this symbol is output as a dynamic symbol.
3324 Undefined weak syms won't yet be marked as dynamic. */
3325 if (h
->dynindx
== -1
3326 && ! h
->forced_local
3327 && ! resolved_to_zero
3328 && h
->root
.type
== bfd_link_hash_undefweak
3329 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3332 /* If that succeeded, we know we'll be keeping all the
3334 if (h
->dynindx
!= -1)
3338 eh
->dyn_relocs
= NULL
;
3339 eh
->func_pointer_refcount
= 0;
3344 /* Finally, allocate space. */
3345 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3349 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3351 BFD_ASSERT (sreloc
!= NULL
);
3353 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3359 /* Allocate space in .plt, .got and associated reloc sections for
3360 local dynamic relocs. */
3363 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3365 struct elf_link_hash_entry
*h
3366 = (struct elf_link_hash_entry
*) *slot
;
3368 if (h
->type
!= STT_GNU_IFUNC
3372 || h
->root
.type
!= bfd_link_hash_defined
)
3375 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3378 /* Find any dynamic relocs that apply to read-only sections. */
3381 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3384 struct elf_x86_64_link_hash_entry
*eh
;
3385 struct elf_dyn_relocs
*p
;
3387 /* Skip local IFUNC symbols. */
3388 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3391 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3392 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3394 asection
*s
= p
->sec
->output_section
;
3396 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3398 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3400 info
->flags
|= DF_TEXTREL
;
3402 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3403 || info
->error_textrel
)
3404 /* xgettext:c-format */
3405 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3406 p
->sec
->owner
, h
->root
.root
.string
,
3409 /* Not an error, just cut short the traversal. */
3416 /* Convert load via the GOT slot to load immediate. */
3419 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3420 struct bfd_link_info
*link_info
)
3422 Elf_Internal_Shdr
*symtab_hdr
;
3423 Elf_Internal_Rela
*internal_relocs
;
3424 Elf_Internal_Rela
*irel
, *irelend
;
3426 struct elf_x86_64_link_hash_table
*htab
;
3427 bfd_boolean changed
;
3428 bfd_signed_vma
*local_got_refcounts
;
3430 /* Don't even try to convert non-ELF outputs. */
3431 if (!is_elf_hash_table (link_info
->hash
))
3434 /* Nothing to do if there is no need or no output. */
3435 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3436 || sec
->need_convert_load
== 0
3437 || bfd_is_abs_section (sec
->output_section
))
3440 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3442 /* Load the relocations for this section. */
3443 internal_relocs
= (_bfd_elf_link_read_relocs
3444 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3445 link_info
->keep_memory
));
3446 if (internal_relocs
== NULL
)
3450 htab
= elf_x86_64_hash_table (link_info
);
3451 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3453 /* Get the section contents. */
3454 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3455 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3458 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3462 irelend
= internal_relocs
+ sec
->reloc_count
;
3463 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3465 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3466 unsigned int r_symndx
;
3467 struct elf_link_hash_entry
*h
;
3468 bfd_boolean converted
;
3470 if (r_type
!= R_X86_64_GOTPCRELX
3471 && r_type
!= R_X86_64_REX_GOTPCRELX
3472 && r_type
!= R_X86_64_GOTPCREL
)
3475 r_symndx
= htab
->r_sym (irel
->r_info
);
3476 if (r_symndx
< symtab_hdr
->sh_info
)
3477 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3478 (const Elf_Internal_Rela
*) irel
,
3482 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3483 while (h
->root
.type
== bfd_link_hash_indirect
3484 || h
->root
.type
== bfd_link_hash_warning
)
3485 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3488 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3489 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3493 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3494 &converted
, link_info
))
3499 changed
= converted
;
3502 if (h
->got
.refcount
> 0)
3503 h
->got
.refcount
-= 1;
3507 if (local_got_refcounts
!= NULL
3508 && local_got_refcounts
[r_symndx
] > 0)
3509 local_got_refcounts
[r_symndx
] -= 1;
3514 if (contents
!= NULL
3515 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3517 if (!changed
&& !link_info
->keep_memory
)
3521 /* Cache the section contents for elf_link_input_bfd. */
3522 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3526 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3529 free (internal_relocs
);
3531 elf_section_data (sec
)->relocs
= internal_relocs
;
3537 if (contents
!= NULL
3538 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3540 if (internal_relocs
!= NULL
3541 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3542 free (internal_relocs
);
3546 /* Set the sizes of the dynamic sections. */
3549 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3550 struct bfd_link_info
*info
)
3552 struct elf_x86_64_link_hash_table
*htab
;
3557 const struct elf_backend_data
*bed
;
3559 htab
= elf_x86_64_hash_table (info
);
3562 bed
= get_elf_backend_data (output_bfd
);
3564 dynobj
= htab
->elf
.dynobj
;
3568 /* Set up .got offsets for local syms, and space for local dynamic
3570 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3572 bfd_signed_vma
*local_got
;
3573 bfd_signed_vma
*end_local_got
;
3574 char *local_tls_type
;
3575 bfd_vma
*local_tlsdesc_gotent
;
3576 bfd_size_type locsymcount
;
3577 Elf_Internal_Shdr
*symtab_hdr
;
3580 if (! is_x86_64_elf (ibfd
))
3583 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3585 struct elf_dyn_relocs
*p
;
3587 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3590 for (p
= (struct elf_dyn_relocs
*)
3591 (elf_section_data (s
)->local_dynrel
);
3595 if (!bfd_is_abs_section (p
->sec
)
3596 && bfd_is_abs_section (p
->sec
->output_section
))
3598 /* Input section has been discarded, either because
3599 it is a copy of a linkonce section or due to
3600 linker script /DISCARD/, so we'll be discarding
3603 else if (p
->count
!= 0)
3605 srel
= elf_section_data (p
->sec
)->sreloc
;
3606 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3607 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3608 && (info
->flags
& DF_TEXTREL
) == 0)
3610 info
->flags
|= DF_TEXTREL
;
3611 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3612 || info
->error_textrel
)
3613 /* xgettext:c-format */
3614 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3615 p
->sec
->owner
, p
->sec
);
3621 local_got
= elf_local_got_refcounts (ibfd
);
3625 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3626 locsymcount
= symtab_hdr
->sh_info
;
3627 end_local_got
= local_got
+ locsymcount
;
3628 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3629 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3631 srel
= htab
->elf
.srelgot
;
3632 for (; local_got
< end_local_got
;
3633 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3635 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3638 if (GOT_TLS_GDESC_P (*local_tls_type
))
3640 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3641 - elf_x86_64_compute_jump_table_size (htab
);
3642 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3643 *local_got
= (bfd_vma
) -2;
3645 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3646 || GOT_TLS_GD_P (*local_tls_type
))
3648 *local_got
= s
->size
;
3649 s
->size
+= GOT_ENTRY_SIZE
;
3650 if (GOT_TLS_GD_P (*local_tls_type
))
3651 s
->size
+= GOT_ENTRY_SIZE
;
3653 if (bfd_link_pic (info
)
3654 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3655 || *local_tls_type
== GOT_TLS_IE
)
3657 if (GOT_TLS_GDESC_P (*local_tls_type
))
3659 htab
->elf
.srelplt
->size
3660 += bed
->s
->sizeof_rela
;
3661 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3663 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3664 || GOT_TLS_GD_P (*local_tls_type
))
3665 srel
->size
+= bed
->s
->sizeof_rela
;
3669 *local_got
= (bfd_vma
) -1;
3673 if (htab
->tls_ld_got
.refcount
> 0)
3675 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3677 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3678 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3679 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3682 htab
->tls_ld_got
.offset
= -1;
3684 /* Allocate global sym .plt and .got entries, and space for global
3685 sym dynamic relocs. */
3686 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3689 /* Allocate .plt and .got entries, and space for local symbols. */
3690 htab_traverse (htab
->loc_hash_table
,
3691 elf_x86_64_allocate_local_dynrelocs
,
3694 /* For every jump slot reserved in the sgotplt, reloc_count is
3695 incremented. However, when we reserve space for TLS descriptors,
3696 it's not incremented, so in order to compute the space reserved
3697 for them, it suffices to multiply the reloc count by the jump
3700 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3701 so that R_X86_64_IRELATIVE entries come last. */
3702 if (htab
->elf
.srelplt
)
3704 htab
->sgotplt_jump_table_size
3705 = elf_x86_64_compute_jump_table_size (htab
);
3706 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3708 else if (htab
->elf
.irelplt
)
3709 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3711 if (htab
->tlsdesc_plt
)
3713 /* If we're not using lazy TLS relocations, don't generate the
3714 PLT and GOT entries they require. */
3715 if ((info
->flags
& DF_BIND_NOW
))
3716 htab
->tlsdesc_plt
= 0;
3719 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3720 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3721 /* Reserve room for the initial entry.
3722 FIXME: we could probably do away with it in this case. */
3723 if (htab
->elf
.splt
->size
== 0)
3724 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
3725 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3726 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
3730 if (htab
->elf
.sgotplt
)
3732 /* Don't allocate .got.plt section if there are no GOT nor PLT
3733 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3734 if ((htab
->elf
.hgot
== NULL
3735 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3736 && (htab
->elf
.sgotplt
->size
3737 == get_elf_backend_data (output_bfd
)->got_header_size
)
3738 && (htab
->elf
.splt
== NULL
3739 || htab
->elf
.splt
->size
== 0)
3740 && (htab
->elf
.sgot
== NULL
3741 || htab
->elf
.sgot
->size
== 0)
3742 && (htab
->elf
.iplt
== NULL
3743 || htab
->elf
.iplt
->size
== 0)
3744 && (htab
->elf
.igotplt
== NULL
3745 || htab
->elf
.igotplt
->size
== 0))
3746 htab
->elf
.sgotplt
->size
= 0;
3749 if (_bfd_elf_eh_frame_present (info
))
3751 if (htab
->plt_eh_frame
!= NULL
3752 && htab
->elf
.splt
!= NULL
3753 && htab
->elf
.splt
->size
!= 0
3754 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
3755 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
3757 if (htab
->plt_got_eh_frame
!= NULL
3758 && htab
->plt_got
!= NULL
3759 && htab
->plt_got
->size
!= 0
3760 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
3761 htab
->plt_got_eh_frame
->size
3762 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3764 /* Unwind info for the second PLT and .plt.got sections are
3766 if (htab
->plt_second_eh_frame
!= NULL
3767 && htab
->plt_second
!= NULL
3768 && htab
->plt_second
->size
!= 0
3769 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
3770 htab
->plt_second_eh_frame
->size
3771 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3774 /* We now have determined the sizes of the various dynamic sections.
3775 Allocate memory for them. */
3777 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3779 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3782 if (s
== htab
->elf
.splt
3783 || s
== htab
->elf
.sgot
3784 || s
== htab
->elf
.sgotplt
3785 || s
== htab
->elf
.iplt
3786 || s
== htab
->elf
.igotplt
3787 || s
== htab
->plt_second
3788 || s
== htab
->plt_got
3789 || s
== htab
->plt_eh_frame
3790 || s
== htab
->plt_got_eh_frame
3791 || s
== htab
->plt_second_eh_frame
3792 || s
== htab
->elf
.sdynbss
3793 || s
== htab
->elf
.sdynrelro
)
3795 /* Strip this section if we don't need it; see the
3798 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3800 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3803 /* We use the reloc_count field as a counter if we need
3804 to copy relocs into the output file. */
3805 if (s
!= htab
->elf
.srelplt
)
3810 /* It's not one of our sections, so don't allocate space. */
3816 /* If we don't need this section, strip it from the
3817 output file. This is mostly to handle .rela.bss and
3818 .rela.plt. We must create both sections in
3819 create_dynamic_sections, because they must be created
3820 before the linker maps input sections to output
3821 sections. The linker does that before
3822 adjust_dynamic_symbol is called, and it is that
3823 function which decides whether anything needs to go
3824 into these sections. */
3826 s
->flags
|= SEC_EXCLUDE
;
3830 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3833 /* Allocate memory for the section contents. We use bfd_zalloc
3834 here in case unused entries are not reclaimed before the
3835 section's contents are written out. This should not happen,
3836 but this way if it does, we get a R_X86_64_NONE reloc instead
3838 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3839 if (s
->contents
== NULL
)
3843 if (htab
->plt_eh_frame
!= NULL
3844 && htab
->plt_eh_frame
->contents
!= NULL
)
3846 memcpy (htab
->plt_eh_frame
->contents
,
3847 htab
->plt
.eh_frame_plt
, htab
->plt_eh_frame
->size
);
3848 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3849 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3852 if (htab
->plt_got_eh_frame
!= NULL
3853 && htab
->plt_got_eh_frame
->contents
!= NULL
)
3855 memcpy (htab
->plt_got_eh_frame
->contents
,
3856 htab
->non_lazy_plt
->eh_frame_plt
,
3857 htab
->plt_got_eh_frame
->size
);
3858 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
3859 (htab
->plt_got_eh_frame
->contents
3860 + PLT_FDE_LEN_OFFSET
));
3863 if (htab
->plt_second_eh_frame
!= NULL
3864 && htab
->plt_second_eh_frame
->contents
!= NULL
)
3866 memcpy (htab
->plt_second_eh_frame
->contents
,
3867 htab
->non_lazy_plt
->eh_frame_plt
,
3868 htab
->plt_second_eh_frame
->size
);
3869 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
3870 (htab
->plt_second_eh_frame
->contents
3871 + PLT_FDE_LEN_OFFSET
));
3874 if (htab
->elf
.dynamic_sections_created
)
3876 /* Add some entries to the .dynamic section. We fill in the
3877 values later, in elf_x86_64_finish_dynamic_sections, but we
3878 must add the entries now so that we get the correct size for
3879 the .dynamic section. The DT_DEBUG entry is filled in by the
3880 dynamic linker and used by the debugger. */
3881 #define add_dynamic_entry(TAG, VAL) \
3882 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3884 if (bfd_link_executable (info
))
3886 if (!add_dynamic_entry (DT_DEBUG
, 0))
3890 if (htab
->elf
.splt
->size
!= 0)
3892 /* DT_PLTGOT is used by prelink even if there is no PLT
3894 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3898 if (htab
->elf
.srelplt
->size
!= 0)
3900 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3901 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3902 || !add_dynamic_entry (DT_JMPREL
, 0))
3906 if (htab
->tlsdesc_plt
3907 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3908 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3913 if (!add_dynamic_entry (DT_RELA
, 0)
3914 || !add_dynamic_entry (DT_RELASZ
, 0)
3915 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3918 /* If any dynamic relocs apply to a read-only section,
3919 then we need a DT_TEXTREL entry. */
3920 if ((info
->flags
& DF_TEXTREL
) == 0)
3921 elf_link_hash_traverse (&htab
->elf
,
3922 elf_x86_64_readonly_dynrelocs
,
3925 if ((info
->flags
& DF_TEXTREL
) != 0)
3927 if (htab
->readonly_dynrelocs_against_ifunc
)
3929 info
->callbacks
->einfo
3930 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3931 bfd_set_error (bfd_error_bad_value
);
3935 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3940 #undef add_dynamic_entry
3946 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3947 struct bfd_link_info
*info
)
3949 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3953 struct elf_link_hash_entry
*tlsbase
;
3955 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3956 "_TLS_MODULE_BASE_",
3957 FALSE
, FALSE
, FALSE
);
3959 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3961 struct elf_x86_64_link_hash_table
*htab
;
3962 struct bfd_link_hash_entry
*bh
= NULL
;
3963 const struct elf_backend_data
*bed
3964 = get_elf_backend_data (output_bfd
);
3966 htab
= elf_x86_64_hash_table (info
);
3970 if (!(_bfd_generic_link_add_one_symbol
3971 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3972 tls_sec
, 0, NULL
, FALSE
,
3973 bed
->collect
, &bh
)))
3976 htab
->tls_module_base
= bh
;
3978 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3979 tlsbase
->def_regular
= 1;
3980 tlsbase
->other
= STV_HIDDEN
;
3981 tlsbase
->root
.linker_def
= 1;
3982 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3989 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3990 executables. Rather than setting it to the beginning of the TLS
3991 section, we have to set it to the end. This function may be called
3992 multiple times, it is idempotent. */
3995 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3997 struct elf_x86_64_link_hash_table
*htab
;
3998 struct bfd_link_hash_entry
*base
;
4000 if (!bfd_link_executable (info
))
4003 htab
= elf_x86_64_hash_table (info
);
4007 base
= htab
->tls_module_base
;
4011 base
->u
.def
.value
= htab
->elf
.tls_size
;
4014 /* Return the base VMA address which should be subtracted from real addresses
4015 when resolving @dtpoff relocation.
4016 This is PT_TLS segment p_vaddr. */
4019 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4021 /* If tls_sec is NULL, we should have signalled an error already. */
4022 if (elf_hash_table (info
)->tls_sec
== NULL
)
4024 return elf_hash_table (info
)->tls_sec
->vma
;
4027 /* Return the relocation value for @tpoff relocation
4028 if STT_TLS virtual address is ADDRESS. */
4031 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4033 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4034 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4035 bfd_vma static_tls_size
;
4037 /* If tls_segment is NULL, we should have signalled an error already. */
4038 if (htab
->tls_sec
== NULL
)
4041 /* Consider special static TLS alignment requirements. */
4042 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4043 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4046 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4050 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4052 /* Opcode Instruction
4055 0x0f 0x8x conditional jump */
4057 && (contents
[offset
- 1] == 0xe8
4058 || contents
[offset
- 1] == 0xe9))
4060 && contents
[offset
- 2] == 0x0f
4061 && (contents
[offset
- 1] & 0xf0) == 0x80));
4064 /* Relocate an x86_64 ELF section. */
4067 elf_x86_64_relocate_section (bfd
*output_bfd
,
4068 struct bfd_link_info
*info
,
4070 asection
*input_section
,
4072 Elf_Internal_Rela
*relocs
,
4073 Elf_Internal_Sym
*local_syms
,
4074 asection
**local_sections
)
4076 struct elf_x86_64_link_hash_table
*htab
;
4077 Elf_Internal_Shdr
*symtab_hdr
;
4078 struct elf_link_hash_entry
**sym_hashes
;
4079 bfd_vma
*local_got_offsets
;
4080 bfd_vma
*local_tlsdesc_gotents
;
4081 Elf_Internal_Rela
*rel
;
4082 Elf_Internal_Rela
*wrel
;
4083 Elf_Internal_Rela
*relend
;
4084 unsigned int plt_entry_size
;
4086 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4088 /* Skip if check_relocs failed. */
4089 if (input_section
->check_relocs_failed
)
4092 htab
= elf_x86_64_hash_table (info
);
4095 plt_entry_size
= htab
->plt
.plt_entry_size
;
4096 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4097 sym_hashes
= elf_sym_hashes (input_bfd
);
4098 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4099 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4101 elf_x86_64_set_tls_module_base (info
);
4103 rel
= wrel
= relocs
;
4104 relend
= relocs
+ input_section
->reloc_count
;
4105 for (; rel
< relend
; wrel
++, rel
++)
4107 unsigned int r_type
;
4108 reloc_howto_type
*howto
;
4109 unsigned long r_symndx
;
4110 struct elf_link_hash_entry
*h
;
4111 struct elf_x86_64_link_hash_entry
*eh
;
4112 Elf_Internal_Sym
*sym
;
4114 bfd_vma off
, offplt
, plt_offset
;
4116 bfd_boolean unresolved_reloc
;
4117 bfd_reloc_status_type r
;
4119 asection
*base_got
, *resolved_plt
;
4121 bfd_boolean resolved_to_zero
;
4122 bfd_boolean relative_reloc
;
4124 r_type
= ELF32_R_TYPE (rel
->r_info
);
4125 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4126 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4133 if (r_type
>= (int) R_X86_64_standard
)
4136 /* xgettext:c-format */
4137 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4138 input_bfd
, r_type
, input_section
);
4139 bfd_set_error (bfd_error_bad_value
);
4143 if (r_type
!= (int) R_X86_64_32
4144 || ABI_64_P (output_bfd
))
4145 howto
= x86_64_elf_howto_table
+ r_type
;
4147 howto
= (x86_64_elf_howto_table
4148 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4149 r_symndx
= htab
->r_sym (rel
->r_info
);
4153 unresolved_reloc
= FALSE
;
4154 if (r_symndx
< symtab_hdr
->sh_info
)
4156 sym
= local_syms
+ r_symndx
;
4157 sec
= local_sections
[r_symndx
];
4159 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4161 st_size
= sym
->st_size
;
4163 /* Relocate against local STT_GNU_IFUNC symbol. */
4164 if (!bfd_link_relocatable (info
)
4165 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4167 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4172 /* Set STT_GNU_IFUNC symbol value. */
4173 h
->root
.u
.def
.value
= sym
->st_value
;
4174 h
->root
.u
.def
.section
= sec
;
4179 bfd_boolean warned ATTRIBUTE_UNUSED
;
4180 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4182 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4183 r_symndx
, symtab_hdr
, sym_hashes
,
4185 unresolved_reloc
, warned
, ignored
);
4189 if (sec
!= NULL
&& discarded_section (sec
))
4191 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4192 contents
+ rel
->r_offset
);
4193 wrel
->r_offset
= rel
->r_offset
;
4197 /* For ld -r, remove relocations in debug sections against
4198 sections defined in discarded sections. Not done for
4199 eh_frame editing code expects to be present. */
4200 if (bfd_link_relocatable (info
)
4201 && (input_section
->flags
& SEC_DEBUGGING
))
4207 if (bfd_link_relocatable (info
))
4214 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4216 if (r_type
== R_X86_64_64
)
4218 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4219 zero-extend it to 64bit if addend is zero. */
4220 r_type
= R_X86_64_32
;
4221 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4223 else if (r_type
== R_X86_64_SIZE64
)
4225 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4226 zero-extend it to 64bit if addend is zero. */
4227 r_type
= R_X86_64_SIZE32
;
4228 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4232 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4234 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4235 it here if it is defined in a non-shared object. */
4237 && h
->type
== STT_GNU_IFUNC
4243 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4245 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4246 sections because such sections are not SEC_ALLOC and
4247 thus ld.so will not process them. */
4248 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4258 case R_X86_64_GOTPCREL
:
4259 case R_X86_64_GOTPCRELX
:
4260 case R_X86_64_REX_GOTPCRELX
:
4261 case R_X86_64_GOTPCREL64
:
4262 base_got
= htab
->elf
.sgot
;
4263 off
= h
->got
.offset
;
4265 if (base_got
== NULL
)
4268 if (off
== (bfd_vma
) -1)
4270 /* We can't use h->got.offset here to save state, or
4271 even just remember the offset, as finish_dynamic_symbol
4272 would use that as offset into .got. */
4274 if (h
->plt
.offset
== (bfd_vma
) -1)
4277 if (htab
->elf
.splt
!= NULL
)
4279 plt_index
= (h
->plt
.offset
/ plt_entry_size
4280 - htab
->plt
.has_plt0
);
4281 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4282 base_got
= htab
->elf
.sgotplt
;
4286 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4287 off
= plt_index
* GOT_ENTRY_SIZE
;
4288 base_got
= htab
->elf
.igotplt
;
4291 if (h
->dynindx
== -1
4295 /* This references the local defitionion. We must
4296 initialize this entry in the global offset table.
4297 Since the offset must always be a multiple of 8,
4298 we use the least significant bit to record
4299 whether we have initialized it already.
4301 When doing a dynamic link, we create a .rela.got
4302 relocation entry to initialize the value. This
4303 is done in the finish_dynamic_symbol routine. */
4308 bfd_put_64 (output_bfd
, relocation
,
4309 base_got
->contents
+ off
);
4310 /* Note that this is harmless for the GOTPLT64
4311 case, as -1 | 1 still is -1. */
4317 relocation
= (base_got
->output_section
->vma
4318 + base_got
->output_offset
+ off
);
4323 if (h
->plt
.offset
== (bfd_vma
) -1)
4325 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4326 if (r_type
== htab
->pointer_r_type
4327 && (input_section
->flags
& SEC_CODE
) == 0)
4328 goto do_ifunc_pointer
;
4329 goto bad_ifunc_reloc
;
4332 /* STT_GNU_IFUNC symbol must go through PLT. */
4333 if (htab
->elf
.splt
!= NULL
)
4335 if (htab
->plt_second
!= NULL
)
4337 resolved_plt
= htab
->plt_second
;
4338 plt_offset
= eh
->plt_second
.offset
;
4342 resolved_plt
= htab
->elf
.splt
;
4343 plt_offset
= h
->plt
.offset
;
4348 resolved_plt
= htab
->elf
.iplt
;
4349 plt_offset
= h
->plt
.offset
;
4352 relocation
= (resolved_plt
->output_section
->vma
4353 + resolved_plt
->output_offset
+ plt_offset
);
4359 if (h
->root
.root
.string
)
4360 name
= h
->root
.root
.string
;
4362 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4365 /* xgettext:c-format */
4366 (_("%B: relocation %s against STT_GNU_IFUNC "
4367 "symbol `%s' isn't supported"), input_bfd
,
4369 bfd_set_error (bfd_error_bad_value
);
4373 if (bfd_link_pic (info
))
4378 if (ABI_64_P (output_bfd
))
4383 if (rel
->r_addend
!= 0)
4385 if (h
->root
.root
.string
)
4386 name
= h
->root
.root
.string
;
4388 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4391 /* xgettext:c-format */
4392 (_("%B: relocation %s against STT_GNU_IFUNC "
4393 "symbol `%s' has non-zero addend: %d"),
4394 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4395 bfd_set_error (bfd_error_bad_value
);
4399 /* Generate dynamic relcoation only when there is a
4400 non-GOT reference in a shared object or there is no
4402 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4403 || h
->plt
.offset
== (bfd_vma
) -1)
4405 Elf_Internal_Rela outrel
;
4408 /* Need a dynamic relocation to get the real function
4410 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4414 if (outrel
.r_offset
== (bfd_vma
) -1
4415 || outrel
.r_offset
== (bfd_vma
) -2)
4418 outrel
.r_offset
+= (input_section
->output_section
->vma
4419 + input_section
->output_offset
);
4421 if (h
->dynindx
== -1
4423 || bfd_link_executable (info
))
4425 /* This symbol is resolved locally. */
4426 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4427 outrel
.r_addend
= (h
->root
.u
.def
.value
4428 + h
->root
.u
.def
.section
->output_section
->vma
4429 + h
->root
.u
.def
.section
->output_offset
);
4433 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4434 outrel
.r_addend
= 0;
4437 /* Dynamic relocations are stored in
4438 1. .rela.ifunc section in PIC object.
4439 2. .rela.got section in dynamic executable.
4440 3. .rela.iplt section in static executable. */
4441 if (bfd_link_pic (info
))
4442 sreloc
= htab
->elf
.irelifunc
;
4443 else if (htab
->elf
.splt
!= NULL
)
4444 sreloc
= htab
->elf
.srelgot
;
4446 sreloc
= htab
->elf
.irelplt
;
4447 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4449 /* If this reloc is against an external symbol, we
4450 do not want to fiddle with the addend. Otherwise,
4451 we need to include the symbol value so that it
4452 becomes an addend for the dynamic reloc. For an
4453 internal symbol, we have updated addend. */
4458 case R_X86_64_PC32_BND
:
4460 case R_X86_64_PLT32
:
4461 case R_X86_64_PLT32_BND
:
4466 resolved_to_zero
= (eh
!= NULL
4467 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4471 /* When generating a shared object, the relocations handled here are
4472 copied into the output file to be resolved at run time. */
4475 case R_X86_64_GOT32
:
4476 case R_X86_64_GOT64
:
4477 /* Relocation is to the entry for this symbol in the global
4479 case R_X86_64_GOTPCREL
:
4480 case R_X86_64_GOTPCRELX
:
4481 case R_X86_64_REX_GOTPCRELX
:
4482 case R_X86_64_GOTPCREL64
:
4483 /* Use global offset table entry as symbol value. */
4484 case R_X86_64_GOTPLT64
:
4485 /* This is obsolete and treated the the same as GOT64. */
4486 base_got
= htab
->elf
.sgot
;
4488 if (htab
->elf
.sgot
== NULL
)
4491 relative_reloc
= FALSE
;
4496 off
= h
->got
.offset
;
4498 && h
->plt
.offset
!= (bfd_vma
)-1
4499 && off
== (bfd_vma
)-1)
4501 /* We can't use h->got.offset here to save
4502 state, or even just remember the offset, as
4503 finish_dynamic_symbol would use that as offset into
4505 bfd_vma plt_index
= (h
->plt
.offset
/ plt_entry_size
4506 - htab
->plt
.has_plt0
);
4507 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4508 base_got
= htab
->elf
.sgotplt
;
4511 dyn
= htab
->elf
.dynamic_sections_created
;
4513 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4514 || (bfd_link_pic (info
)
4515 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4516 || (ELF_ST_VISIBILITY (h
->other
)
4517 && h
->root
.type
== bfd_link_hash_undefweak
))
4519 /* This is actually a static link, or it is a -Bsymbolic
4520 link and the symbol is defined locally, or the symbol
4521 was forced to be local because of a version file. We
4522 must initialize this entry in the global offset table.
4523 Since the offset must always be a multiple of 8, we
4524 use the least significant bit to record whether we
4525 have initialized it already.
4527 When doing a dynamic link, we create a .rela.got
4528 relocation entry to initialize the value. This is
4529 done in the finish_dynamic_symbol routine. */
4534 bfd_put_64 (output_bfd
, relocation
,
4535 base_got
->contents
+ off
);
4536 /* Note that this is harmless for the GOTPLT64 case,
4537 as -1 | 1 still is -1. */
4540 if (h
->dynindx
== -1
4542 && h
->root
.type
!= bfd_link_hash_undefweak
4543 && bfd_link_pic (info
))
4545 /* If this symbol isn't dynamic in PIC,
4546 generate R_X86_64_RELATIVE here. */
4547 eh
->no_finish_dynamic_symbol
= 1;
4548 relative_reloc
= TRUE
;
4553 unresolved_reloc
= FALSE
;
4557 if (local_got_offsets
== NULL
)
4560 off
= local_got_offsets
[r_symndx
];
4562 /* The offset must always be a multiple of 8. We use
4563 the least significant bit to record whether we have
4564 already generated the necessary reloc. */
4569 bfd_put_64 (output_bfd
, relocation
,
4570 base_got
->contents
+ off
);
4571 local_got_offsets
[r_symndx
] |= 1;
4573 if (bfd_link_pic (info
))
4574 relative_reloc
= TRUE
;
4581 Elf_Internal_Rela outrel
;
4583 /* We need to generate a R_X86_64_RELATIVE reloc
4584 for the dynamic linker. */
4585 s
= htab
->elf
.srelgot
;
4589 outrel
.r_offset
= (base_got
->output_section
->vma
4590 + base_got
->output_offset
4592 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4593 outrel
.r_addend
= relocation
;
4594 elf_append_rela (output_bfd
, s
, &outrel
);
4597 if (off
>= (bfd_vma
) -2)
4600 relocation
= base_got
->output_section
->vma
4601 + base_got
->output_offset
+ off
;
4602 if (r_type
!= R_X86_64_GOTPCREL
4603 && r_type
!= R_X86_64_GOTPCRELX
4604 && r_type
!= R_X86_64_REX_GOTPCRELX
4605 && r_type
!= R_X86_64_GOTPCREL64
)
4606 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4607 - htab
->elf
.sgotplt
->output_offset
;
4611 case R_X86_64_GOTOFF64
:
4612 /* Relocation is relative to the start of the global offset
4615 /* Check to make sure it isn't a protected function or data
4616 symbol for shared library since it may not be local when
4617 used as function address or with copy relocation. We also
4618 need to make sure that a symbol is referenced locally. */
4619 if (bfd_link_pic (info
) && h
)
4621 if (!h
->def_regular
)
4625 switch (ELF_ST_VISIBILITY (h
->other
))
4628 v
= _("hidden symbol");
4631 v
= _("internal symbol");
4634 v
= _("protected symbol");
4642 /* xgettext:c-format */
4643 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
4644 " `%s' can not be used when making a shared object"),
4645 input_bfd
, v
, h
->root
.root
.string
);
4646 bfd_set_error (bfd_error_bad_value
);
4649 else if (!bfd_link_executable (info
)
4650 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4651 && (h
->type
== STT_FUNC
4652 || h
->type
== STT_OBJECT
)
4653 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4656 /* xgettext:c-format */
4657 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
4658 " `%s' can not be used when making a shared object"),
4660 h
->type
== STT_FUNC
? "function" : "data",
4661 h
->root
.root
.string
);
4662 bfd_set_error (bfd_error_bad_value
);
4667 /* Note that sgot is not involved in this
4668 calculation. We always want the start of .got.plt. If we
4669 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4670 permitted by the ABI, we might have to change this
4672 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4673 + htab
->elf
.sgotplt
->output_offset
;
4676 case R_X86_64_GOTPC32
:
4677 case R_X86_64_GOTPC64
:
4678 /* Use global offset table as symbol value. */
4679 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4680 + htab
->elf
.sgotplt
->output_offset
;
4681 unresolved_reloc
= FALSE
;
4684 case R_X86_64_PLTOFF64
:
4685 /* Relocation is PLT entry relative to GOT. For local
4686 symbols it's the symbol itself relative to GOT. */
4688 /* See PLT32 handling. */
4689 && (h
->plt
.offset
!= (bfd_vma
) -1
4690 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
4691 && htab
->elf
.splt
!= NULL
)
4693 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4695 /* Use the GOT PLT. */
4696 resolved_plt
= htab
->plt_got
;
4697 plt_offset
= eh
->plt_got
.offset
;
4699 else if (htab
->plt_second
!= NULL
)
4701 resolved_plt
= htab
->plt_second
;
4702 plt_offset
= eh
->plt_second
.offset
;
4706 resolved_plt
= htab
->elf
.splt
;
4707 plt_offset
= h
->plt
.offset
;
4710 relocation
= (resolved_plt
->output_section
->vma
4711 + resolved_plt
->output_offset
4713 unresolved_reloc
= FALSE
;
4716 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4717 + htab
->elf
.sgotplt
->output_offset
;
4720 case R_X86_64_PLT32
:
4721 case R_X86_64_PLT32_BND
:
4722 /* Relocation is to the entry for this symbol in the
4723 procedure linkage table. */
4725 /* Resolve a PLT32 reloc against a local symbol directly,
4726 without using the procedure linkage table. */
4730 if ((h
->plt
.offset
== (bfd_vma
) -1
4731 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4732 || htab
->elf
.splt
== NULL
)
4734 /* We didn't make a PLT entry for this symbol. This
4735 happens when statically linking PIC code, or when
4736 using -Bsymbolic. */
4740 if (h
->plt
.offset
!= (bfd_vma
) -1)
4742 if (htab
->plt_second
!= NULL
)
4744 resolved_plt
= htab
->plt_second
;
4745 plt_offset
= eh
->plt_second
.offset
;
4749 resolved_plt
= htab
->elf
.splt
;
4750 plt_offset
= h
->plt
.offset
;
4755 /* Use the GOT PLT. */
4756 resolved_plt
= htab
->plt_got
;
4757 plt_offset
= eh
->plt_got
.offset
;
4760 relocation
= (resolved_plt
->output_section
->vma
4761 + resolved_plt
->output_offset
4763 unresolved_reloc
= FALSE
;
4766 case R_X86_64_SIZE32
:
4767 case R_X86_64_SIZE64
:
4768 /* Set to symbol size. */
4769 relocation
= st_size
;
4775 case R_X86_64_PC32_BND
:
4776 /* Don't complain about -fPIC if the symbol is undefined when
4777 building executable unless it is unresolved weak symbol. */
4778 if ((input_section
->flags
& SEC_ALLOC
) != 0
4779 && (input_section
->flags
& SEC_READONLY
) != 0
4781 && ((bfd_link_executable (info
)
4782 && h
->root
.type
== bfd_link_hash_undefweak
4783 && !resolved_to_zero
)
4784 || (bfd_link_pic (info
)
4785 && !(bfd_link_pie (info
)
4786 && h
->root
.type
== bfd_link_hash_undefined
))))
4788 bfd_boolean fail
= FALSE
;
4790 = ((r_type
== R_X86_64_PC32
4791 || r_type
== R_X86_64_PC32_BND
)
4792 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4794 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4796 /* Symbol is referenced locally. Make sure it is
4797 defined locally or for a branch. */
4798 fail
= (!(h
->def_regular
|| ELF_COMMON_DEF_P (h
))
4801 else if (!(bfd_link_pie (info
)
4802 && (h
->needs_copy
|| eh
->needs_copy
)))
4804 /* Symbol doesn't need copy reloc and isn't referenced
4805 locally. We only allow branch to symbol with
4806 non-default visibility. */
4808 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4812 return elf_x86_64_need_pic (input_bfd
, input_section
,
4813 h
, NULL
, NULL
, howto
);
4822 /* FIXME: The ABI says the linker should make sure the value is
4823 the same when it's zeroextended to 64 bit. */
4826 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4829 /* Don't copy a pc-relative relocation into the output file
4830 if the symbol needs copy reloc or the symbol is undefined
4831 when building executable. Copy dynamic function pointer
4832 relocations. Don't generate dynamic relocations against
4833 resolved undefined weak symbols in PIE. */
4834 if ((bfd_link_pic (info
)
4835 && !(bfd_link_pie (info
)
4839 || h
->root
.type
== bfd_link_hash_undefined
)
4840 && (IS_X86_64_PCREL_TYPE (r_type
)
4841 || r_type
== R_X86_64_SIZE32
4842 || r_type
== R_X86_64_SIZE64
))
4844 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4845 && !resolved_to_zero
)
4846 || h
->root
.type
!= bfd_link_hash_undefweak
))
4847 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4848 && r_type
!= R_X86_64_SIZE32
4849 && r_type
!= R_X86_64_SIZE64
)
4850 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4851 || (ELIMINATE_COPY_RELOCS
4852 && !bfd_link_pic (info
)
4856 || eh
->func_pointer_refcount
> 0
4857 || (h
->root
.type
== bfd_link_hash_undefweak
4858 && !resolved_to_zero
))
4859 && ((h
->def_dynamic
&& !h
->def_regular
)
4860 /* Undefined weak symbol is bound locally when
4862 || h
->root
.type
== bfd_link_hash_undefined
)))
4864 Elf_Internal_Rela outrel
;
4865 bfd_boolean skip
, relocate
;
4868 /* When generating a shared object, these relocations
4869 are copied into the output file to be resolved at run
4875 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4877 if (outrel
.r_offset
== (bfd_vma
) -1)
4879 else if (outrel
.r_offset
== (bfd_vma
) -2)
4880 skip
= TRUE
, relocate
= TRUE
;
4882 outrel
.r_offset
+= (input_section
->output_section
->vma
4883 + input_section
->output_offset
);
4886 memset (&outrel
, 0, sizeof outrel
);
4888 /* h->dynindx may be -1 if this symbol was marked to
4892 && (IS_X86_64_PCREL_TYPE (r_type
)
4893 || !(bfd_link_executable (info
)
4894 || SYMBOLIC_BIND (info
, h
))
4895 || ! h
->def_regular
))
4897 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4898 outrel
.r_addend
= rel
->r_addend
;
4902 /* This symbol is local, or marked to become local.
4903 When relocation overflow check is disabled, we
4904 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4905 if (r_type
== htab
->pointer_r_type
4906 || (r_type
== R_X86_64_32
4907 && info
->no_reloc_overflow_check
))
4910 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4911 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4913 else if (r_type
== R_X86_64_64
4914 && !ABI_64_P (output_bfd
))
4917 outrel
.r_info
= htab
->r_info (0,
4918 R_X86_64_RELATIVE64
);
4919 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4920 /* Check addend overflow. */
4921 if ((outrel
.r_addend
& 0x80000000)
4922 != (rel
->r_addend
& 0x80000000))
4925 int addend
= rel
->r_addend
;
4926 if (h
&& h
->root
.root
.string
)
4927 name
= h
->root
.root
.string
;
4929 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4933 /* xgettext:c-format */
4934 (_("%B: addend -0x%x in relocation %s against "
4935 "symbol `%s' at 0x%lx in section `%A' is "
4937 input_bfd
, addend
, howto
->name
, name
,
4938 (unsigned long) rel
->r_offset
, input_section
);
4941 /* xgettext:c-format */
4942 (_("%B: addend 0x%x in relocation %s against "
4943 "symbol `%s' at 0x%lx in section `%A' is "
4945 input_bfd
, addend
, howto
->name
, name
,
4946 (unsigned long) rel
->r_offset
, input_section
);
4947 bfd_set_error (bfd_error_bad_value
);
4955 if (bfd_is_abs_section (sec
))
4957 else if (sec
== NULL
|| sec
->owner
== NULL
)
4959 bfd_set_error (bfd_error_bad_value
);
4966 /* We are turning this relocation into one
4967 against a section symbol. It would be
4968 proper to subtract the symbol's value,
4969 osec->vma, from the emitted reloc addend,
4970 but ld.so expects buggy relocs. */
4971 osec
= sec
->output_section
;
4972 sindx
= elf_section_data (osec
)->dynindx
;
4975 asection
*oi
= htab
->elf
.text_index_section
;
4976 sindx
= elf_section_data (oi
)->dynindx
;
4978 BFD_ASSERT (sindx
!= 0);
4981 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4982 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4986 sreloc
= elf_section_data (input_section
)->sreloc
;
4988 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4990 r
= bfd_reloc_notsupported
;
4991 goto check_relocation_error
;
4994 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4996 /* If this reloc is against an external symbol, we do
4997 not want to fiddle with the addend. Otherwise, we
4998 need to include the symbol value so that it becomes
4999 an addend for the dynamic reloc. */
5006 case R_X86_64_TLSGD
:
5007 case R_X86_64_GOTPC32_TLSDESC
:
5008 case R_X86_64_TLSDESC_CALL
:
5009 case R_X86_64_GOTTPOFF
:
5010 tls_type
= GOT_UNKNOWN
;
5011 if (h
== NULL
&& local_got_offsets
)
5012 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
5014 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
5016 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5017 input_section
, contents
,
5018 symtab_hdr
, sym_hashes
,
5019 &r_type
, tls_type
, rel
,
5020 relend
, h
, r_symndx
, TRUE
))
5023 if (r_type
== R_X86_64_TPOFF32
)
5025 bfd_vma roff
= rel
->r_offset
;
5027 BFD_ASSERT (! unresolved_reloc
);
5029 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5031 /* GD->LE transition. For 64bit, change
5032 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5033 .word 0x6666; rex64; call __tls_get_addr@PLT
5035 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5037 call *__tls_get_addr@GOTPCREL(%rip)
5038 which may be converted to
5039 addr32 call __tls_get_addr
5042 leaq foo@tpoff(%rax), %rax
5044 leaq foo@tlsgd(%rip), %rdi
5045 .word 0x6666; rex64; call __tls_get_addr@PLT
5047 leaq foo@tlsgd(%rip), %rdi
5049 call *__tls_get_addr@GOTPCREL(%rip)
5050 which may be converted to
5051 addr32 call __tls_get_addr
5054 leaq foo@tpoff(%rax), %rax
5055 For largepic, change:
5056 leaq foo@tlsgd(%rip), %rdi
5057 movabsq $__tls_get_addr@pltoff, %rax
5062 leaq foo@tpoff(%rax), %rax
5063 nopw 0x0(%rax,%rax,1) */
5065 if (ABI_64_P (output_bfd
))
5067 if (contents
[roff
+ 5] == 0xb8)
5069 memcpy (contents
+ roff
- 3,
5070 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5071 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5075 memcpy (contents
+ roff
- 4,
5076 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5080 memcpy (contents
+ roff
- 3,
5081 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5083 bfd_put_32 (output_bfd
,
5084 elf_x86_64_tpoff (info
, relocation
),
5085 contents
+ roff
+ 8 + largepic
);
5086 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5087 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5092 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5094 /* GDesc -> LE transition.
5095 It's originally something like:
5096 leaq x@tlsdesc(%rip), %rax
5099 movl $x@tpoff, %rax. */
5101 unsigned int val
, type
;
5103 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5104 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5105 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5106 contents
+ roff
- 3);
5107 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5108 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5109 contents
+ roff
- 1);
5110 bfd_put_32 (output_bfd
,
5111 elf_x86_64_tpoff (info
, relocation
),
5115 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5117 /* GDesc -> LE transition.
5122 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5123 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5126 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5128 /* IE->LE transition:
5129 For 64bit, originally it can be one of:
5130 movq foo@gottpoff(%rip), %reg
5131 addq foo@gottpoff(%rip), %reg
5134 leaq foo(%reg), %reg
5136 For 32bit, originally it can be one of:
5137 movq foo@gottpoff(%rip), %reg
5138 addl foo@gottpoff(%rip), %reg
5141 leal foo(%reg), %reg
5144 unsigned int val
, type
, reg
;
5147 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5150 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5151 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5157 bfd_put_8 (output_bfd
, 0x49,
5158 contents
+ roff
- 3);
5159 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5160 bfd_put_8 (output_bfd
, 0x41,
5161 contents
+ roff
- 3);
5162 bfd_put_8 (output_bfd
, 0xc7,
5163 contents
+ roff
- 2);
5164 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5165 contents
+ roff
- 1);
5169 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5172 bfd_put_8 (output_bfd
, 0x49,
5173 contents
+ roff
- 3);
5174 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5175 bfd_put_8 (output_bfd
, 0x41,
5176 contents
+ roff
- 3);
5177 bfd_put_8 (output_bfd
, 0x81,
5178 contents
+ roff
- 2);
5179 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5180 contents
+ roff
- 1);
5184 /* addq/addl -> leaq/leal */
5186 bfd_put_8 (output_bfd
, 0x4d,
5187 contents
+ roff
- 3);
5188 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5189 bfd_put_8 (output_bfd
, 0x45,
5190 contents
+ roff
- 3);
5191 bfd_put_8 (output_bfd
, 0x8d,
5192 contents
+ roff
- 2);
5193 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5194 contents
+ roff
- 1);
5196 bfd_put_32 (output_bfd
,
5197 elf_x86_64_tpoff (info
, relocation
),
5205 if (htab
->elf
.sgot
== NULL
)
5210 off
= h
->got
.offset
;
5211 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5215 if (local_got_offsets
== NULL
)
5218 off
= local_got_offsets
[r_symndx
];
5219 offplt
= local_tlsdesc_gotents
[r_symndx
];
5226 Elf_Internal_Rela outrel
;
5230 if (htab
->elf
.srelgot
== NULL
)
5233 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5235 if (GOT_TLS_GDESC_P (tls_type
))
5237 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5238 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5239 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5240 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5241 + htab
->elf
.sgotplt
->output_offset
5243 + htab
->sgotplt_jump_table_size
);
5244 sreloc
= htab
->elf
.srelplt
;
5246 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5248 outrel
.r_addend
= 0;
5249 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5252 sreloc
= htab
->elf
.srelgot
;
5254 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5255 + htab
->elf
.sgot
->output_offset
+ off
);
5257 if (GOT_TLS_GD_P (tls_type
))
5258 dr_type
= R_X86_64_DTPMOD64
;
5259 else if (GOT_TLS_GDESC_P (tls_type
))
5262 dr_type
= R_X86_64_TPOFF64
;
5264 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5265 outrel
.r_addend
= 0;
5266 if ((dr_type
== R_X86_64_TPOFF64
5267 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5268 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5269 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5271 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5273 if (GOT_TLS_GD_P (tls_type
))
5277 BFD_ASSERT (! unresolved_reloc
);
5278 bfd_put_64 (output_bfd
,
5279 relocation
- elf_x86_64_dtpoff_base (info
),
5280 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5284 bfd_put_64 (output_bfd
, 0,
5285 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5286 outrel
.r_info
= htab
->r_info (indx
,
5288 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5289 elf_append_rela (output_bfd
, sreloc
,
5298 local_got_offsets
[r_symndx
] |= 1;
5301 if (off
>= (bfd_vma
) -2
5302 && ! GOT_TLS_GDESC_P (tls_type
))
5304 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5306 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5307 || r_type
== R_X86_64_TLSDESC_CALL
)
5308 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5309 + htab
->elf
.sgotplt
->output_offset
5310 + offplt
+ htab
->sgotplt_jump_table_size
;
5312 relocation
= htab
->elf
.sgot
->output_section
->vma
5313 + htab
->elf
.sgot
->output_offset
+ off
;
5314 unresolved_reloc
= FALSE
;
5318 bfd_vma roff
= rel
->r_offset
;
5320 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5322 /* GD->IE transition. For 64bit, change
5323 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5324 .word 0x6666; rex64; call __tls_get_addr@PLT
5326 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5328 call *__tls_get_addr@GOTPCREL(%rip
5329 which may be converted to
5330 addr32 call __tls_get_addr
5333 addq foo@gottpoff(%rip), %rax
5335 leaq foo@tlsgd(%rip), %rdi
5336 .word 0x6666; rex64; call __tls_get_addr@PLT
5338 leaq foo@tlsgd(%rip), %rdi
5340 call *__tls_get_addr@GOTPCREL(%rip)
5341 which may be converted to
5342 addr32 call __tls_get_addr
5345 addq foo@gottpoff(%rip), %rax
5346 For largepic, change:
5347 leaq foo@tlsgd(%rip), %rdi
5348 movabsq $__tls_get_addr@pltoff, %rax
5353 addq foo@gottpoff(%rax), %rax
5354 nopw 0x0(%rax,%rax,1) */
5356 if (ABI_64_P (output_bfd
))
5358 if (contents
[roff
+ 5] == 0xb8)
5360 memcpy (contents
+ roff
- 3,
5361 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5362 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5366 memcpy (contents
+ roff
- 4,
5367 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5371 memcpy (contents
+ roff
- 3,
5372 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5375 relocation
= (htab
->elf
.sgot
->output_section
->vma
5376 + htab
->elf
.sgot
->output_offset
+ off
5379 - input_section
->output_section
->vma
5380 - input_section
->output_offset
5382 bfd_put_32 (output_bfd
, relocation
,
5383 contents
+ roff
+ 8 + largepic
);
5384 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5389 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5391 /* GDesc -> IE transition.
5392 It's originally something like:
5393 leaq x@tlsdesc(%rip), %rax
5396 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5398 /* Now modify the instruction as appropriate. To
5399 turn a leaq into a movq in the form we use it, it
5400 suffices to change the second byte from 0x8d to
5402 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5404 bfd_put_32 (output_bfd
,
5405 htab
->elf
.sgot
->output_section
->vma
5406 + htab
->elf
.sgot
->output_offset
+ off
5408 - input_section
->output_section
->vma
5409 - input_section
->output_offset
5414 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5416 /* GDesc -> IE transition.
5423 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5424 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5432 case R_X86_64_TLSLD
:
5433 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5434 input_section
, contents
,
5435 symtab_hdr
, sym_hashes
,
5436 &r_type
, GOT_UNKNOWN
, rel
,
5437 relend
, h
, r_symndx
, TRUE
))
5440 if (r_type
!= R_X86_64_TLSLD
)
5442 /* LD->LE transition:
5443 leaq foo@tlsld(%rip), %rdi
5444 call __tls_get_addr@PLT
5445 For 64bit, we change it into:
5446 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5447 For 32bit, we change it into:
5448 nopl 0x0(%rax); movl %fs:0, %eax
5450 leaq foo@tlsld(%rip), %rdi;
5451 call *__tls_get_addr@GOTPCREL(%rip)
5452 which may be converted to
5453 addr32 call __tls_get_addr
5454 For 64bit, we change it into:
5455 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5456 For 32bit, we change it into:
5457 nopw 0x0(%rax); movl %fs:0, %eax
5458 For largepic, change:
5459 leaq foo@tlsgd(%rip), %rdi
5460 movabsq $__tls_get_addr@pltoff, %rax
5464 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5467 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5468 if (ABI_64_P (output_bfd
))
5470 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5471 memcpy (contents
+ rel
->r_offset
- 3,
5472 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5473 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5474 else if (contents
[rel
->r_offset
+ 4] == 0xff
5475 || contents
[rel
->r_offset
+ 4] == 0x67)
5476 memcpy (contents
+ rel
->r_offset
- 3,
5477 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5480 memcpy (contents
+ rel
->r_offset
- 3,
5481 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5485 if (contents
[rel
->r_offset
+ 4] == 0xff)
5486 memcpy (contents
+ rel
->r_offset
- 3,
5487 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5490 memcpy (contents
+ rel
->r_offset
- 3,
5491 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5493 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5494 and R_X86_64_PLTOFF64. */
5500 if (htab
->elf
.sgot
== NULL
)
5503 off
= htab
->tls_ld_got
.offset
;
5508 Elf_Internal_Rela outrel
;
5510 if (htab
->elf
.srelgot
== NULL
)
5513 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5514 + htab
->elf
.sgot
->output_offset
+ off
);
5516 bfd_put_64 (output_bfd
, 0,
5517 htab
->elf
.sgot
->contents
+ off
);
5518 bfd_put_64 (output_bfd
, 0,
5519 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5520 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5521 outrel
.r_addend
= 0;
5522 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5524 htab
->tls_ld_got
.offset
|= 1;
5526 relocation
= htab
->elf
.sgot
->output_section
->vma
5527 + htab
->elf
.sgot
->output_offset
+ off
;
5528 unresolved_reloc
= FALSE
;
5531 case R_X86_64_DTPOFF32
:
5532 if (!bfd_link_executable (info
)
5533 || (input_section
->flags
& SEC_CODE
) == 0)
5534 relocation
-= elf_x86_64_dtpoff_base (info
);
5536 relocation
= elf_x86_64_tpoff (info
, relocation
);
5539 case R_X86_64_TPOFF32
:
5540 case R_X86_64_TPOFF64
:
5541 BFD_ASSERT (bfd_link_executable (info
));
5542 relocation
= elf_x86_64_tpoff (info
, relocation
);
5545 case R_X86_64_DTPOFF64
:
5546 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5547 relocation
-= elf_x86_64_dtpoff_base (info
);
5554 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5555 because such sections are not SEC_ALLOC and thus ld.so will
5556 not process them. */
5557 if (unresolved_reloc
5558 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5560 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5561 rel
->r_offset
) != (bfd_vma
) -1)
5564 /* xgettext:c-format */
5565 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5568 (long) rel
->r_offset
,
5570 h
->root
.root
.string
);
5575 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5576 contents
, rel
->r_offset
,
5577 relocation
, rel
->r_addend
);
5579 check_relocation_error
:
5580 if (r
!= bfd_reloc_ok
)
5585 name
= h
->root
.root
.string
;
5588 name
= bfd_elf_string_from_elf_section (input_bfd
,
5589 symtab_hdr
->sh_link
,
5594 name
= bfd_section_name (input_bfd
, sec
);
5597 if (r
== bfd_reloc_overflow
)
5598 (*info
->callbacks
->reloc_overflow
)
5599 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5600 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5604 /* xgettext:c-format */
5605 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5606 input_bfd
, input_section
,
5607 (long) rel
->r_offset
, name
, (int) r
);
5618 Elf_Internal_Shdr
*rel_hdr
;
5619 size_t deleted
= rel
- wrel
;
5621 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5622 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5623 if (rel_hdr
->sh_size
== 0)
5625 /* It is too late to remove an empty reloc section. Leave
5627 ??? What is wrong with an empty section??? */
5628 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5631 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5632 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5633 input_section
->reloc_count
-= deleted
;
5639 /* Finish up dynamic symbol handling. We set the contents of various
5640 dynamic sections here. */
5643 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5644 struct bfd_link_info
*info
,
5645 struct elf_link_hash_entry
*h
,
5646 Elf_Internal_Sym
*sym
)
5648 struct elf_x86_64_link_hash_table
*htab
;
5649 bfd_boolean use_plt_second
;
5650 struct elf_x86_64_link_hash_entry
*eh
;
5651 bfd_boolean local_undefweak
;
5653 htab
= elf_x86_64_hash_table (info
);
5657 /* Use the second PLT section only if there is .plt section. */
5658 use_plt_second
= htab
->elf
.splt
!= NULL
&& htab
->plt_second
!= NULL
;
5660 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5661 if (eh
->no_finish_dynamic_symbol
)
5664 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5665 resolved undefined weak symbols in executable so that their
5666 references have value 0 at run-time. */
5667 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5671 if (h
->plt
.offset
!= (bfd_vma
) -1)
5674 bfd_vma got_offset
, plt_offset
;
5675 Elf_Internal_Rela rela
;
5677 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5678 const struct elf_backend_data
*bed
;
5679 bfd_vma plt_got_pcrel_offset
;
5681 /* When building a static executable, use .iplt, .igot.plt and
5682 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5683 if (htab
->elf
.splt
!= NULL
)
5685 plt
= htab
->elf
.splt
;
5686 gotplt
= htab
->elf
.sgotplt
;
5687 relplt
= htab
->elf
.srelplt
;
5691 plt
= htab
->elf
.iplt
;
5692 gotplt
= htab
->elf
.igotplt
;
5693 relplt
= htab
->elf
.irelplt
;
5696 /* This symbol has an entry in the procedure linkage table. Set
5698 if ((h
->dynindx
== -1
5700 && !((h
->forced_local
|| bfd_link_executable (info
))
5702 && h
->type
== STT_GNU_IFUNC
))
5708 /* Get the index in the procedure linkage table which
5709 corresponds to this symbol. This is the index of this symbol
5710 in all the symbols for which we are making plt entries. The
5711 first entry in the procedure linkage table is reserved.
5713 Get the offset into the .got table of the entry that
5714 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5715 bytes. The first three are reserved for the dynamic linker.
5717 For static executables, we don't reserve anything. */
5719 if (plt
== htab
->elf
.splt
)
5721 got_offset
= (h
->plt
.offset
/ htab
->plt
.plt_entry_size
5722 - htab
->plt
.has_plt0
);
5723 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5727 got_offset
= h
->plt
.offset
/ htab
->plt
.plt_entry_size
;
5728 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5731 /* Fill in the entry in the procedure linkage table. */
5732 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
5733 htab
->plt
.plt_entry_size
);
5736 memcpy (htab
->plt_second
->contents
+ eh
->plt_second
.offset
,
5737 htab
->non_lazy_plt
->plt_entry
,
5738 htab
->non_lazy_plt
->plt_entry_size
);
5740 resolved_plt
= htab
->plt_second
;
5741 plt_offset
= eh
->plt_second
.offset
;
5746 plt_offset
= h
->plt
.offset
;
5749 /* Insert the relocation positions of the plt section. */
5751 /* Put offset the PC-relative instruction referring to the GOT entry,
5752 subtracting the size of that instruction. */
5753 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5754 + gotplt
->output_offset
5756 - resolved_plt
->output_section
->vma
5757 - resolved_plt
->output_offset
5759 - htab
->plt
.plt_got_insn_size
);
5761 /* Check PC-relative offset overflow in PLT entry. */
5762 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5763 /* xgettext:c-format */
5764 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5765 output_bfd
, h
->root
.root
.string
);
5767 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5768 (resolved_plt
->contents
+ plt_offset
5769 + htab
->plt
.plt_got_offset
));
5771 /* Fill in the entry in the global offset table, initially this
5772 points to the second part of the PLT entry. Leave the entry
5773 as zero for undefined weak symbol in PIE. No PLT relocation
5774 against undefined weak symbol in PIE. */
5775 if (!local_undefweak
)
5777 if (htab
->plt
.has_plt0
)
5778 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5779 + plt
->output_offset
5781 + htab
->lazy_plt
->plt_lazy_offset
),
5782 gotplt
->contents
+ got_offset
);
5784 /* Fill in the entry in the .rela.plt section. */
5785 rela
.r_offset
= (gotplt
->output_section
->vma
5786 + gotplt
->output_offset
5788 if (h
->dynindx
== -1
5789 || ((bfd_link_executable (info
)
5790 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5792 && h
->type
== STT_GNU_IFUNC
))
5794 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5795 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5796 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5797 rela
.r_addend
= (h
->root
.u
.def
.value
5798 + h
->root
.u
.def
.section
->output_section
->vma
5799 + h
->root
.u
.def
.section
->output_offset
);
5800 /* R_X86_64_IRELATIVE comes last. */
5801 plt_index
= htab
->next_irelative_index
--;
5805 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5807 plt_index
= htab
->next_jump_slot_index
++;
5810 /* Don't fill the second and third slots in PLT entry for
5811 static executables nor without PLT0. */
5812 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
5815 = h
->plt
.offset
+ htab
->lazy_plt
->plt_plt_insn_end
;
5817 /* Put relocation index. */
5818 bfd_put_32 (output_bfd
, plt_index
,
5819 (plt
->contents
+ h
->plt
.offset
5820 + htab
->lazy_plt
->plt_reloc_offset
));
5822 /* Put offset for jmp .PLT0 and check for overflow. We don't
5823 check relocation index for overflow since branch displacement
5824 will overflow first. */
5825 if (plt0_offset
> 0x80000000)
5826 /* xgettext:c-format */
5827 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5828 output_bfd
, h
->root
.root
.string
);
5829 bfd_put_32 (output_bfd
, - plt0_offset
,
5830 (plt
->contents
+ h
->plt
.offset
5831 + htab
->lazy_plt
->plt_plt_offset
));
5834 bed
= get_elf_backend_data (output_bfd
);
5835 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5836 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5839 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5841 bfd_vma got_offset
, plt_offset
;
5842 asection
*plt
, *got
;
5843 bfd_boolean got_after_plt
;
5844 int32_t got_pcrel_offset
;
5846 /* Set the entry in the GOT procedure linkage table. */
5847 plt
= htab
->plt_got
;
5848 got
= htab
->elf
.sgot
;
5849 got_offset
= h
->got
.offset
;
5851 if (got_offset
== (bfd_vma
) -1
5852 || (h
->type
== STT_GNU_IFUNC
&& h
->def_regular
)
5857 /* Use the non-lazy PLT entry template for the GOT PLT since they
5858 are the identical. */
5859 /* Fill in the entry in the GOT procedure linkage table. */
5860 plt_offset
= eh
->plt_got
.offset
;
5861 memcpy (plt
->contents
+ plt_offset
,
5862 htab
->non_lazy_plt
->plt_entry
,
5863 htab
->non_lazy_plt
->plt_entry_size
);
5865 /* Put offset the PC-relative instruction referring to the GOT
5866 entry, subtracting the size of that instruction. */
5867 got_pcrel_offset
= (got
->output_section
->vma
5868 + got
->output_offset
5870 - plt
->output_section
->vma
5871 - plt
->output_offset
5873 - htab
->non_lazy_plt
->plt_got_insn_size
);
5875 /* Check PC-relative offset overflow in GOT PLT entry. */
5876 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5877 if ((got_after_plt
&& got_pcrel_offset
< 0)
5878 || (!got_after_plt
&& got_pcrel_offset
> 0))
5879 /* xgettext:c-format */
5880 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5881 output_bfd
, h
->root
.root
.string
);
5883 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5884 (plt
->contents
+ plt_offset
5885 + htab
->non_lazy_plt
->plt_got_offset
));
5888 if (!local_undefweak
5890 && (h
->plt
.offset
!= (bfd_vma
) -1
5891 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5893 /* Mark the symbol as undefined, rather than as defined in
5894 the .plt section. Leave the value if there were any
5895 relocations where pointer equality matters (this is a clue
5896 for the dynamic linker, to make function pointer
5897 comparisons work between an application and shared
5898 library), otherwise set it to zero. If a function is only
5899 called from a binary, there is no need to slow down
5900 shared libraries because of that. */
5901 sym
->st_shndx
= SHN_UNDEF
;
5902 if (!h
->pointer_equality_needed
)
5906 /* Don't generate dynamic GOT relocation against undefined weak
5907 symbol in executable. */
5908 if (h
->got
.offset
!= (bfd_vma
) -1
5909 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5910 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5911 && !local_undefweak
)
5913 Elf_Internal_Rela rela
;
5914 asection
*relgot
= htab
->elf
.srelgot
;
5916 /* This symbol has an entry in the global offset table. Set it
5918 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5921 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5922 + htab
->elf
.sgot
->output_offset
5923 + (h
->got
.offset
&~ (bfd_vma
) 1));
5925 /* If this is a static link, or it is a -Bsymbolic link and the
5926 symbol is defined locally or was forced to be local because
5927 of a version file, we just want to emit a RELATIVE reloc.
5928 The entry in the global offset table will already have been
5929 initialized in the relocate_section function. */
5931 && h
->type
== STT_GNU_IFUNC
)
5933 if (h
->plt
.offset
== (bfd_vma
) -1)
5935 /* STT_GNU_IFUNC is referenced without PLT. */
5936 if (htab
->elf
.splt
== NULL
)
5938 /* use .rel[a].iplt section to store .got relocations
5939 in static executable. */
5940 relgot
= htab
->elf
.irelplt
;
5942 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5944 rela
.r_info
= htab
->r_info (0,
5945 R_X86_64_IRELATIVE
);
5946 rela
.r_addend
= (h
->root
.u
.def
.value
5947 + h
->root
.u
.def
.section
->output_section
->vma
5948 + h
->root
.u
.def
.section
->output_offset
);
5953 else if (bfd_link_pic (info
))
5955 /* Generate R_X86_64_GLOB_DAT. */
5963 if (!h
->pointer_equality_needed
)
5966 /* For non-shared object, we can't use .got.plt, which
5967 contains the real function addres if we need pointer
5968 equality. We load the GOT entry with the PLT entry. */
5969 if (htab
->plt_second
!= NULL
)
5971 plt
= htab
->plt_second
;
5972 plt_offset
= eh
->plt_second
.offset
;
5976 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5977 plt_offset
= h
->plt
.offset
;
5979 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5980 + plt
->output_offset
5982 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5986 else if (bfd_link_pic (info
)
5987 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5989 if (!h
->def_regular
)
5991 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5992 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5993 rela
.r_addend
= (h
->root
.u
.def
.value
5994 + h
->root
.u
.def
.section
->output_section
->vma
5995 + h
->root
.u
.def
.section
->output_offset
);
5999 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6001 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6002 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6003 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6007 elf_append_rela (output_bfd
, relgot
, &rela
);
6012 Elf_Internal_Rela rela
;
6015 /* This symbol needs a copy reloc. Set it up. */
6017 if (h
->dynindx
== -1
6018 || (h
->root
.type
!= bfd_link_hash_defined
6019 && h
->root
.type
!= bfd_link_hash_defweak
)
6020 || htab
->elf
.srelbss
== NULL
6021 || htab
->elf
.sreldynrelro
== NULL
)
6024 rela
.r_offset
= (h
->root
.u
.def
.value
6025 + h
->root
.u
.def
.section
->output_section
->vma
6026 + h
->root
.u
.def
.section
->output_offset
);
6027 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6029 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6030 s
= htab
->elf
.sreldynrelro
;
6032 s
= htab
->elf
.srelbss
;
6033 elf_append_rela (output_bfd
, s
, &rela
);
6039 /* Finish up local dynamic symbol handling. We set the contents of
6040 various dynamic sections here. */
6043 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6045 struct elf_link_hash_entry
*h
6046 = (struct elf_link_hash_entry
*) *slot
;
6047 struct bfd_link_info
*info
6048 = (struct bfd_link_info
*) inf
;
6050 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6054 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6055 here since undefined weak symbol may not be dynamic and may not be
6056 called for elf_x86_64_finish_dynamic_symbol. */
6059 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6062 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6063 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6065 if (h
->root
.type
!= bfd_link_hash_undefweak
6066 || h
->dynindx
!= -1)
6069 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6073 /* Used to decide how to sort relocs in an optimal manner for the
6074 dynamic linker, before writing them out. */
6076 static enum elf_reloc_type_class
6077 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6078 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6079 const Elf_Internal_Rela
*rela
)
6081 bfd
*abfd
= info
->output_bfd
;
6082 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6083 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6085 if (htab
->elf
.dynsym
!= NULL
6086 && htab
->elf
.dynsym
->contents
!= NULL
)
6088 /* Check relocation against STT_GNU_IFUNC symbol if there are
6090 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6091 if (r_symndx
!= STN_UNDEF
)
6093 Elf_Internal_Sym sym
;
6094 if (!bed
->s
->swap_symbol_in (abfd
,
6095 (htab
->elf
.dynsym
->contents
6096 + r_symndx
* bed
->s
->sizeof_sym
),
6100 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6101 return reloc_class_ifunc
;
6105 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6107 case R_X86_64_IRELATIVE
:
6108 return reloc_class_ifunc
;
6109 case R_X86_64_RELATIVE
:
6110 case R_X86_64_RELATIVE64
:
6111 return reloc_class_relative
;
6112 case R_X86_64_JUMP_SLOT
:
6113 return reloc_class_plt
;
6115 return reloc_class_copy
;
6117 return reloc_class_normal
;
6121 /* Finish up the dynamic sections. */
6124 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6125 struct bfd_link_info
*info
)
6127 struct elf_x86_64_link_hash_table
*htab
;
6131 htab
= elf_x86_64_hash_table (info
);
6135 dynobj
= htab
->elf
.dynobj
;
6136 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6138 if (htab
->elf
.dynamic_sections_created
)
6140 bfd_byte
*dyncon
, *dynconend
;
6141 const struct elf_backend_data
*bed
;
6142 bfd_size_type sizeof_dyn
;
6144 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6147 bed
= get_elf_backend_data (dynobj
);
6148 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6149 dyncon
= sdyn
->contents
;
6150 dynconend
= sdyn
->contents
+ sdyn
->size
;
6151 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6153 Elf_Internal_Dyn dyn
;
6156 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6164 s
= htab
->elf
.sgotplt
;
6165 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6169 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6173 s
= htab
->elf
.srelplt
->output_section
;
6174 dyn
.d_un
.d_val
= s
->size
;
6177 case DT_TLSDESC_PLT
:
6179 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6180 + htab
->tlsdesc_plt
;
6183 case DT_TLSDESC_GOT
:
6185 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6186 + htab
->tlsdesc_got
;
6190 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6193 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6195 elf_section_data (htab
->elf
.splt
->output_section
)
6196 ->this_hdr
.sh_entsize
= htab
->plt
.plt_entry_size
;
6198 if (htab
->plt
.has_plt0
)
6200 /* Fill in the special first entry in the procedure linkage
6202 memcpy (htab
->elf
.splt
->contents
,
6203 htab
->lazy_plt
->plt0_entry
,
6204 htab
->lazy_plt
->plt_entry_size
);
6205 /* Add offset for pushq GOT+8(%rip), since the instruction
6206 uses 6 bytes subtract this value. */
6207 bfd_put_32 (output_bfd
,
6208 (htab
->elf
.sgotplt
->output_section
->vma
6209 + htab
->elf
.sgotplt
->output_offset
6211 - htab
->elf
.splt
->output_section
->vma
6212 - htab
->elf
.splt
->output_offset
6214 (htab
->elf
.splt
->contents
6215 + htab
->lazy_plt
->plt0_got1_offset
));
6216 /* Add offset for the PC-relative instruction accessing
6217 GOT+16, subtracting the offset to the end of that
6219 bfd_put_32 (output_bfd
,
6220 (htab
->elf
.sgotplt
->output_section
->vma
6221 + htab
->elf
.sgotplt
->output_offset
6223 - htab
->elf
.splt
->output_section
->vma
6224 - htab
->elf
.splt
->output_offset
6225 - htab
->lazy_plt
->plt0_got2_insn_end
),
6226 (htab
->elf
.splt
->contents
6227 + htab
->lazy_plt
->plt0_got2_offset
));
6229 if (htab
->tlsdesc_plt
)
6231 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6232 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6234 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6235 htab
->lazy_plt
->plt0_entry
,
6236 htab
->lazy_plt
->plt_entry_size
);
6238 /* Add offset for pushq GOT+8(%rip), since the
6239 instruction uses 6 bytes subtract this value. */
6240 bfd_put_32 (output_bfd
,
6241 (htab
->elf
.sgotplt
->output_section
->vma
6242 + htab
->elf
.sgotplt
->output_offset
6244 - htab
->elf
.splt
->output_section
->vma
6245 - htab
->elf
.splt
->output_offset
6248 (htab
->elf
.splt
->contents
6250 + htab
->lazy_plt
->plt0_got1_offset
));
6251 /* Add offset for the PC-relative instruction accessing
6252 GOT+TDG, where TDG stands for htab->tlsdesc_got,
6253 subtracting the offset to the end of that
6255 bfd_put_32 (output_bfd
,
6256 (htab
->elf
.sgot
->output_section
->vma
6257 + htab
->elf
.sgot
->output_offset
6259 - htab
->elf
.splt
->output_section
->vma
6260 - htab
->elf
.splt
->output_offset
6262 - htab
->lazy_plt
->plt0_got2_insn_end
),
6263 (htab
->elf
.splt
->contents
6265 + htab
->lazy_plt
->plt0_got2_offset
));
6271 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
6272 elf_section_data (htab
->plt_got
->output_section
)
6273 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6275 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
6276 elf_section_data (htab
->plt_second
->output_section
)
6277 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6279 /* GOT is always created in setup_gnu_properties. But it may not be
6281 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
6283 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6286 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6290 /* Set the first entry in the global offset table to the address of
6291 the dynamic section. */
6293 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6295 bfd_put_64 (output_bfd
,
6296 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6297 htab
->elf
.sgotplt
->contents
);
6298 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6299 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6300 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6301 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6302 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6304 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
6308 /* Adjust .eh_frame for .plt section. */
6309 if (htab
->plt_eh_frame
!= NULL
6310 && htab
->plt_eh_frame
->contents
!= NULL
)
6312 if (htab
->elf
.splt
!= NULL
6313 && htab
->elf
.splt
->size
!= 0
6314 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6315 && htab
->elf
.splt
->output_section
!= NULL
6316 && htab
->plt_eh_frame
->output_section
!= NULL
)
6318 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6319 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6320 + htab
->plt_eh_frame
->output_offset
6321 + PLT_FDE_START_OFFSET
;
6322 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6323 htab
->plt_eh_frame
->contents
6324 + PLT_FDE_START_OFFSET
);
6326 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6328 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6330 htab
->plt_eh_frame
->contents
))
6335 /* Adjust .eh_frame for .plt.got section. */
6336 if (htab
->plt_got_eh_frame
!= NULL
6337 && htab
->plt_got_eh_frame
->contents
!= NULL
)
6339 if (htab
->plt_got
!= NULL
6340 && htab
->plt_got
->size
!= 0
6341 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
6342 && htab
->plt_got
->output_section
!= NULL
6343 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
6345 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
6346 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
6347 + htab
->plt_got_eh_frame
->output_offset
6348 + PLT_FDE_START_OFFSET
;
6349 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6350 htab
->plt_got_eh_frame
->contents
6351 + PLT_FDE_START_OFFSET
);
6353 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6355 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6356 htab
->plt_got_eh_frame
,
6357 htab
->plt_got_eh_frame
->contents
))
6362 /* Adjust .eh_frame for the second PLT section. */
6363 if (htab
->plt_second_eh_frame
!= NULL
6364 && htab
->plt_second_eh_frame
->contents
!= NULL
)
6366 if (htab
->plt_second
!= NULL
6367 && htab
->plt_second
->size
!= 0
6368 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
6369 && htab
->plt_second
->output_section
!= NULL
6370 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
6372 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
6373 bfd_vma eh_frame_start
6374 = (htab
->plt_second_eh_frame
->output_section
->vma
6375 + htab
->plt_second_eh_frame
->output_offset
6376 + PLT_FDE_START_OFFSET
);
6377 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6378 htab
->plt_second_eh_frame
->contents
6379 + PLT_FDE_START_OFFSET
);
6381 if (htab
->plt_second_eh_frame
->sec_info_type
6382 == SEC_INFO_TYPE_EH_FRAME
)
6384 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6385 htab
->plt_second_eh_frame
,
6386 htab
->plt_second_eh_frame
->contents
))
6391 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6392 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6395 /* Fill PLT entries for undefined weak symbols in PIE. */
6396 if (bfd_link_pie (info
))
6397 bfd_hash_traverse (&info
->hash
->table
,
6398 elf_x86_64_pie_finish_undefweak_symbol
,
6404 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6405 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6406 It has to be done before elf_link_sort_relocs is called so that
6407 dynamic relocations are properly sorted. */
6410 elf_x86_64_output_arch_local_syms
6411 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6412 struct bfd_link_info
*info
,
6413 void *flaginfo ATTRIBUTE_UNUSED
,
6414 int (*func
) (void *, const char *,
6417 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6419 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6423 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6424 htab_traverse (htab
->loc_hash_table
,
6425 elf_x86_64_finish_local_dynamic_symbol
,
6431 /* Sort relocs into address order. */
6434 compare_relocs (const void *ap
, const void *bp
)
6436 const arelent
*a
= * (const arelent
**) ap
;
6437 const arelent
*b
= * (const arelent
**) bp
;
6439 if (a
->address
> b
->address
)
6441 else if (a
->address
< b
->address
)
6447 enum elf_x86_64_plt_type
6451 plt_second
= 1 << 1,
6455 struct elf_x86_64_plt
6460 enum elf_x86_64_plt_type type
;
6461 unsigned int plt_got_offset
;
6462 unsigned int plt_got_insn_size
;
6463 unsigned int plt_entry_size
;
6467 /* Forward declaration. */
6468 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
;
6470 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
6471 dynamic relocations. */
6474 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6475 long symcount ATTRIBUTE_UNUSED
,
6476 asymbol
**syms ATTRIBUTE_UNUSED
,
6481 long size
, count
, i
, n
;
6483 unsigned int plt_got_offset
, plt_entry_size
, plt_got_insn_size
;
6485 bfd_byte
*plt_contents
;
6486 long dynrelcount
, relsize
;
6487 arelent
**dynrelbuf
;
6488 const struct elf_x86_64_lazy_plt_layout
*lazy_plt
;
6489 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_plt
;
6490 const struct elf_x86_64_lazy_plt_layout
*lazy_bnd_plt
;
6491 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_bnd_plt
;
6494 enum elf_x86_64_plt_type plt_type
;
6495 struct elf_x86_64_plt plts
[] =
6497 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0, 0 },
6498 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 },
6499 { ".plt.sec", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6500 { ".plt.bnd", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6501 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 }
6506 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
6509 if (dynsymcount
<= 0)
6512 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
6516 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
6517 if (dynrelbuf
== NULL
)
6520 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
6523 /* Sort the relocs by address. */
6524 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*), compare_relocs
);
6526 if (get_elf_x86_64_backend_data (abfd
)->os
== is_normal
)
6528 lazy_plt
= &elf_x86_64_lazy_plt
;
6529 non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
6530 lazy_bnd_plt
= &elf_x86_64_lazy_bnd_plt
;
6531 non_lazy_bnd_plt
= &elf_x86_64_non_lazy_bnd_plt
;
6535 lazy_plt
= &elf_x86_64_nacl_plt
;
6536 non_lazy_plt
= NULL
;
6537 lazy_bnd_plt
= NULL
;
6538 non_lazy_bnd_plt
= NULL
;
6542 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6544 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
6548 /* Get the PLT section contents. */
6549 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6550 if (plt_contents
== NULL
)
6552 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6553 plt_contents
, 0, plt
->size
))
6555 free (plt_contents
);
6559 /* Check what kind of PLT it is. */
6560 plt_type
= plt_unknown
;
6561 if (plts
[j
].type
== plt_unknown
)
6563 /* Match lazy PLT first. Need to check the first two
6565 if ((memcmp (plt_contents
, lazy_plt
->plt0_entry
,
6566 lazy_plt
->plt0_got1_offset
) == 0)
6567 && (memcmp (plt_contents
+ 6, lazy_plt
->plt0_entry
+ 6,
6569 plt_type
= plt_lazy
;
6570 else if (lazy_bnd_plt
!= NULL
6571 && (memcmp (plt_contents
, lazy_bnd_plt
->plt0_entry
,
6572 lazy_bnd_plt
->plt0_got1_offset
) == 0)
6573 && (memcmp (plt_contents
+ 6,
6574 lazy_bnd_plt
->plt0_entry
+ 6, 3) == 0))
6576 plt_type
= plt_lazy
| plt_second
;
6577 lazy_plt
= lazy_bnd_plt
;
6581 if (non_lazy_plt
!= NULL
6582 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
))
6584 /* Match non-lazy PLT. */
6585 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
6586 non_lazy_plt
->plt_got_offset
) == 0)
6587 plt_type
= plt_non_lazy
;
6590 if (non_lazy_bnd_plt
!= NULL
6591 && (plt_type
== plt_unknown
|| plt_type
== plt_second
))
6593 /* Match BND PLT. */
6594 if (memcmp (plt_contents
, non_lazy_bnd_plt
->plt_entry
,
6595 non_lazy_bnd_plt
->plt_got_offset
) == 0)
6597 plt_type
= plt_second
;
6598 non_lazy_plt
= non_lazy_bnd_plt
;
6602 if (plt_type
== plt_unknown
)
6606 plts
[j
].type
= plt_type
;
6608 if ((plt_type
& plt_lazy
))
6610 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
6611 plts
[j
].plt_got_insn_size
= lazy_plt
->plt_got_insn_size
;
6612 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
6613 /* Skip PLT0 in lazy PLT. */
6618 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
6619 plts
[j
].plt_got_insn_size
= non_lazy_plt
->plt_got_insn_size
;
6620 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
6624 /* Skip lazy PLT when the second PLT is used. */
6625 if (plt_type
== (plt_lazy
| plt_second
))
6629 n
= plt
->size
/ plts
[j
].plt_entry_size
;
6634 plts
[j
].contents
= plt_contents
;
6637 size
= count
* sizeof (asymbol
);
6638 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
6642 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6643 if (plts
[j
].contents
!= NULL
)
6644 free (plts
[j
].contents
);
6649 /* Check for each PLT section. */
6652 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6653 if ((plt_contents
= plts
[j
].contents
) != NULL
)
6658 plt_got_offset
= plts
[j
].plt_got_offset
;
6659 plt_got_insn_size
= plts
[j
].plt_got_insn_size
;
6660 plt_entry_size
= plts
[j
].plt_entry_size
;
6664 if ((plts
[j
].type
& plt_lazy
))
6666 /* Skip PLT0 in lazy PLT. */
6668 offset
= plt_entry_size
;
6676 /* Check each PLT entry against dynamic relocations. */
6677 for (; k
< plts
[j
].count
; k
++)
6684 /* Get the PC-relative offset, a signed 32-bit integer. */
6685 off
= H_GET_32 (abfd
, (plt_contents
+ offset
6687 got_vma
= plt
->vma
+ offset
+ off
+ plt_got_insn_size
;
6689 /* Binary search. */
6693 while ((min
+ 1) < max
)
6697 mid
= (min
+ max
) / 2;
6699 if (got_vma
> r
->address
)
6701 else if (got_vma
< r
->address
)
6710 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6711 if (got_vma
== p
->address
6713 && (p
->howto
->type
== R_X86_64_JUMP_SLOT
6714 || p
->howto
->type
== R_X86_64_GLOB_DAT
6715 || p
->howto
->type
== R_X86_64_IRELATIVE
))
6717 *s
= **p
->sym_ptr_ptr
;
6718 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6719 set. Since we are defining a symbol, ensure one
6721 if ((s
->flags
& BSF_LOCAL
) == 0)
6722 s
->flags
|= BSF_GLOBAL
;
6723 s
->flags
|= BSF_SYNTHETIC
;
6724 /* This is no longer a section symbol. */
6725 s
->flags
&= ~BSF_SECTION_SYM
;
6727 s
->the_bfd
= plt
->owner
;
6729 /* Store relocation for later use. */
6731 /* Add @plt to function name later. */
6732 size
+= strlen (s
->name
) + sizeof ("@plt");
6734 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
6738 offset
+= plt_entry_size
;
6742 /* PLT entries with R_X86_64_TLSDESC relocations are skipped. */
6748 /* Allocate space for @plt suffixes. */
6749 names
= (char *) bfd_malloc (size
);
6754 for (i
= 0; i
< count
; i
++)
6756 /* Add @plt to function name. */
6757 arelent
*p
= (arelent
*) s
->udata
.p
;
6760 size
= strlen (s
->name
);
6761 memcpy (names
, s
->name
, size
);
6768 memcpy (names
, "+0x", sizeof ("+0x") - 1);
6769 names
+= sizeof ("+0x") - 1;
6770 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
6771 for (a
= buf
; *a
== '0'; ++a
)
6774 memcpy (names
, a
, size
);
6777 memcpy (names
, "@plt", sizeof ("@plt"));
6778 names
+= sizeof ("@plt");
6782 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6783 if (plts
[j
].contents
!= NULL
)
6784 free (plts
[j
].contents
);
6791 /* Handle an x86-64 specific section when reading an object file. This
6792 is called when elfcode.h finds a section with an unknown type. */
6795 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6796 const char *name
, int shindex
)
6798 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6801 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6807 /* Hook called by the linker routine which adds symbols from an object
6808 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6812 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6813 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6814 Elf_Internal_Sym
*sym
,
6815 const char **namep ATTRIBUTE_UNUSED
,
6816 flagword
*flagsp ATTRIBUTE_UNUSED
,
6822 switch (sym
->st_shndx
)
6824 case SHN_X86_64_LCOMMON
:
6825 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6828 lcomm
= bfd_make_section_with_flags (abfd
,
6832 | SEC_LINKER_CREATED
));
6835 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6838 *valp
= sym
->st_size
;
6846 /* Given a BFD section, try to locate the corresponding ELF section
6850 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6851 asection
*sec
, int *index_return
)
6853 if (sec
== &_bfd_elf_large_com_section
)
6855 *index_return
= SHN_X86_64_LCOMMON
;
6861 /* Process a symbol. */
6864 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6867 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6869 switch (elfsym
->internal_elf_sym
.st_shndx
)
6871 case SHN_X86_64_LCOMMON
:
6872 asym
->section
= &_bfd_elf_large_com_section
;
6873 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6874 /* Common symbol doesn't set BSF_GLOBAL. */
6875 asym
->flags
&= ~BSF_GLOBAL
;
6881 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6883 return (sym
->st_shndx
== SHN_COMMON
6884 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6888 elf_x86_64_common_section_index (asection
*sec
)
6890 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6893 return SHN_X86_64_LCOMMON
;
6897 elf_x86_64_common_section (asection
*sec
)
6899 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6900 return bfd_com_section_ptr
;
6902 return &_bfd_elf_large_com_section
;
6906 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6907 const Elf_Internal_Sym
*sym
,
6912 const asection
*oldsec
)
6914 /* A normal common symbol and a large common symbol result in a
6915 normal common symbol. We turn the large common symbol into a
6918 && h
->root
.type
== bfd_link_hash_common
6920 && bfd_is_com_section (*psec
)
6923 if (sym
->st_shndx
== SHN_COMMON
6924 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6926 h
->root
.u
.c
.p
->section
6927 = bfd_make_section_old_way (oldbfd
, "COMMON");
6928 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6930 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6931 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6932 *psec
= bfd_com_section_ptr
;
6939 elf_x86_64_additional_program_headers (bfd
*abfd
,
6940 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6945 /* Check to see if we need a large readonly segment. */
6946 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6947 if (s
&& (s
->flags
& SEC_LOAD
))
6950 /* Check to see if we need a large data segment. Since .lbss sections
6951 is placed right after the .bss section, there should be no need for
6952 a large data segment just because of .lbss. */
6953 s
= bfd_get_section_by_name (abfd
, ".ldata");
6954 if (s
&& (s
->flags
& SEC_LOAD
))
6960 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6963 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6965 if (h
->plt
.offset
!= (bfd_vma
) -1
6967 && !h
->pointer_equality_needed
)
6970 return _bfd_elf_hash_symbol (h
);
6973 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6976 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6977 const bfd_target
*output
)
6979 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6980 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6981 && _bfd_elf_relocs_compatible (input
, output
));
6984 /* Parse x86-64 GNU properties. */
6986 static enum elf_property_kind
6987 elf_x86_64_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
6988 bfd_byte
*ptr
, unsigned int datasz
)
6994 case GNU_PROPERTY_X86_ISA_1_USED
:
6995 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
6999 ((type
== GNU_PROPERTY_X86_ISA_1_USED
7000 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
7001 : _("error: %B: <corrupt x86 ISA needed size: 0x%x>")),
7003 return property_corrupt
;
7005 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
7006 /* Combine properties of the same type. */
7007 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
7008 prop
->pr_kind
= property_number
;
7012 return property_ignored
;
7015 return property_number
;
7018 /* Merge x86-64 GNU property BPROP with APROP. If APROP isn't NULL,
7019 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
7020 should be merged with ABFD. */
7023 elf_x86_64_merge_gnu_properties (bfd
*abfd ATTRIBUTE_UNUSED
,
7024 elf_property
*aprop
,
7025 elf_property
*bprop
)
7027 unsigned int number
;
7028 bfd_boolean updated
= FALSE
;
7029 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
7033 case GNU_PROPERTY_X86_ISA_1_USED
:
7034 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
7035 if (aprop
!= NULL
&& bprop
!= NULL
)
7037 number
= aprop
->u
.number
;
7038 aprop
->u
.number
= number
| bprop
->u
.number
;
7039 updated
= number
!= (unsigned int) aprop
->u
.number
;
7043 /* Return TRUE if APROP is NULL to indicate that BPROP should
7044 be added to ABFD. */
7045 updated
= aprop
== NULL
;
7050 /* Never should happen. */
7057 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
7058 with GNU properties if found. Otherwise, return NULL. */
7061 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info
*info
)
7063 bfd_boolean normal_target
;
7064 bfd_boolean lazy_plt
;
7065 asection
*sec
, *pltsec
;
7067 unsigned int plt_alignment
;
7068 struct elf_x86_64_link_hash_table
*htab
;
7069 bfd
*pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
7071 if (bfd_link_relocatable (info
))
7074 htab
= elf_x86_64_hash_table (info
);
7078 dynobj
= htab
->elf
.dynobj
;
7080 /* Set htab->elf.dynobj here so that there is no need to check and
7081 set it in check_relocs. */
7086 /* Find a normal input file to hold linker created
7088 for (abfd
= info
->input_bfds
;
7090 abfd
= abfd
->link
.next
)
7092 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
7094 htab
->elf
.dynobj
= abfd
;
7100 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
7101 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
7102 canonical function address. */
7103 htab
->plt
.has_plt0
= 1;
7105 if (get_elf_x86_64_backend_data (info
->output_bfd
)->os
7110 htab
->lazy_plt
= &elf_x86_64_lazy_bnd_plt
;
7111 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_bnd_plt
;
7115 htab
->lazy_plt
= &elf_x86_64_lazy_plt
;
7116 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
7118 normal_target
= TRUE
;
7122 htab
->lazy_plt
= &elf_x86_64_nacl_plt
;
7123 htab
->non_lazy_plt
= NULL
;
7124 normal_target
= FALSE
;
7127 pltsec
= htab
->elf
.splt
;
7129 /* If the non-lazy PLT is available, use it for all PLT entries if
7130 there are no PLT0 or no .plt section. */
7131 if (htab
->non_lazy_plt
!= NULL
7132 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
7136 = htab
->non_lazy_plt
->plt_entry
;
7137 htab
->plt
.plt_entry_size
7138 = htab
->non_lazy_plt
->plt_entry_size
;
7139 htab
->plt
.plt_got_offset
7140 = htab
->non_lazy_plt
->plt_got_offset
;
7141 htab
->plt
.plt_got_insn_size
7142 = htab
->non_lazy_plt
->plt_got_insn_size
;
7143 htab
->plt
.eh_frame_plt_size
7144 = htab
->non_lazy_plt
->eh_frame_plt_size
;
7145 htab
->plt
.eh_frame_plt
7146 = htab
->non_lazy_plt
->eh_frame_plt
;
7152 = htab
->lazy_plt
->plt_entry
;
7153 htab
->plt
.plt_entry_size
7154 = htab
->lazy_plt
->plt_entry_size
;
7155 htab
->plt
.plt_got_offset
7156 = htab
->lazy_plt
->plt_got_offset
;
7157 htab
->plt
.plt_got_insn_size
7158 = htab
->lazy_plt
->plt_got_insn_size
;
7159 htab
->plt
.eh_frame_plt_size
7160 = htab
->lazy_plt
->eh_frame_plt_size
;
7161 htab
->plt
.eh_frame_plt
7162 = htab
->lazy_plt
->eh_frame_plt
;
7165 /* Return if there are no normal input files. */
7169 /* Since create_dynamic_sections isn't always called, but GOT
7170 relocations need GOT relocations, create them here so that we
7171 don't need to do it in check_relocs. */
7172 if (htab
->elf
.sgot
== NULL
7173 && !_bfd_elf_create_got_section (dynobj
, info
))
7174 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
7176 /* Align .got and .got.plt sections to their entry size. Do it here
7177 instead of in create_dynamic_sections so that they are always
7178 properly aligned even if create_dynamic_sections isn't called. */
7179 sec
= htab
->elf
.sgot
;
7180 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7183 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
7187 sec
= htab
->elf
.sgotplt
;
7188 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7189 goto error_alignment
;
7191 /* Create the ifunc sections here so that check_relocs can be
7193 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
7194 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
7196 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
7200 /* Whe creating executable, set the contents of the .interp
7201 section to the interpreter. */
7202 if (bfd_link_executable (info
) && !info
->nointerp
)
7204 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
7207 s
->size
= htab
->dynamic_interpreter_size
;
7208 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
7212 /* Don't change PLT section alignment for NaCl since it uses
7213 64-byte PLT entry and sets PLT section alignment to 32
7214 bytes. Don't create additional PLT sections for NaCl. */
7217 const struct elf_backend_data
*bed
7218 = get_elf_backend_data (dynobj
);
7219 flagword pltflags
= (bed
->dynamic_sec_flags
7224 unsigned int non_lazy_plt_alignment
7225 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
7228 if (!bfd_set_section_alignment (sec
->owner
, sec
,
7230 goto error_alignment
;
7232 /* Create the GOT procedure linkage table. */
7233 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7237 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
7239 if (!bfd_set_section_alignment (dynobj
, sec
,
7240 non_lazy_plt_alignment
))
7241 goto error_alignment
;
7243 htab
->plt_got
= sec
;
7245 /* MPX PLT is supported only for non-NaCl target in 64-bit
7246 mode and is needed only for lazy binding. */
7249 && ABI_64_P (htab
->elf
.dynobj
))
7251 /* Create the second PLT for Intel MPX support. */
7252 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7256 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
7258 if (!bfd_set_section_alignment (dynobj
, sec
,
7259 non_lazy_plt_alignment
))
7260 goto error_alignment
;
7262 htab
->plt_second
= sec
;
7266 if (!info
->no_ld_generated_unwind_info
)
7268 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
7269 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7270 | SEC_LINKER_CREATED
);
7272 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7276 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
7278 if (!bfd_set_section_alignment (dynobj
, sec
,
7279 ABI_64_P (dynobj
) ? 3 : 2))
7280 goto error_alignment
;
7282 htab
->plt_eh_frame
= sec
;
7284 if (htab
->plt_got
!= NULL
)
7286 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7290 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
7292 if (!bfd_set_section_alignment (dynobj
, sec
,
7293 ABI_64_P (dynobj
) ? 3 : 2))
7294 goto error_alignment
;
7296 htab
->plt_got_eh_frame
= sec
;
7299 if (htab
->plt_second
!= NULL
)
7301 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7305 info
->callbacks
->einfo (_("%F: failed to create BND PLT .eh_frame section\n"));
7307 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7308 goto error_alignment
;
7310 htab
->plt_second_eh_frame
= sec
;
7317 /* The .iplt section is used for IFUNC symbols in static
7319 sec
= htab
->elf
.iplt
;
7321 && !bfd_set_section_alignment (sec
->owner
, sec
,
7323 goto error_alignment
;
7329 static const struct bfd_elf_special_section
7330 elf_x86_64_special_sections
[]=
7332 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7333 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7334 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
7335 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7336 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7337 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7338 { NULL
, 0, 0, 0, 0 }
7341 #define TARGET_LITTLE_SYM x86_64_elf64_vec
7342 #define TARGET_LITTLE_NAME "elf64-x86-64"
7343 #define ELF_ARCH bfd_arch_i386
7344 #define ELF_TARGET_ID X86_64_ELF_DATA
7345 #define ELF_MACHINE_CODE EM_X86_64
7346 #define ELF_MAXPAGESIZE 0x200000
7347 #define ELF_MINPAGESIZE 0x1000
7348 #define ELF_COMMONPAGESIZE 0x1000
7350 #define elf_backend_can_gc_sections 1
7351 #define elf_backend_can_refcount 1
7352 #define elf_backend_want_got_plt 1
7353 #define elf_backend_plt_readonly 1
7354 #define elf_backend_want_plt_sym 0
7355 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
7356 #define elf_backend_rela_normal 1
7357 #define elf_backend_plt_alignment 4
7358 #define elf_backend_extern_protected_data 1
7359 #define elf_backend_caches_rawsize 1
7360 #define elf_backend_dtrel_excludes_plt 1
7361 #define elf_backend_want_dynrelro 1
7363 #define elf_info_to_howto elf_x86_64_info_to_howto
7365 #define bfd_elf64_bfd_link_hash_table_create \
7366 elf_x86_64_link_hash_table_create
7367 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
7368 #define bfd_elf64_bfd_reloc_name_lookup \
7369 elf_x86_64_reloc_name_lookup
7371 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
7372 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
7373 #define elf_backend_check_relocs elf_x86_64_check_relocs
7374 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
7375 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
7376 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
7377 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
7378 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
7379 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
7380 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
7381 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
7383 #define elf_backend_write_core_note elf_x86_64_write_core_note
7385 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
7386 #define elf_backend_relocate_section elf_x86_64_relocate_section
7387 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
7388 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
7389 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
7390 #define elf_backend_object_p elf64_x86_64_elf_object_p
7391 #define bfd_elf64_mkobject elf_x86_64_mkobject
7392 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
7394 #define elf_backend_section_from_shdr \
7395 elf_x86_64_section_from_shdr
7397 #define elf_backend_section_from_bfd_section \
7398 elf_x86_64_elf_section_from_bfd_section
7399 #define elf_backend_add_symbol_hook \
7400 elf_x86_64_add_symbol_hook
7401 #define elf_backend_symbol_processing \
7402 elf_x86_64_symbol_processing
7403 #define elf_backend_common_section_index \
7404 elf_x86_64_common_section_index
7405 #define elf_backend_common_section \
7406 elf_x86_64_common_section
7407 #define elf_backend_common_definition \
7408 elf_x86_64_common_definition
7409 #define elf_backend_merge_symbol \
7410 elf_x86_64_merge_symbol
7411 #define elf_backend_special_sections \
7412 elf_x86_64_special_sections
7413 #define elf_backend_additional_program_headers \
7414 elf_x86_64_additional_program_headers
7415 #define elf_backend_hash_symbol \
7416 elf_x86_64_hash_symbol
7417 #define elf_backend_omit_section_dynsym \
7418 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
7419 #define elf_backend_fixup_symbol \
7420 elf_x86_64_fixup_symbol
7421 #define elf_backend_parse_gnu_properties \
7422 elf_x86_64_parse_gnu_properties
7423 #define elf_backend_merge_gnu_properties \
7424 elf_x86_64_merge_gnu_properties
7425 #define elf_backend_setup_gnu_properties \
7426 elf_x86_64_link_setup_gnu_properties
7428 #include "elf64-target.h"
7430 /* CloudABI support. */
7432 #undef TARGET_LITTLE_SYM
7433 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
7434 #undef TARGET_LITTLE_NAME
7435 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
7438 #define ELF_OSABI ELFOSABI_CLOUDABI
7441 #define elf64_bed elf64_x86_64_cloudabi_bed
7443 #include "elf64-target.h"
7445 /* FreeBSD support. */
7447 #undef TARGET_LITTLE_SYM
7448 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
7449 #undef TARGET_LITTLE_NAME
7450 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
7453 #define ELF_OSABI ELFOSABI_FREEBSD
7456 #define elf64_bed elf64_x86_64_fbsd_bed
7458 #include "elf64-target.h"
7460 /* Solaris 2 support. */
7462 #undef TARGET_LITTLE_SYM
7463 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
7464 #undef TARGET_LITTLE_NAME
7465 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
7467 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
7468 objects won't be recognized. */
7472 #define elf64_bed elf64_x86_64_sol2_bed
7474 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
7476 #undef elf_backend_static_tls_alignment
7477 #define elf_backend_static_tls_alignment 16
7479 /* The Solaris 2 ABI requires a plt symbol on all platforms.
7481 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
7483 #undef elf_backend_want_plt_sym
7484 #define elf_backend_want_plt_sym 1
7486 #undef elf_backend_strtab_flags
7487 #define elf_backend_strtab_flags SHF_STRINGS
7490 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
7491 bfd
*obfd ATTRIBUTE_UNUSED
,
7492 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
7493 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
7495 /* PR 19938: FIXME: Need to add code for setting the sh_info
7496 and sh_link fields of Solaris specific section types. */
7500 #undef elf_backend_copy_special_section_fields
7501 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
7503 #include "elf64-target.h"
7505 /* Native Client support. */
7508 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
7510 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
7511 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
7515 #undef TARGET_LITTLE_SYM
7516 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
7517 #undef TARGET_LITTLE_NAME
7518 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
7520 #define elf64_bed elf64_x86_64_nacl_bed
7522 #undef ELF_MAXPAGESIZE
7523 #undef ELF_MINPAGESIZE
7524 #undef ELF_COMMONPAGESIZE
7525 #define ELF_MAXPAGESIZE 0x10000
7526 #define ELF_MINPAGESIZE 0x10000
7527 #define ELF_COMMONPAGESIZE 0x10000
7529 /* Restore defaults. */
7531 #undef elf_backend_static_tls_alignment
7532 #undef elf_backend_want_plt_sym
7533 #define elf_backend_want_plt_sym 0
7534 #undef elf_backend_strtab_flags
7535 #undef elf_backend_copy_special_section_fields
7537 /* NaCl uses substantially different PLT entries for the same effects. */
7539 #undef elf_backend_plt_alignment
7540 #define elf_backend_plt_alignment 5
7541 #define NACL_PLT_ENTRY_SIZE 64
7542 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
7544 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
7546 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
7547 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
7548 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7549 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7550 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7552 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
7553 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
7555 /* 32 bytes of nop to pad out to the standard size. */
7556 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7557 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7558 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7559 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7560 0x66, /* excess data16 prefix */
7564 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
7566 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
7567 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7568 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7569 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7571 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
7572 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7573 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7575 /* Lazy GOT entries point here (32-byte aligned). */
7576 0x68, /* pushq immediate */
7577 0, 0, 0, 0, /* replaced with index into relocation table. */
7578 0xe9, /* jmp relative */
7579 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
7581 /* 22 bytes of nop to pad out to the standard size. */
7582 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7583 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7584 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
7587 /* .eh_frame covering the .plt section. */
7589 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
7591 #if (PLT_CIE_LENGTH != 20 \
7592 || PLT_FDE_LENGTH != 36 \
7593 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
7594 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
7595 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
7597 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
7598 0, 0, 0, 0, /* CIE ID */
7599 1, /* CIE version */
7600 'z', 'R', 0, /* Augmentation string */
7601 1, /* Code alignment factor */
7602 0x78, /* Data alignment factor */
7603 16, /* Return address column */
7604 1, /* Augmentation size */
7605 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
7606 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
7607 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
7608 DW_CFA_nop
, DW_CFA_nop
,
7610 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
7611 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
7612 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
7613 0, 0, 0, 0, /* .plt size goes here */
7614 0, /* Augmentation size */
7615 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
7616 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
7617 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
7618 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
7619 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
7620 13, /* Block length */
7621 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
7622 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
7623 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
7624 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
7625 DW_CFA_nop
, DW_CFA_nop
7628 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
=
7630 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
7631 elf_x86_64_nacl_plt_entry
, /* plt_entry */
7632 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
7633 2, /* plt0_got1_offset */
7634 9, /* plt0_got2_offset */
7635 13, /* plt0_got2_insn_end */
7636 3, /* plt_got_offset */
7637 33, /* plt_reloc_offset */
7638 38, /* plt_plt_offset */
7639 7, /* plt_got_insn_size */
7640 42, /* plt_plt_insn_end */
7641 32, /* plt_lazy_offset */
7642 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
7643 sizeof (elf_x86_64_nacl_eh_frame_plt
) /* eh_frame_plt_size */
7646 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
7651 #undef elf_backend_arch_data
7652 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
7654 #undef elf_backend_object_p
7655 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
7656 #undef elf_backend_modify_segment_map
7657 #define elf_backend_modify_segment_map nacl_modify_segment_map
7658 #undef elf_backend_modify_program_headers
7659 #define elf_backend_modify_program_headers nacl_modify_program_headers
7660 #undef elf_backend_final_write_processing
7661 #define elf_backend_final_write_processing nacl_final_write_processing
7663 #include "elf64-target.h"
7665 /* Native Client x32 support. */
7668 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
7670 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
7671 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
7675 #undef TARGET_LITTLE_SYM
7676 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
7677 #undef TARGET_LITTLE_NAME
7678 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
7680 #define elf32_bed elf32_x86_64_nacl_bed
7682 #define bfd_elf32_bfd_link_hash_table_create \
7683 elf_x86_64_link_hash_table_create
7684 #define bfd_elf32_bfd_reloc_type_lookup \
7685 elf_x86_64_reloc_type_lookup
7686 #define bfd_elf32_bfd_reloc_name_lookup \
7687 elf_x86_64_reloc_name_lookup
7688 #define bfd_elf32_mkobject \
7690 #define bfd_elf32_get_synthetic_symtab \
7691 elf_x86_64_get_synthetic_symtab
7693 #undef elf_backend_object_p
7694 #define elf_backend_object_p \
7695 elf32_x86_64_nacl_elf_object_p
7697 #undef elf_backend_bfd_from_remote_memory
7698 #define elf_backend_bfd_from_remote_memory \
7699 _bfd_elf32_bfd_from_remote_memory
7701 #undef elf_backend_size_info
7702 #define elf_backend_size_info \
7703 _bfd_elf32_size_info
7705 #include "elf32-target.h"
7707 /* Restore defaults. */
7708 #undef elf_backend_object_p
7709 #define elf_backend_object_p elf64_x86_64_elf_object_p
7710 #undef elf_backend_bfd_from_remote_memory
7711 #undef elf_backend_size_info
7712 #undef elf_backend_modify_segment_map
7713 #undef elf_backend_modify_program_headers
7714 #undef elf_backend_final_write_processing
7716 /* Intel L1OM support. */
7719 elf64_l1om_elf_object_p (bfd
*abfd
)
7721 /* Set the right machine number for an L1OM elf64 file. */
7722 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
7726 #undef TARGET_LITTLE_SYM
7727 #define TARGET_LITTLE_SYM l1om_elf64_vec
7728 #undef TARGET_LITTLE_NAME
7729 #define TARGET_LITTLE_NAME "elf64-l1om"
7731 #define ELF_ARCH bfd_arch_l1om
7733 #undef ELF_MACHINE_CODE
7734 #define ELF_MACHINE_CODE EM_L1OM
7739 #define elf64_bed elf64_l1om_bed
7741 #undef elf_backend_object_p
7742 #define elf_backend_object_p elf64_l1om_elf_object_p
7744 /* Restore defaults. */
7745 #undef ELF_MAXPAGESIZE
7746 #undef ELF_MINPAGESIZE
7747 #undef ELF_COMMONPAGESIZE
7748 #define ELF_MAXPAGESIZE 0x200000
7749 #define ELF_MINPAGESIZE 0x1000
7750 #define ELF_COMMONPAGESIZE 0x1000
7751 #undef elf_backend_plt_alignment
7752 #define elf_backend_plt_alignment 4
7753 #undef elf_backend_arch_data
7754 #define elf_backend_arch_data &elf_x86_64_arch_bed
7756 #include "elf64-target.h"
7758 /* FreeBSD L1OM support. */
7760 #undef TARGET_LITTLE_SYM
7761 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7762 #undef TARGET_LITTLE_NAME
7763 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7766 #define ELF_OSABI ELFOSABI_FREEBSD
7769 #define elf64_bed elf64_l1om_fbsd_bed
7771 #include "elf64-target.h"
7773 /* Intel K1OM support. */
7776 elf64_k1om_elf_object_p (bfd
*abfd
)
7778 /* Set the right machine number for an K1OM elf64 file. */
7779 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7783 #undef TARGET_LITTLE_SYM
7784 #define TARGET_LITTLE_SYM k1om_elf64_vec
7785 #undef TARGET_LITTLE_NAME
7786 #define TARGET_LITTLE_NAME "elf64-k1om"
7788 #define ELF_ARCH bfd_arch_k1om
7790 #undef ELF_MACHINE_CODE
7791 #define ELF_MACHINE_CODE EM_K1OM
7796 #define elf64_bed elf64_k1om_bed
7798 #undef elf_backend_object_p
7799 #define elf_backend_object_p elf64_k1om_elf_object_p
7801 #undef elf_backend_static_tls_alignment
7803 #undef elf_backend_want_plt_sym
7804 #define elf_backend_want_plt_sym 0
7806 #include "elf64-target.h"
7808 /* FreeBSD K1OM support. */
7810 #undef TARGET_LITTLE_SYM
7811 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7812 #undef TARGET_LITTLE_NAME
7813 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7816 #define ELF_OSABI ELFOSABI_FREEBSD
7819 #define elf64_bed elf64_k1om_fbsd_bed
7821 #include "elf64-target.h"
7823 /* 32bit x86-64 support. */
7825 #undef TARGET_LITTLE_SYM
7826 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7827 #undef TARGET_LITTLE_NAME
7828 #define TARGET_LITTLE_NAME "elf32-x86-64"
7832 #define ELF_ARCH bfd_arch_i386
7834 #undef ELF_MACHINE_CODE
7835 #define ELF_MACHINE_CODE EM_X86_64
7839 #undef elf_backend_object_p
7840 #define elf_backend_object_p \
7841 elf32_x86_64_elf_object_p
7843 #undef elf_backend_bfd_from_remote_memory
7844 #define elf_backend_bfd_from_remote_memory \
7845 _bfd_elf32_bfd_from_remote_memory
7847 #undef elf_backend_size_info
7848 #define elf_backend_size_info \
7849 _bfd_elf32_size_info
7851 #include "elf32-target.h"