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 /* The first entry in the IBT-enabled lazy procedure linkage table is the
600 the same as the lazy PLT with BND prefix so that bound registers are
601 preserved when control is passed to dynamic linker. Subsequent
602 entries for a IBT-enabled lazy procedure linkage table look like
605 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
607 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
608 0x68, 0, 0, 0, 0, /* pushq immediate */
609 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
613 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
614 is the same as the normal lazy PLT. Subsequent entries for an
615 x32 IBT-enabled lazy procedure linkage table look like this. */
617 static const bfd_byte elf_x32_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
619 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
620 0x68, 0, 0, 0, 0, /* pushq immediate */
621 0xe9, 0, 0, 0, 0, /* jmpq relative */
622 0x66, 0x90 /* xchg %ax,%ax */
625 /* Entries in the non-lazey procedure linkage table look like this. */
627 static const bfd_byte elf_x86_64_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
629 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
630 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
631 0x66, 0x90 /* xchg %ax,%ax */
634 /* Entries for branches with BND prefix in the non-lazey procedure
635 linkage table look like this. */
637 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
639 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
640 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
644 /* Entries for branches with IBT-enabled in the non-lazey procedure
645 linkage table look like this. They have the same size as the lazy
648 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
650 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
651 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
652 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */
656 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
657 linkage table look like this. They have the same size as the lazy
660 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
662 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
663 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
664 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
665 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
668 /* .eh_frame covering the lazy .plt section. */
670 static const bfd_byte elf_x86_64_eh_frame_lazy_plt
[] =
672 #define PLT_CIE_LENGTH 20
673 #define PLT_FDE_LENGTH 36
674 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
675 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
676 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
677 0, 0, 0, 0, /* CIE ID */
679 'z', 'R', 0, /* Augmentation string */
680 1, /* Code alignment factor */
681 0x78, /* Data alignment factor */
682 16, /* Return address column */
683 1, /* Augmentation size */
684 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
685 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
686 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
687 DW_CFA_nop
, DW_CFA_nop
,
689 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
690 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
691 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
692 0, 0, 0, 0, /* .plt size goes here */
693 0, /* Augmentation size */
694 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
695 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
696 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
697 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
698 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
699 11, /* Block length */
700 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
701 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
702 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
703 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
704 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
707 /* .eh_frame covering the lazy BND .plt section. */
709 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt
[] =
711 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
712 0, 0, 0, 0, /* CIE ID */
714 'z', 'R', 0, /* Augmentation string */
715 1, /* Code alignment factor */
716 0x78, /* Data alignment factor */
717 16, /* Return address column */
718 1, /* Augmentation size */
719 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
720 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
721 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
722 DW_CFA_nop
, DW_CFA_nop
,
724 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
725 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
726 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
727 0, 0, 0, 0, /* .plt size goes here */
728 0, /* Augmentation size */
729 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
730 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
731 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
732 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
733 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
734 11, /* Block length */
735 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
736 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
737 DW_OP_lit15
, DW_OP_and
, DW_OP_lit5
, DW_OP_ge
,
738 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
739 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
742 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
744 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt
[] =
746 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
747 0, 0, 0, 0, /* CIE ID */
749 'z', 'R', 0, /* Augmentation string */
750 1, /* Code alignment factor */
751 0x78, /* Data alignment factor */
752 16, /* Return address column */
753 1, /* Augmentation size */
754 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
755 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
756 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
757 DW_CFA_nop
, DW_CFA_nop
,
759 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
760 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
761 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
762 0, 0, 0, 0, /* .plt size goes here */
763 0, /* Augmentation size */
764 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
765 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
766 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
767 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
768 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
769 11, /* Block length */
770 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
771 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
772 DW_OP_lit15
, DW_OP_and
, DW_OP_lit10
, DW_OP_ge
,
773 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
774 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
777 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled. */
779 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt
[] =
781 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
782 0, 0, 0, 0, /* CIE ID */
784 'z', 'R', 0, /* Augmentation string */
785 1, /* Code alignment factor */
786 0x78, /* Data alignment factor */
787 16, /* Return address column */
788 1, /* Augmentation size */
789 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
790 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
791 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
792 DW_CFA_nop
, DW_CFA_nop
,
794 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
795 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
796 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
797 0, 0, 0, 0, /* .plt size goes here */
798 0, /* Augmentation size */
799 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
800 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
801 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
802 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
803 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
804 11, /* Block length */
805 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
806 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
807 DW_OP_lit15
, DW_OP_and
, DW_OP_lit9
, DW_OP_ge
,
808 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
809 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
812 /* .eh_frame covering the non-lazy .plt section. */
814 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt
[] =
816 #define PLT_GOT_FDE_LENGTH 20
817 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
818 0, 0, 0, 0, /* CIE ID */
820 'z', 'R', 0, /* Augmentation string */
821 1, /* Code alignment factor */
822 0x78, /* Data alignment factor */
823 16, /* Return address column */
824 1, /* Augmentation size */
825 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
826 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
827 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
828 DW_CFA_nop
, DW_CFA_nop
,
830 PLT_GOT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
831 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
832 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
833 0, 0, 0, 0, /* non-lazy .plt size goes here */
834 0, /* Augmentation size */
835 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
,
836 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
839 struct elf_x86_64_lazy_plt_layout
841 /* Templates for the initial PLT entry and for subsequent entries. */
842 const bfd_byte
*plt0_entry
;
843 const bfd_byte
*plt_entry
;
844 unsigned int plt_entry_size
; /* Size of each PLT entry. */
846 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
847 unsigned int plt0_got1_offset
;
848 unsigned int plt0_got2_offset
;
850 /* Offset of the end of the PC-relative instruction containing
852 unsigned int plt0_got2_insn_end
;
854 /* Offsets into plt_entry that are to be replaced with... */
855 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
856 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
857 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
859 /* Length of the PC-relative instruction containing plt_got_offset. */
860 unsigned int plt_got_insn_size
;
862 /* Offset of the end of the PC-relative jump to plt0_entry. */
863 unsigned int plt_plt_insn_end
;
865 /* Offset into plt_entry where the initial value of the GOT entry points. */
866 unsigned int plt_lazy_offset
;
868 /* .eh_frame covering the lazy .plt section. */
869 const bfd_byte
*eh_frame_plt
;
870 unsigned int eh_frame_plt_size
;
873 struct elf_x86_64_non_lazy_plt_layout
875 /* Template for the lazy PLT entries. */
876 const bfd_byte
*plt_entry
;
877 unsigned int plt_entry_size
; /* Size of each PLT entry. */
879 /* Offsets into plt_entry that are to be replaced with... */
880 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
882 /* Length of the PC-relative instruction containing plt_got_offset. */
883 unsigned int plt_got_insn_size
;
885 /* .eh_frame covering the non-lazy .plt section. */
886 const bfd_byte
*eh_frame_plt
;
887 unsigned int eh_frame_plt_size
;
890 struct elf_x86_64_plt_layout
892 /* Template for the PLT entries. */
893 const bfd_byte
*plt_entry
;
894 unsigned int plt_entry_size
; /* Size of each PLT entry. */
897 unsigned int has_plt0
;
899 /* Offsets into plt_entry that are to be replaced with... */
900 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
902 /* Length of the PC-relative instruction containing plt_got_offset. */
903 unsigned int plt_got_insn_size
;
905 /* .eh_frame covering the .plt section. */
906 const bfd_byte
*eh_frame_plt
;
907 unsigned int eh_frame_plt_size
;
910 /* Architecture-specific backend data for x86-64. */
912 struct elf_x86_64_backend_data
922 #define get_elf_x86_64_arch_data(bed) \
923 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
925 #define get_elf_x86_64_backend_data(abfd) \
926 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
928 /* These are the standard parameters. */
929 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_plt
=
931 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
932 elf_x86_64_lazy_plt_entry
, /* plt_entry */
933 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
934 2, /* plt0_got1_offset */
935 8, /* plt0_got2_offset */
936 12, /* plt0_got2_insn_end */
937 2, /* plt_got_offset */
938 7, /* plt_reloc_offset */
939 12, /* plt_plt_offset */
940 6, /* plt_got_insn_size */
941 LAZY_PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
942 6, /* plt_lazy_offset */
943 elf_x86_64_eh_frame_lazy_plt
, /* eh_frame_plt */
944 sizeof (elf_x86_64_eh_frame_lazy_plt
) /* eh_frame_plt_size */
947 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_plt
=
949 elf_x86_64_non_lazy_plt_entry
, /* plt_entry */
950 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
951 2, /* plt_got_offset */
952 6, /* plt_got_insn_size */
953 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
954 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
957 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_bnd_plt
=
959 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
960 elf_x86_64_lazy_bnd_plt_entry
, /* plt_entry */
961 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
962 2, /* plt0_got1_offset */
963 1+8, /* plt0_got2_offset */
964 1+12, /* plt0_got2_insn_end */
965 1+2, /* plt_got_offset */
966 1, /* plt_reloc_offset */
967 7, /* plt_plt_offset */
968 1+6, /* plt_got_insn_size */
969 11, /* plt_plt_insn_end */
970 0, /* plt_lazy_offset */
971 elf_x86_64_eh_frame_lazy_bnd_plt
, /* eh_frame_plt */
972 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt
) /* eh_frame_plt_size */
975 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt
=
977 elf_x86_64_non_lazy_bnd_plt_entry
, /* plt_entry */
978 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
979 1+2, /* plt_got_offset */
980 1+6, /* plt_got_insn_size */
981 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
982 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
985 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_ibt_plt
=
987 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
988 elf_x86_64_lazy_ibt_plt_entry
, /* plt_entry */
989 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
990 2, /* plt0_got1_offset */
991 1+8, /* plt0_got2_offset */
992 1+12, /* plt0_got2_insn_end */
993 4+1+2, /* plt_got_offset */
994 4+1, /* plt_reloc_offset */
995 4+1+6, /* plt_plt_offset */
996 4+1+6, /* plt_got_insn_size */
997 4+1+5+5, /* plt_plt_insn_end */
998 0, /* plt_lazy_offset */
999 elf_x86_64_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
1000 sizeof (elf_x86_64_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
1003 static const struct elf_x86_64_lazy_plt_layout elf_x32_lazy_ibt_plt
=
1005 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
1006 elf_x32_lazy_ibt_plt_entry
, /* plt_entry */
1007 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
1008 2, /* plt0_got1_offset */
1009 8, /* plt0_got2_offset */
1010 12, /* plt0_got2_insn_end */
1011 4+2, /* plt_got_offset */
1012 4+1, /* plt_reloc_offset */
1013 4+6, /* plt_plt_offset */
1014 4+6, /* plt_got_insn_size */
1015 4+5+5, /* plt_plt_insn_end */
1016 0, /* plt_lazy_offset */
1017 elf_x32_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
1018 sizeof (elf_x32_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
1021 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt
=
1023 elf_x86_64_non_lazy_ibt_plt_entry
, /* plt_entry */
1024 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
1025 4+1+2, /* plt_got_offset */
1026 4+1+6, /* plt_got_insn_size */
1027 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
1028 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
1031 static const struct elf_x86_64_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt
=
1033 elf_x32_non_lazy_ibt_plt_entry
, /* plt_entry */
1034 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
1035 4+2, /* plt_got_offset */
1036 4+6, /* plt_got_insn_size */
1037 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
1038 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
1041 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
1046 #define elf_backend_arch_data &elf_x86_64_arch_bed
1048 /* Is a undefined weak symbol which is resolved to 0. Reference to an
1049 undefined weak symbol is resolved to 0 when building executable if
1050 it isn't dynamic and
1051 1. Has non-GOT/non-PLT relocations in text section. Or
1052 2. Has no GOT/PLT relocation.
1053 Local undefined weak symbol is always resolved to 0.
1055 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
1056 ((EH)->elf.root.type == bfd_link_hash_undefweak \
1057 && ((EH)->elf.forced_local \
1058 || (bfd_link_executable (INFO) \
1059 && (elf_x86_64_hash_table (INFO)->interp == NULL \
1061 || (EH)->has_non_got_reloc \
1062 || !(INFO)->dynamic_undefined_weak))))
1064 /* x86-64 ELF linker hash entry. */
1066 struct elf_x86_64_link_hash_entry
1068 struct elf_link_hash_entry elf
;
1070 /* Track dynamic relocs copied for this symbol. */
1071 struct elf_dyn_relocs
*dyn_relocs
;
1073 #define GOT_UNKNOWN 0
1074 #define GOT_NORMAL 1
1075 #define GOT_TLS_GD 2
1076 #define GOT_TLS_IE 3
1077 #define GOT_TLS_GDESC 4
1078 #define GOT_TLS_GD_BOTH_P(type) \
1079 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
1080 #define GOT_TLS_GD_P(type) \
1081 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
1082 #define GOT_TLS_GDESC_P(type) \
1083 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
1084 #define GOT_TLS_GD_ANY_P(type) \
1085 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
1086 unsigned char tls_type
;
1088 /* TRUE if a weak symbol with a real definition needs a copy reloc.
1089 When there is a weak symbol with a real definition, the processor
1090 independent code will have arranged for us to see the real
1091 definition first. We need to copy the needs_copy bit from the
1092 real definition and check it when allowing copy reloc in PIE. */
1093 unsigned int needs_copy
: 1;
1095 /* TRUE if symbol has GOT or PLT relocations. */
1096 unsigned int has_got_reloc
: 1;
1098 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
1099 unsigned int has_non_got_reloc
: 1;
1101 /* Don't call finish_dynamic_symbol on this symbol. */
1102 unsigned int no_finish_dynamic_symbol
: 1;
1104 /* TRUE if symbol symbol is __tls_get_addr. */
1105 unsigned int tls_get_addr
: 1;
1107 /* Reference count of C/C++ function pointer relocations in read-write
1108 section which can be resolved at run-time. */
1109 bfd_signed_vma func_pointer_refcount
;
1111 /* Information about the GOT PLT entry. Filled when there are both
1112 GOT and PLT relocations against the same function. */
1113 union gotplt_union plt_got
;
1115 /* Information about the second PLT entry. */
1116 union gotplt_union plt_second
;
1118 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
1119 starting at the end of the jump table. */
1120 bfd_vma tlsdesc_got
;
1123 #define elf_x86_64_hash_entry(ent) \
1124 ((struct elf_x86_64_link_hash_entry *)(ent))
1126 struct elf_x86_64_obj_tdata
1128 struct elf_obj_tdata root
;
1130 /* tls_type for each local got entry. */
1131 char *local_got_tls_type
;
1133 /* GOTPLT entries for TLS descriptors. */
1134 bfd_vma
*local_tlsdesc_gotent
;
1137 #define elf_x86_64_tdata(abfd) \
1138 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
1140 #define elf_x86_64_local_got_tls_type(abfd) \
1141 (elf_x86_64_tdata (abfd)->local_got_tls_type)
1143 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
1144 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
1146 #define is_x86_64_elf(bfd) \
1147 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1148 && elf_tdata (bfd) != NULL \
1149 && elf_object_id (bfd) == X86_64_ELF_DATA)
1152 elf_x86_64_mkobject (bfd
*abfd
)
1154 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
1158 /* x86-64 ELF linker hash table. */
1160 struct elf_x86_64_link_hash_table
1162 struct elf_link_hash_table elf
;
1164 /* Short-cuts to get to dynamic linker sections. */
1166 asection
*plt_eh_frame
;
1167 asection
*plt_second
;
1168 asection
*plt_second_eh_frame
;
1170 asection
*plt_got_eh_frame
;
1172 /* Parameters describing PLT generation, lazy or non-lazy. */
1173 struct elf_x86_64_plt_layout plt
;
1175 /* Parameters describing lazy PLT generation. */
1176 const struct elf_x86_64_lazy_plt_layout
*lazy_plt
;
1178 /* Parameters describing non-lazy PLT generation. */
1179 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_plt
;
1183 bfd_signed_vma refcount
;
1187 /* The amount of space used by the jump slots in the GOT. */
1188 bfd_vma sgotplt_jump_table_size
;
1190 /* Small local sym cache. */
1191 struct sym_cache sym_cache
;
1193 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
1194 bfd_vma (*r_sym
) (bfd_vma
);
1195 unsigned int pointer_r_type
;
1196 const char *dynamic_interpreter
;
1197 int dynamic_interpreter_size
;
1199 /* _TLS_MODULE_BASE_ symbol. */
1200 struct bfd_link_hash_entry
*tls_module_base
;
1202 /* Used by local STT_GNU_IFUNC symbols. */
1203 htab_t loc_hash_table
;
1204 void * loc_hash_memory
;
1206 /* The offset into splt of the PLT entry for the TLS descriptor
1207 resolver. Special values are 0, if not necessary (or not found
1208 to be necessary yet), and -1 if needed but not determined
1210 bfd_vma tlsdesc_plt
;
1211 /* The offset into sgot of the GOT entry used by the PLT entry
1213 bfd_vma tlsdesc_got
;
1215 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
1216 bfd_vma next_jump_slot_index
;
1217 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
1218 bfd_vma next_irelative_index
;
1220 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
1221 to read-only sections. */
1222 bfd_boolean readonly_dynrelocs_against_ifunc
;
1225 /* Get the x86-64 ELF linker hash table from a link_info structure. */
1227 #define elf_x86_64_hash_table(p) \
1228 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1229 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
1231 #define elf_x86_64_compute_jump_table_size(htab) \
1232 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
1234 /* Create an entry in an x86-64 ELF linker hash table. */
1236 static struct bfd_hash_entry
*
1237 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1238 struct bfd_hash_table
*table
,
1241 /* Allocate the structure if it has not already been allocated by a
1245 entry
= (struct bfd_hash_entry
*)
1246 bfd_hash_allocate (table
,
1247 sizeof (struct elf_x86_64_link_hash_entry
));
1252 /* Call the allocation method of the superclass. */
1253 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
1256 struct elf_x86_64_link_hash_entry
*eh
;
1258 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
1259 eh
->dyn_relocs
= NULL
;
1260 eh
->tls_type
= GOT_UNKNOWN
;
1262 eh
->has_got_reloc
= 0;
1263 eh
->has_non_got_reloc
= 0;
1264 eh
->no_finish_dynamic_symbol
= 0;
1265 eh
->tls_get_addr
= 0;
1266 eh
->func_pointer_refcount
= 0;
1267 eh
->plt_second
.offset
= (bfd_vma
) -1;
1268 eh
->plt_got
.offset
= (bfd_vma
) -1;
1269 eh
->tlsdesc_got
= (bfd_vma
) -1;
1275 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
1276 for local symbol so that we can handle local STT_GNU_IFUNC symbols
1277 as global symbol. We reuse indx and dynstr_index for local symbol
1278 hash since they aren't used by global symbols in this backend. */
1281 elf_x86_64_local_htab_hash (const void *ptr
)
1283 struct elf_link_hash_entry
*h
1284 = (struct elf_link_hash_entry
*) ptr
;
1285 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
1288 /* Compare local hash entries. */
1291 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1293 struct elf_link_hash_entry
*h1
1294 = (struct elf_link_hash_entry
*) ptr1
;
1295 struct elf_link_hash_entry
*h2
1296 = (struct elf_link_hash_entry
*) ptr2
;
1298 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
1301 /* Find and/or create a hash entry for local symbol. */
1303 static struct elf_link_hash_entry
*
1304 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
1305 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1308 struct elf_x86_64_link_hash_entry e
, *ret
;
1309 asection
*sec
= abfd
->sections
;
1310 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1311 htab
->r_sym (rel
->r_info
));
1314 e
.elf
.indx
= sec
->id
;
1315 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1316 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1317 create
? INSERT
: NO_INSERT
);
1324 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1328 ret
= (struct elf_x86_64_link_hash_entry
*)
1329 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1330 sizeof (struct elf_x86_64_link_hash_entry
));
1333 memset (ret
, 0, sizeof (*ret
));
1334 ret
->elf
.indx
= sec
->id
;
1335 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1336 ret
->elf
.dynindx
= -1;
1337 ret
->func_pointer_refcount
= 0;
1338 ret
->plt_got
.offset
= (bfd_vma
) -1;
1344 /* Destroy an X86-64 ELF linker hash table. */
1347 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1349 struct elf_x86_64_link_hash_table
*htab
1350 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1352 if (htab
->loc_hash_table
)
1353 htab_delete (htab
->loc_hash_table
);
1354 if (htab
->loc_hash_memory
)
1355 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1356 _bfd_elf_link_hash_table_free (obfd
);
1359 /* Create an X86-64 ELF linker hash table. */
1361 static struct bfd_link_hash_table
*
1362 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1364 struct elf_x86_64_link_hash_table
*ret
;
1365 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1367 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1371 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1372 elf_x86_64_link_hash_newfunc
,
1373 sizeof (struct elf_x86_64_link_hash_entry
),
1380 if (ABI_64_P (abfd
))
1382 ret
->r_info
= elf64_r_info
;
1383 ret
->r_sym
= elf64_r_sym
;
1384 ret
->pointer_r_type
= R_X86_64_64
;
1385 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1386 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1390 ret
->r_info
= elf32_r_info
;
1391 ret
->r_sym
= elf32_r_sym
;
1392 ret
->pointer_r_type
= R_X86_64_32
;
1393 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1394 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1397 ret
->loc_hash_table
= htab_try_create (1024,
1398 elf_x86_64_local_htab_hash
,
1399 elf_x86_64_local_htab_eq
,
1401 ret
->loc_hash_memory
= objalloc_create ();
1402 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1404 elf_x86_64_link_hash_table_free (abfd
);
1407 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1409 return &ret
->elf
.root
;
1412 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1415 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1416 struct elf_link_hash_entry
*dir
,
1417 struct elf_link_hash_entry
*ind
)
1419 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1421 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1422 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1424 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1425 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1427 if (eind
->dyn_relocs
!= NULL
)
1429 if (edir
->dyn_relocs
!= NULL
)
1431 struct elf_dyn_relocs
**pp
;
1432 struct elf_dyn_relocs
*p
;
1434 /* Add reloc counts against the indirect sym to the direct sym
1435 list. Merge any entries against the same section. */
1436 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1438 struct elf_dyn_relocs
*q
;
1440 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1441 if (q
->sec
== p
->sec
)
1443 q
->pc_count
+= p
->pc_count
;
1444 q
->count
+= p
->count
;
1451 *pp
= edir
->dyn_relocs
;
1454 edir
->dyn_relocs
= eind
->dyn_relocs
;
1455 eind
->dyn_relocs
= NULL
;
1458 if (ind
->root
.type
== bfd_link_hash_indirect
1459 && dir
->got
.refcount
<= 0)
1461 edir
->tls_type
= eind
->tls_type
;
1462 eind
->tls_type
= GOT_UNKNOWN
;
1465 if (ELIMINATE_COPY_RELOCS
1466 && ind
->root
.type
!= bfd_link_hash_indirect
1467 && dir
->dynamic_adjusted
)
1469 /* If called to transfer flags for a weakdef during processing
1470 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1471 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1472 if (dir
->versioned
!= versioned_hidden
)
1473 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1474 dir
->ref_regular
|= ind
->ref_regular
;
1475 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1476 dir
->needs_plt
|= ind
->needs_plt
;
1477 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1481 if (eind
->func_pointer_refcount
> 0)
1483 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1484 eind
->func_pointer_refcount
= 0;
1487 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1492 elf64_x86_64_elf_object_p (bfd
*abfd
)
1494 /* Set the right machine number for an x86-64 elf64 file. */
1495 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1500 elf32_x86_64_elf_object_p (bfd
*abfd
)
1502 /* Set the right machine number for an x86-64 elf32 file. */
1503 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1507 /* Return TRUE if the TLS access code sequence support transition
1511 elf_x86_64_check_tls_transition (bfd
*abfd
,
1512 struct bfd_link_info
*info
,
1515 Elf_Internal_Shdr
*symtab_hdr
,
1516 struct elf_link_hash_entry
**sym_hashes
,
1517 unsigned int r_type
,
1518 const Elf_Internal_Rela
*rel
,
1519 const Elf_Internal_Rela
*relend
)
1522 unsigned long r_symndx
;
1523 bfd_boolean largepic
= FALSE
;
1524 struct elf_link_hash_entry
*h
;
1526 struct elf_x86_64_link_hash_table
*htab
;
1528 bfd_boolean indirect_call
;
1530 htab
= elf_x86_64_hash_table (info
);
1531 offset
= rel
->r_offset
;
1534 case R_X86_64_TLSGD
:
1535 case R_X86_64_TLSLD
:
1536 if ((rel
+ 1) >= relend
)
1539 if (r_type
== R_X86_64_TLSGD
)
1541 /* Check transition from GD access model. For 64bit, only
1542 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1543 .word 0x6666; rex64; call __tls_get_addr@PLT
1545 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1547 call *__tls_get_addr@GOTPCREL(%rip)
1548 which may be converted to
1549 addr32 call __tls_get_addr
1550 can transit to different access model. For 32bit, only
1551 leaq foo@tlsgd(%rip), %rdi
1552 .word 0x6666; rex64; call __tls_get_addr@PLT
1554 leaq foo@tlsgd(%rip), %rdi
1556 call *__tls_get_addr@GOTPCREL(%rip)
1557 which may be converted to
1558 addr32 call __tls_get_addr
1559 can transit to different access model. For largepic,
1561 leaq foo@tlsgd(%rip), %rdi
1562 movabsq $__tls_get_addr@pltoff, %rax
1566 leaq foo@tlsgd(%rip), %rdi
1567 movabsq $__tls_get_addr@pltoff, %rax
1571 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1573 if ((offset
+ 12) > sec
->size
)
1576 call
= contents
+ offset
+ 4;
1578 || !((call
[1] == 0x48
1586 && call
[3] == 0xe8)))
1588 if (!ABI_64_P (abfd
)
1589 || (offset
+ 19) > sec
->size
1591 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1592 || memcmp (call
, "\x48\xb8", 2) != 0
1596 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1597 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1601 else if (ABI_64_P (abfd
))
1604 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1610 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1613 indirect_call
= call
[2] == 0xff;
1617 /* Check transition from LD access model. Only
1618 leaq foo@tlsld(%rip), %rdi;
1619 call __tls_get_addr@PLT
1621 leaq foo@tlsld(%rip), %rdi;
1622 call *__tls_get_addr@GOTPCREL(%rip)
1623 which may be converted to
1624 addr32 call __tls_get_addr
1625 can transit to different access model. For largepic
1627 leaq foo@tlsld(%rip), %rdi
1628 movabsq $__tls_get_addr@pltoff, %rax
1632 leaq foo@tlsld(%rip), %rdi
1633 movabsq $__tls_get_addr@pltoff, %rax
1637 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1639 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1642 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1645 call
= contents
+ offset
+ 4;
1646 if (!(call
[0] == 0xe8
1647 || (call
[0] == 0xff && call
[1] == 0x15)
1648 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1650 if (!ABI_64_P (abfd
)
1651 || (offset
+ 19) > sec
->size
1652 || memcmp (call
, "\x48\xb8", 2) != 0
1656 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1657 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1661 indirect_call
= call
[0] == 0xff;
1664 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1665 if (r_symndx
< symtab_hdr
->sh_info
)
1668 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1670 || !((struct elf_x86_64_link_hash_entry
*) h
)->tls_get_addr
)
1673 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1674 else if (indirect_call
)
1675 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1677 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1678 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1680 case R_X86_64_GOTTPOFF
:
1681 /* Check transition from IE access model:
1682 mov foo@gottpoff(%rip), %reg
1683 add foo@gottpoff(%rip), %reg
1686 /* Check REX prefix first. */
1687 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1689 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1690 if (val
!= 0x48 && val
!= 0x4c)
1692 /* X32 may have 0x44 REX prefix or no REX prefix. */
1693 if (ABI_64_P (abfd
))
1699 /* X32 may not have any REX prefix. */
1700 if (ABI_64_P (abfd
))
1702 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1706 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1707 if (val
!= 0x8b && val
!= 0x03)
1710 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1711 return (val
& 0xc7) == 5;
1713 case R_X86_64_GOTPC32_TLSDESC
:
1714 /* Check transition from GDesc access model:
1715 leaq x@tlsdesc(%rip), %rax
1717 Make sure it's a leaq adding rip to a 32-bit offset
1718 into any register, although it's probably almost always
1721 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1724 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1725 if ((val
& 0xfb) != 0x48)
1728 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1731 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1732 return (val
& 0xc7) == 0x05;
1734 case R_X86_64_TLSDESC_CALL
:
1735 /* Check transition from GDesc access model:
1736 call *x@tlsdesc(%rax)
1738 if (offset
+ 2 <= sec
->size
)
1740 /* Make sure that it's a call *x@tlsdesc(%rax). */
1741 call
= contents
+ offset
;
1742 return call
[0] == 0xff && call
[1] == 0x10;
1752 /* Return TRUE if the TLS access transition is OK or no transition
1753 will be performed. Update R_TYPE if there is a transition. */
1756 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1757 asection
*sec
, bfd_byte
*contents
,
1758 Elf_Internal_Shdr
*symtab_hdr
,
1759 struct elf_link_hash_entry
**sym_hashes
,
1760 unsigned int *r_type
, int tls_type
,
1761 const Elf_Internal_Rela
*rel
,
1762 const Elf_Internal_Rela
*relend
,
1763 struct elf_link_hash_entry
*h
,
1764 unsigned long r_symndx
,
1765 bfd_boolean from_relocate_section
)
1767 unsigned int from_type
= *r_type
;
1768 unsigned int to_type
= from_type
;
1769 bfd_boolean check
= TRUE
;
1771 /* Skip TLS transition for functions. */
1773 && (h
->type
== STT_FUNC
1774 || h
->type
== STT_GNU_IFUNC
))
1779 case R_X86_64_TLSGD
:
1780 case R_X86_64_GOTPC32_TLSDESC
:
1781 case R_X86_64_TLSDESC_CALL
:
1782 case R_X86_64_GOTTPOFF
:
1783 if (bfd_link_executable (info
))
1786 to_type
= R_X86_64_TPOFF32
;
1788 to_type
= R_X86_64_GOTTPOFF
;
1791 /* When we are called from elf_x86_64_relocate_section, there may
1792 be additional transitions based on TLS_TYPE. */
1793 if (from_relocate_section
)
1795 unsigned int new_to_type
= to_type
;
1797 if (bfd_link_executable (info
)
1800 && tls_type
== GOT_TLS_IE
)
1801 new_to_type
= R_X86_64_TPOFF32
;
1803 if (to_type
== R_X86_64_TLSGD
1804 || to_type
== R_X86_64_GOTPC32_TLSDESC
1805 || to_type
== R_X86_64_TLSDESC_CALL
)
1807 if (tls_type
== GOT_TLS_IE
)
1808 new_to_type
= R_X86_64_GOTTPOFF
;
1811 /* We checked the transition before when we were called from
1812 elf_x86_64_check_relocs. We only want to check the new
1813 transition which hasn't been checked before. */
1814 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1815 to_type
= new_to_type
;
1820 case R_X86_64_TLSLD
:
1821 if (bfd_link_executable (info
))
1822 to_type
= R_X86_64_TPOFF32
;
1829 /* Return TRUE if there is no transition. */
1830 if (from_type
== to_type
)
1833 /* Check if the transition can be performed. */
1835 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1836 symtab_hdr
, sym_hashes
,
1837 from_type
, rel
, relend
))
1839 reloc_howto_type
*from
, *to
;
1842 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1843 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1846 name
= h
->root
.root
.string
;
1849 struct elf_x86_64_link_hash_table
*htab
;
1851 htab
= elf_x86_64_hash_table (info
);
1856 Elf_Internal_Sym
*isym
;
1858 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1860 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1865 /* xgettext:c-format */
1866 (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
1867 "in section `%A' failed"),
1868 abfd
, from
->name
, to
->name
, name
, rel
->r_offset
, sec
);
1869 bfd_set_error (bfd_error_bad_value
);
1877 /* Rename some of the generic section flags to better document how they
1879 #define need_convert_load sec_flg0
1880 #define check_relocs_failed sec_flg1
1883 elf_x86_64_need_pic (struct bfd_link_info
*info
,
1884 bfd
*input_bfd
, asection
*sec
,
1885 struct elf_link_hash_entry
*h
,
1886 Elf_Internal_Shdr
*symtab_hdr
,
1887 Elf_Internal_Sym
*isym
,
1888 reloc_howto_type
*howto
)
1891 const char *und
= "";
1892 const char *pic
= "";
1898 name
= h
->root
.root
.string
;
1899 switch (ELF_ST_VISIBILITY (h
->other
))
1902 v
= _("hidden symbol ");
1905 v
= _("internal symbol ");
1908 v
= _("protected symbol ");
1912 pic
= _("; recompile with -fPIC");
1916 if (!h
->def_regular
&& !h
->def_dynamic
)
1917 und
= _("undefined ");
1921 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1922 pic
= _("; recompile with -fPIC");
1925 if (bfd_link_dll (info
))
1926 object
= _("a shared object");
1927 else if (bfd_link_pie (info
))
1928 object
= _("a PIE object");
1930 object
= _("a PDE object");
1932 /* xgettext:c-format */
1933 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1934 "not be used when making %s%s"),
1935 input_bfd
, howto
->name
, und
, v
, name
,
1937 bfd_set_error (bfd_error_bad_value
);
1938 sec
->check_relocs_failed
= 1;
1942 /* With the local symbol, foo, we convert
1943 mov foo@GOTPCREL(%rip), %reg
1947 call/jmp *foo@GOTPCREL(%rip)
1949 nop call foo/jmp foo nop
1950 When PIC is false, convert
1951 test %reg, foo@GOTPCREL(%rip)
1955 binop foo@GOTPCREL(%rip), %reg
1958 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1962 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1964 Elf_Internal_Rela
*irel
,
1965 struct elf_link_hash_entry
*h
,
1966 bfd_boolean
*converted
,
1967 struct bfd_link_info
*link_info
)
1969 struct elf_x86_64_link_hash_table
*htab
;
1971 bfd_boolean require_reloc_pc32
;
1973 bfd_boolean to_reloc_pc32
;
1976 bfd_signed_vma raddend
;
1977 unsigned int opcode
;
1979 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1980 unsigned int r_symndx
;
1982 bfd_vma roff
= irel
->r_offset
;
1984 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1987 raddend
= irel
->r_addend
;
1988 /* Addend for 32-bit PC-relative relocation must be -4. */
1992 htab
= elf_x86_64_hash_table (link_info
);
1993 is_pic
= bfd_link_pic (link_info
);
1995 relocx
= (r_type
== R_X86_64_GOTPCRELX
1996 || r_type
== R_X86_64_REX_GOTPCRELX
);
1998 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
2001 = link_info
->disable_target_specific_optimizations
> 1;
2003 r_symndx
= htab
->r_sym (irel
->r_info
);
2005 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
2007 /* Convert mov to lea since it has been done for a while. */
2010 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
2011 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
2012 test, xor instructions. */
2017 /* We convert only to R_X86_64_PC32:
2019 2. R_X86_64_GOTPCREL since we can't modify REX byte.
2020 3. require_reloc_pc32 is true.
2023 to_reloc_pc32
= (opcode
== 0xff
2025 || require_reloc_pc32
2028 /* Get the symbol referred to by the reloc. */
2031 Elf_Internal_Sym
*isym
2032 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
2034 /* Skip relocation against undefined symbols. */
2035 if (isym
->st_shndx
== SHN_UNDEF
)
2038 symtype
= ELF_ST_TYPE (isym
->st_info
);
2040 if (isym
->st_shndx
== SHN_ABS
)
2041 tsec
= bfd_abs_section_ptr
;
2042 else if (isym
->st_shndx
== SHN_COMMON
)
2043 tsec
= bfd_com_section_ptr
;
2044 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
2045 tsec
= &_bfd_elf_large_com_section
;
2047 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2049 toff
= isym
->st_value
;
2053 /* Undefined weak symbol is only bound locally in executable
2054 and its reference is resolved as 0 without relocation
2055 overflow. We can only perform this optimization for
2056 GOTPCRELX relocations since we need to modify REX byte.
2057 It is OK convert mov with R_X86_64_GOTPCREL to
2059 if ((relocx
|| opcode
== 0x8b)
2060 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
2062 elf_x86_64_hash_entry (h
)))
2066 /* Skip for branch instructions since R_X86_64_PC32
2068 if (require_reloc_pc32
)
2073 /* For non-branch instructions, we can convert to
2074 R_X86_64_32/R_X86_64_32S since we know if there
2076 to_reloc_pc32
= FALSE
;
2079 /* Since we don't know the current PC when PIC is true,
2080 we can't convert to R_X86_64_PC32. */
2081 if (to_reloc_pc32
&& is_pic
)
2086 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
2087 ld.so may use its link-time address. */
2088 else if (h
->start_stop
2090 || h
->root
.type
== bfd_link_hash_defined
2091 || h
->root
.type
== bfd_link_hash_defweak
)
2092 && h
!= htab
->elf
.hdynamic
2093 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)))
2095 /* bfd_link_hash_new or bfd_link_hash_undefined is
2096 set by an assignment in a linker script in
2097 bfd_elf_record_link_assignment. start_stop is set
2098 on __start_SECNAME/__stop_SECNAME which mark section
2102 && (h
->root
.type
== bfd_link_hash_new
2103 || h
->root
.type
== bfd_link_hash_undefined
2104 || ((h
->root
.type
== bfd_link_hash_defined
2105 || h
->root
.type
== bfd_link_hash_defweak
)
2106 && h
->root
.u
.def
.section
== bfd_und_section_ptr
))))
2108 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
2109 if (require_reloc_pc32
)
2113 tsec
= h
->root
.u
.def
.section
;
2114 toff
= h
->root
.u
.def
.value
;
2121 /* Don't convert GOTPCREL relocation against large section. */
2122 if (elf_section_data (tsec
) != NULL
2123 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
2126 /* We can only estimate relocation overflow for R_X86_64_PC32. */
2130 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2132 /* At this stage in linking, no SEC_MERGE symbol has been
2133 adjusted, so all references to such symbols need to be
2134 passed through _bfd_merged_section_offset. (Later, in
2135 relocate_section, all SEC_MERGE symbols *except* for
2136 section symbols have been adjusted.)
2138 gas may reduce relocations against symbols in SEC_MERGE
2139 sections to a relocation against the section symbol when
2140 the original addend was zero. When the reloc is against
2141 a section symbol we should include the addend in the
2142 offset passed to _bfd_merged_section_offset, since the
2143 location of interest is the original symbol. On the
2144 other hand, an access to "sym+addend" where "sym" is not
2145 a section symbol should not include the addend; Such an
2146 access is presumed to be an offset from "sym"; The
2147 location of interest is just "sym". */
2148 if (symtype
== STT_SECTION
)
2151 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
2152 elf_section_data (tsec
)->sec_info
,
2155 if (symtype
!= STT_SECTION
)
2161 /* Don't convert if R_X86_64_PC32 relocation overflows. */
2162 if (tsec
->output_section
== sec
->output_section
)
2164 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
2169 bfd_signed_vma distance
;
2171 /* At this point, we don't know the load addresses of TSEC
2172 section nor SEC section. We estimate the distrance between
2173 SEC and TSEC. We store the estimated distances in the
2174 compressed_size field of the output section, which is only
2175 used to decompress the compressed input section. */
2176 if (sec
->output_section
->compressed_size
== 0)
2179 bfd_size_type size
= 0;
2180 for (asect
= link_info
->output_bfd
->sections
;
2182 asect
= asect
->next
)
2183 /* Skip debug sections since compressed_size is used to
2184 compress debug sections. */
2185 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
2188 for (i
= asect
->map_head
.s
;
2192 size
= align_power (size
, i
->alignment_power
);
2195 asect
->compressed_size
= size
;
2199 /* Don't convert GOTPCREL relocations if TSEC isn't placed
2201 distance
= (tsec
->output_section
->compressed_size
2202 - sec
->output_section
->compressed_size
);
2206 /* Take PT_GNU_RELRO segment into account by adding
2208 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
2209 - roff
+ 0x80000000) > 0xffffffff)
2216 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
2221 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
2223 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2226 /* Convert to "jmp foo nop". */
2229 nop_offset
= irel
->r_offset
+ 3;
2230 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2231 irel
->r_offset
-= 1;
2232 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2236 struct elf_x86_64_link_hash_entry
*eh
2237 = (struct elf_x86_64_link_hash_entry
*) h
;
2239 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2242 /* To support TLS optimization, always use addr32 prefix for
2243 "call *__tls_get_addr@GOTPCREL(%rip)". */
2244 if (eh
&& eh
->tls_get_addr
)
2247 nop_offset
= irel
->r_offset
- 2;
2251 nop
= link_info
->call_nop_byte
;
2252 if (link_info
->call_nop_as_suffix
)
2254 nop_offset
= irel
->r_offset
+ 3;
2255 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2256 irel
->r_offset
-= 1;
2257 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2260 nop_offset
= irel
->r_offset
- 2;
2263 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2264 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2265 r_type
= R_X86_64_PC32
;
2270 unsigned int rex_mask
= REX_R
;
2272 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2273 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2281 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2282 "lea foo(%rip), %reg". */
2284 r_type
= R_X86_64_PC32
;
2288 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2289 "mov $foo, %reg". */
2291 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2292 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2293 if ((rex
& REX_W
) != 0
2294 && ABI_64_P (link_info
->output_bfd
))
2296 /* Keep the REX_W bit in REX byte for LP64. */
2297 r_type
= R_X86_64_32S
;
2298 goto rewrite_modrm_rex
;
2302 /* If the REX_W bit in REX byte isn't needed,
2303 use R_X86_64_32 and clear the W bit to avoid
2304 sign-extend imm32 to imm64. */
2305 r_type
= R_X86_64_32
;
2306 /* Clear the W bit in REX byte. */
2308 goto rewrite_modrm_rex
;
2314 /* R_X86_64_PC32 isn't supported. */
2318 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2321 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2322 "test $foo, %reg". */
2323 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2328 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2329 "binop $foo, %reg". */
2330 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2334 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2335 overflow when sign-extending imm32 to imm64. */
2336 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2339 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2343 /* Move the R bit to the B bit in REX byte. */
2344 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2345 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2348 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2352 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2355 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2362 /* Look through the relocs for a section during the first phase, and
2363 calculate needed space in the global offset table, procedure
2364 linkage table, and dynamic reloc sections. */
2367 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2369 const Elf_Internal_Rela
*relocs
)
2371 struct elf_x86_64_link_hash_table
*htab
;
2372 Elf_Internal_Shdr
*symtab_hdr
;
2373 struct elf_link_hash_entry
**sym_hashes
;
2374 const Elf_Internal_Rela
*rel
;
2375 const Elf_Internal_Rela
*rel_end
;
2379 if (bfd_link_relocatable (info
))
2382 /* Don't do anything special with non-loaded, non-alloced sections.
2383 In particular, any relocs in such sections should not affect GOT
2384 and PLT reference counting (ie. we don't allow them to create GOT
2385 or PLT entries), there's no possibility or desire to optimize TLS
2386 relocs, and there's not much point in propagating relocs to shared
2387 libs that the dynamic linker won't relocate. */
2388 if ((sec
->flags
& SEC_ALLOC
) == 0)
2391 BFD_ASSERT (is_x86_64_elf (abfd
));
2393 htab
= elf_x86_64_hash_table (info
);
2396 sec
->check_relocs_failed
= 1;
2400 /* Get the section contents. */
2401 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2402 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2403 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2405 sec
->check_relocs_failed
= 1;
2409 symtab_hdr
= &elf_symtab_hdr (abfd
);
2410 sym_hashes
= elf_sym_hashes (abfd
);
2414 rel_end
= relocs
+ sec
->reloc_count
;
2415 for (rel
= relocs
; rel
< rel_end
; rel
++)
2417 unsigned int r_type
;
2418 unsigned int r_symndx
;
2419 struct elf_link_hash_entry
*h
;
2420 struct elf_x86_64_link_hash_entry
*eh
;
2421 Elf_Internal_Sym
*isym
;
2423 bfd_boolean size_reloc
;
2425 r_symndx
= htab
->r_sym (rel
->r_info
);
2426 r_type
= ELF32_R_TYPE (rel
->r_info
);
2428 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2430 /* xgettext:c-format */
2431 _bfd_error_handler (_("%B: bad symbol index: %d"),
2436 if (r_symndx
< symtab_hdr
->sh_info
)
2438 /* A local symbol. */
2439 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2444 /* Check relocation against local STT_GNU_IFUNC symbol. */
2445 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2447 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2452 /* Fake a STT_GNU_IFUNC symbol. */
2453 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2455 h
->type
= STT_GNU_IFUNC
;
2458 h
->forced_local
= 1;
2459 h
->root
.type
= bfd_link_hash_defined
;
2467 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2468 while (h
->root
.type
== bfd_link_hash_indirect
2469 || h
->root
.type
== bfd_link_hash_warning
)
2470 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2473 /* Check invalid x32 relocations. */
2474 if (!ABI_64_P (abfd
))
2480 case R_X86_64_DTPOFF64
:
2481 case R_X86_64_TPOFF64
:
2483 case R_X86_64_GOTOFF64
:
2484 case R_X86_64_GOT64
:
2485 case R_X86_64_GOTPCREL64
:
2486 case R_X86_64_GOTPC64
:
2487 case R_X86_64_GOTPLT64
:
2488 case R_X86_64_PLTOFF64
:
2491 name
= h
->root
.root
.string
;
2493 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2496 /* xgettext:c-format */
2497 (_("%B: relocation %s against symbol `%s' isn't "
2498 "supported in x32 mode"), abfd
,
2499 x86_64_elf_howto_table
[r_type
].name
, name
);
2500 bfd_set_error (bfd_error_bad_value
);
2508 /* It is referenced by a non-shared object. */
2510 h
->root
.non_ir_ref_regular
= 1;
2512 if (h
->type
== STT_GNU_IFUNC
)
2513 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2514 |= elf_gnu_symbol_ifunc
;
2517 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2518 symtab_hdr
, sym_hashes
,
2519 &r_type
, GOT_UNKNOWN
,
2520 rel
, rel_end
, h
, r_symndx
, FALSE
))
2523 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2526 case R_X86_64_TLSLD
:
2527 htab
->tls_ld_got
.refcount
+= 1;
2530 case R_X86_64_TPOFF32
:
2531 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2532 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2533 &x86_64_elf_howto_table
[r_type
]);
2535 eh
->has_got_reloc
= 1;
2538 case R_X86_64_GOTTPOFF
:
2539 if (!bfd_link_executable (info
))
2540 info
->flags
|= DF_STATIC_TLS
;
2543 case R_X86_64_GOT32
:
2544 case R_X86_64_GOTPCREL
:
2545 case R_X86_64_GOTPCRELX
:
2546 case R_X86_64_REX_GOTPCRELX
:
2547 case R_X86_64_TLSGD
:
2548 case R_X86_64_GOT64
:
2549 case R_X86_64_GOTPCREL64
:
2550 case R_X86_64_GOTPLT64
:
2551 case R_X86_64_GOTPC32_TLSDESC
:
2552 case R_X86_64_TLSDESC_CALL
:
2553 /* This symbol requires a global offset table entry. */
2555 int tls_type
, old_tls_type
;
2559 default: tls_type
= GOT_NORMAL
; break;
2560 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2561 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2562 case R_X86_64_GOTPC32_TLSDESC
:
2563 case R_X86_64_TLSDESC_CALL
:
2564 tls_type
= GOT_TLS_GDESC
; break;
2569 h
->got
.refcount
+= 1;
2570 old_tls_type
= eh
->tls_type
;
2574 bfd_signed_vma
*local_got_refcounts
;
2576 /* This is a global offset table entry for a local symbol. */
2577 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2578 if (local_got_refcounts
== NULL
)
2582 size
= symtab_hdr
->sh_info
;
2583 size
*= sizeof (bfd_signed_vma
)
2584 + sizeof (bfd_vma
) + sizeof (char);
2585 local_got_refcounts
= ((bfd_signed_vma
*)
2586 bfd_zalloc (abfd
, size
));
2587 if (local_got_refcounts
== NULL
)
2589 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2590 elf_x86_64_local_tlsdesc_gotent (abfd
)
2591 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2592 elf_x86_64_local_got_tls_type (abfd
)
2593 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2595 local_got_refcounts
[r_symndx
] += 1;
2597 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2600 /* If a TLS symbol is accessed using IE at least once,
2601 there is no point to use dynamic model for it. */
2602 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2603 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2604 || tls_type
!= GOT_TLS_IE
))
2606 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2607 tls_type
= old_tls_type
;
2608 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2609 && GOT_TLS_GD_ANY_P (tls_type
))
2610 tls_type
|= old_tls_type
;
2614 name
= h
->root
.root
.string
;
2616 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2619 /* xgettext:c-format */
2620 (_("%B: '%s' accessed both as normal and"
2621 " thread local symbol"),
2623 bfd_set_error (bfd_error_bad_value
);
2628 if (old_tls_type
!= tls_type
)
2631 eh
->tls_type
= tls_type
;
2633 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2638 case R_X86_64_GOTOFF64
:
2639 case R_X86_64_GOTPC32
:
2640 case R_X86_64_GOTPC64
:
2643 eh
->has_got_reloc
= 1;
2646 case R_X86_64_PLT32
:
2647 case R_X86_64_PLT32_BND
:
2648 /* This symbol requires a procedure linkage table entry. We
2649 actually build the entry in adjust_dynamic_symbol,
2650 because this might be a case of linking PIC code which is
2651 never referenced by a dynamic object, in which case we
2652 don't need to generate a procedure linkage table entry
2655 /* If this is a local symbol, we resolve it directly without
2656 creating a procedure linkage table entry. */
2660 eh
->has_got_reloc
= 1;
2662 h
->plt
.refcount
+= 1;
2665 case R_X86_64_PLTOFF64
:
2666 /* This tries to form the 'address' of a function relative
2667 to GOT. For global symbols we need a PLT entry. */
2671 h
->plt
.refcount
+= 1;
2675 case R_X86_64_SIZE32
:
2676 case R_X86_64_SIZE64
:
2681 if (!ABI_64_P (abfd
))
2687 /* Check relocation overflow as these relocs may lead to
2688 run-time relocation overflow. Don't error out for
2689 sections we don't care about, such as debug sections or
2690 when relocation overflow check is disabled. */
2691 if (!info
->no_reloc_overflow_check
2692 && (bfd_link_pic (info
)
2693 || (bfd_link_executable (info
)
2697 && (sec
->flags
& SEC_READONLY
) == 0)))
2698 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2699 &x86_64_elf_howto_table
[r_type
]);
2705 case R_X86_64_PC32_BND
:
2709 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2710 eh
->has_non_got_reloc
= 1;
2711 /* We are called after all symbols have been resolved. Only
2712 relocation against STT_GNU_IFUNC symbol must go through
2715 && (bfd_link_executable (info
)
2716 || h
->type
== STT_GNU_IFUNC
))
2718 /* If this reloc is in a read-only section, we might
2719 need a copy reloc. We can't check reliably at this
2720 stage whether the section is read-only, as input
2721 sections have not yet been mapped to output sections.
2722 Tentatively set the flag for now, and correct in
2723 adjust_dynamic_symbol. */
2726 /* We may need a .plt entry if the symbol is a function
2727 defined in a shared lib or is a STT_GNU_IFUNC function
2728 referenced from the code or read-only section. */
2729 if ((h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
)
2731 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0))
2732 h
->plt
.refcount
+= 1;
2734 if (r_type
== R_X86_64_PC32
)
2736 /* Since something like ".long foo - ." may be used
2737 as pointer, make sure that PLT is used if foo is
2738 a function defined in a shared library. */
2739 if ((sec
->flags
& SEC_CODE
) == 0)
2740 h
->pointer_equality_needed
= 1;
2742 else if (r_type
!= R_X86_64_PC32_BND
2743 && r_type
!= R_X86_64_PC64
)
2745 h
->pointer_equality_needed
= 1;
2746 /* At run-time, R_X86_64_64 can be resolved for both
2747 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2748 can only be resolved for x32. */
2749 if ((sec
->flags
& SEC_READONLY
) == 0
2750 && (r_type
== R_X86_64_64
2751 || (!ABI_64_P (abfd
)
2752 && (r_type
== R_X86_64_32
2753 || r_type
== R_X86_64_32S
))))
2754 eh
->func_pointer_refcount
+= 1;
2760 /* If we are creating a shared library, and this is a reloc
2761 against a global symbol, or a non PC relative reloc
2762 against a local symbol, then we need to copy the reloc
2763 into the shared library. However, if we are linking with
2764 -Bsymbolic, we do not need to copy a reloc against a
2765 global symbol which is defined in an object we are
2766 including in the link (i.e., DEF_REGULAR is set). At
2767 this point we have not seen all the input files, so it is
2768 possible that DEF_REGULAR is not set now but will be set
2769 later (it is never cleared). In case of a weak definition,
2770 DEF_REGULAR may be cleared later by a strong definition in
2771 a shared library. We account for that possibility below by
2772 storing information in the relocs_copied field of the hash
2773 table entry. A similar situation occurs when creating
2774 shared libraries and symbol visibility changes render the
2777 If on the other hand, we are creating an executable, we
2778 may need to keep relocations for symbols satisfied by a
2779 dynamic library if we manage to avoid copy relocs for the
2782 Generate dynamic pointer relocation against STT_GNU_IFUNC
2783 symbol in the non-code section. */
2784 if ((bfd_link_pic (info
)
2785 && (! IS_X86_64_PCREL_TYPE (r_type
)
2787 && (! (bfd_link_pie (info
)
2788 || SYMBOLIC_BIND (info
, h
))
2789 || h
->root
.type
== bfd_link_hash_defweak
2790 || !h
->def_regular
))))
2792 && h
->type
== STT_GNU_IFUNC
2793 && r_type
== htab
->pointer_r_type
2794 && (sec
->flags
& SEC_CODE
) == 0)
2795 || (ELIMINATE_COPY_RELOCS
2796 && !bfd_link_pic (info
)
2798 && (h
->root
.type
== bfd_link_hash_defweak
2799 || !h
->def_regular
)))
2801 struct elf_dyn_relocs
*p
;
2802 struct elf_dyn_relocs
**head
;
2804 /* We must copy these reloc types into the output file.
2805 Create a reloc section in dynobj and make room for
2809 sreloc
= _bfd_elf_make_dynamic_reloc_section
2810 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2811 abfd
, /*rela?*/ TRUE
);
2817 /* If this is a global symbol, we count the number of
2818 relocations we need for this symbol. */
2820 head
= &eh
->dyn_relocs
;
2823 /* Track dynamic relocs needed for local syms too.
2824 We really need local syms available to do this
2829 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2834 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2838 /* Beware of type punned pointers vs strict aliasing
2840 vpp
= &(elf_section_data (s
)->local_dynrel
);
2841 head
= (struct elf_dyn_relocs
**)vpp
;
2845 if (p
== NULL
|| p
->sec
!= sec
)
2847 bfd_size_type amt
= sizeof *p
;
2849 p
= ((struct elf_dyn_relocs
*)
2850 bfd_alloc (htab
->elf
.dynobj
, amt
));
2861 /* Count size relocation as PC-relative relocation. */
2862 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2867 /* This relocation describes the C++ object vtable hierarchy.
2868 Reconstruct it for later use during GC. */
2869 case R_X86_64_GNU_VTINHERIT
:
2870 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2874 /* This relocation describes which C++ vtable entries are actually
2875 used. Record for later use during GC. */
2876 case R_X86_64_GNU_VTENTRY
:
2877 BFD_ASSERT (h
!= NULL
);
2879 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2887 if ((r_type
== R_X86_64_GOTPCREL
2888 || r_type
== R_X86_64_GOTPCRELX
2889 || r_type
== R_X86_64_REX_GOTPCRELX
)
2890 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2891 sec
->need_convert_load
= 1;
2894 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2896 if (!info
->keep_memory
)
2900 /* Cache the section contents for elf_link_input_bfd. */
2901 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2908 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2910 sec
->check_relocs_failed
= 1;
2914 /* Return the section that should be marked against GC for a given
2918 elf_x86_64_gc_mark_hook (asection
*sec
,
2919 struct bfd_link_info
*info
,
2920 Elf_Internal_Rela
*rel
,
2921 struct elf_link_hash_entry
*h
,
2922 Elf_Internal_Sym
*sym
)
2925 switch (ELF32_R_TYPE (rel
->r_info
))
2927 case R_X86_64_GNU_VTINHERIT
:
2928 case R_X86_64_GNU_VTENTRY
:
2932 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2935 /* Remove undefined weak symbol from the dynamic symbol table if it
2936 is resolved to 0. */
2939 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2940 struct elf_link_hash_entry
*h
)
2942 if (h
->dynindx
!= -1
2943 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2944 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2945 elf_x86_64_hash_entry (h
)))
2948 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2954 /* Adjust a symbol defined by a dynamic object and referenced by a
2955 regular object. The current definition is in some section of the
2956 dynamic object, but we're not including those sections. We have to
2957 change the definition to something the rest of the link can
2961 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2962 struct elf_link_hash_entry
*h
)
2964 struct elf_x86_64_link_hash_table
*htab
;
2966 struct elf_x86_64_link_hash_entry
*eh
;
2967 struct elf_dyn_relocs
*p
;
2969 /* STT_GNU_IFUNC symbol must go through PLT. */
2970 if (h
->type
== STT_GNU_IFUNC
)
2972 /* All local STT_GNU_IFUNC references must be treate as local
2973 calls via local PLT. */
2975 && SYMBOL_CALLS_LOCAL (info
, h
))
2977 bfd_size_type pc_count
= 0, count
= 0;
2978 struct elf_dyn_relocs
**pp
;
2980 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2981 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2983 pc_count
+= p
->pc_count
;
2984 p
->count
-= p
->pc_count
;
2993 if (pc_count
|| count
)
2998 /* Increment PLT reference count only for PC-relative
3001 if (h
->plt
.refcount
<= 0)
3002 h
->plt
.refcount
= 1;
3004 h
->plt
.refcount
+= 1;
3009 if (h
->plt
.refcount
<= 0)
3011 h
->plt
.offset
= (bfd_vma
) -1;
3017 /* If this is a function, put it in the procedure linkage table. We
3018 will fill in the contents of the procedure linkage table later,
3019 when we know the address of the .got section. */
3020 if (h
->type
== STT_FUNC
3023 if (h
->plt
.refcount
<= 0
3024 || SYMBOL_CALLS_LOCAL (info
, h
)
3025 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3026 && h
->root
.type
== bfd_link_hash_undefweak
))
3028 /* This case can occur if we saw a PLT32 reloc in an input
3029 file, but the symbol was never referred to by a dynamic
3030 object, or if all references were garbage collected. In
3031 such a case, we don't actually need to build a procedure
3032 linkage table, and we can just do a PC32 reloc instead. */
3033 h
->plt
.offset
= (bfd_vma
) -1;
3040 /* It's possible that we incorrectly decided a .plt reloc was
3041 needed for an R_X86_64_PC32 reloc to a non-function sym in
3042 check_relocs. We can't decide accurately between function and
3043 non-function syms in check-relocs; Objects loaded later in
3044 the link may change h->type. So fix it now. */
3045 h
->plt
.offset
= (bfd_vma
) -1;
3047 /* If this is a weak symbol, and there is a real definition, the
3048 processor independent code will have arranged for us to see the
3049 real definition first, and we can just use the same value. */
3050 if (h
->u
.weakdef
!= NULL
)
3052 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3053 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3054 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3055 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3056 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
3058 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3059 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
3060 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
3065 /* This is a reference to a symbol defined by a dynamic object which
3066 is not a function. */
3068 /* If we are creating a shared library, we must presume that the
3069 only references to the symbol are via the global offset table.
3070 For such cases we need not do anything here; the relocations will
3071 be handled correctly by relocate_section. */
3072 if (!bfd_link_executable (info
))
3075 /* If there are no references to this symbol that do not use the
3076 GOT, we don't need to generate a copy reloc. */
3077 if (!h
->non_got_ref
)
3080 /* If -z nocopyreloc was given, we won't generate them either. */
3081 if (info
->nocopyreloc
)
3087 if (ELIMINATE_COPY_RELOCS
)
3089 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3090 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3092 s
= p
->sec
->output_section
;
3093 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3097 /* If we didn't find any dynamic relocs in read-only sections, then
3098 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
3106 /* We must allocate the symbol in our .dynbss section, which will
3107 become part of the .bss section of the executable. There will be
3108 an entry for this symbol in the .dynsym section. The dynamic
3109 object will contain position independent code, so all references
3110 from the dynamic object to this symbol will go through the global
3111 offset table. The dynamic linker will use the .dynsym entry to
3112 determine the address it must put in the global offset table, so
3113 both the dynamic object and the regular object will refer to the
3114 same memory location for the variable. */
3116 htab
= elf_x86_64_hash_table (info
);
3120 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
3121 to copy the initial value out of the dynamic object and into the
3122 runtime process image. */
3123 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
3125 s
= htab
->elf
.sdynrelro
;
3126 srel
= htab
->elf
.sreldynrelro
;
3130 s
= htab
->elf
.sdynbss
;
3131 srel
= htab
->elf
.srelbss
;
3133 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
3135 const struct elf_backend_data
*bed
;
3136 bed
= get_elf_backend_data (info
->output_bfd
);
3137 srel
->size
+= bed
->s
->sizeof_rela
;
3141 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
3144 /* Allocate space in .plt, .got and associated reloc sections for
3148 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3150 struct bfd_link_info
*info
;
3151 struct elf_x86_64_link_hash_table
*htab
;
3152 struct elf_x86_64_link_hash_entry
*eh
;
3153 struct elf_dyn_relocs
*p
;
3154 const struct elf_backend_data
*bed
;
3155 unsigned int plt_entry_size
;
3156 bfd_boolean resolved_to_zero
;
3158 if (h
->root
.type
== bfd_link_hash_indirect
)
3161 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3163 info
= (struct bfd_link_info
*) inf
;
3164 htab
= elf_x86_64_hash_table (info
);
3167 bed
= get_elf_backend_data (info
->output_bfd
);
3168 plt_entry_size
= htab
->plt
.plt_entry_size
;
3170 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3174 /* We can't use the GOT PLT if pointer equality is needed since
3175 finish_dynamic_symbol won't clear symbol value and the dynamic
3176 linker won't update the GOT slot. We will get into an infinite
3177 loop at run-time. */
3178 if (htab
->plt_got
!= NULL
3179 && h
->type
!= STT_GNU_IFUNC
3180 && !h
->pointer_equality_needed
3181 && h
->plt
.refcount
> 0
3182 && h
->got
.refcount
> 0)
3184 /* Don't use the regular PLT if there are both GOT and GOTPLT
3186 h
->plt
.offset
= (bfd_vma
) -1;
3188 /* Use the GOT PLT. */
3189 eh
->plt_got
.refcount
= 1;
3192 /* Clear the reference count of function pointer relocations if
3193 symbol isn't a normal function. */
3194 if (h
->type
!= STT_FUNC
)
3195 eh
->func_pointer_refcount
= 0;
3197 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3198 here if it is defined and referenced in a non-shared object. */
3199 if (h
->type
== STT_GNU_IFUNC
3202 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3204 &htab
->readonly_dynrelocs_against_ifunc
,
3208 GOT_ENTRY_SIZE
, TRUE
))
3210 asection
*s
= htab
->plt_second
;
3211 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3213 /* Use the second PLT section if it is created. */
3214 eh
->plt_second
.offset
= s
->size
;
3216 /* Make room for this entry in the second PLT section. */
3217 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3225 /* Don't create the PLT entry if there are only function pointer
3226 relocations which can be resolved at run-time. */
3227 else if (htab
->elf
.dynamic_sections_created
3228 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3229 || eh
->plt_got
.refcount
> 0))
3231 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
3233 /* Clear the reference count of function pointer relocations
3235 eh
->func_pointer_refcount
= 0;
3237 /* Make sure this symbol is output as a dynamic symbol.
3238 Undefined weak syms won't yet be marked as dynamic. */
3239 if (h
->dynindx
== -1
3241 && !resolved_to_zero
3242 && h
->root
.type
== bfd_link_hash_undefweak
)
3244 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3248 if (bfd_link_pic (info
)
3249 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3251 asection
*s
= htab
->elf
.splt
;
3252 asection
*second_s
= htab
->plt_second
;
3253 asection
*got_s
= htab
->plt_got
;
3255 /* If this is the first .plt entry, make room for the special
3256 first entry. The .plt section is used by prelink to undo
3257 prelinking for dynamic relocations. */
3259 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
3262 eh
->plt_got
.offset
= got_s
->size
;
3265 h
->plt
.offset
= s
->size
;
3267 eh
->plt_second
.offset
= second_s
->size
;
3270 /* If this symbol is not defined in a regular file, and we are
3271 not generating a shared library, then set the symbol to this
3272 location in the .plt. This is required to make function
3273 pointers compare as equal between the normal executable and
3274 the shared library. */
3275 if (! bfd_link_pic (info
)
3280 /* We need to make a call to the entry of the GOT PLT
3281 instead of regular PLT entry. */
3282 h
->root
.u
.def
.section
= got_s
;
3283 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3289 /* We need to make a call to the entry of the
3290 second PLT instead of regular PLT entry. */
3291 h
->root
.u
.def
.section
= second_s
;
3292 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
3296 h
->root
.u
.def
.section
= s
;
3297 h
->root
.u
.def
.value
= h
->plt
.offset
;
3302 /* Make room for this entry. */
3304 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3307 s
->size
+= plt_entry_size
;
3309 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3311 /* We also need to make an entry in the .got.plt section,
3312 which will be placed in the .got section by the linker
3314 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3316 /* There should be no PLT relocation against resolved
3317 undefined weak symbol in executable. */
3318 if (!resolved_to_zero
)
3320 /* We also need to make an entry in the .rela.plt
3322 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3323 htab
->elf
.srelplt
->reloc_count
++;
3329 eh
->plt_got
.offset
= (bfd_vma
) -1;
3330 h
->plt
.offset
= (bfd_vma
) -1;
3336 eh
->plt_got
.offset
= (bfd_vma
) -1;
3337 h
->plt
.offset
= (bfd_vma
) -1;
3341 eh
->tlsdesc_got
= (bfd_vma
) -1;
3343 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3344 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3345 if (h
->got
.refcount
> 0
3346 && bfd_link_executable (info
)
3348 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3350 h
->got
.offset
= (bfd_vma
) -1;
3352 else if (h
->got
.refcount
> 0)
3356 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3358 /* Make sure this symbol is output as a dynamic symbol.
3359 Undefined weak syms won't yet be marked as dynamic. */
3360 if (h
->dynindx
== -1
3362 && !resolved_to_zero
3363 && h
->root
.type
== bfd_link_hash_undefweak
)
3365 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3369 if (GOT_TLS_GDESC_P (tls_type
))
3371 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3372 - elf_x86_64_compute_jump_table_size (htab
);
3373 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3374 h
->got
.offset
= (bfd_vma
) -2;
3376 if (! GOT_TLS_GDESC_P (tls_type
)
3377 || GOT_TLS_GD_P (tls_type
))
3380 h
->got
.offset
= s
->size
;
3381 s
->size
+= GOT_ENTRY_SIZE
;
3382 if (GOT_TLS_GD_P (tls_type
))
3383 s
->size
+= GOT_ENTRY_SIZE
;
3385 dyn
= htab
->elf
.dynamic_sections_created
;
3386 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3387 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3388 relocation. No dynamic relocation against resolved undefined
3389 weak symbol in executable. */
3390 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3391 || tls_type
== GOT_TLS_IE
)
3392 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3393 else if (GOT_TLS_GD_P (tls_type
))
3394 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3395 else if (! GOT_TLS_GDESC_P (tls_type
)
3396 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3397 && !resolved_to_zero
)
3398 || h
->root
.type
!= bfd_link_hash_undefweak
)
3399 && (bfd_link_pic (info
)
3400 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3401 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3402 if (GOT_TLS_GDESC_P (tls_type
))
3404 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3405 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3409 h
->got
.offset
= (bfd_vma
) -1;
3411 if (eh
->dyn_relocs
== NULL
)
3414 /* In the shared -Bsymbolic case, discard space allocated for
3415 dynamic pc-relative relocs against symbols which turn out to be
3416 defined in regular objects. For the normal shared case, discard
3417 space for pc-relative relocs that have become local due to symbol
3418 visibility changes. */
3420 if (bfd_link_pic (info
))
3422 /* Relocs that use pc_count are those that appear on a call
3423 insn, or certain REL relocs that can generated via assembly.
3424 We want calls to protected symbols to resolve directly to the
3425 function rather than going via the plt. If people want
3426 function pointer comparisons to work as expected then they
3427 should avoid writing weird assembly. */
3428 if (SYMBOL_CALLS_LOCAL (info
, h
))
3430 struct elf_dyn_relocs
**pp
;
3432 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3434 p
->count
-= p
->pc_count
;
3443 /* Also discard relocs on undefined weak syms with non-default
3444 visibility or in PIE. */
3445 if (eh
->dyn_relocs
!= NULL
)
3447 if (h
->root
.type
== bfd_link_hash_undefweak
)
3449 /* Undefined weak symbol is never bound locally in shared
3451 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3452 || resolved_to_zero
)
3453 eh
->dyn_relocs
= NULL
;
3454 else if (h
->dynindx
== -1
3455 && ! h
->forced_local
3456 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3459 /* For PIE, discard space for pc-relative relocs against
3460 symbols which turn out to need copy relocs. */
3461 else if (bfd_link_executable (info
)
3462 && (h
->needs_copy
|| eh
->needs_copy
)
3466 struct elf_dyn_relocs
**pp
;
3468 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3470 if (p
->pc_count
!= 0)
3478 else if (ELIMINATE_COPY_RELOCS
)
3480 /* For the non-shared case, discard space for relocs against
3481 symbols which turn out to need copy relocs or are not
3482 dynamic. Keep dynamic relocations for run-time function
3483 pointer initialization. */
3485 if ((!h
->non_got_ref
3486 || eh
->func_pointer_refcount
> 0
3487 || (h
->root
.type
== bfd_link_hash_undefweak
3488 && !resolved_to_zero
))
3491 || (htab
->elf
.dynamic_sections_created
3492 && (h
->root
.type
== bfd_link_hash_undefweak
3493 || h
->root
.type
== bfd_link_hash_undefined
))))
3495 /* Make sure this symbol is output as a dynamic symbol.
3496 Undefined weak syms won't yet be marked as dynamic. */
3497 if (h
->dynindx
== -1
3498 && ! h
->forced_local
3499 && ! resolved_to_zero
3500 && h
->root
.type
== bfd_link_hash_undefweak
3501 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3504 /* If that succeeded, we know we'll be keeping all the
3506 if (h
->dynindx
!= -1)
3510 eh
->dyn_relocs
= NULL
;
3511 eh
->func_pointer_refcount
= 0;
3516 /* Finally, allocate space. */
3517 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3521 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3523 BFD_ASSERT (sreloc
!= NULL
);
3525 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3531 /* Allocate space in .plt, .got and associated reloc sections for
3532 local dynamic relocs. */
3535 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3537 struct elf_link_hash_entry
*h
3538 = (struct elf_link_hash_entry
*) *slot
;
3540 if (h
->type
!= STT_GNU_IFUNC
3544 || h
->root
.type
!= bfd_link_hash_defined
)
3547 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3550 /* Find any dynamic relocs that apply to read-only sections. */
3553 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3556 struct elf_x86_64_link_hash_entry
*eh
;
3557 struct elf_dyn_relocs
*p
;
3559 /* Skip local IFUNC symbols. */
3560 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3563 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3564 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3566 asection
*s
= p
->sec
->output_section
;
3568 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3570 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3572 info
->flags
|= DF_TEXTREL
;
3574 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3575 || info
->error_textrel
)
3576 /* xgettext:c-format */
3577 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3578 p
->sec
->owner
, h
->root
.root
.string
,
3581 /* Not an error, just cut short the traversal. */
3588 /* Convert load via the GOT slot to load immediate. */
3591 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3592 struct bfd_link_info
*link_info
)
3594 Elf_Internal_Shdr
*symtab_hdr
;
3595 Elf_Internal_Rela
*internal_relocs
;
3596 Elf_Internal_Rela
*irel
, *irelend
;
3598 struct elf_x86_64_link_hash_table
*htab
;
3599 bfd_boolean changed
;
3600 bfd_signed_vma
*local_got_refcounts
;
3602 /* Don't even try to convert non-ELF outputs. */
3603 if (!is_elf_hash_table (link_info
->hash
))
3606 /* Nothing to do if there is no need or no output. */
3607 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3608 || sec
->need_convert_load
== 0
3609 || bfd_is_abs_section (sec
->output_section
))
3612 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3614 /* Load the relocations for this section. */
3615 internal_relocs
= (_bfd_elf_link_read_relocs
3616 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3617 link_info
->keep_memory
));
3618 if (internal_relocs
== NULL
)
3622 htab
= elf_x86_64_hash_table (link_info
);
3623 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3625 /* Get the section contents. */
3626 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3627 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3630 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3634 irelend
= internal_relocs
+ sec
->reloc_count
;
3635 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3637 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3638 unsigned int r_symndx
;
3639 struct elf_link_hash_entry
*h
;
3640 bfd_boolean converted
;
3642 if (r_type
!= R_X86_64_GOTPCRELX
3643 && r_type
!= R_X86_64_REX_GOTPCRELX
3644 && r_type
!= R_X86_64_GOTPCREL
)
3647 r_symndx
= htab
->r_sym (irel
->r_info
);
3648 if (r_symndx
< symtab_hdr
->sh_info
)
3649 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3650 (const Elf_Internal_Rela
*) irel
,
3654 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3655 while (h
->root
.type
== bfd_link_hash_indirect
3656 || h
->root
.type
== bfd_link_hash_warning
)
3657 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3660 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3661 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3665 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3666 &converted
, link_info
))
3671 changed
= converted
;
3674 if (h
->got
.refcount
> 0)
3675 h
->got
.refcount
-= 1;
3679 if (local_got_refcounts
!= NULL
3680 && local_got_refcounts
[r_symndx
] > 0)
3681 local_got_refcounts
[r_symndx
] -= 1;
3686 if (contents
!= NULL
3687 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3689 if (!changed
&& !link_info
->keep_memory
)
3693 /* Cache the section contents for elf_link_input_bfd. */
3694 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3698 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3701 free (internal_relocs
);
3703 elf_section_data (sec
)->relocs
= internal_relocs
;
3709 if (contents
!= NULL
3710 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3712 if (internal_relocs
!= NULL
3713 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3714 free (internal_relocs
);
3718 /* Set the sizes of the dynamic sections. */
3721 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3722 struct bfd_link_info
*info
)
3724 struct elf_x86_64_link_hash_table
*htab
;
3729 const struct elf_backend_data
*bed
;
3731 htab
= elf_x86_64_hash_table (info
);
3734 bed
= get_elf_backend_data (output_bfd
);
3736 dynobj
= htab
->elf
.dynobj
;
3740 /* Set up .got offsets for local syms, and space for local dynamic
3742 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3744 bfd_signed_vma
*local_got
;
3745 bfd_signed_vma
*end_local_got
;
3746 char *local_tls_type
;
3747 bfd_vma
*local_tlsdesc_gotent
;
3748 bfd_size_type locsymcount
;
3749 Elf_Internal_Shdr
*symtab_hdr
;
3752 if (! is_x86_64_elf (ibfd
))
3755 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3757 struct elf_dyn_relocs
*p
;
3759 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3762 for (p
= (struct elf_dyn_relocs
*)
3763 (elf_section_data (s
)->local_dynrel
);
3767 if (!bfd_is_abs_section (p
->sec
)
3768 && bfd_is_abs_section (p
->sec
->output_section
))
3770 /* Input section has been discarded, either because
3771 it is a copy of a linkonce section or due to
3772 linker script /DISCARD/, so we'll be discarding
3775 else if (p
->count
!= 0)
3777 srel
= elf_section_data (p
->sec
)->sreloc
;
3778 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3779 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3780 && (info
->flags
& DF_TEXTREL
) == 0)
3782 info
->flags
|= DF_TEXTREL
;
3783 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3784 || info
->error_textrel
)
3785 /* xgettext:c-format */
3786 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3787 p
->sec
->owner
, p
->sec
);
3793 local_got
= elf_local_got_refcounts (ibfd
);
3797 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3798 locsymcount
= symtab_hdr
->sh_info
;
3799 end_local_got
= local_got
+ locsymcount
;
3800 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3801 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3803 srel
= htab
->elf
.srelgot
;
3804 for (; local_got
< end_local_got
;
3805 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3807 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3810 if (GOT_TLS_GDESC_P (*local_tls_type
))
3812 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3813 - elf_x86_64_compute_jump_table_size (htab
);
3814 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3815 *local_got
= (bfd_vma
) -2;
3817 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3818 || GOT_TLS_GD_P (*local_tls_type
))
3820 *local_got
= s
->size
;
3821 s
->size
+= GOT_ENTRY_SIZE
;
3822 if (GOT_TLS_GD_P (*local_tls_type
))
3823 s
->size
+= GOT_ENTRY_SIZE
;
3825 if (bfd_link_pic (info
)
3826 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3827 || *local_tls_type
== GOT_TLS_IE
)
3829 if (GOT_TLS_GDESC_P (*local_tls_type
))
3831 htab
->elf
.srelplt
->size
3832 += bed
->s
->sizeof_rela
;
3833 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3835 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3836 || GOT_TLS_GD_P (*local_tls_type
))
3837 srel
->size
+= bed
->s
->sizeof_rela
;
3841 *local_got
= (bfd_vma
) -1;
3845 if (htab
->tls_ld_got
.refcount
> 0)
3847 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3849 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3850 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3851 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3854 htab
->tls_ld_got
.offset
= -1;
3856 /* Allocate global sym .plt and .got entries, and space for global
3857 sym dynamic relocs. */
3858 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3861 /* Allocate .plt and .got entries, and space for local symbols. */
3862 htab_traverse (htab
->loc_hash_table
,
3863 elf_x86_64_allocate_local_dynrelocs
,
3866 /* For every jump slot reserved in the sgotplt, reloc_count is
3867 incremented. However, when we reserve space for TLS descriptors,
3868 it's not incremented, so in order to compute the space reserved
3869 for them, it suffices to multiply the reloc count by the jump
3872 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3873 so that R_X86_64_IRELATIVE entries come last. */
3874 if (htab
->elf
.srelplt
)
3876 htab
->sgotplt_jump_table_size
3877 = elf_x86_64_compute_jump_table_size (htab
);
3878 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3880 else if (htab
->elf
.irelplt
)
3881 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3883 if (htab
->tlsdesc_plt
)
3885 /* If we're not using lazy TLS relocations, don't generate the
3886 PLT and GOT entries they require. */
3887 if ((info
->flags
& DF_BIND_NOW
))
3888 htab
->tlsdesc_plt
= 0;
3891 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3892 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3893 /* Reserve room for the initial entry.
3894 FIXME: we could probably do away with it in this case. */
3895 if (htab
->elf
.splt
->size
== 0)
3896 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
3897 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3898 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
3902 if (htab
->elf
.sgotplt
)
3904 /* Don't allocate .got.plt section if there are no GOT nor PLT
3905 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3906 if ((htab
->elf
.hgot
== NULL
3907 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3908 && (htab
->elf
.sgotplt
->size
3909 == get_elf_backend_data (output_bfd
)->got_header_size
)
3910 && (htab
->elf
.splt
== NULL
3911 || htab
->elf
.splt
->size
== 0)
3912 && (htab
->elf
.sgot
== NULL
3913 || htab
->elf
.sgot
->size
== 0)
3914 && (htab
->elf
.iplt
== NULL
3915 || htab
->elf
.iplt
->size
== 0)
3916 && (htab
->elf
.igotplt
== NULL
3917 || htab
->elf
.igotplt
->size
== 0))
3918 htab
->elf
.sgotplt
->size
= 0;
3921 if (_bfd_elf_eh_frame_present (info
))
3923 if (htab
->plt_eh_frame
!= NULL
3924 && htab
->elf
.splt
!= NULL
3925 && htab
->elf
.splt
->size
!= 0
3926 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
3927 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
3929 if (htab
->plt_got_eh_frame
!= NULL
3930 && htab
->plt_got
!= NULL
3931 && htab
->plt_got
->size
!= 0
3932 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
3933 htab
->plt_got_eh_frame
->size
3934 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3936 /* Unwind info for the second PLT and .plt.got sections are
3938 if (htab
->plt_second_eh_frame
!= NULL
3939 && htab
->plt_second
!= NULL
3940 && htab
->plt_second
->size
!= 0
3941 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
3942 htab
->plt_second_eh_frame
->size
3943 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3946 /* We now have determined the sizes of the various dynamic sections.
3947 Allocate memory for them. */
3949 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3951 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3954 if (s
== htab
->elf
.splt
3955 || s
== htab
->elf
.sgot
3956 || s
== htab
->elf
.sgotplt
3957 || s
== htab
->elf
.iplt
3958 || s
== htab
->elf
.igotplt
3959 || s
== htab
->plt_second
3960 || s
== htab
->plt_got
3961 || s
== htab
->plt_eh_frame
3962 || s
== htab
->plt_got_eh_frame
3963 || s
== htab
->plt_second_eh_frame
3964 || s
== htab
->elf
.sdynbss
3965 || s
== htab
->elf
.sdynrelro
)
3967 /* Strip this section if we don't need it; see the
3970 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3972 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3975 /* We use the reloc_count field as a counter if we need
3976 to copy relocs into the output file. */
3977 if (s
!= htab
->elf
.srelplt
)
3982 /* It's not one of our sections, so don't allocate space. */
3988 /* If we don't need this section, strip it from the
3989 output file. This is mostly to handle .rela.bss and
3990 .rela.plt. We must create both sections in
3991 create_dynamic_sections, because they must be created
3992 before the linker maps input sections to output
3993 sections. The linker does that before
3994 adjust_dynamic_symbol is called, and it is that
3995 function which decides whether anything needs to go
3996 into these sections. */
3998 s
->flags
|= SEC_EXCLUDE
;
4002 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
4005 /* Allocate memory for the section contents. We use bfd_zalloc
4006 here in case unused entries are not reclaimed before the
4007 section's contents are written out. This should not happen,
4008 but this way if it does, we get a R_X86_64_NONE reloc instead
4010 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
4011 if (s
->contents
== NULL
)
4015 if (htab
->plt_eh_frame
!= NULL
4016 && htab
->plt_eh_frame
->contents
!= NULL
)
4018 memcpy (htab
->plt_eh_frame
->contents
,
4019 htab
->plt
.eh_frame_plt
, htab
->plt_eh_frame
->size
);
4020 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
4021 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
4024 if (htab
->plt_got_eh_frame
!= NULL
4025 && htab
->plt_got_eh_frame
->contents
!= NULL
)
4027 memcpy (htab
->plt_got_eh_frame
->contents
,
4028 htab
->non_lazy_plt
->eh_frame_plt
,
4029 htab
->plt_got_eh_frame
->size
);
4030 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
4031 (htab
->plt_got_eh_frame
->contents
4032 + PLT_FDE_LEN_OFFSET
));
4035 if (htab
->plt_second_eh_frame
!= NULL
4036 && htab
->plt_second_eh_frame
->contents
!= NULL
)
4038 memcpy (htab
->plt_second_eh_frame
->contents
,
4039 htab
->non_lazy_plt
->eh_frame_plt
,
4040 htab
->plt_second_eh_frame
->size
);
4041 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
4042 (htab
->plt_second_eh_frame
->contents
4043 + PLT_FDE_LEN_OFFSET
));
4046 if (htab
->elf
.dynamic_sections_created
)
4048 /* Add some entries to the .dynamic section. We fill in the
4049 values later, in elf_x86_64_finish_dynamic_sections, but we
4050 must add the entries now so that we get the correct size for
4051 the .dynamic section. The DT_DEBUG entry is filled in by the
4052 dynamic linker and used by the debugger. */
4053 #define add_dynamic_entry(TAG, VAL) \
4054 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4056 if (bfd_link_executable (info
))
4058 if (!add_dynamic_entry (DT_DEBUG
, 0))
4062 if (htab
->elf
.splt
->size
!= 0)
4064 /* DT_PLTGOT is used by prelink even if there is no PLT
4066 if (!add_dynamic_entry (DT_PLTGOT
, 0))
4070 if (htab
->elf
.srelplt
->size
!= 0)
4072 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
4073 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
4074 || !add_dynamic_entry (DT_JMPREL
, 0))
4078 if (htab
->tlsdesc_plt
4079 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
4080 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
4085 if (!add_dynamic_entry (DT_RELA
, 0)
4086 || !add_dynamic_entry (DT_RELASZ
, 0)
4087 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
4090 /* If any dynamic relocs apply to a read-only section,
4091 then we need a DT_TEXTREL entry. */
4092 if ((info
->flags
& DF_TEXTREL
) == 0)
4093 elf_link_hash_traverse (&htab
->elf
,
4094 elf_x86_64_readonly_dynrelocs
,
4097 if ((info
->flags
& DF_TEXTREL
) != 0)
4099 if (htab
->readonly_dynrelocs_against_ifunc
)
4101 info
->callbacks
->einfo
4102 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
4103 bfd_set_error (bfd_error_bad_value
);
4107 if (!add_dynamic_entry (DT_TEXTREL
, 0))
4112 #undef add_dynamic_entry
4118 elf_x86_64_always_size_sections (bfd
*output_bfd
,
4119 struct bfd_link_info
*info
)
4121 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
4125 struct elf_link_hash_entry
*tlsbase
;
4127 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
4128 "_TLS_MODULE_BASE_",
4129 FALSE
, FALSE
, FALSE
);
4131 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
4133 struct elf_x86_64_link_hash_table
*htab
;
4134 struct bfd_link_hash_entry
*bh
= NULL
;
4135 const struct elf_backend_data
*bed
4136 = get_elf_backend_data (output_bfd
);
4138 htab
= elf_x86_64_hash_table (info
);
4142 if (!(_bfd_generic_link_add_one_symbol
4143 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
4144 tls_sec
, 0, NULL
, FALSE
,
4145 bed
->collect
, &bh
)))
4148 htab
->tls_module_base
= bh
;
4150 tlsbase
= (struct elf_link_hash_entry
*)bh
;
4151 tlsbase
->def_regular
= 1;
4152 tlsbase
->other
= STV_HIDDEN
;
4153 tlsbase
->root
.linker_def
= 1;
4154 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4161 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4162 executables. Rather than setting it to the beginning of the TLS
4163 section, we have to set it to the end. This function may be called
4164 multiple times, it is idempotent. */
4167 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4169 struct elf_x86_64_link_hash_table
*htab
;
4170 struct bfd_link_hash_entry
*base
;
4172 if (!bfd_link_executable (info
))
4175 htab
= elf_x86_64_hash_table (info
);
4179 base
= htab
->tls_module_base
;
4183 base
->u
.def
.value
= htab
->elf
.tls_size
;
4186 /* Return the base VMA address which should be subtracted from real addresses
4187 when resolving @dtpoff relocation.
4188 This is PT_TLS segment p_vaddr. */
4191 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4193 /* If tls_sec is NULL, we should have signalled an error already. */
4194 if (elf_hash_table (info
)->tls_sec
== NULL
)
4196 return elf_hash_table (info
)->tls_sec
->vma
;
4199 /* Return the relocation value for @tpoff relocation
4200 if STT_TLS virtual address is ADDRESS. */
4203 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4205 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4206 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4207 bfd_vma static_tls_size
;
4209 /* If tls_segment is NULL, we should have signalled an error already. */
4210 if (htab
->tls_sec
== NULL
)
4213 /* Consider special static TLS alignment requirements. */
4214 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4215 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4218 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4222 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4224 /* Opcode Instruction
4227 0x0f 0x8x conditional jump */
4229 && (contents
[offset
- 1] == 0xe8
4230 || contents
[offset
- 1] == 0xe9))
4232 && contents
[offset
- 2] == 0x0f
4233 && (contents
[offset
- 1] & 0xf0) == 0x80));
4236 /* Relocate an x86_64 ELF section. */
4239 elf_x86_64_relocate_section (bfd
*output_bfd
,
4240 struct bfd_link_info
*info
,
4242 asection
*input_section
,
4244 Elf_Internal_Rela
*relocs
,
4245 Elf_Internal_Sym
*local_syms
,
4246 asection
**local_sections
)
4248 struct elf_x86_64_link_hash_table
*htab
;
4249 Elf_Internal_Shdr
*symtab_hdr
;
4250 struct elf_link_hash_entry
**sym_hashes
;
4251 bfd_vma
*local_got_offsets
;
4252 bfd_vma
*local_tlsdesc_gotents
;
4253 Elf_Internal_Rela
*rel
;
4254 Elf_Internal_Rela
*wrel
;
4255 Elf_Internal_Rela
*relend
;
4256 unsigned int plt_entry_size
;
4258 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4260 /* Skip if check_relocs failed. */
4261 if (input_section
->check_relocs_failed
)
4264 htab
= elf_x86_64_hash_table (info
);
4267 plt_entry_size
= htab
->plt
.plt_entry_size
;
4268 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4269 sym_hashes
= elf_sym_hashes (input_bfd
);
4270 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4271 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4273 elf_x86_64_set_tls_module_base (info
);
4275 rel
= wrel
= relocs
;
4276 relend
= relocs
+ input_section
->reloc_count
;
4277 for (; rel
< relend
; wrel
++, rel
++)
4279 unsigned int r_type
;
4280 reloc_howto_type
*howto
;
4281 unsigned long r_symndx
;
4282 struct elf_link_hash_entry
*h
;
4283 struct elf_x86_64_link_hash_entry
*eh
;
4284 Elf_Internal_Sym
*sym
;
4286 bfd_vma off
, offplt
, plt_offset
;
4288 bfd_boolean unresolved_reloc
;
4289 bfd_reloc_status_type r
;
4291 asection
*base_got
, *resolved_plt
;
4293 bfd_boolean resolved_to_zero
;
4294 bfd_boolean relative_reloc
;
4296 r_type
= ELF32_R_TYPE (rel
->r_info
);
4297 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4298 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4305 if (r_type
>= (int) R_X86_64_standard
)
4306 return _bfd_unrecognized_reloc (input_bfd
, input_section
, r_type
);
4308 if (r_type
!= (int) R_X86_64_32
4309 || ABI_64_P (output_bfd
))
4310 howto
= x86_64_elf_howto_table
+ r_type
;
4312 howto
= (x86_64_elf_howto_table
4313 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4314 r_symndx
= htab
->r_sym (rel
->r_info
);
4318 unresolved_reloc
= FALSE
;
4319 if (r_symndx
< symtab_hdr
->sh_info
)
4321 sym
= local_syms
+ r_symndx
;
4322 sec
= local_sections
[r_symndx
];
4324 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4326 st_size
= sym
->st_size
;
4328 /* Relocate against local STT_GNU_IFUNC symbol. */
4329 if (!bfd_link_relocatable (info
)
4330 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4332 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4337 /* Set STT_GNU_IFUNC symbol value. */
4338 h
->root
.u
.def
.value
= sym
->st_value
;
4339 h
->root
.u
.def
.section
= sec
;
4344 bfd_boolean warned ATTRIBUTE_UNUSED
;
4345 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4347 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4348 r_symndx
, symtab_hdr
, sym_hashes
,
4350 unresolved_reloc
, warned
, ignored
);
4354 if (sec
!= NULL
&& discarded_section (sec
))
4356 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4357 contents
+ rel
->r_offset
);
4358 wrel
->r_offset
= rel
->r_offset
;
4362 /* For ld -r, remove relocations in debug sections against
4363 sections defined in discarded sections. Not done for
4364 eh_frame editing code expects to be present. */
4365 if (bfd_link_relocatable (info
)
4366 && (input_section
->flags
& SEC_DEBUGGING
))
4372 if (bfd_link_relocatable (info
))
4379 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4381 if (r_type
== R_X86_64_64
)
4383 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4384 zero-extend it to 64bit if addend is zero. */
4385 r_type
= R_X86_64_32
;
4386 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4388 else if (r_type
== R_X86_64_SIZE64
)
4390 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4391 zero-extend it to 64bit if addend is zero. */
4392 r_type
= R_X86_64_SIZE32
;
4393 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4397 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4399 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4400 it here if it is defined in a non-shared object. */
4402 && h
->type
== STT_GNU_IFUNC
4408 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4410 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4411 sections because such sections are not SEC_ALLOC and
4412 thus ld.so will not process them. */
4413 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4423 case R_X86_64_GOTPCREL
:
4424 case R_X86_64_GOTPCRELX
:
4425 case R_X86_64_REX_GOTPCRELX
:
4426 case R_X86_64_GOTPCREL64
:
4427 base_got
= htab
->elf
.sgot
;
4428 off
= h
->got
.offset
;
4430 if (base_got
== NULL
)
4433 if (off
== (bfd_vma
) -1)
4435 /* We can't use h->got.offset here to save state, or
4436 even just remember the offset, as finish_dynamic_symbol
4437 would use that as offset into .got. */
4439 if (h
->plt
.offset
== (bfd_vma
) -1)
4442 if (htab
->elf
.splt
!= NULL
)
4444 plt_index
= (h
->plt
.offset
/ plt_entry_size
4445 - htab
->plt
.has_plt0
);
4446 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4447 base_got
= htab
->elf
.sgotplt
;
4451 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4452 off
= plt_index
* GOT_ENTRY_SIZE
;
4453 base_got
= htab
->elf
.igotplt
;
4456 if (h
->dynindx
== -1
4460 /* This references the local defitionion. We must
4461 initialize this entry in the global offset table.
4462 Since the offset must always be a multiple of 8,
4463 we use the least significant bit to record
4464 whether we have initialized it already.
4466 When doing a dynamic link, we create a .rela.got
4467 relocation entry to initialize the value. This
4468 is done in the finish_dynamic_symbol routine. */
4473 bfd_put_64 (output_bfd
, relocation
,
4474 base_got
->contents
+ off
);
4475 /* Note that this is harmless for the GOTPLT64
4476 case, as -1 | 1 still is -1. */
4482 relocation
= (base_got
->output_section
->vma
4483 + base_got
->output_offset
+ off
);
4488 if (h
->plt
.offset
== (bfd_vma
) -1)
4490 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4491 if (r_type
== htab
->pointer_r_type
4492 && (input_section
->flags
& SEC_CODE
) == 0)
4493 goto do_ifunc_pointer
;
4494 goto bad_ifunc_reloc
;
4497 /* STT_GNU_IFUNC symbol must go through PLT. */
4498 if (htab
->elf
.splt
!= NULL
)
4500 if (htab
->plt_second
!= NULL
)
4502 resolved_plt
= htab
->plt_second
;
4503 plt_offset
= eh
->plt_second
.offset
;
4507 resolved_plt
= htab
->elf
.splt
;
4508 plt_offset
= h
->plt
.offset
;
4513 resolved_plt
= htab
->elf
.iplt
;
4514 plt_offset
= h
->plt
.offset
;
4517 relocation
= (resolved_plt
->output_section
->vma
4518 + resolved_plt
->output_offset
+ plt_offset
);
4524 if (h
->root
.root
.string
)
4525 name
= h
->root
.root
.string
;
4527 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4530 /* xgettext:c-format */
4531 (_("%B: relocation %s against STT_GNU_IFUNC "
4532 "symbol `%s' isn't supported"), input_bfd
,
4534 bfd_set_error (bfd_error_bad_value
);
4538 if (bfd_link_pic (info
))
4543 if (ABI_64_P (output_bfd
))
4548 if (rel
->r_addend
!= 0)
4550 if (h
->root
.root
.string
)
4551 name
= h
->root
.root
.string
;
4553 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4556 /* xgettext:c-format */
4557 (_("%B: relocation %s against STT_GNU_IFUNC "
4558 "symbol `%s' has non-zero addend: %Ld"),
4559 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4560 bfd_set_error (bfd_error_bad_value
);
4564 /* Generate dynamic relcoation only when there is a
4565 non-GOT reference in a shared object or there is no
4567 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4568 || h
->plt
.offset
== (bfd_vma
) -1)
4570 Elf_Internal_Rela outrel
;
4573 /* Need a dynamic relocation to get the real function
4575 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4579 if (outrel
.r_offset
== (bfd_vma
) -1
4580 || outrel
.r_offset
== (bfd_vma
) -2)
4583 outrel
.r_offset
+= (input_section
->output_section
->vma
4584 + input_section
->output_offset
);
4586 if (h
->dynindx
== -1
4588 || bfd_link_executable (info
))
4590 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
4591 h
->root
.root
.string
,
4592 h
->root
.u
.def
.section
->owner
);
4594 /* This symbol is resolved locally. */
4595 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4596 outrel
.r_addend
= (h
->root
.u
.def
.value
4597 + h
->root
.u
.def
.section
->output_section
->vma
4598 + h
->root
.u
.def
.section
->output_offset
);
4602 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4603 outrel
.r_addend
= 0;
4606 /* Dynamic relocations are stored in
4607 1. .rela.ifunc section in PIC object.
4608 2. .rela.got section in dynamic executable.
4609 3. .rela.iplt section in static executable. */
4610 if (bfd_link_pic (info
))
4611 sreloc
= htab
->elf
.irelifunc
;
4612 else if (htab
->elf
.splt
!= NULL
)
4613 sreloc
= htab
->elf
.srelgot
;
4615 sreloc
= htab
->elf
.irelplt
;
4616 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4618 /* If this reloc is against an external symbol, we
4619 do not want to fiddle with the addend. Otherwise,
4620 we need to include the symbol value so that it
4621 becomes an addend for the dynamic reloc. For an
4622 internal symbol, we have updated addend. */
4627 case R_X86_64_PC32_BND
:
4629 case R_X86_64_PLT32
:
4630 case R_X86_64_PLT32_BND
:
4635 resolved_to_zero
= (eh
!= NULL
4636 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4640 /* When generating a shared object, the relocations handled here are
4641 copied into the output file to be resolved at run time. */
4644 case R_X86_64_GOT32
:
4645 case R_X86_64_GOT64
:
4646 /* Relocation is to the entry for this symbol in the global
4648 case R_X86_64_GOTPCREL
:
4649 case R_X86_64_GOTPCRELX
:
4650 case R_X86_64_REX_GOTPCRELX
:
4651 case R_X86_64_GOTPCREL64
:
4652 /* Use global offset table entry as symbol value. */
4653 case R_X86_64_GOTPLT64
:
4654 /* This is obsolete and treated the same as GOT64. */
4655 base_got
= htab
->elf
.sgot
;
4657 if (htab
->elf
.sgot
== NULL
)
4660 relative_reloc
= FALSE
;
4665 off
= h
->got
.offset
;
4667 && h
->plt
.offset
!= (bfd_vma
)-1
4668 && off
== (bfd_vma
)-1)
4670 /* We can't use h->got.offset here to save
4671 state, or even just remember the offset, as
4672 finish_dynamic_symbol would use that as offset into
4674 bfd_vma plt_index
= (h
->plt
.offset
/ plt_entry_size
4675 - htab
->plt
.has_plt0
);
4676 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4677 base_got
= htab
->elf
.sgotplt
;
4680 dyn
= htab
->elf
.dynamic_sections_created
;
4682 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4683 || (bfd_link_pic (info
)
4684 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4685 || (ELF_ST_VISIBILITY (h
->other
)
4686 && h
->root
.type
== bfd_link_hash_undefweak
))
4688 /* This is actually a static link, or it is a -Bsymbolic
4689 link and the symbol is defined locally, or the symbol
4690 was forced to be local because of a version file. We
4691 must initialize this entry in the global offset table.
4692 Since the offset must always be a multiple of 8, we
4693 use the least significant bit to record whether we
4694 have initialized it already.
4696 When doing a dynamic link, we create a .rela.got
4697 relocation entry to initialize the value. This is
4698 done in the finish_dynamic_symbol routine. */
4703 bfd_put_64 (output_bfd
, relocation
,
4704 base_got
->contents
+ off
);
4705 /* Note that this is harmless for the GOTPLT64 case,
4706 as -1 | 1 still is -1. */
4709 if (h
->dynindx
== -1
4711 && h
->root
.type
!= bfd_link_hash_undefweak
4712 && bfd_link_pic (info
))
4714 /* If this symbol isn't dynamic in PIC,
4715 generate R_X86_64_RELATIVE here. */
4716 eh
->no_finish_dynamic_symbol
= 1;
4717 relative_reloc
= TRUE
;
4722 unresolved_reloc
= FALSE
;
4726 if (local_got_offsets
== NULL
)
4729 off
= local_got_offsets
[r_symndx
];
4731 /* The offset must always be a multiple of 8. We use
4732 the least significant bit to record whether we have
4733 already generated the necessary reloc. */
4738 bfd_put_64 (output_bfd
, relocation
,
4739 base_got
->contents
+ off
);
4740 local_got_offsets
[r_symndx
] |= 1;
4742 if (bfd_link_pic (info
))
4743 relative_reloc
= TRUE
;
4750 Elf_Internal_Rela outrel
;
4752 /* We need to generate a R_X86_64_RELATIVE reloc
4753 for the dynamic linker. */
4754 s
= htab
->elf
.srelgot
;
4758 outrel
.r_offset
= (base_got
->output_section
->vma
4759 + base_got
->output_offset
4761 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4762 outrel
.r_addend
= relocation
;
4763 elf_append_rela (output_bfd
, s
, &outrel
);
4766 if (off
>= (bfd_vma
) -2)
4769 relocation
= base_got
->output_section
->vma
4770 + base_got
->output_offset
+ off
;
4771 if (r_type
!= R_X86_64_GOTPCREL
4772 && r_type
!= R_X86_64_GOTPCRELX
4773 && r_type
!= R_X86_64_REX_GOTPCRELX
4774 && r_type
!= R_X86_64_GOTPCREL64
)
4775 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4776 - htab
->elf
.sgotplt
->output_offset
;
4780 case R_X86_64_GOTOFF64
:
4781 /* Relocation is relative to the start of the global offset
4784 /* Check to make sure it isn't a protected function or data
4785 symbol for shared library since it may not be local when
4786 used as function address or with copy relocation. We also
4787 need to make sure that a symbol is referenced locally. */
4788 if (bfd_link_pic (info
) && h
)
4790 if (!h
->def_regular
)
4794 switch (ELF_ST_VISIBILITY (h
->other
))
4797 v
= _("hidden symbol");
4800 v
= _("internal symbol");
4803 v
= _("protected symbol");
4811 /* xgettext:c-format */
4812 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
4813 " `%s' can not be used when making a shared object"),
4814 input_bfd
, v
, h
->root
.root
.string
);
4815 bfd_set_error (bfd_error_bad_value
);
4818 else if (!bfd_link_executable (info
)
4819 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4820 && (h
->type
== STT_FUNC
4821 || h
->type
== STT_OBJECT
)
4822 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4825 /* xgettext:c-format */
4826 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
4827 " `%s' can not be used when making a shared object"),
4829 h
->type
== STT_FUNC
? "function" : "data",
4830 h
->root
.root
.string
);
4831 bfd_set_error (bfd_error_bad_value
);
4836 /* Note that sgot is not involved in this
4837 calculation. We always want the start of .got.plt. If we
4838 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4839 permitted by the ABI, we might have to change this
4841 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4842 + htab
->elf
.sgotplt
->output_offset
;
4845 case R_X86_64_GOTPC32
:
4846 case R_X86_64_GOTPC64
:
4847 /* Use global offset table as symbol value. */
4848 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4849 + htab
->elf
.sgotplt
->output_offset
;
4850 unresolved_reloc
= FALSE
;
4853 case R_X86_64_PLTOFF64
:
4854 /* Relocation is PLT entry relative to GOT. For local
4855 symbols it's the symbol itself relative to GOT. */
4857 /* See PLT32 handling. */
4858 && (h
->plt
.offset
!= (bfd_vma
) -1
4859 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
4860 && htab
->elf
.splt
!= NULL
)
4862 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4864 /* Use the GOT PLT. */
4865 resolved_plt
= htab
->plt_got
;
4866 plt_offset
= eh
->plt_got
.offset
;
4868 else if (htab
->plt_second
!= NULL
)
4870 resolved_plt
= htab
->plt_second
;
4871 plt_offset
= eh
->plt_second
.offset
;
4875 resolved_plt
= htab
->elf
.splt
;
4876 plt_offset
= h
->plt
.offset
;
4879 relocation
= (resolved_plt
->output_section
->vma
4880 + resolved_plt
->output_offset
4882 unresolved_reloc
= FALSE
;
4885 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4886 + htab
->elf
.sgotplt
->output_offset
;
4889 case R_X86_64_PLT32
:
4890 case R_X86_64_PLT32_BND
:
4891 /* Relocation is to the entry for this symbol in the
4892 procedure linkage table. */
4894 /* Resolve a PLT32 reloc against a local symbol directly,
4895 without using the procedure linkage table. */
4899 if ((h
->plt
.offset
== (bfd_vma
) -1
4900 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4901 || htab
->elf
.splt
== NULL
)
4903 /* We didn't make a PLT entry for this symbol. This
4904 happens when statically linking PIC code, or when
4905 using -Bsymbolic. */
4909 if (h
->plt
.offset
!= (bfd_vma
) -1)
4911 if (htab
->plt_second
!= NULL
)
4913 resolved_plt
= htab
->plt_second
;
4914 plt_offset
= eh
->plt_second
.offset
;
4918 resolved_plt
= htab
->elf
.splt
;
4919 plt_offset
= h
->plt
.offset
;
4924 /* Use the GOT PLT. */
4925 resolved_plt
= htab
->plt_got
;
4926 plt_offset
= eh
->plt_got
.offset
;
4929 relocation
= (resolved_plt
->output_section
->vma
4930 + resolved_plt
->output_offset
4932 unresolved_reloc
= FALSE
;
4935 case R_X86_64_SIZE32
:
4936 case R_X86_64_SIZE64
:
4937 /* Set to symbol size. */
4938 relocation
= st_size
;
4944 case R_X86_64_PC32_BND
:
4945 /* Don't complain about -fPIC if the symbol is undefined when
4946 building executable unless it is unresolved weak symbol. */
4947 if ((input_section
->flags
& SEC_ALLOC
) != 0
4948 && (input_section
->flags
& SEC_READONLY
) != 0
4950 && ((bfd_link_executable (info
)
4951 && h
->root
.type
== bfd_link_hash_undefweak
4952 && !resolved_to_zero
)
4953 || bfd_link_dll (info
)))
4955 bfd_boolean fail
= FALSE
;
4957 = ((r_type
== R_X86_64_PC32
4958 || r_type
== R_X86_64_PC32_BND
)
4959 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4961 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4963 /* Symbol is referenced locally. Make sure it is
4964 defined locally or for a branch. */
4965 fail
= (!(h
->def_regular
|| ELF_COMMON_DEF_P (h
))
4968 else if (!(bfd_link_pie (info
)
4969 && (h
->needs_copy
|| eh
->needs_copy
)))
4971 /* Symbol doesn't need copy reloc and isn't referenced
4972 locally. We only allow branch to symbol with
4973 non-default visibility. */
4975 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4979 return elf_x86_64_need_pic (info
, input_bfd
, input_section
,
4980 h
, NULL
, NULL
, howto
);
4989 /* FIXME: The ABI says the linker should make sure the value is
4990 the same when it's zeroextended to 64 bit. */
4993 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4996 /* Don't copy a pc-relative relocation into the output file
4997 if the symbol needs copy reloc or the symbol is undefined
4998 when building executable. Copy dynamic function pointer
4999 relocations. Don't generate dynamic relocations against
5000 resolved undefined weak symbols in PIE. */
5001 if ((bfd_link_pic (info
)
5002 && !(bfd_link_pie (info
)
5006 || h
->root
.type
== bfd_link_hash_undefined
)
5007 && (IS_X86_64_PCREL_TYPE (r_type
)
5008 || r_type
== R_X86_64_SIZE32
5009 || r_type
== R_X86_64_SIZE64
))
5011 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5012 && !resolved_to_zero
)
5013 || h
->root
.type
!= bfd_link_hash_undefweak
))
5014 && ((! IS_X86_64_PCREL_TYPE (r_type
)
5015 && r_type
!= R_X86_64_SIZE32
5016 && r_type
!= R_X86_64_SIZE64
)
5017 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
5018 || (ELIMINATE_COPY_RELOCS
5019 && !bfd_link_pic (info
)
5023 || eh
->func_pointer_refcount
> 0
5024 || (h
->root
.type
== bfd_link_hash_undefweak
5025 && !resolved_to_zero
))
5026 && ((h
->def_dynamic
&& !h
->def_regular
)
5027 /* Undefined weak symbol is bound locally when
5029 || h
->root
.type
== bfd_link_hash_undefined
)))
5031 Elf_Internal_Rela outrel
;
5032 bfd_boolean skip
, relocate
;
5035 /* When generating a shared object, these relocations
5036 are copied into the output file to be resolved at run
5042 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5044 if (outrel
.r_offset
== (bfd_vma
) -1)
5046 else if (outrel
.r_offset
== (bfd_vma
) -2)
5047 skip
= TRUE
, relocate
= TRUE
;
5049 outrel
.r_offset
+= (input_section
->output_section
->vma
5050 + input_section
->output_offset
);
5053 memset (&outrel
, 0, sizeof outrel
);
5055 /* h->dynindx may be -1 if this symbol was marked to
5059 && (IS_X86_64_PCREL_TYPE (r_type
)
5060 || !(bfd_link_executable (info
)
5061 || SYMBOLIC_BIND (info
, h
))
5062 || ! h
->def_regular
))
5064 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
5065 outrel
.r_addend
= rel
->r_addend
;
5069 /* This symbol is local, or marked to become local.
5070 When relocation overflow check is disabled, we
5071 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
5072 if (r_type
== htab
->pointer_r_type
5073 || (r_type
== R_X86_64_32
5074 && info
->no_reloc_overflow_check
))
5077 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5078 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5080 else if (r_type
== R_X86_64_64
5081 && !ABI_64_P (output_bfd
))
5084 outrel
.r_info
= htab
->r_info (0,
5085 R_X86_64_RELATIVE64
);
5086 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5087 /* Check addend overflow. */
5088 if ((outrel
.r_addend
& 0x80000000)
5089 != (rel
->r_addend
& 0x80000000))
5092 int addend
= rel
->r_addend
;
5093 if (h
&& h
->root
.root
.string
)
5094 name
= h
->root
.root
.string
;
5096 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
5099 /* xgettext:c-format */
5100 (_("%B: addend %s%#x in relocation %s against "
5101 "symbol `%s' at %#Lx in section `%A' is "
5103 input_bfd
, addend
< 0 ? "-" : "", addend
,
5104 howto
->name
, name
, rel
->r_offset
, input_section
);
5105 bfd_set_error (bfd_error_bad_value
);
5113 if (bfd_is_abs_section (sec
))
5115 else if (sec
== NULL
|| sec
->owner
== NULL
)
5117 bfd_set_error (bfd_error_bad_value
);
5124 /* We are turning this relocation into one
5125 against a section symbol. It would be
5126 proper to subtract the symbol's value,
5127 osec->vma, from the emitted reloc addend,
5128 but ld.so expects buggy relocs. */
5129 osec
= sec
->output_section
;
5130 sindx
= elf_section_data (osec
)->dynindx
;
5133 asection
*oi
= htab
->elf
.text_index_section
;
5134 sindx
= elf_section_data (oi
)->dynindx
;
5136 BFD_ASSERT (sindx
!= 0);
5139 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
5140 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5144 sreloc
= elf_section_data (input_section
)->sreloc
;
5146 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
5148 r
= bfd_reloc_notsupported
;
5149 goto check_relocation_error
;
5152 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5154 /* If this reloc is against an external symbol, we do
5155 not want to fiddle with the addend. Otherwise, we
5156 need to include the symbol value so that it becomes
5157 an addend for the dynamic reloc. */
5164 case R_X86_64_TLSGD
:
5165 case R_X86_64_GOTPC32_TLSDESC
:
5166 case R_X86_64_TLSDESC_CALL
:
5167 case R_X86_64_GOTTPOFF
:
5168 tls_type
= GOT_UNKNOWN
;
5169 if (h
== NULL
&& local_got_offsets
)
5170 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
5172 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
5174 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5175 input_section
, contents
,
5176 symtab_hdr
, sym_hashes
,
5177 &r_type
, tls_type
, rel
,
5178 relend
, h
, r_symndx
, TRUE
))
5181 if (r_type
== R_X86_64_TPOFF32
)
5183 bfd_vma roff
= rel
->r_offset
;
5185 BFD_ASSERT (! unresolved_reloc
);
5187 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5189 /* GD->LE transition. For 64bit, change
5190 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5191 .word 0x6666; rex64; call __tls_get_addr@PLT
5193 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5195 call *__tls_get_addr@GOTPCREL(%rip)
5196 which may be converted to
5197 addr32 call __tls_get_addr
5200 leaq foo@tpoff(%rax), %rax
5202 leaq foo@tlsgd(%rip), %rdi
5203 .word 0x6666; rex64; call __tls_get_addr@PLT
5205 leaq foo@tlsgd(%rip), %rdi
5207 call *__tls_get_addr@GOTPCREL(%rip)
5208 which may be converted to
5209 addr32 call __tls_get_addr
5212 leaq foo@tpoff(%rax), %rax
5213 For largepic, change:
5214 leaq foo@tlsgd(%rip), %rdi
5215 movabsq $__tls_get_addr@pltoff, %rax
5220 leaq foo@tpoff(%rax), %rax
5221 nopw 0x0(%rax,%rax,1) */
5223 if (ABI_64_P (output_bfd
))
5225 if (contents
[roff
+ 5] == 0xb8)
5227 memcpy (contents
+ roff
- 3,
5228 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5229 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5233 memcpy (contents
+ roff
- 4,
5234 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5238 memcpy (contents
+ roff
- 3,
5239 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5241 bfd_put_32 (output_bfd
,
5242 elf_x86_64_tpoff (info
, relocation
),
5243 contents
+ roff
+ 8 + largepic
);
5244 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5245 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5250 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5252 /* GDesc -> LE transition.
5253 It's originally something like:
5254 leaq x@tlsdesc(%rip), %rax
5257 movl $x@tpoff, %rax. */
5259 unsigned int val
, type
;
5261 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5262 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5263 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5264 contents
+ roff
- 3);
5265 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5266 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5267 contents
+ roff
- 1);
5268 bfd_put_32 (output_bfd
,
5269 elf_x86_64_tpoff (info
, relocation
),
5273 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5275 /* GDesc -> LE transition.
5280 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5281 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5284 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5286 /* IE->LE transition:
5287 For 64bit, originally it can be one of:
5288 movq foo@gottpoff(%rip), %reg
5289 addq foo@gottpoff(%rip), %reg
5292 leaq foo(%reg), %reg
5294 For 32bit, originally it can be one of:
5295 movq foo@gottpoff(%rip), %reg
5296 addl foo@gottpoff(%rip), %reg
5299 leal foo(%reg), %reg
5302 unsigned int val
, type
, reg
;
5305 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5308 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5309 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5315 bfd_put_8 (output_bfd
, 0x49,
5316 contents
+ roff
- 3);
5317 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5318 bfd_put_8 (output_bfd
, 0x41,
5319 contents
+ roff
- 3);
5320 bfd_put_8 (output_bfd
, 0xc7,
5321 contents
+ roff
- 2);
5322 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5323 contents
+ roff
- 1);
5327 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5330 bfd_put_8 (output_bfd
, 0x49,
5331 contents
+ roff
- 3);
5332 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5333 bfd_put_8 (output_bfd
, 0x41,
5334 contents
+ roff
- 3);
5335 bfd_put_8 (output_bfd
, 0x81,
5336 contents
+ roff
- 2);
5337 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5338 contents
+ roff
- 1);
5342 /* addq/addl -> leaq/leal */
5344 bfd_put_8 (output_bfd
, 0x4d,
5345 contents
+ roff
- 3);
5346 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5347 bfd_put_8 (output_bfd
, 0x45,
5348 contents
+ roff
- 3);
5349 bfd_put_8 (output_bfd
, 0x8d,
5350 contents
+ roff
- 2);
5351 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5352 contents
+ roff
- 1);
5354 bfd_put_32 (output_bfd
,
5355 elf_x86_64_tpoff (info
, relocation
),
5363 if (htab
->elf
.sgot
== NULL
)
5368 off
= h
->got
.offset
;
5369 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5373 if (local_got_offsets
== NULL
)
5376 off
= local_got_offsets
[r_symndx
];
5377 offplt
= local_tlsdesc_gotents
[r_symndx
];
5384 Elf_Internal_Rela outrel
;
5388 if (htab
->elf
.srelgot
== NULL
)
5391 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5393 if (GOT_TLS_GDESC_P (tls_type
))
5395 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5396 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5397 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5398 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5399 + htab
->elf
.sgotplt
->output_offset
5401 + htab
->sgotplt_jump_table_size
);
5402 sreloc
= htab
->elf
.srelplt
;
5404 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5406 outrel
.r_addend
= 0;
5407 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5410 sreloc
= htab
->elf
.srelgot
;
5412 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5413 + htab
->elf
.sgot
->output_offset
+ off
);
5415 if (GOT_TLS_GD_P (tls_type
))
5416 dr_type
= R_X86_64_DTPMOD64
;
5417 else if (GOT_TLS_GDESC_P (tls_type
))
5420 dr_type
= R_X86_64_TPOFF64
;
5422 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5423 outrel
.r_addend
= 0;
5424 if ((dr_type
== R_X86_64_TPOFF64
5425 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5426 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5427 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5429 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5431 if (GOT_TLS_GD_P (tls_type
))
5435 BFD_ASSERT (! unresolved_reloc
);
5436 bfd_put_64 (output_bfd
,
5437 relocation
- elf_x86_64_dtpoff_base (info
),
5438 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5442 bfd_put_64 (output_bfd
, 0,
5443 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5444 outrel
.r_info
= htab
->r_info (indx
,
5446 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5447 elf_append_rela (output_bfd
, sreloc
,
5456 local_got_offsets
[r_symndx
] |= 1;
5459 if (off
>= (bfd_vma
) -2
5460 && ! GOT_TLS_GDESC_P (tls_type
))
5462 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5464 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5465 || r_type
== R_X86_64_TLSDESC_CALL
)
5466 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5467 + htab
->elf
.sgotplt
->output_offset
5468 + offplt
+ htab
->sgotplt_jump_table_size
;
5470 relocation
= htab
->elf
.sgot
->output_section
->vma
5471 + htab
->elf
.sgot
->output_offset
+ off
;
5472 unresolved_reloc
= FALSE
;
5476 bfd_vma roff
= rel
->r_offset
;
5478 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5480 /* GD->IE transition. For 64bit, change
5481 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5482 .word 0x6666; rex64; call __tls_get_addr@PLT
5484 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5486 call *__tls_get_addr@GOTPCREL(%rip
5487 which may be converted to
5488 addr32 call __tls_get_addr
5491 addq foo@gottpoff(%rip), %rax
5493 leaq foo@tlsgd(%rip), %rdi
5494 .word 0x6666; rex64; call __tls_get_addr@PLT
5496 leaq foo@tlsgd(%rip), %rdi
5498 call *__tls_get_addr@GOTPCREL(%rip)
5499 which may be converted to
5500 addr32 call __tls_get_addr
5503 addq foo@gottpoff(%rip), %rax
5504 For largepic, change:
5505 leaq foo@tlsgd(%rip), %rdi
5506 movabsq $__tls_get_addr@pltoff, %rax
5511 addq foo@gottpoff(%rax), %rax
5512 nopw 0x0(%rax,%rax,1) */
5514 if (ABI_64_P (output_bfd
))
5516 if (contents
[roff
+ 5] == 0xb8)
5518 memcpy (contents
+ roff
- 3,
5519 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5520 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5524 memcpy (contents
+ roff
- 4,
5525 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5529 memcpy (contents
+ roff
- 3,
5530 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5533 relocation
= (htab
->elf
.sgot
->output_section
->vma
5534 + htab
->elf
.sgot
->output_offset
+ off
5537 - input_section
->output_section
->vma
5538 - input_section
->output_offset
5540 bfd_put_32 (output_bfd
, relocation
,
5541 contents
+ roff
+ 8 + largepic
);
5542 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5547 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5549 /* GDesc -> IE transition.
5550 It's originally something like:
5551 leaq x@tlsdesc(%rip), %rax
5554 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5556 /* Now modify the instruction as appropriate. To
5557 turn a leaq into a movq in the form we use it, it
5558 suffices to change the second byte from 0x8d to
5560 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5562 bfd_put_32 (output_bfd
,
5563 htab
->elf
.sgot
->output_section
->vma
5564 + htab
->elf
.sgot
->output_offset
+ off
5566 - input_section
->output_section
->vma
5567 - input_section
->output_offset
5572 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5574 /* GDesc -> IE transition.
5581 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5582 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5590 case R_X86_64_TLSLD
:
5591 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5592 input_section
, contents
,
5593 symtab_hdr
, sym_hashes
,
5594 &r_type
, GOT_UNKNOWN
, rel
,
5595 relend
, h
, r_symndx
, TRUE
))
5598 if (r_type
!= R_X86_64_TLSLD
)
5600 /* LD->LE transition:
5601 leaq foo@tlsld(%rip), %rdi
5602 call __tls_get_addr@PLT
5603 For 64bit, we change it into:
5604 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5605 For 32bit, we change it into:
5606 nopl 0x0(%rax); movl %fs:0, %eax
5608 leaq foo@tlsld(%rip), %rdi;
5609 call *__tls_get_addr@GOTPCREL(%rip)
5610 which may be converted to
5611 addr32 call __tls_get_addr
5612 For 64bit, we change it into:
5613 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5614 For 32bit, we change it into:
5615 nopw 0x0(%rax); movl %fs:0, %eax
5616 For largepic, change:
5617 leaq foo@tlsgd(%rip), %rdi
5618 movabsq $__tls_get_addr@pltoff, %rax
5622 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5625 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5626 if (ABI_64_P (output_bfd
))
5628 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5629 memcpy (contents
+ rel
->r_offset
- 3,
5630 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5631 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5632 else if (contents
[rel
->r_offset
+ 4] == 0xff
5633 || contents
[rel
->r_offset
+ 4] == 0x67)
5634 memcpy (contents
+ rel
->r_offset
- 3,
5635 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5638 memcpy (contents
+ rel
->r_offset
- 3,
5639 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5643 if (contents
[rel
->r_offset
+ 4] == 0xff)
5644 memcpy (contents
+ rel
->r_offset
- 3,
5645 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5648 memcpy (contents
+ rel
->r_offset
- 3,
5649 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5651 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5652 and R_X86_64_PLTOFF64. */
5658 if (htab
->elf
.sgot
== NULL
)
5661 off
= htab
->tls_ld_got
.offset
;
5666 Elf_Internal_Rela outrel
;
5668 if (htab
->elf
.srelgot
== NULL
)
5671 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5672 + htab
->elf
.sgot
->output_offset
+ off
);
5674 bfd_put_64 (output_bfd
, 0,
5675 htab
->elf
.sgot
->contents
+ off
);
5676 bfd_put_64 (output_bfd
, 0,
5677 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5678 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5679 outrel
.r_addend
= 0;
5680 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5682 htab
->tls_ld_got
.offset
|= 1;
5684 relocation
= htab
->elf
.sgot
->output_section
->vma
5685 + htab
->elf
.sgot
->output_offset
+ off
;
5686 unresolved_reloc
= FALSE
;
5689 case R_X86_64_DTPOFF32
:
5690 if (!bfd_link_executable (info
)
5691 || (input_section
->flags
& SEC_CODE
) == 0)
5692 relocation
-= elf_x86_64_dtpoff_base (info
);
5694 relocation
= elf_x86_64_tpoff (info
, relocation
);
5697 case R_X86_64_TPOFF32
:
5698 case R_X86_64_TPOFF64
:
5699 BFD_ASSERT (bfd_link_executable (info
));
5700 relocation
= elf_x86_64_tpoff (info
, relocation
);
5703 case R_X86_64_DTPOFF64
:
5704 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5705 relocation
-= elf_x86_64_dtpoff_base (info
);
5712 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5713 because such sections are not SEC_ALLOC and thus ld.so will
5714 not process them. */
5715 if (unresolved_reloc
5716 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5718 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5719 rel
->r_offset
) != (bfd_vma
) -1)
5722 /* xgettext:c-format */
5723 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
5728 h
->root
.root
.string
);
5733 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5734 contents
, rel
->r_offset
,
5735 relocation
, rel
->r_addend
);
5737 check_relocation_error
:
5738 if (r
!= bfd_reloc_ok
)
5743 name
= h
->root
.root
.string
;
5746 name
= bfd_elf_string_from_elf_section (input_bfd
,
5747 symtab_hdr
->sh_link
,
5752 name
= bfd_section_name (input_bfd
, sec
);
5755 if (r
== bfd_reloc_overflow
)
5756 (*info
->callbacks
->reloc_overflow
)
5757 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5758 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5762 /* xgettext:c-format */
5763 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
5764 input_bfd
, input_section
,
5765 rel
->r_offset
, name
, (int) r
);
5776 Elf_Internal_Shdr
*rel_hdr
;
5777 size_t deleted
= rel
- wrel
;
5779 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5780 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5781 if (rel_hdr
->sh_size
== 0)
5783 /* It is too late to remove an empty reloc section. Leave
5785 ??? What is wrong with an empty section??? */
5786 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5789 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5790 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5791 input_section
->reloc_count
-= deleted
;
5797 /* Finish up dynamic symbol handling. We set the contents of various
5798 dynamic sections here. */
5801 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5802 struct bfd_link_info
*info
,
5803 struct elf_link_hash_entry
*h
,
5804 Elf_Internal_Sym
*sym
)
5806 struct elf_x86_64_link_hash_table
*htab
;
5807 bfd_boolean use_plt_second
;
5808 struct elf_x86_64_link_hash_entry
*eh
;
5809 bfd_boolean local_undefweak
;
5811 htab
= elf_x86_64_hash_table (info
);
5815 /* Use the second PLT section only if there is .plt section. */
5816 use_plt_second
= htab
->elf
.splt
!= NULL
&& htab
->plt_second
!= NULL
;
5818 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5819 if (eh
->no_finish_dynamic_symbol
)
5822 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5823 resolved undefined weak symbols in executable so that their
5824 references have value 0 at run-time. */
5825 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5829 if (h
->plt
.offset
!= (bfd_vma
) -1)
5832 bfd_vma got_offset
, plt_offset
;
5833 Elf_Internal_Rela rela
;
5835 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5836 const struct elf_backend_data
*bed
;
5837 bfd_vma plt_got_pcrel_offset
;
5839 /* When building a static executable, use .iplt, .igot.plt and
5840 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5841 if (htab
->elf
.splt
!= NULL
)
5843 plt
= htab
->elf
.splt
;
5844 gotplt
= htab
->elf
.sgotplt
;
5845 relplt
= htab
->elf
.srelplt
;
5849 plt
= htab
->elf
.iplt
;
5850 gotplt
= htab
->elf
.igotplt
;
5851 relplt
= htab
->elf
.irelplt
;
5854 /* This symbol has an entry in the procedure linkage table. Set
5856 if ((h
->dynindx
== -1
5858 && !((h
->forced_local
|| bfd_link_executable (info
))
5860 && h
->type
== STT_GNU_IFUNC
))
5866 /* Get the index in the procedure linkage table which
5867 corresponds to this symbol. This is the index of this symbol
5868 in all the symbols for which we are making plt entries. The
5869 first entry in the procedure linkage table is reserved.
5871 Get the offset into the .got table of the entry that
5872 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5873 bytes. The first three are reserved for the dynamic linker.
5875 For static executables, we don't reserve anything. */
5877 if (plt
== htab
->elf
.splt
)
5879 got_offset
= (h
->plt
.offset
/ htab
->plt
.plt_entry_size
5880 - htab
->plt
.has_plt0
);
5881 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5885 got_offset
= h
->plt
.offset
/ htab
->plt
.plt_entry_size
;
5886 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5889 /* Fill in the entry in the procedure linkage table. */
5890 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
5891 htab
->plt
.plt_entry_size
);
5894 memcpy (htab
->plt_second
->contents
+ eh
->plt_second
.offset
,
5895 htab
->non_lazy_plt
->plt_entry
,
5896 htab
->non_lazy_plt
->plt_entry_size
);
5898 resolved_plt
= htab
->plt_second
;
5899 plt_offset
= eh
->plt_second
.offset
;
5904 plt_offset
= h
->plt
.offset
;
5907 /* Insert the relocation positions of the plt section. */
5909 /* Put offset the PC-relative instruction referring to the GOT entry,
5910 subtracting the size of that instruction. */
5911 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5912 + gotplt
->output_offset
5914 - resolved_plt
->output_section
->vma
5915 - resolved_plt
->output_offset
5917 - htab
->plt
.plt_got_insn_size
);
5919 /* Check PC-relative offset overflow in PLT entry. */
5920 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5921 /* xgettext:c-format */
5922 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5923 output_bfd
, h
->root
.root
.string
);
5925 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5926 (resolved_plt
->contents
+ plt_offset
5927 + htab
->plt
.plt_got_offset
));
5929 /* Fill in the entry in the global offset table, initially this
5930 points to the second part of the PLT entry. Leave the entry
5931 as zero for undefined weak symbol in PIE. No PLT relocation
5932 against undefined weak symbol in PIE. */
5933 if (!local_undefweak
)
5935 if (htab
->plt
.has_plt0
)
5936 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5937 + plt
->output_offset
5939 + htab
->lazy_plt
->plt_lazy_offset
),
5940 gotplt
->contents
+ got_offset
);
5942 /* Fill in the entry in the .rela.plt section. */
5943 rela
.r_offset
= (gotplt
->output_section
->vma
5944 + gotplt
->output_offset
5946 if (h
->dynindx
== -1
5947 || ((bfd_link_executable (info
)
5948 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5950 && h
->type
== STT_GNU_IFUNC
))
5952 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
5953 h
->root
.root
.string
,
5954 h
->root
.u
.def
.section
->owner
);
5956 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5957 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5958 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5959 rela
.r_addend
= (h
->root
.u
.def
.value
5960 + h
->root
.u
.def
.section
->output_section
->vma
5961 + h
->root
.u
.def
.section
->output_offset
);
5962 /* R_X86_64_IRELATIVE comes last. */
5963 plt_index
= htab
->next_irelative_index
--;
5967 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5969 plt_index
= htab
->next_jump_slot_index
++;
5972 /* Don't fill the second and third slots in PLT entry for
5973 static executables nor without PLT0. */
5974 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
5977 = h
->plt
.offset
+ htab
->lazy_plt
->plt_plt_insn_end
;
5979 /* Put relocation index. */
5980 bfd_put_32 (output_bfd
, plt_index
,
5981 (plt
->contents
+ h
->plt
.offset
5982 + htab
->lazy_plt
->plt_reloc_offset
));
5984 /* Put offset for jmp .PLT0 and check for overflow. We don't
5985 check relocation index for overflow since branch displacement
5986 will overflow first. */
5987 if (plt0_offset
> 0x80000000)
5988 /* xgettext:c-format */
5989 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5990 output_bfd
, h
->root
.root
.string
);
5991 bfd_put_32 (output_bfd
, - plt0_offset
,
5992 (plt
->contents
+ h
->plt
.offset
5993 + htab
->lazy_plt
->plt_plt_offset
));
5996 bed
= get_elf_backend_data (output_bfd
);
5997 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5998 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
6001 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
6003 bfd_vma got_offset
, plt_offset
;
6004 asection
*plt
, *got
;
6005 bfd_boolean got_after_plt
;
6006 int32_t got_pcrel_offset
;
6008 /* Set the entry in the GOT procedure linkage table. */
6009 plt
= htab
->plt_got
;
6010 got
= htab
->elf
.sgot
;
6011 got_offset
= h
->got
.offset
;
6013 if (got_offset
== (bfd_vma
) -1
6014 || (h
->type
== STT_GNU_IFUNC
&& h
->def_regular
)
6019 /* Use the non-lazy PLT entry template for the GOT PLT since they
6020 are the identical. */
6021 /* Fill in the entry in the GOT procedure linkage table. */
6022 plt_offset
= eh
->plt_got
.offset
;
6023 memcpy (plt
->contents
+ plt_offset
,
6024 htab
->non_lazy_plt
->plt_entry
,
6025 htab
->non_lazy_plt
->plt_entry_size
);
6027 /* Put offset the PC-relative instruction referring to the GOT
6028 entry, subtracting the size of that instruction. */
6029 got_pcrel_offset
= (got
->output_section
->vma
6030 + got
->output_offset
6032 - plt
->output_section
->vma
6033 - plt
->output_offset
6035 - htab
->non_lazy_plt
->plt_got_insn_size
);
6037 /* Check PC-relative offset overflow in GOT PLT entry. */
6038 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
6039 if ((got_after_plt
&& got_pcrel_offset
< 0)
6040 || (!got_after_plt
&& got_pcrel_offset
> 0))
6041 /* xgettext:c-format */
6042 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
6043 output_bfd
, h
->root
.root
.string
);
6045 bfd_put_32 (output_bfd
, got_pcrel_offset
,
6046 (plt
->contents
+ plt_offset
6047 + htab
->non_lazy_plt
->plt_got_offset
));
6050 if (!local_undefweak
6052 && (h
->plt
.offset
!= (bfd_vma
) -1
6053 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
6055 /* Mark the symbol as undefined, rather than as defined in
6056 the .plt section. Leave the value if there were any
6057 relocations where pointer equality matters (this is a clue
6058 for the dynamic linker, to make function pointer
6059 comparisons work between an application and shared
6060 library), otherwise set it to zero. If a function is only
6061 called from a binary, there is no need to slow down
6062 shared libraries because of that. */
6063 sym
->st_shndx
= SHN_UNDEF
;
6064 if (!h
->pointer_equality_needed
)
6068 /* Don't generate dynamic GOT relocation against undefined weak
6069 symbol in executable. */
6070 if (h
->got
.offset
!= (bfd_vma
) -1
6071 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
6072 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
6073 && !local_undefweak
)
6075 Elf_Internal_Rela rela
;
6076 asection
*relgot
= htab
->elf
.srelgot
;
6078 /* This symbol has an entry in the global offset table. Set it
6080 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
6083 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
6084 + htab
->elf
.sgot
->output_offset
6085 + (h
->got
.offset
&~ (bfd_vma
) 1));
6087 /* If this is a static link, or it is a -Bsymbolic link and the
6088 symbol is defined locally or was forced to be local because
6089 of a version file, we just want to emit a RELATIVE reloc.
6090 The entry in the global offset table will already have been
6091 initialized in the relocate_section function. */
6093 && h
->type
== STT_GNU_IFUNC
)
6095 if (h
->plt
.offset
== (bfd_vma
) -1)
6097 /* STT_GNU_IFUNC is referenced without PLT. */
6098 if (htab
->elf
.splt
== NULL
)
6100 /* use .rel[a].iplt section to store .got relocations
6101 in static executable. */
6102 relgot
= htab
->elf
.irelplt
;
6104 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
6106 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
6108 h
->root
.root
.string
,
6109 h
->root
.u
.def
.section
->owner
);
6111 rela
.r_info
= htab
->r_info (0,
6112 R_X86_64_IRELATIVE
);
6113 rela
.r_addend
= (h
->root
.u
.def
.value
6114 + h
->root
.u
.def
.section
->output_section
->vma
6115 + h
->root
.u
.def
.section
->output_offset
);
6120 else if (bfd_link_pic (info
))
6122 /* Generate R_X86_64_GLOB_DAT. */
6130 if (!h
->pointer_equality_needed
)
6133 /* For non-shared object, we can't use .got.plt, which
6134 contains the real function addres if we need pointer
6135 equality. We load the GOT entry with the PLT entry. */
6136 if (htab
->plt_second
!= NULL
)
6138 plt
= htab
->plt_second
;
6139 plt_offset
= eh
->plt_second
.offset
;
6143 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
6144 plt_offset
= h
->plt
.offset
;
6146 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
6147 + plt
->output_offset
6149 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6153 else if (bfd_link_pic (info
)
6154 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6156 if (!h
->def_regular
)
6158 BFD_ASSERT((h
->got
.offset
& 1) != 0);
6159 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
6160 rela
.r_addend
= (h
->root
.u
.def
.value
6161 + h
->root
.u
.def
.section
->output_section
->vma
6162 + h
->root
.u
.def
.section
->output_offset
);
6166 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6168 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6169 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6170 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6174 elf_append_rela (output_bfd
, relgot
, &rela
);
6179 Elf_Internal_Rela rela
;
6182 /* This symbol needs a copy reloc. Set it up. */
6184 if (h
->dynindx
== -1
6185 || (h
->root
.type
!= bfd_link_hash_defined
6186 && h
->root
.type
!= bfd_link_hash_defweak
)
6187 || htab
->elf
.srelbss
== NULL
6188 || htab
->elf
.sreldynrelro
== NULL
)
6191 rela
.r_offset
= (h
->root
.u
.def
.value
6192 + h
->root
.u
.def
.section
->output_section
->vma
6193 + h
->root
.u
.def
.section
->output_offset
);
6194 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6196 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6197 s
= htab
->elf
.sreldynrelro
;
6199 s
= htab
->elf
.srelbss
;
6200 elf_append_rela (output_bfd
, s
, &rela
);
6206 /* Finish up local dynamic symbol handling. We set the contents of
6207 various dynamic sections here. */
6210 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6212 struct elf_link_hash_entry
*h
6213 = (struct elf_link_hash_entry
*) *slot
;
6214 struct bfd_link_info
*info
6215 = (struct bfd_link_info
*) inf
;
6217 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6221 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6222 here since undefined weak symbol may not be dynamic and may not be
6223 called for elf_x86_64_finish_dynamic_symbol. */
6226 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6229 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6230 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6232 if (h
->root
.type
!= bfd_link_hash_undefweak
6233 || h
->dynindx
!= -1)
6236 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6240 /* Used to decide how to sort relocs in an optimal manner for the
6241 dynamic linker, before writing them out. */
6243 static enum elf_reloc_type_class
6244 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6245 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6246 const Elf_Internal_Rela
*rela
)
6248 bfd
*abfd
= info
->output_bfd
;
6249 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6250 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6252 if (htab
->elf
.dynsym
!= NULL
6253 && htab
->elf
.dynsym
->contents
!= NULL
)
6255 /* Check relocation against STT_GNU_IFUNC symbol if there are
6257 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6258 if (r_symndx
!= STN_UNDEF
)
6260 Elf_Internal_Sym sym
;
6261 if (!bed
->s
->swap_symbol_in (abfd
,
6262 (htab
->elf
.dynsym
->contents
6263 + r_symndx
* bed
->s
->sizeof_sym
),
6267 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6268 return reloc_class_ifunc
;
6272 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6274 case R_X86_64_IRELATIVE
:
6275 return reloc_class_ifunc
;
6276 case R_X86_64_RELATIVE
:
6277 case R_X86_64_RELATIVE64
:
6278 return reloc_class_relative
;
6279 case R_X86_64_JUMP_SLOT
:
6280 return reloc_class_plt
;
6282 return reloc_class_copy
;
6284 return reloc_class_normal
;
6288 /* Finish up the dynamic sections. */
6291 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6292 struct bfd_link_info
*info
)
6294 struct elf_x86_64_link_hash_table
*htab
;
6298 htab
= elf_x86_64_hash_table (info
);
6302 dynobj
= htab
->elf
.dynobj
;
6303 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6305 if (htab
->elf
.dynamic_sections_created
)
6307 bfd_byte
*dyncon
, *dynconend
;
6308 const struct elf_backend_data
*bed
;
6309 bfd_size_type sizeof_dyn
;
6311 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6314 bed
= get_elf_backend_data (dynobj
);
6315 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6316 dyncon
= sdyn
->contents
;
6317 dynconend
= sdyn
->contents
+ sdyn
->size
;
6318 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6320 Elf_Internal_Dyn dyn
;
6323 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6331 s
= htab
->elf
.sgotplt
;
6332 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6336 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6340 s
= htab
->elf
.srelplt
->output_section
;
6341 dyn
.d_un
.d_val
= s
->size
;
6344 case DT_TLSDESC_PLT
:
6346 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6347 + htab
->tlsdesc_plt
;
6350 case DT_TLSDESC_GOT
:
6352 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6353 + htab
->tlsdesc_got
;
6357 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6360 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6362 elf_section_data (htab
->elf
.splt
->output_section
)
6363 ->this_hdr
.sh_entsize
= htab
->plt
.plt_entry_size
;
6365 if (htab
->plt
.has_plt0
)
6367 /* Fill in the special first entry in the procedure linkage
6369 memcpy (htab
->elf
.splt
->contents
,
6370 htab
->lazy_plt
->plt0_entry
,
6371 htab
->lazy_plt
->plt_entry_size
);
6372 /* Add offset for pushq GOT+8(%rip), since the instruction
6373 uses 6 bytes subtract this value. */
6374 bfd_put_32 (output_bfd
,
6375 (htab
->elf
.sgotplt
->output_section
->vma
6376 + htab
->elf
.sgotplt
->output_offset
6378 - htab
->elf
.splt
->output_section
->vma
6379 - htab
->elf
.splt
->output_offset
6381 (htab
->elf
.splt
->contents
6382 + htab
->lazy_plt
->plt0_got1_offset
));
6383 /* Add offset for the PC-relative instruction accessing
6384 GOT+16, subtracting the offset to the end of that
6386 bfd_put_32 (output_bfd
,
6387 (htab
->elf
.sgotplt
->output_section
->vma
6388 + htab
->elf
.sgotplt
->output_offset
6390 - htab
->elf
.splt
->output_section
->vma
6391 - htab
->elf
.splt
->output_offset
6392 - htab
->lazy_plt
->plt0_got2_insn_end
),
6393 (htab
->elf
.splt
->contents
6394 + htab
->lazy_plt
->plt0_got2_offset
));
6396 if (htab
->tlsdesc_plt
)
6398 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6399 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6401 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6402 htab
->lazy_plt
->plt0_entry
,
6403 htab
->lazy_plt
->plt_entry_size
);
6405 /* Add offset for pushq GOT+8(%rip), since the
6406 instruction uses 6 bytes subtract this value. */
6407 bfd_put_32 (output_bfd
,
6408 (htab
->elf
.sgotplt
->output_section
->vma
6409 + htab
->elf
.sgotplt
->output_offset
6411 - htab
->elf
.splt
->output_section
->vma
6412 - htab
->elf
.splt
->output_offset
6415 (htab
->elf
.splt
->contents
6417 + htab
->lazy_plt
->plt0_got1_offset
));
6418 /* Add offset for the PC-relative instruction accessing
6419 GOT+TDG, where TDG stands for htab->tlsdesc_got,
6420 subtracting the offset to the end of that
6422 bfd_put_32 (output_bfd
,
6423 (htab
->elf
.sgot
->output_section
->vma
6424 + htab
->elf
.sgot
->output_offset
6426 - htab
->elf
.splt
->output_section
->vma
6427 - htab
->elf
.splt
->output_offset
6429 - htab
->lazy_plt
->plt0_got2_insn_end
),
6430 (htab
->elf
.splt
->contents
6432 + htab
->lazy_plt
->plt0_got2_offset
));
6438 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
6439 elf_section_data (htab
->plt_got
->output_section
)
6440 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6442 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
6443 elf_section_data (htab
->plt_second
->output_section
)
6444 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6446 /* GOT is always created in setup_gnu_properties. But it may not be
6448 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
6450 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6453 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6457 /* Set the first entry in the global offset table to the address of
6458 the dynamic section. */
6460 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6462 bfd_put_64 (output_bfd
,
6463 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6464 htab
->elf
.sgotplt
->contents
);
6465 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6466 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6467 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6468 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6469 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6471 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
6475 /* Adjust .eh_frame for .plt section. */
6476 if (htab
->plt_eh_frame
!= NULL
6477 && htab
->plt_eh_frame
->contents
!= NULL
)
6479 if (htab
->elf
.splt
!= NULL
6480 && htab
->elf
.splt
->size
!= 0
6481 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6482 && htab
->elf
.splt
->output_section
!= NULL
6483 && htab
->plt_eh_frame
->output_section
!= NULL
)
6485 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6486 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6487 + htab
->plt_eh_frame
->output_offset
6488 + PLT_FDE_START_OFFSET
;
6489 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6490 htab
->plt_eh_frame
->contents
6491 + PLT_FDE_START_OFFSET
);
6493 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6495 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6497 htab
->plt_eh_frame
->contents
))
6502 /* Adjust .eh_frame for .plt.got section. */
6503 if (htab
->plt_got_eh_frame
!= NULL
6504 && htab
->plt_got_eh_frame
->contents
!= NULL
)
6506 if (htab
->plt_got
!= NULL
6507 && htab
->plt_got
->size
!= 0
6508 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
6509 && htab
->plt_got
->output_section
!= NULL
6510 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
6512 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
6513 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
6514 + htab
->plt_got_eh_frame
->output_offset
6515 + PLT_FDE_START_OFFSET
;
6516 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6517 htab
->plt_got_eh_frame
->contents
6518 + PLT_FDE_START_OFFSET
);
6520 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6522 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6523 htab
->plt_got_eh_frame
,
6524 htab
->plt_got_eh_frame
->contents
))
6529 /* Adjust .eh_frame for the second PLT section. */
6530 if (htab
->plt_second_eh_frame
!= NULL
6531 && htab
->plt_second_eh_frame
->contents
!= NULL
)
6533 if (htab
->plt_second
!= NULL
6534 && htab
->plt_second
->size
!= 0
6535 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
6536 && htab
->plt_second
->output_section
!= NULL
6537 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
6539 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
6540 bfd_vma eh_frame_start
6541 = (htab
->plt_second_eh_frame
->output_section
->vma
6542 + htab
->plt_second_eh_frame
->output_offset
6543 + PLT_FDE_START_OFFSET
);
6544 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6545 htab
->plt_second_eh_frame
->contents
6546 + PLT_FDE_START_OFFSET
);
6548 if (htab
->plt_second_eh_frame
->sec_info_type
6549 == SEC_INFO_TYPE_EH_FRAME
)
6551 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6552 htab
->plt_second_eh_frame
,
6553 htab
->plt_second_eh_frame
->contents
))
6558 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6559 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6562 /* Fill PLT entries for undefined weak symbols in PIE. */
6563 if (bfd_link_pie (info
))
6564 bfd_hash_traverse (&info
->hash
->table
,
6565 elf_x86_64_pie_finish_undefweak_symbol
,
6571 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6572 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6573 It has to be done before elf_link_sort_relocs is called so that
6574 dynamic relocations are properly sorted. */
6577 elf_x86_64_output_arch_local_syms
6578 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6579 struct bfd_link_info
*info
,
6580 void *flaginfo ATTRIBUTE_UNUSED
,
6581 int (*func
) (void *, const char *,
6584 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6586 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6590 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6591 htab_traverse (htab
->loc_hash_table
,
6592 elf_x86_64_finish_local_dynamic_symbol
,
6598 /* Sort relocs into address order. */
6601 compare_relocs (const void *ap
, const void *bp
)
6603 const arelent
*a
= * (const arelent
**) ap
;
6604 const arelent
*b
= * (const arelent
**) bp
;
6606 if (a
->address
> b
->address
)
6608 else if (a
->address
< b
->address
)
6614 enum elf_x86_64_plt_type
6618 plt_second
= 1 << 1,
6622 struct elf_x86_64_plt
6627 enum elf_x86_64_plt_type type
;
6628 unsigned int plt_got_offset
;
6629 unsigned int plt_got_insn_size
;
6630 unsigned int plt_entry_size
;
6634 /* Forward declaration. */
6635 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
;
6637 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
6638 dynamic relocations. */
6641 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6642 long symcount ATTRIBUTE_UNUSED
,
6643 asymbol
**syms ATTRIBUTE_UNUSED
,
6648 long size
, count
, i
, n
, len
;
6650 unsigned int plt_got_offset
, plt_entry_size
, plt_got_insn_size
;
6652 bfd_byte
*plt_contents
;
6653 long dynrelcount
, relsize
;
6654 arelent
**dynrelbuf
, *p
;
6655 const struct elf_x86_64_lazy_plt_layout
*lazy_plt
;
6656 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_plt
;
6657 const struct elf_x86_64_lazy_plt_layout
*lazy_bnd_plt
;
6658 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_bnd_plt
;
6659 const struct elf_x86_64_lazy_plt_layout
*lazy_ibt_plt
;
6660 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_ibt_plt
;
6663 enum elf_x86_64_plt_type plt_type
;
6664 struct elf_x86_64_plt plts
[] =
6666 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0, 0 },
6667 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 },
6668 { ".plt.sec", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6669 { ".plt.bnd", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6670 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 }
6675 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
6678 if (dynsymcount
<= 0)
6681 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
6685 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
6686 if (dynrelbuf
== NULL
)
6689 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
6692 /* Sort the relocs by address. */
6693 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*), compare_relocs
);
6695 if (get_elf_x86_64_backend_data (abfd
)->os
== is_normal
)
6697 lazy_plt
= &elf_x86_64_lazy_plt
;
6698 non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
6699 lazy_bnd_plt
= &elf_x86_64_lazy_bnd_plt
;
6700 non_lazy_bnd_plt
= &elf_x86_64_non_lazy_bnd_plt
;
6701 if (ABI_64_P (abfd
))
6703 lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
6704 non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
6708 lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
6709 non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
6714 lazy_plt
= &elf_x86_64_nacl_plt
;
6715 non_lazy_plt
= NULL
;
6716 lazy_bnd_plt
= NULL
;
6717 non_lazy_bnd_plt
= NULL
;
6718 lazy_ibt_plt
= NULL
;
6719 non_lazy_ibt_plt
= NULL
;
6723 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6725 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
6729 /* Get the PLT section contents. */
6730 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6731 if (plt_contents
== NULL
)
6733 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6734 plt_contents
, 0, plt
->size
))
6736 free (plt_contents
);
6740 /* Check what kind of PLT it is. */
6741 plt_type
= plt_unknown
;
6742 if (plts
[j
].type
== plt_unknown
)
6744 /* Match lazy PLT first. Need to check the first two
6746 if ((memcmp (plt_contents
, lazy_plt
->plt0_entry
,
6747 lazy_plt
->plt0_got1_offset
) == 0)
6748 && (memcmp (plt_contents
+ 6, lazy_plt
->plt0_entry
+ 6,
6750 plt_type
= plt_lazy
;
6751 else if (lazy_bnd_plt
!= NULL
6752 && (memcmp (plt_contents
, lazy_bnd_plt
->plt0_entry
,
6753 lazy_bnd_plt
->plt0_got1_offset
) == 0)
6754 && (memcmp (plt_contents
+ 6,
6755 lazy_bnd_plt
->plt0_entry
+ 6, 3) == 0))
6757 plt_type
= plt_lazy
| plt_second
;
6758 /* The fist entry in the lazy IBT PLT is the same as the
6760 if ((memcmp (plt_contents
+ lazy_ibt_plt
->plt_entry_size
,
6761 lazy_ibt_plt
->plt_entry
,
6762 lazy_ibt_plt
->plt_got_offset
) == 0))
6763 lazy_plt
= lazy_ibt_plt
;
6765 lazy_plt
= lazy_bnd_plt
;
6769 if (non_lazy_plt
!= NULL
6770 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
))
6772 /* Match non-lazy PLT. */
6773 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
6774 non_lazy_plt
->plt_got_offset
) == 0)
6775 plt_type
= plt_non_lazy
;
6778 if (plt_type
== plt_unknown
|| plt_type
== plt_second
)
6780 if (non_lazy_bnd_plt
!= NULL
6781 && (memcmp (plt_contents
, non_lazy_bnd_plt
->plt_entry
,
6782 non_lazy_bnd_plt
->plt_got_offset
) == 0))
6784 /* Match BND PLT. */
6785 plt_type
= plt_second
;
6786 non_lazy_plt
= non_lazy_bnd_plt
;
6788 else if (non_lazy_ibt_plt
!= NULL
6789 && (memcmp (plt_contents
,
6790 non_lazy_ibt_plt
->plt_entry
,
6791 non_lazy_ibt_plt
->plt_got_offset
) == 0))
6793 /* Match IBT PLT. */
6794 plt_type
= plt_second
;
6795 non_lazy_plt
= non_lazy_ibt_plt
;
6799 if (plt_type
== plt_unknown
)
6803 plts
[j
].type
= plt_type
;
6805 if ((plt_type
& plt_lazy
))
6807 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
6808 plts
[j
].plt_got_insn_size
= lazy_plt
->plt_got_insn_size
;
6809 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
6810 /* Skip PLT0 in lazy PLT. */
6815 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
6816 plts
[j
].plt_got_insn_size
= non_lazy_plt
->plt_got_insn_size
;
6817 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
6821 /* Skip lazy PLT when the second PLT is used. */
6822 if (plt_type
== (plt_lazy
| plt_second
))
6826 n
= plt
->size
/ plts
[j
].plt_entry_size
;
6831 plts
[j
].contents
= plt_contents
;
6834 size
= count
* sizeof (asymbol
);
6836 /* Allocate space for @plt suffixes. */
6838 for (i
= 0; i
< dynrelcount
; i
++)
6841 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
6843 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
6846 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
6850 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6851 if (plts
[j
].contents
!= NULL
)
6852 free (plts
[j
].contents
);
6857 /* Check for each PLT section. */
6858 names
= (char *) (s
+ count
);
6861 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6862 if ((plt_contents
= plts
[j
].contents
) != NULL
)
6867 plt_got_offset
= plts
[j
].plt_got_offset
;
6868 plt_got_insn_size
= plts
[j
].plt_got_insn_size
;
6869 plt_entry_size
= plts
[j
].plt_entry_size
;
6873 if ((plts
[j
].type
& plt_lazy
))
6875 /* Skip PLT0 in lazy PLT. */
6877 offset
= plt_entry_size
;
6885 /* Check each PLT entry against dynamic relocations. */
6886 for (; k
< plts
[j
].count
; k
++)
6892 /* Get the PC-relative offset, a signed 32-bit integer. */
6893 off
= H_GET_32 (abfd
, (plt_contents
+ offset
6895 got_vma
= plt
->vma
+ offset
+ off
+ plt_got_insn_size
;
6897 /* Binary search. */
6901 while ((min
+ 1) < max
)
6905 mid
= (min
+ max
) / 2;
6907 if (got_vma
> r
->address
)
6909 else if (got_vma
< r
->address
)
6918 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6919 if (got_vma
== p
->address
6921 && (p
->howto
->type
== R_X86_64_JUMP_SLOT
6922 || p
->howto
->type
== R_X86_64_GLOB_DAT
6923 || p
->howto
->type
== R_X86_64_IRELATIVE
))
6925 *s
= **p
->sym_ptr_ptr
;
6926 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6927 set. Since we are defining a symbol, ensure one
6929 if ((s
->flags
& BSF_LOCAL
) == 0)
6930 s
->flags
|= BSF_GLOBAL
;
6931 s
->flags
|= BSF_SYNTHETIC
;
6932 /* This is no longer a section symbol. */
6933 s
->flags
&= ~BSF_SECTION_SYM
;
6935 s
->the_bfd
= plt
->owner
;
6939 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
6940 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
6946 memcpy (names
, "+0x", sizeof ("+0x") - 1);
6947 names
+= sizeof ("+0x") - 1;
6948 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
6949 for (a
= buf
; *a
== '0'; ++a
)
6952 memcpy (names
, a
, size
);
6955 memcpy (names
, "@plt", sizeof ("@plt"));
6956 names
+= sizeof ("@plt");
6960 offset
+= plt_entry_size
;
6964 /* PLT entries with R_X86_64_TLSDESC relocations are skipped. */
6970 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6971 if (plts
[j
].contents
!= NULL
)
6972 free (plts
[j
].contents
);
6979 /* Handle an x86-64 specific section when reading an object file. This
6980 is called when elfcode.h finds a section with an unknown type. */
6983 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6984 const char *name
, int shindex
)
6986 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6989 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6995 /* Hook called by the linker routine which adds symbols from an object
6996 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
7000 elf_x86_64_add_symbol_hook (bfd
*abfd
,
7001 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7002 Elf_Internal_Sym
*sym
,
7003 const char **namep ATTRIBUTE_UNUSED
,
7004 flagword
*flagsp ATTRIBUTE_UNUSED
,
7010 switch (sym
->st_shndx
)
7012 case SHN_X86_64_LCOMMON
:
7013 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
7016 lcomm
= bfd_make_section_with_flags (abfd
,
7020 | SEC_LINKER_CREATED
));
7023 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
7026 *valp
= sym
->st_size
;
7034 /* Given a BFD section, try to locate the corresponding ELF section
7038 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
7039 asection
*sec
, int *index_return
)
7041 if (sec
== &_bfd_elf_large_com_section
)
7043 *index_return
= SHN_X86_64_LCOMMON
;
7049 /* Process a symbol. */
7052 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
7055 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
7057 switch (elfsym
->internal_elf_sym
.st_shndx
)
7059 case SHN_X86_64_LCOMMON
:
7060 asym
->section
= &_bfd_elf_large_com_section
;
7061 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
7062 /* Common symbol doesn't set BSF_GLOBAL. */
7063 asym
->flags
&= ~BSF_GLOBAL
;
7069 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
7071 return (sym
->st_shndx
== SHN_COMMON
7072 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
7076 elf_x86_64_common_section_index (asection
*sec
)
7078 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
7081 return SHN_X86_64_LCOMMON
;
7085 elf_x86_64_common_section (asection
*sec
)
7087 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
7088 return bfd_com_section_ptr
;
7090 return &_bfd_elf_large_com_section
;
7094 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
7095 const Elf_Internal_Sym
*sym
,
7100 const asection
*oldsec
)
7102 /* A normal common symbol and a large common symbol result in a
7103 normal common symbol. We turn the large common symbol into a
7106 && h
->root
.type
== bfd_link_hash_common
7108 && bfd_is_com_section (*psec
)
7111 if (sym
->st_shndx
== SHN_COMMON
7112 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
7114 h
->root
.u
.c
.p
->section
7115 = bfd_make_section_old_way (oldbfd
, "COMMON");
7116 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
7118 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
7119 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
7120 *psec
= bfd_com_section_ptr
;
7127 elf_x86_64_additional_program_headers (bfd
*abfd
,
7128 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7133 /* Check to see if we need a large readonly segment. */
7134 s
= bfd_get_section_by_name (abfd
, ".lrodata");
7135 if (s
&& (s
->flags
& SEC_LOAD
))
7138 /* Check to see if we need a large data segment. Since .lbss sections
7139 is placed right after the .bss section, there should be no need for
7140 a large data segment just because of .lbss. */
7141 s
= bfd_get_section_by_name (abfd
, ".ldata");
7142 if (s
&& (s
->flags
& SEC_LOAD
))
7148 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
7151 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
7153 if (h
->plt
.offset
!= (bfd_vma
) -1
7155 && !h
->pointer_equality_needed
)
7158 return _bfd_elf_hash_symbol (h
);
7161 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
7164 elf_x86_64_relocs_compatible (const bfd_target
*input
,
7165 const bfd_target
*output
)
7167 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
7168 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
7169 && _bfd_elf_relocs_compatible (input
, output
));
7172 /* Parse x86-64 GNU properties. */
7174 static enum elf_property_kind
7175 elf_x86_64_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
7176 bfd_byte
*ptr
, unsigned int datasz
)
7182 case GNU_PROPERTY_X86_ISA_1_USED
:
7183 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
7184 case GNU_PROPERTY_X86_FEATURE_1_AND
:
7188 ((type
== GNU_PROPERTY_X86_ISA_1_USED
7189 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
7190 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
7191 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
7192 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
7194 return property_corrupt
;
7196 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
7197 /* Combine properties of the same type. */
7198 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
7199 prop
->pr_kind
= property_number
;
7203 return property_ignored
;
7206 return property_number
;
7209 /* Merge x86-64 GNU property BPROP with APROP. If APROP isn't NULL,
7210 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
7211 should be merged with ABFD. */
7214 elf_x86_64_merge_gnu_properties (struct bfd_link_info
*info
,
7215 bfd
*abfd ATTRIBUTE_UNUSED
,
7216 elf_property
*aprop
,
7217 elf_property
*bprop
)
7219 unsigned int number
, features
;
7220 bfd_boolean updated
= FALSE
;
7221 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
7225 case GNU_PROPERTY_X86_ISA_1_USED
:
7226 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
7227 if (aprop
!= NULL
&& bprop
!= NULL
)
7229 number
= aprop
->u
.number
;
7230 aprop
->u
.number
= number
| bprop
->u
.number
;
7231 updated
= number
!= (unsigned int) aprop
->u
.number
;
7235 /* Return TRUE if APROP is NULL to indicate that BPROP should
7236 be added to ABFD. */
7237 updated
= aprop
== NULL
;
7241 case GNU_PROPERTY_X86_FEATURE_1_AND
:
7242 /* Only one of APROP and BPROP can be NULL:
7243 1. APROP & BPROP when both APROP and BPROP aren't NULL.
7244 2. If APROP is NULL, remove x86 feature.
7245 3. Otherwise, do nothing.
7247 if (aprop
!= NULL
&& bprop
!= NULL
)
7251 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7253 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7254 number
= aprop
->u
.number
;
7255 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7256 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7257 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
7258 updated
= number
!= (unsigned int) aprop
->u
.number
;
7259 /* Remove the property if all feature bits are cleared. */
7260 if (aprop
->u
.number
== 0)
7261 aprop
->pr_kind
= property_remove
;
7267 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7269 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7272 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7273 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7276 number
= aprop
->u
.number
;
7277 aprop
->u
.number
= number
| features
;
7278 updated
= number
!= (unsigned int) aprop
->u
.number
;
7282 bprop
->u
.number
|= features
;
7286 else if (aprop
!= NULL
)
7288 aprop
->pr_kind
= property_remove
;
7295 /* Never should happen. */
7302 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
7303 with GNU properties if found. Otherwise, return NULL. */
7306 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info
*info
)
7308 bfd_boolean normal_target
;
7309 bfd_boolean lazy_plt
;
7310 asection
*sec
, *pltsec
;
7312 bfd_boolean use_ibt_plt
;
7313 unsigned int plt_alignment
, features
;
7314 struct elf_x86_64_link_hash_table
*htab
;
7321 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7323 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7325 /* Find a normal input file with GNU property note. */
7326 for (pbfd
= info
->input_bfds
;
7328 pbfd
= pbfd
->link
.next
)
7329 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
7330 && bfd_count_sections (pbfd
) != 0)
7334 if (elf_properties (pbfd
) != NULL
)
7342 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
7343 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7344 prop
= _bfd_elf_get_property (ebfd
,
7345 GNU_PROPERTY_X86_FEATURE_1_AND
,
7347 prop
->u
.number
|= features
;
7348 prop
->pr_kind
= property_number
;
7350 /* Create the GNU property note section if needed. */
7353 sec
= bfd_make_section_with_flags (ebfd
,
7354 NOTE_GNU_PROPERTY_SECTION_NAME
,
7362 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
7364 if (!bfd_set_section_alignment (ebfd
, sec
,
7365 ABI_64_P (ebfd
) ? 3 : 2))
7368 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
7372 elf_section_type (sec
) = SHT_NOTE
;
7376 /* Check GNU_PROPERTY_NO_COPY_ON_PROTECTED. */
7377 for (; pbfd
!= NULL
; pbfd
= pbfd
->link
.next
)
7378 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
7380 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
7382 elf_property_list
*p
;
7384 /* The property list is sorted in order of type. */
7385 for (p
= elf_properties (pbfd
); p
!= NULL
; p
= p
->next
)
7387 if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7388 == p
->property
.pr_type
)
7390 /* Clear extern_protected_data if
7391 GNU_PROPERTY_NO_COPY_ON_PROTECTED is
7392 set on any input relocatable file. */
7393 info
->extern_protected_data
= FALSE
;
7396 else if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7397 < p
->property
.pr_type
)
7403 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
7405 if (bfd_link_relocatable (info
))
7408 htab
= elf_x86_64_hash_table (info
);
7412 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
7413 if (!use_ibt_plt
&& pbfd
!= NULL
)
7415 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
7416 elf_property_list
*p
;
7418 /* The property list is sorted in order of type. */
7419 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
7421 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
7423 use_ibt_plt
= !!(p
->property
.u
.number
7424 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
7427 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
7432 dynobj
= htab
->elf
.dynobj
;
7434 /* Set htab->elf.dynobj here so that there is no need to check and
7435 set it in check_relocs. */
7440 htab
->elf
.dynobj
= pbfd
;
7447 /* Find a normal input file to hold linker created
7449 for (abfd
= info
->input_bfds
;
7451 abfd
= abfd
->link
.next
)
7452 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7454 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
7456 htab
->elf
.dynobj
= abfd
;
7463 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
7464 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
7465 canonical function address. */
7466 htab
->plt
.has_plt0
= 1;
7468 if (get_elf_x86_64_backend_data (info
->output_bfd
)->os
7473 if (ABI_64_P (dynobj
))
7475 htab
->lazy_plt
= &elf_x86_64_lazy_ibt_plt
;
7476 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_ibt_plt
;
7480 htab
->lazy_plt
= &elf_x32_lazy_ibt_plt
;
7481 htab
->non_lazy_plt
= &elf_x32_non_lazy_ibt_plt
;
7484 else if (info
->bndplt
)
7486 htab
->lazy_plt
= &elf_x86_64_lazy_bnd_plt
;
7487 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_bnd_plt
;
7491 htab
->lazy_plt
= &elf_x86_64_lazy_plt
;
7492 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
7494 normal_target
= TRUE
;
7498 htab
->lazy_plt
= &elf_x86_64_nacl_plt
;
7499 htab
->non_lazy_plt
= NULL
;
7500 normal_target
= FALSE
;
7503 pltsec
= htab
->elf
.splt
;
7505 /* If the non-lazy PLT is available, use it for all PLT entries if
7506 there are no PLT0 or no .plt section. */
7507 if (htab
->non_lazy_plt
!= NULL
7508 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
7512 = htab
->non_lazy_plt
->plt_entry
;
7513 htab
->plt
.plt_entry_size
7514 = htab
->non_lazy_plt
->plt_entry_size
;
7515 htab
->plt
.plt_got_offset
7516 = htab
->non_lazy_plt
->plt_got_offset
;
7517 htab
->plt
.plt_got_insn_size
7518 = htab
->non_lazy_plt
->plt_got_insn_size
;
7519 htab
->plt
.eh_frame_plt_size
7520 = htab
->non_lazy_plt
->eh_frame_plt_size
;
7521 htab
->plt
.eh_frame_plt
7522 = htab
->non_lazy_plt
->eh_frame_plt
;
7528 = htab
->lazy_plt
->plt_entry
;
7529 htab
->plt
.plt_entry_size
7530 = htab
->lazy_plt
->plt_entry_size
;
7531 htab
->plt
.plt_got_offset
7532 = htab
->lazy_plt
->plt_got_offset
;
7533 htab
->plt
.plt_got_insn_size
7534 = htab
->lazy_plt
->plt_got_insn_size
;
7535 htab
->plt
.eh_frame_plt_size
7536 = htab
->lazy_plt
->eh_frame_plt_size
;
7537 htab
->plt
.eh_frame_plt
7538 = htab
->lazy_plt
->eh_frame_plt
;
7541 /* Return if there are no normal input files. */
7545 /* Since create_dynamic_sections isn't always called, but GOT
7546 relocations need GOT relocations, create them here so that we
7547 don't need to do it in check_relocs. */
7548 if (htab
->elf
.sgot
== NULL
7549 && !_bfd_elf_create_got_section (dynobj
, info
))
7550 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
7552 /* Align .got and .got.plt sections to their entry size. Do it here
7553 instead of in create_dynamic_sections so that they are always
7554 properly aligned even if create_dynamic_sections isn't called. */
7555 sec
= htab
->elf
.sgot
;
7556 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7557 goto error_alignment
;
7559 sec
= htab
->elf
.sgotplt
;
7560 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7561 goto error_alignment
;
7563 /* Create the ifunc sections here so that check_relocs can be
7565 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
7566 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
7568 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
7572 /* Whe creating executable, set the contents of the .interp
7573 section to the interpreter. */
7574 if (bfd_link_executable (info
) && !info
->nointerp
)
7576 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
7579 s
->size
= htab
->dynamic_interpreter_size
;
7580 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
7584 /* Don't change PLT section alignment for NaCl since it uses
7585 64-byte PLT entry and sets PLT section alignment to 32
7586 bytes. Don't create additional PLT sections for NaCl. */
7589 const struct elf_backend_data
*bed
7590 = get_elf_backend_data (dynobj
);
7591 flagword pltflags
= (bed
->dynamic_sec_flags
7596 unsigned int non_lazy_plt_alignment
7597 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
7600 if (!bfd_set_section_alignment (sec
->owner
, sec
,
7602 goto error_alignment
;
7604 /* Create the GOT procedure linkage table. */
7605 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7609 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
7611 if (!bfd_set_section_alignment (dynobj
, sec
,
7612 non_lazy_plt_alignment
))
7613 goto error_alignment
;
7615 htab
->plt_got
= sec
;
7623 /* Create the second PLT for Intel IBT support. IBT
7624 PLT is supported only for non-NaCl target and is
7625 is needed only for lazy binding. */
7626 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7630 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
7632 if (!bfd_set_section_alignment (dynobj
, sec
,
7634 goto error_alignment
;
7636 else if (info
->bndplt
&& ABI_64_P (dynobj
))
7638 /* Create the second PLT for Intel MPX support. MPX
7639 PLT is supported only for non-NaCl target in 64-bit
7640 mode and is needed only for lazy binding. */
7641 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7645 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
7647 if (!bfd_set_section_alignment (dynobj
, sec
,
7648 non_lazy_plt_alignment
))
7649 goto error_alignment
;
7652 htab
->plt_second
= sec
;
7656 if (!info
->no_ld_generated_unwind_info
)
7658 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
7659 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7660 | SEC_LINKER_CREATED
);
7662 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7666 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
7668 if (!bfd_set_section_alignment (dynobj
, sec
,
7669 ABI_64_P (dynobj
) ? 3 : 2))
7670 goto error_alignment
;
7672 htab
->plt_eh_frame
= sec
;
7674 if (htab
->plt_got
!= NULL
)
7676 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7680 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
7682 if (!bfd_set_section_alignment (dynobj
, sec
,
7683 ABI_64_P (dynobj
) ? 3 : 2))
7684 goto error_alignment
;
7686 htab
->plt_got_eh_frame
= sec
;
7689 if (htab
->plt_second
!= NULL
)
7691 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7695 info
->callbacks
->einfo (_("%F: failed to create BND PLT .eh_frame section\n"));
7697 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7698 goto error_alignment
;
7700 htab
->plt_second_eh_frame
= sec
;
7707 /* The .iplt section is used for IFUNC symbols in static
7709 sec
= htab
->elf
.iplt
;
7711 && !bfd_set_section_alignment (sec
->owner
, sec
,
7713 goto error_alignment
;
7720 elf_x86_64_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
7722 if (!bfd_link_relocatable (info
))
7724 /* Check for __tls_get_addr reference. */
7725 struct elf_link_hash_entry
*h
;
7726 h
= elf_link_hash_lookup (elf_hash_table (info
), "__tls_get_addr",
7727 FALSE
, FALSE
, FALSE
);
7729 ((struct elf_x86_64_link_hash_entry
*) h
)->tls_get_addr
= 1;
7732 /* Invoke the regular ELF backend linker to do all the work. */
7733 return _bfd_elf_link_check_relocs (abfd
, info
);
7736 static const struct bfd_elf_special_section
7737 elf_x86_64_special_sections
[]=
7739 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7740 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7741 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
7742 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7743 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7744 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7745 { NULL
, 0, 0, 0, 0 }
7748 #define TARGET_LITTLE_SYM x86_64_elf64_vec
7749 #define TARGET_LITTLE_NAME "elf64-x86-64"
7750 #define ELF_ARCH bfd_arch_i386
7751 #define ELF_TARGET_ID X86_64_ELF_DATA
7752 #define ELF_MACHINE_CODE EM_X86_64
7753 #define ELF_MAXPAGESIZE 0x200000
7754 #define ELF_MINPAGESIZE 0x1000
7755 #define ELF_COMMONPAGESIZE 0x1000
7757 #define elf_backend_can_gc_sections 1
7758 #define elf_backend_can_refcount 1
7759 #define elf_backend_want_got_plt 1
7760 #define elf_backend_plt_readonly 1
7761 #define elf_backend_want_plt_sym 0
7762 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
7763 #define elf_backend_rela_normal 1
7764 #define elf_backend_plt_alignment 4
7765 #define elf_backend_extern_protected_data 1
7766 #define elf_backend_caches_rawsize 1
7767 #define elf_backend_dtrel_excludes_plt 1
7768 #define elf_backend_want_dynrelro 1
7770 #define elf_info_to_howto elf_x86_64_info_to_howto
7772 #define bfd_elf64_bfd_link_hash_table_create \
7773 elf_x86_64_link_hash_table_create
7774 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
7775 #define bfd_elf64_bfd_reloc_name_lookup \
7776 elf_x86_64_reloc_name_lookup
7778 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
7779 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
7780 #define elf_backend_check_relocs elf_x86_64_check_relocs
7781 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
7782 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
7783 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
7784 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
7785 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
7786 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
7787 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
7788 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
7790 #define elf_backend_write_core_note elf_x86_64_write_core_note
7792 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
7793 #define elf_backend_relocate_section elf_x86_64_relocate_section
7794 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
7795 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
7796 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
7797 #define elf_backend_object_p elf64_x86_64_elf_object_p
7798 #define bfd_elf64_mkobject elf_x86_64_mkobject
7799 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
7800 #define bfd_elf64_bfd_link_check_relocs elf_x86_64_link_check_relocs
7802 #define elf_backend_section_from_shdr \
7803 elf_x86_64_section_from_shdr
7805 #define elf_backend_section_from_bfd_section \
7806 elf_x86_64_elf_section_from_bfd_section
7807 #define elf_backend_add_symbol_hook \
7808 elf_x86_64_add_symbol_hook
7809 #define elf_backend_symbol_processing \
7810 elf_x86_64_symbol_processing
7811 #define elf_backend_common_section_index \
7812 elf_x86_64_common_section_index
7813 #define elf_backend_common_section \
7814 elf_x86_64_common_section
7815 #define elf_backend_common_definition \
7816 elf_x86_64_common_definition
7817 #define elf_backend_merge_symbol \
7818 elf_x86_64_merge_symbol
7819 #define elf_backend_special_sections \
7820 elf_x86_64_special_sections
7821 #define elf_backend_additional_program_headers \
7822 elf_x86_64_additional_program_headers
7823 #define elf_backend_hash_symbol \
7824 elf_x86_64_hash_symbol
7825 #define elf_backend_omit_section_dynsym \
7826 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
7827 #define elf_backend_fixup_symbol \
7828 elf_x86_64_fixup_symbol
7829 #define elf_backend_parse_gnu_properties \
7830 elf_x86_64_parse_gnu_properties
7831 #define elf_backend_merge_gnu_properties \
7832 elf_x86_64_merge_gnu_properties
7833 #define elf_backend_setup_gnu_properties \
7834 elf_x86_64_link_setup_gnu_properties
7836 #include "elf64-target.h"
7838 /* CloudABI support. */
7840 #undef TARGET_LITTLE_SYM
7841 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
7842 #undef TARGET_LITTLE_NAME
7843 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
7846 #define ELF_OSABI ELFOSABI_CLOUDABI
7849 #define elf64_bed elf64_x86_64_cloudabi_bed
7851 #include "elf64-target.h"
7853 /* FreeBSD support. */
7855 #undef TARGET_LITTLE_SYM
7856 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
7857 #undef TARGET_LITTLE_NAME
7858 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
7861 #define ELF_OSABI ELFOSABI_FREEBSD
7864 #define elf64_bed elf64_x86_64_fbsd_bed
7866 #include "elf64-target.h"
7868 /* Solaris 2 support. */
7870 #undef TARGET_LITTLE_SYM
7871 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
7872 #undef TARGET_LITTLE_NAME
7873 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
7875 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
7876 objects won't be recognized. */
7880 #define elf64_bed elf64_x86_64_sol2_bed
7882 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
7884 #undef elf_backend_static_tls_alignment
7885 #define elf_backend_static_tls_alignment 16
7887 /* The Solaris 2 ABI requires a plt symbol on all platforms.
7889 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
7891 #undef elf_backend_want_plt_sym
7892 #define elf_backend_want_plt_sym 1
7894 #undef elf_backend_strtab_flags
7895 #define elf_backend_strtab_flags SHF_STRINGS
7898 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
7899 bfd
*obfd ATTRIBUTE_UNUSED
,
7900 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
7901 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
7903 /* PR 19938: FIXME: Need to add code for setting the sh_info
7904 and sh_link fields of Solaris specific section types. */
7908 #undef elf_backend_copy_special_section_fields
7909 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
7911 #include "elf64-target.h"
7913 /* Native Client support. */
7916 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
7918 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
7919 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
7923 #undef TARGET_LITTLE_SYM
7924 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
7925 #undef TARGET_LITTLE_NAME
7926 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
7928 #define elf64_bed elf64_x86_64_nacl_bed
7930 #undef ELF_MAXPAGESIZE
7931 #undef ELF_MINPAGESIZE
7932 #undef ELF_COMMONPAGESIZE
7933 #define ELF_MAXPAGESIZE 0x10000
7934 #define ELF_MINPAGESIZE 0x10000
7935 #define ELF_COMMONPAGESIZE 0x10000
7937 /* Restore defaults. */
7939 #undef elf_backend_static_tls_alignment
7940 #undef elf_backend_want_plt_sym
7941 #define elf_backend_want_plt_sym 0
7942 #undef elf_backend_strtab_flags
7943 #undef elf_backend_copy_special_section_fields
7945 /* NaCl uses substantially different PLT entries for the same effects. */
7947 #undef elf_backend_plt_alignment
7948 #define elf_backend_plt_alignment 5
7949 #define NACL_PLT_ENTRY_SIZE 64
7950 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
7952 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
7954 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
7955 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
7956 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7957 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7958 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7960 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
7961 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
7963 /* 32 bytes of nop to pad out to the standard size. */
7964 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7965 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7966 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7967 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7968 0x66, /* excess data16 prefix */
7972 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
7974 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
7975 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7976 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7977 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7979 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
7980 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7981 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7983 /* Lazy GOT entries point here (32-byte aligned). */
7984 0x68, /* pushq immediate */
7985 0, 0, 0, 0, /* replaced with index into relocation table. */
7986 0xe9, /* jmp relative */
7987 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
7989 /* 22 bytes of nop to pad out to the standard size. */
7990 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7991 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7992 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
7995 /* .eh_frame covering the .plt section. */
7997 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
7999 #if (PLT_CIE_LENGTH != 20 \
8000 || PLT_FDE_LENGTH != 36 \
8001 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
8002 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
8003 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
8005 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
8006 0, 0, 0, 0, /* CIE ID */
8007 1, /* CIE version */
8008 'z', 'R', 0, /* Augmentation string */
8009 1, /* Code alignment factor */
8010 0x78, /* Data alignment factor */
8011 16, /* Return address column */
8012 1, /* Augmentation size */
8013 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
8014 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
8015 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
8016 DW_CFA_nop
, DW_CFA_nop
,
8018 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
8019 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
8020 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
8021 0, 0, 0, 0, /* .plt size goes here */
8022 0, /* Augmentation size */
8023 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
8024 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
8025 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
8026 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
8027 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
8028 13, /* Block length */
8029 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
8030 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
8031 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
8032 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
8033 DW_CFA_nop
, DW_CFA_nop
8036 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
=
8038 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
8039 elf_x86_64_nacl_plt_entry
, /* plt_entry */
8040 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
8041 2, /* plt0_got1_offset */
8042 9, /* plt0_got2_offset */
8043 13, /* plt0_got2_insn_end */
8044 3, /* plt_got_offset */
8045 33, /* plt_reloc_offset */
8046 38, /* plt_plt_offset */
8047 7, /* plt_got_insn_size */
8048 42, /* plt_plt_insn_end */
8049 32, /* plt_lazy_offset */
8050 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
8051 sizeof (elf_x86_64_nacl_eh_frame_plt
) /* eh_frame_plt_size */
8054 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
8059 #undef elf_backend_arch_data
8060 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
8062 #undef elf_backend_object_p
8063 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
8064 #undef elf_backend_modify_segment_map
8065 #define elf_backend_modify_segment_map nacl_modify_segment_map
8066 #undef elf_backend_modify_program_headers
8067 #define elf_backend_modify_program_headers nacl_modify_program_headers
8068 #undef elf_backend_final_write_processing
8069 #define elf_backend_final_write_processing nacl_final_write_processing
8071 #include "elf64-target.h"
8073 /* Native Client x32 support. */
8076 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
8078 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
8079 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
8083 #undef TARGET_LITTLE_SYM
8084 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
8085 #undef TARGET_LITTLE_NAME
8086 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
8088 #define elf32_bed elf32_x86_64_nacl_bed
8090 #define bfd_elf32_bfd_link_hash_table_create \
8091 elf_x86_64_link_hash_table_create
8092 #define bfd_elf32_bfd_reloc_type_lookup \
8093 elf_x86_64_reloc_type_lookup
8094 #define bfd_elf32_bfd_reloc_name_lookup \
8095 elf_x86_64_reloc_name_lookup
8096 #define bfd_elf32_mkobject \
8098 #define bfd_elf32_get_synthetic_symtab \
8099 elf_x86_64_get_synthetic_symtab
8100 #define bfd_elf32_bfd_link_check_relocs \
8101 elf_x86_64_link_check_relocs
8103 #undef elf_backend_object_p
8104 #define elf_backend_object_p \
8105 elf32_x86_64_nacl_elf_object_p
8107 #undef elf_backend_bfd_from_remote_memory
8108 #define elf_backend_bfd_from_remote_memory \
8109 _bfd_elf32_bfd_from_remote_memory
8111 #undef elf_backend_size_info
8112 #define elf_backend_size_info \
8113 _bfd_elf32_size_info
8115 #include "elf32-target.h"
8117 /* Restore defaults. */
8118 #undef elf_backend_object_p
8119 #define elf_backend_object_p elf64_x86_64_elf_object_p
8120 #undef elf_backend_bfd_from_remote_memory
8121 #undef elf_backend_size_info
8122 #undef elf_backend_modify_segment_map
8123 #undef elf_backend_modify_program_headers
8124 #undef elf_backend_final_write_processing
8126 /* Intel L1OM support. */
8129 elf64_l1om_elf_object_p (bfd
*abfd
)
8131 /* Set the right machine number for an L1OM elf64 file. */
8132 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
8136 #undef TARGET_LITTLE_SYM
8137 #define TARGET_LITTLE_SYM l1om_elf64_vec
8138 #undef TARGET_LITTLE_NAME
8139 #define TARGET_LITTLE_NAME "elf64-l1om"
8141 #define ELF_ARCH bfd_arch_l1om
8143 #undef ELF_MACHINE_CODE
8144 #define ELF_MACHINE_CODE EM_L1OM
8149 #define elf64_bed elf64_l1om_bed
8151 #undef elf_backend_object_p
8152 #define elf_backend_object_p elf64_l1om_elf_object_p
8154 /* Restore defaults. */
8155 #undef ELF_MAXPAGESIZE
8156 #undef ELF_MINPAGESIZE
8157 #undef ELF_COMMONPAGESIZE
8158 #define ELF_MAXPAGESIZE 0x200000
8159 #define ELF_MINPAGESIZE 0x1000
8160 #define ELF_COMMONPAGESIZE 0x1000
8161 #undef elf_backend_plt_alignment
8162 #define elf_backend_plt_alignment 4
8163 #undef elf_backend_arch_data
8164 #define elf_backend_arch_data &elf_x86_64_arch_bed
8166 #include "elf64-target.h"
8168 /* FreeBSD L1OM support. */
8170 #undef TARGET_LITTLE_SYM
8171 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
8172 #undef TARGET_LITTLE_NAME
8173 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
8176 #define ELF_OSABI ELFOSABI_FREEBSD
8179 #define elf64_bed elf64_l1om_fbsd_bed
8181 #include "elf64-target.h"
8183 /* Intel K1OM support. */
8186 elf64_k1om_elf_object_p (bfd
*abfd
)
8188 /* Set the right machine number for an K1OM elf64 file. */
8189 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
8193 #undef TARGET_LITTLE_SYM
8194 #define TARGET_LITTLE_SYM k1om_elf64_vec
8195 #undef TARGET_LITTLE_NAME
8196 #define TARGET_LITTLE_NAME "elf64-k1om"
8198 #define ELF_ARCH bfd_arch_k1om
8200 #undef ELF_MACHINE_CODE
8201 #define ELF_MACHINE_CODE EM_K1OM
8206 #define elf64_bed elf64_k1om_bed
8208 #undef elf_backend_object_p
8209 #define elf_backend_object_p elf64_k1om_elf_object_p
8211 #undef elf_backend_static_tls_alignment
8213 #undef elf_backend_want_plt_sym
8214 #define elf_backend_want_plt_sym 0
8216 #include "elf64-target.h"
8218 /* FreeBSD K1OM support. */
8220 #undef TARGET_LITTLE_SYM
8221 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
8222 #undef TARGET_LITTLE_NAME
8223 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
8226 #define ELF_OSABI ELFOSABI_FREEBSD
8229 #define elf64_bed elf64_k1om_fbsd_bed
8231 #include "elf64-target.h"
8233 /* 32bit x86-64 support. */
8235 #undef TARGET_LITTLE_SYM
8236 #define TARGET_LITTLE_SYM x86_64_elf32_vec
8237 #undef TARGET_LITTLE_NAME
8238 #define TARGET_LITTLE_NAME "elf32-x86-64"
8242 #define ELF_ARCH bfd_arch_i386
8244 #undef ELF_MACHINE_CODE
8245 #define ELF_MACHINE_CODE EM_X86_64
8249 #undef elf_backend_object_p
8250 #define elf_backend_object_p \
8251 elf32_x86_64_elf_object_p
8253 #undef elf_backend_bfd_from_remote_memory
8254 #define elf_backend_bfd_from_remote_memory \
8255 _bfd_elf32_bfd_from_remote_memory
8257 #undef elf_backend_size_info
8258 #define elf_backend_size_info \
8259 _bfd_elf32_size_info
8261 #include "elf32-target.h"