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 (bfd
*input_bfd
, asection
*sec
,
1884 struct elf_link_hash_entry
*h
,
1885 Elf_Internal_Shdr
*symtab_hdr
,
1886 Elf_Internal_Sym
*isym
,
1887 reloc_howto_type
*howto
)
1890 const char *und
= "";
1891 const char *pic
= "";
1896 name
= h
->root
.root
.string
;
1897 switch (ELF_ST_VISIBILITY (h
->other
))
1900 v
= _("hidden symbol ");
1903 v
= _("internal symbol ");
1906 v
= _("protected symbol ");
1910 pic
= _("; recompile with -fPIC");
1914 if (!h
->def_regular
&& !h
->def_dynamic
)
1915 und
= _("undefined ");
1919 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1920 pic
= _("; recompile with -fPIC");
1923 /* xgettext:c-format */
1924 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1925 "not be used when making a shared object%s"),
1926 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1927 bfd_set_error (bfd_error_bad_value
);
1928 sec
->check_relocs_failed
= 1;
1932 /* With the local symbol, foo, we convert
1933 mov foo@GOTPCREL(%rip), %reg
1937 call/jmp *foo@GOTPCREL(%rip)
1939 nop call foo/jmp foo nop
1940 When PIC is false, convert
1941 test %reg, foo@GOTPCREL(%rip)
1945 binop foo@GOTPCREL(%rip), %reg
1948 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1952 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1954 Elf_Internal_Rela
*irel
,
1955 struct elf_link_hash_entry
*h
,
1956 bfd_boolean
*converted
,
1957 struct bfd_link_info
*link_info
)
1959 struct elf_x86_64_link_hash_table
*htab
;
1961 bfd_boolean require_reloc_pc32
;
1963 bfd_boolean to_reloc_pc32
;
1966 bfd_signed_vma raddend
;
1967 unsigned int opcode
;
1969 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1970 unsigned int r_symndx
;
1972 bfd_vma roff
= irel
->r_offset
;
1974 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1977 raddend
= irel
->r_addend
;
1978 /* Addend for 32-bit PC-relative relocation must be -4. */
1982 htab
= elf_x86_64_hash_table (link_info
);
1983 is_pic
= bfd_link_pic (link_info
);
1985 relocx
= (r_type
== R_X86_64_GOTPCRELX
1986 || r_type
== R_X86_64_REX_GOTPCRELX
);
1988 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1991 = link_info
->disable_target_specific_optimizations
> 1;
1993 r_symndx
= htab
->r_sym (irel
->r_info
);
1995 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1997 /* Convert mov to lea since it has been done for a while. */
2000 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
2001 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
2002 test, xor instructions. */
2007 /* We convert only to R_X86_64_PC32:
2009 2. R_X86_64_GOTPCREL since we can't modify REX byte.
2010 3. require_reloc_pc32 is true.
2013 to_reloc_pc32
= (opcode
== 0xff
2015 || require_reloc_pc32
2018 /* Get the symbol referred to by the reloc. */
2021 Elf_Internal_Sym
*isym
2022 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
2024 /* Skip relocation against undefined symbols. */
2025 if (isym
->st_shndx
== SHN_UNDEF
)
2028 symtype
= ELF_ST_TYPE (isym
->st_info
);
2030 if (isym
->st_shndx
== SHN_ABS
)
2031 tsec
= bfd_abs_section_ptr
;
2032 else if (isym
->st_shndx
== SHN_COMMON
)
2033 tsec
= bfd_com_section_ptr
;
2034 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
2035 tsec
= &_bfd_elf_large_com_section
;
2037 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2039 toff
= isym
->st_value
;
2043 /* Undefined weak symbol is only bound locally in executable
2044 and its reference is resolved as 0 without relocation
2045 overflow. We can only perform this optimization for
2046 GOTPCRELX relocations since we need to modify REX byte.
2047 It is OK convert mov with R_X86_64_GOTPCREL to
2049 if ((relocx
|| opcode
== 0x8b)
2050 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
2052 elf_x86_64_hash_entry (h
)))
2056 /* Skip for branch instructions since R_X86_64_PC32
2058 if (require_reloc_pc32
)
2063 /* For non-branch instructions, we can convert to
2064 R_X86_64_32/R_X86_64_32S since we know if there
2066 to_reloc_pc32
= FALSE
;
2069 /* Since we don't know the current PC when PIC is true,
2070 we can't convert to R_X86_64_PC32. */
2071 if (to_reloc_pc32
&& is_pic
)
2076 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
2077 ld.so may use its link-time address. */
2078 else if (h
->start_stop
2080 || h
->root
.type
== bfd_link_hash_defined
2081 || h
->root
.type
== bfd_link_hash_defweak
)
2082 && h
!= htab
->elf
.hdynamic
2083 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)))
2085 /* bfd_link_hash_new or bfd_link_hash_undefined is
2086 set by an assignment in a linker script in
2087 bfd_elf_record_link_assignment. start_stop is set
2088 on __start_SECNAME/__stop_SECNAME which mark section
2092 && (h
->root
.type
== bfd_link_hash_new
2093 || h
->root
.type
== bfd_link_hash_undefined
2094 || ((h
->root
.type
== bfd_link_hash_defined
2095 || h
->root
.type
== bfd_link_hash_defweak
)
2096 && h
->root
.u
.def
.section
== bfd_und_section_ptr
))))
2098 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
2099 if (require_reloc_pc32
)
2103 tsec
= h
->root
.u
.def
.section
;
2104 toff
= h
->root
.u
.def
.value
;
2111 /* Don't convert GOTPCREL relocation against large section. */
2112 if (elf_section_data (tsec
) != NULL
2113 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
2116 /* We can only estimate relocation overflow for R_X86_64_PC32. */
2120 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
2122 /* At this stage in linking, no SEC_MERGE symbol has been
2123 adjusted, so all references to such symbols need to be
2124 passed through _bfd_merged_section_offset. (Later, in
2125 relocate_section, all SEC_MERGE symbols *except* for
2126 section symbols have been adjusted.)
2128 gas may reduce relocations against symbols in SEC_MERGE
2129 sections to a relocation against the section symbol when
2130 the original addend was zero. When the reloc is against
2131 a section symbol we should include the addend in the
2132 offset passed to _bfd_merged_section_offset, since the
2133 location of interest is the original symbol. On the
2134 other hand, an access to "sym+addend" where "sym" is not
2135 a section symbol should not include the addend; Such an
2136 access is presumed to be an offset from "sym"; The
2137 location of interest is just "sym". */
2138 if (symtype
== STT_SECTION
)
2141 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
2142 elf_section_data (tsec
)->sec_info
,
2145 if (symtype
!= STT_SECTION
)
2151 /* Don't convert if R_X86_64_PC32 relocation overflows. */
2152 if (tsec
->output_section
== sec
->output_section
)
2154 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
2159 bfd_signed_vma distance
;
2161 /* At this point, we don't know the load addresses of TSEC
2162 section nor SEC section. We estimate the distrance between
2163 SEC and TSEC. We store the estimated distances in the
2164 compressed_size field of the output section, which is only
2165 used to decompress the compressed input section. */
2166 if (sec
->output_section
->compressed_size
== 0)
2169 bfd_size_type size
= 0;
2170 for (asect
= link_info
->output_bfd
->sections
;
2172 asect
= asect
->next
)
2173 /* Skip debug sections since compressed_size is used to
2174 compress debug sections. */
2175 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
2178 for (i
= asect
->map_head
.s
;
2182 size
= align_power (size
, i
->alignment_power
);
2185 asect
->compressed_size
= size
;
2189 /* Don't convert GOTPCREL relocations if TSEC isn't placed
2191 distance
= (tsec
->output_section
->compressed_size
2192 - sec
->output_section
->compressed_size
);
2196 /* Take PT_GNU_RELRO segment into account by adding
2198 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
2199 - roff
+ 0x80000000) > 0xffffffff)
2206 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
2211 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
2213 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2216 /* Convert to "jmp foo nop". */
2219 nop_offset
= irel
->r_offset
+ 3;
2220 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2221 irel
->r_offset
-= 1;
2222 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2226 struct elf_x86_64_link_hash_entry
*eh
2227 = (struct elf_x86_64_link_hash_entry
*) h
;
2229 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2232 /* To support TLS optimization, always use addr32 prefix for
2233 "call *__tls_get_addr@GOTPCREL(%rip)". */
2234 if (eh
&& eh
->tls_get_addr
)
2237 nop_offset
= irel
->r_offset
- 2;
2241 nop
= link_info
->call_nop_byte
;
2242 if (link_info
->call_nop_as_suffix
)
2244 nop_offset
= irel
->r_offset
+ 3;
2245 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2246 irel
->r_offset
-= 1;
2247 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2250 nop_offset
= irel
->r_offset
- 2;
2253 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2254 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2255 r_type
= R_X86_64_PC32
;
2260 unsigned int rex_mask
= REX_R
;
2262 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2263 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2271 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2272 "lea foo(%rip), %reg". */
2274 r_type
= R_X86_64_PC32
;
2278 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2279 "mov $foo, %reg". */
2281 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2282 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2283 if ((rex
& REX_W
) != 0
2284 && ABI_64_P (link_info
->output_bfd
))
2286 /* Keep the REX_W bit in REX byte for LP64. */
2287 r_type
= R_X86_64_32S
;
2288 goto rewrite_modrm_rex
;
2292 /* If the REX_W bit in REX byte isn't needed,
2293 use R_X86_64_32 and clear the W bit to avoid
2294 sign-extend imm32 to imm64. */
2295 r_type
= R_X86_64_32
;
2296 /* Clear the W bit in REX byte. */
2298 goto rewrite_modrm_rex
;
2304 /* R_X86_64_PC32 isn't supported. */
2308 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2311 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2312 "test $foo, %reg". */
2313 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2318 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2319 "binop $foo, %reg". */
2320 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2324 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2325 overflow when sign-extending imm32 to imm64. */
2326 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2329 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2333 /* Move the R bit to the B bit in REX byte. */
2334 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2335 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2338 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2342 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2345 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2352 /* Look through the relocs for a section during the first phase, and
2353 calculate needed space in the global offset table, procedure
2354 linkage table, and dynamic reloc sections. */
2357 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2359 const Elf_Internal_Rela
*relocs
)
2361 struct elf_x86_64_link_hash_table
*htab
;
2362 Elf_Internal_Shdr
*symtab_hdr
;
2363 struct elf_link_hash_entry
**sym_hashes
;
2364 const Elf_Internal_Rela
*rel
;
2365 const Elf_Internal_Rela
*rel_end
;
2369 if (bfd_link_relocatable (info
))
2372 /* Don't do anything special with non-loaded, non-alloced sections.
2373 In particular, any relocs in such sections should not affect GOT
2374 and PLT reference counting (ie. we don't allow them to create GOT
2375 or PLT entries), there's no possibility or desire to optimize TLS
2376 relocs, and there's not much point in propagating relocs to shared
2377 libs that the dynamic linker won't relocate. */
2378 if ((sec
->flags
& SEC_ALLOC
) == 0)
2381 BFD_ASSERT (is_x86_64_elf (abfd
));
2383 htab
= elf_x86_64_hash_table (info
);
2386 sec
->check_relocs_failed
= 1;
2390 /* Get the section contents. */
2391 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2392 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2393 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2395 sec
->check_relocs_failed
= 1;
2399 symtab_hdr
= &elf_symtab_hdr (abfd
);
2400 sym_hashes
= elf_sym_hashes (abfd
);
2404 rel_end
= relocs
+ sec
->reloc_count
;
2405 for (rel
= relocs
; rel
< rel_end
; rel
++)
2407 unsigned int r_type
;
2408 unsigned int r_symndx
;
2409 struct elf_link_hash_entry
*h
;
2410 struct elf_x86_64_link_hash_entry
*eh
;
2411 Elf_Internal_Sym
*isym
;
2413 bfd_boolean size_reloc
;
2415 r_symndx
= htab
->r_sym (rel
->r_info
);
2416 r_type
= ELF32_R_TYPE (rel
->r_info
);
2418 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2420 /* xgettext:c-format */
2421 _bfd_error_handler (_("%B: bad symbol index: %d"),
2426 if (r_symndx
< symtab_hdr
->sh_info
)
2428 /* A local symbol. */
2429 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2434 /* Check relocation against local STT_GNU_IFUNC symbol. */
2435 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2437 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2442 /* Fake a STT_GNU_IFUNC symbol. */
2443 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2445 h
->type
= STT_GNU_IFUNC
;
2448 h
->forced_local
= 1;
2449 h
->root
.type
= bfd_link_hash_defined
;
2457 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2458 while (h
->root
.type
== bfd_link_hash_indirect
2459 || h
->root
.type
== bfd_link_hash_warning
)
2460 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2463 /* Check invalid x32 relocations. */
2464 if (!ABI_64_P (abfd
))
2470 case R_X86_64_DTPOFF64
:
2471 case R_X86_64_TPOFF64
:
2473 case R_X86_64_GOTOFF64
:
2474 case R_X86_64_GOT64
:
2475 case R_X86_64_GOTPCREL64
:
2476 case R_X86_64_GOTPC64
:
2477 case R_X86_64_GOTPLT64
:
2478 case R_X86_64_PLTOFF64
:
2481 name
= h
->root
.root
.string
;
2483 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2486 /* xgettext:c-format */
2487 (_("%B: relocation %s against symbol `%s' isn't "
2488 "supported in x32 mode"), abfd
,
2489 x86_64_elf_howto_table
[r_type
].name
, name
);
2490 bfd_set_error (bfd_error_bad_value
);
2498 /* It is referenced by a non-shared object. */
2500 h
->root
.non_ir_ref_regular
= 1;
2502 if (h
->type
== STT_GNU_IFUNC
)
2503 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2504 |= elf_gnu_symbol_ifunc
;
2507 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2508 symtab_hdr
, sym_hashes
,
2509 &r_type
, GOT_UNKNOWN
,
2510 rel
, rel_end
, h
, r_symndx
, FALSE
))
2513 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2516 case R_X86_64_TLSLD
:
2517 htab
->tls_ld_got
.refcount
+= 1;
2520 case R_X86_64_TPOFF32
:
2521 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2522 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2523 &x86_64_elf_howto_table
[r_type
]);
2525 eh
->has_got_reloc
= 1;
2528 case R_X86_64_GOTTPOFF
:
2529 if (!bfd_link_executable (info
))
2530 info
->flags
|= DF_STATIC_TLS
;
2533 case R_X86_64_GOT32
:
2534 case R_X86_64_GOTPCREL
:
2535 case R_X86_64_GOTPCRELX
:
2536 case R_X86_64_REX_GOTPCRELX
:
2537 case R_X86_64_TLSGD
:
2538 case R_X86_64_GOT64
:
2539 case R_X86_64_GOTPCREL64
:
2540 case R_X86_64_GOTPLT64
:
2541 case R_X86_64_GOTPC32_TLSDESC
:
2542 case R_X86_64_TLSDESC_CALL
:
2543 /* This symbol requires a global offset table entry. */
2545 int tls_type
, old_tls_type
;
2549 default: tls_type
= GOT_NORMAL
; break;
2550 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2551 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2552 case R_X86_64_GOTPC32_TLSDESC
:
2553 case R_X86_64_TLSDESC_CALL
:
2554 tls_type
= GOT_TLS_GDESC
; break;
2559 h
->got
.refcount
+= 1;
2560 old_tls_type
= eh
->tls_type
;
2564 bfd_signed_vma
*local_got_refcounts
;
2566 /* This is a global offset table entry for a local symbol. */
2567 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2568 if (local_got_refcounts
== NULL
)
2572 size
= symtab_hdr
->sh_info
;
2573 size
*= sizeof (bfd_signed_vma
)
2574 + sizeof (bfd_vma
) + sizeof (char);
2575 local_got_refcounts
= ((bfd_signed_vma
*)
2576 bfd_zalloc (abfd
, size
));
2577 if (local_got_refcounts
== NULL
)
2579 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2580 elf_x86_64_local_tlsdesc_gotent (abfd
)
2581 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2582 elf_x86_64_local_got_tls_type (abfd
)
2583 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2585 local_got_refcounts
[r_symndx
] += 1;
2587 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2590 /* If a TLS symbol is accessed using IE at least once,
2591 there is no point to use dynamic model for it. */
2592 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2593 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2594 || tls_type
!= GOT_TLS_IE
))
2596 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2597 tls_type
= old_tls_type
;
2598 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2599 && GOT_TLS_GD_ANY_P (tls_type
))
2600 tls_type
|= old_tls_type
;
2604 name
= h
->root
.root
.string
;
2606 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2609 /* xgettext:c-format */
2610 (_("%B: '%s' accessed both as normal and"
2611 " thread local symbol"),
2613 bfd_set_error (bfd_error_bad_value
);
2618 if (old_tls_type
!= tls_type
)
2621 eh
->tls_type
= tls_type
;
2623 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2628 case R_X86_64_GOTOFF64
:
2629 case R_X86_64_GOTPC32
:
2630 case R_X86_64_GOTPC64
:
2633 eh
->has_got_reloc
= 1;
2636 case R_X86_64_PLT32
:
2637 case R_X86_64_PLT32_BND
:
2638 /* This symbol requires a procedure linkage table entry. We
2639 actually build the entry in adjust_dynamic_symbol,
2640 because this might be a case of linking PIC code which is
2641 never referenced by a dynamic object, in which case we
2642 don't need to generate a procedure linkage table entry
2645 /* If this is a local symbol, we resolve it directly without
2646 creating a procedure linkage table entry. */
2650 eh
->has_got_reloc
= 1;
2652 h
->plt
.refcount
+= 1;
2655 case R_X86_64_PLTOFF64
:
2656 /* This tries to form the 'address' of a function relative
2657 to GOT. For global symbols we need a PLT entry. */
2661 h
->plt
.refcount
+= 1;
2665 case R_X86_64_SIZE32
:
2666 case R_X86_64_SIZE64
:
2671 if (!ABI_64_P (abfd
))
2677 /* Check relocation overflow as these relocs may lead to
2678 run-time relocation overflow. Don't error out for
2679 sections we don't care about, such as debug sections or
2680 when relocation overflow check is disabled. */
2681 if (!info
->no_reloc_overflow_check
2682 && (bfd_link_pic (info
)
2683 || (bfd_link_executable (info
)
2687 && (sec
->flags
& SEC_READONLY
) == 0)))
2688 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2689 &x86_64_elf_howto_table
[r_type
]);
2695 case R_X86_64_PC32_BND
:
2699 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2700 eh
->has_non_got_reloc
= 1;
2701 /* We are called after all symbols have been resolved. Only
2702 relocation against STT_GNU_IFUNC symbol must go through
2705 && (bfd_link_executable (info
)
2706 || h
->type
== STT_GNU_IFUNC
))
2708 /* If this reloc is in a read-only section, we might
2709 need a copy reloc. We can't check reliably at this
2710 stage whether the section is read-only, as input
2711 sections have not yet been mapped to output sections.
2712 Tentatively set the flag for now, and correct in
2713 adjust_dynamic_symbol. */
2716 /* We may need a .plt entry if the symbol is a function
2717 defined in a shared lib or is a STT_GNU_IFUNC function
2718 referenced from the code or read-only section. */
2719 if ((h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
)
2721 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0))
2722 h
->plt
.refcount
+= 1;
2724 if (r_type
== R_X86_64_PC32
)
2726 /* Since something like ".long foo - ." may be used
2727 as pointer, make sure that PLT is used if foo is
2728 a function defined in a shared library. */
2729 if ((sec
->flags
& SEC_CODE
) == 0)
2730 h
->pointer_equality_needed
= 1;
2732 else if (r_type
!= R_X86_64_PC32_BND
2733 && r_type
!= R_X86_64_PC64
)
2735 h
->pointer_equality_needed
= 1;
2736 /* At run-time, R_X86_64_64 can be resolved for both
2737 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2738 can only be resolved for x32. */
2739 if ((sec
->flags
& SEC_READONLY
) == 0
2740 && (r_type
== R_X86_64_64
2741 || (!ABI_64_P (abfd
)
2742 && (r_type
== R_X86_64_32
2743 || r_type
== R_X86_64_32S
))))
2744 eh
->func_pointer_refcount
+= 1;
2750 /* If we are creating a shared library, and this is a reloc
2751 against a global symbol, or a non PC relative reloc
2752 against a local symbol, then we need to copy the reloc
2753 into the shared library. However, if we are linking with
2754 -Bsymbolic, we do not need to copy a reloc against a
2755 global symbol which is defined in an object we are
2756 including in the link (i.e., DEF_REGULAR is set). At
2757 this point we have not seen all the input files, so it is
2758 possible that DEF_REGULAR is not set now but will be set
2759 later (it is never cleared). In case of a weak definition,
2760 DEF_REGULAR may be cleared later by a strong definition in
2761 a shared library. We account for that possibility below by
2762 storing information in the relocs_copied field of the hash
2763 table entry. A similar situation occurs when creating
2764 shared libraries and symbol visibility changes render the
2767 If on the other hand, we are creating an executable, we
2768 may need to keep relocations for symbols satisfied by a
2769 dynamic library if we manage to avoid copy relocs for the
2772 Generate dynamic pointer relocation against STT_GNU_IFUNC
2773 symbol in the non-code section. */
2774 if ((bfd_link_pic (info
)
2775 && (! IS_X86_64_PCREL_TYPE (r_type
)
2777 && (! (bfd_link_pie (info
)
2778 || SYMBOLIC_BIND (info
, h
))
2779 || h
->root
.type
== bfd_link_hash_defweak
2780 || !h
->def_regular
))))
2782 && h
->type
== STT_GNU_IFUNC
2783 && r_type
== htab
->pointer_r_type
2784 && (sec
->flags
& SEC_CODE
) == 0)
2785 || (ELIMINATE_COPY_RELOCS
2786 && !bfd_link_pic (info
)
2788 && (h
->root
.type
== bfd_link_hash_defweak
2789 || !h
->def_regular
)))
2791 struct elf_dyn_relocs
*p
;
2792 struct elf_dyn_relocs
**head
;
2794 /* We must copy these reloc types into the output file.
2795 Create a reloc section in dynobj and make room for
2799 sreloc
= _bfd_elf_make_dynamic_reloc_section
2800 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2801 abfd
, /*rela?*/ TRUE
);
2807 /* If this is a global symbol, we count the number of
2808 relocations we need for this symbol. */
2810 head
= &eh
->dyn_relocs
;
2813 /* Track dynamic relocs needed for local syms too.
2814 We really need local syms available to do this
2819 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2824 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2828 /* Beware of type punned pointers vs strict aliasing
2830 vpp
= &(elf_section_data (s
)->local_dynrel
);
2831 head
= (struct elf_dyn_relocs
**)vpp
;
2835 if (p
== NULL
|| p
->sec
!= sec
)
2837 bfd_size_type amt
= sizeof *p
;
2839 p
= ((struct elf_dyn_relocs
*)
2840 bfd_alloc (htab
->elf
.dynobj
, amt
));
2851 /* Count size relocation as PC-relative relocation. */
2852 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2857 /* This relocation describes the C++ object vtable hierarchy.
2858 Reconstruct it for later use during GC. */
2859 case R_X86_64_GNU_VTINHERIT
:
2860 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2864 /* This relocation describes which C++ vtable entries are actually
2865 used. Record for later use during GC. */
2866 case R_X86_64_GNU_VTENTRY
:
2867 BFD_ASSERT (h
!= NULL
);
2869 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2877 if ((r_type
== R_X86_64_GOTPCREL
2878 || r_type
== R_X86_64_GOTPCRELX
2879 || r_type
== R_X86_64_REX_GOTPCRELX
)
2880 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2881 sec
->need_convert_load
= 1;
2884 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2886 if (!info
->keep_memory
)
2890 /* Cache the section contents for elf_link_input_bfd. */
2891 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2898 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2900 sec
->check_relocs_failed
= 1;
2904 /* Return the section that should be marked against GC for a given
2908 elf_x86_64_gc_mark_hook (asection
*sec
,
2909 struct bfd_link_info
*info
,
2910 Elf_Internal_Rela
*rel
,
2911 struct elf_link_hash_entry
*h
,
2912 Elf_Internal_Sym
*sym
)
2915 switch (ELF32_R_TYPE (rel
->r_info
))
2917 case R_X86_64_GNU_VTINHERIT
:
2918 case R_X86_64_GNU_VTENTRY
:
2922 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2925 /* Remove undefined weak symbol from the dynamic symbol table if it
2926 is resolved to 0. */
2929 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2930 struct elf_link_hash_entry
*h
)
2932 if (h
->dynindx
!= -1
2933 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2934 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2935 elf_x86_64_hash_entry (h
)))
2938 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2944 /* Adjust a symbol defined by a dynamic object and referenced by a
2945 regular object. The current definition is in some section of the
2946 dynamic object, but we're not including those sections. We have to
2947 change the definition to something the rest of the link can
2951 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2952 struct elf_link_hash_entry
*h
)
2954 struct elf_x86_64_link_hash_table
*htab
;
2956 struct elf_x86_64_link_hash_entry
*eh
;
2957 struct elf_dyn_relocs
*p
;
2959 /* STT_GNU_IFUNC symbol must go through PLT. */
2960 if (h
->type
== STT_GNU_IFUNC
)
2962 /* All local STT_GNU_IFUNC references must be treate as local
2963 calls via local PLT. */
2965 && SYMBOL_CALLS_LOCAL (info
, h
))
2967 bfd_size_type pc_count
= 0, count
= 0;
2968 struct elf_dyn_relocs
**pp
;
2970 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2971 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2973 pc_count
+= p
->pc_count
;
2974 p
->count
-= p
->pc_count
;
2983 if (pc_count
|| count
)
2988 /* Increment PLT reference count only for PC-relative
2991 if (h
->plt
.refcount
<= 0)
2992 h
->plt
.refcount
= 1;
2994 h
->plt
.refcount
+= 1;
2999 if (h
->plt
.refcount
<= 0)
3001 h
->plt
.offset
= (bfd_vma
) -1;
3007 /* If this is a function, put it in the procedure linkage table. We
3008 will fill in the contents of the procedure linkage table later,
3009 when we know the address of the .got section. */
3010 if (h
->type
== STT_FUNC
3013 if (h
->plt
.refcount
<= 0
3014 || SYMBOL_CALLS_LOCAL (info
, h
)
3015 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3016 && h
->root
.type
== bfd_link_hash_undefweak
))
3018 /* This case can occur if we saw a PLT32 reloc in an input
3019 file, but the symbol was never referred to by a dynamic
3020 object, or if all references were garbage collected. In
3021 such a case, we don't actually need to build a procedure
3022 linkage table, and we can just do a PC32 reloc instead. */
3023 h
->plt
.offset
= (bfd_vma
) -1;
3030 /* It's possible that we incorrectly decided a .plt reloc was
3031 needed for an R_X86_64_PC32 reloc to a non-function sym in
3032 check_relocs. We can't decide accurately between function and
3033 non-function syms in check-relocs; Objects loaded later in
3034 the link may change h->type. So fix it now. */
3035 h
->plt
.offset
= (bfd_vma
) -1;
3037 /* If this is a weak symbol, and there is a real definition, the
3038 processor independent code will have arranged for us to see the
3039 real definition first, and we can just use the same value. */
3040 if (h
->u
.weakdef
!= NULL
)
3042 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3043 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3044 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3045 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3046 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
3048 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3049 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
3050 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
3055 /* This is a reference to a symbol defined by a dynamic object which
3056 is not a function. */
3058 /* If we are creating a shared library, we must presume that the
3059 only references to the symbol are via the global offset table.
3060 For such cases we need not do anything here; the relocations will
3061 be handled correctly by relocate_section. */
3062 if (!bfd_link_executable (info
))
3065 /* If there are no references to this symbol that do not use the
3066 GOT, we don't need to generate a copy reloc. */
3067 if (!h
->non_got_ref
)
3070 /* If -z nocopyreloc was given, we won't generate them either. */
3071 if (info
->nocopyreloc
)
3077 if (ELIMINATE_COPY_RELOCS
)
3079 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3080 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3082 s
= p
->sec
->output_section
;
3083 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3087 /* If we didn't find any dynamic relocs in read-only sections, then
3088 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
3096 /* We must allocate the symbol in our .dynbss section, which will
3097 become part of the .bss section of the executable. There will be
3098 an entry for this symbol in the .dynsym section. The dynamic
3099 object will contain position independent code, so all references
3100 from the dynamic object to this symbol will go through the global
3101 offset table. The dynamic linker will use the .dynsym entry to
3102 determine the address it must put in the global offset table, so
3103 both the dynamic object and the regular object will refer to the
3104 same memory location for the variable. */
3106 htab
= elf_x86_64_hash_table (info
);
3110 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
3111 to copy the initial value out of the dynamic object and into the
3112 runtime process image. */
3113 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
3115 s
= htab
->elf
.sdynrelro
;
3116 srel
= htab
->elf
.sreldynrelro
;
3120 s
= htab
->elf
.sdynbss
;
3121 srel
= htab
->elf
.srelbss
;
3123 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
3125 const struct elf_backend_data
*bed
;
3126 bed
= get_elf_backend_data (info
->output_bfd
);
3127 srel
->size
+= bed
->s
->sizeof_rela
;
3131 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
3134 /* Allocate space in .plt, .got and associated reloc sections for
3138 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3140 struct bfd_link_info
*info
;
3141 struct elf_x86_64_link_hash_table
*htab
;
3142 struct elf_x86_64_link_hash_entry
*eh
;
3143 struct elf_dyn_relocs
*p
;
3144 const struct elf_backend_data
*bed
;
3145 unsigned int plt_entry_size
;
3146 bfd_boolean resolved_to_zero
;
3148 if (h
->root
.type
== bfd_link_hash_indirect
)
3151 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3153 info
= (struct bfd_link_info
*) inf
;
3154 htab
= elf_x86_64_hash_table (info
);
3157 bed
= get_elf_backend_data (info
->output_bfd
);
3158 plt_entry_size
= htab
->plt
.plt_entry_size
;
3160 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3164 /* We can't use the GOT PLT if pointer equality is needed since
3165 finish_dynamic_symbol won't clear symbol value and the dynamic
3166 linker won't update the GOT slot. We will get into an infinite
3167 loop at run-time. */
3168 if (htab
->plt_got
!= NULL
3169 && h
->type
!= STT_GNU_IFUNC
3170 && !h
->pointer_equality_needed
3171 && h
->plt
.refcount
> 0
3172 && h
->got
.refcount
> 0)
3174 /* Don't use the regular PLT if there are both GOT and GOTPLT
3176 h
->plt
.offset
= (bfd_vma
) -1;
3178 /* Use the GOT PLT. */
3179 eh
->plt_got
.refcount
= 1;
3182 /* Clear the reference count of function pointer relocations if
3183 symbol isn't a normal function. */
3184 if (h
->type
!= STT_FUNC
)
3185 eh
->func_pointer_refcount
= 0;
3187 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3188 here if it is defined and referenced in a non-shared object. */
3189 if (h
->type
== STT_GNU_IFUNC
3192 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3194 &htab
->readonly_dynrelocs_against_ifunc
,
3198 GOT_ENTRY_SIZE
, TRUE
))
3200 asection
*s
= htab
->plt_second
;
3201 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3203 /* Use the second PLT section if it is created. */
3204 eh
->plt_second
.offset
= s
->size
;
3206 /* Make room for this entry in the second PLT section. */
3207 s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3215 /* Don't create the PLT entry if there are only function pointer
3216 relocations which can be resolved at run-time. */
3217 else if (htab
->elf
.dynamic_sections_created
3218 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3219 || eh
->plt_got
.refcount
> 0))
3221 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
3223 /* Clear the reference count of function pointer relocations
3225 eh
->func_pointer_refcount
= 0;
3227 /* Make sure this symbol is output as a dynamic symbol.
3228 Undefined weak syms won't yet be marked as dynamic. */
3229 if (h
->dynindx
== -1
3231 && !resolved_to_zero
3232 && h
->root
.type
== bfd_link_hash_undefweak
)
3234 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3238 if (bfd_link_pic (info
)
3239 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3241 asection
*s
= htab
->elf
.splt
;
3242 asection
*second_s
= htab
->plt_second
;
3243 asection
*got_s
= htab
->plt_got
;
3245 /* If this is the first .plt entry, make room for the special
3246 first entry. The .plt section is used by prelink to undo
3247 prelinking for dynamic relocations. */
3249 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
3252 eh
->plt_got
.offset
= got_s
->size
;
3255 h
->plt
.offset
= s
->size
;
3257 eh
->plt_second
.offset
= second_s
->size
;
3260 /* If this symbol is not defined in a regular file, and we are
3261 not generating a shared library, then set the symbol to this
3262 location in the .plt. This is required to make function
3263 pointers compare as equal between the normal executable and
3264 the shared library. */
3265 if (! bfd_link_pic (info
)
3270 /* We need to make a call to the entry of the GOT PLT
3271 instead of regular PLT entry. */
3272 h
->root
.u
.def
.section
= got_s
;
3273 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3279 /* We need to make a call to the entry of the
3280 second PLT instead of regular PLT entry. */
3281 h
->root
.u
.def
.section
= second_s
;
3282 h
->root
.u
.def
.value
= eh
->plt_second
.offset
;
3286 h
->root
.u
.def
.section
= s
;
3287 h
->root
.u
.def
.value
= h
->plt
.offset
;
3292 /* Make room for this entry. */
3294 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3297 s
->size
+= plt_entry_size
;
3299 second_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
3301 /* We also need to make an entry in the .got.plt section,
3302 which will be placed in the .got section by the linker
3304 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3306 /* There should be no PLT relocation against resolved
3307 undefined weak symbol in executable. */
3308 if (!resolved_to_zero
)
3310 /* We also need to make an entry in the .rela.plt
3312 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3313 htab
->elf
.srelplt
->reloc_count
++;
3319 eh
->plt_got
.offset
= (bfd_vma
) -1;
3320 h
->plt
.offset
= (bfd_vma
) -1;
3326 eh
->plt_got
.offset
= (bfd_vma
) -1;
3327 h
->plt
.offset
= (bfd_vma
) -1;
3331 eh
->tlsdesc_got
= (bfd_vma
) -1;
3333 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3334 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3335 if (h
->got
.refcount
> 0
3336 && bfd_link_executable (info
)
3338 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3340 h
->got
.offset
= (bfd_vma
) -1;
3342 else if (h
->got
.refcount
> 0)
3346 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3348 /* Make sure this symbol is output as a dynamic symbol.
3349 Undefined weak syms won't yet be marked as dynamic. */
3350 if (h
->dynindx
== -1
3352 && !resolved_to_zero
3353 && h
->root
.type
== bfd_link_hash_undefweak
)
3355 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3359 if (GOT_TLS_GDESC_P (tls_type
))
3361 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3362 - elf_x86_64_compute_jump_table_size (htab
);
3363 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3364 h
->got
.offset
= (bfd_vma
) -2;
3366 if (! GOT_TLS_GDESC_P (tls_type
)
3367 || GOT_TLS_GD_P (tls_type
))
3370 h
->got
.offset
= s
->size
;
3371 s
->size
+= GOT_ENTRY_SIZE
;
3372 if (GOT_TLS_GD_P (tls_type
))
3373 s
->size
+= GOT_ENTRY_SIZE
;
3375 dyn
= htab
->elf
.dynamic_sections_created
;
3376 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3377 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3378 relocation. No dynamic relocation against resolved undefined
3379 weak symbol in executable. */
3380 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3381 || tls_type
== GOT_TLS_IE
)
3382 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3383 else if (GOT_TLS_GD_P (tls_type
))
3384 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3385 else if (! GOT_TLS_GDESC_P (tls_type
)
3386 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3387 && !resolved_to_zero
)
3388 || h
->root
.type
!= bfd_link_hash_undefweak
)
3389 && (bfd_link_pic (info
)
3390 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3391 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3392 if (GOT_TLS_GDESC_P (tls_type
))
3394 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3395 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3399 h
->got
.offset
= (bfd_vma
) -1;
3401 if (eh
->dyn_relocs
== NULL
)
3404 /* In the shared -Bsymbolic case, discard space allocated for
3405 dynamic pc-relative relocs against symbols which turn out to be
3406 defined in regular objects. For the normal shared case, discard
3407 space for pc-relative relocs that have become local due to symbol
3408 visibility changes. */
3410 if (bfd_link_pic (info
))
3412 /* Relocs that use pc_count are those that appear on a call
3413 insn, or certain REL relocs that can generated via assembly.
3414 We want calls to protected symbols to resolve directly to the
3415 function rather than going via the plt. If people want
3416 function pointer comparisons to work as expected then they
3417 should avoid writing weird assembly. */
3418 if (SYMBOL_CALLS_LOCAL (info
, h
))
3420 struct elf_dyn_relocs
**pp
;
3422 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3424 p
->count
-= p
->pc_count
;
3433 /* Also discard relocs on undefined weak syms with non-default
3434 visibility or in PIE. */
3435 if (eh
->dyn_relocs
!= NULL
)
3437 if (h
->root
.type
== bfd_link_hash_undefweak
)
3439 /* Undefined weak symbol is never bound locally in shared
3441 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3442 || resolved_to_zero
)
3443 eh
->dyn_relocs
= NULL
;
3444 else if (h
->dynindx
== -1
3445 && ! h
->forced_local
3446 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3449 /* For PIE, discard space for pc-relative relocs against
3450 symbols which turn out to need copy relocs. */
3451 else if (bfd_link_executable (info
)
3452 && (h
->needs_copy
|| eh
->needs_copy
)
3456 struct elf_dyn_relocs
**pp
;
3458 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3460 if (p
->pc_count
!= 0)
3468 else if (ELIMINATE_COPY_RELOCS
)
3470 /* For the non-shared case, discard space for relocs against
3471 symbols which turn out to need copy relocs or are not
3472 dynamic. Keep dynamic relocations for run-time function
3473 pointer initialization. */
3475 if ((!h
->non_got_ref
3476 || eh
->func_pointer_refcount
> 0
3477 || (h
->root
.type
== bfd_link_hash_undefweak
3478 && !resolved_to_zero
))
3481 || (htab
->elf
.dynamic_sections_created
3482 && (h
->root
.type
== bfd_link_hash_undefweak
3483 || h
->root
.type
== bfd_link_hash_undefined
))))
3485 /* Make sure this symbol is output as a dynamic symbol.
3486 Undefined weak syms won't yet be marked as dynamic. */
3487 if (h
->dynindx
== -1
3488 && ! h
->forced_local
3489 && ! resolved_to_zero
3490 && h
->root
.type
== bfd_link_hash_undefweak
3491 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3494 /* If that succeeded, we know we'll be keeping all the
3496 if (h
->dynindx
!= -1)
3500 eh
->dyn_relocs
= NULL
;
3501 eh
->func_pointer_refcount
= 0;
3506 /* Finally, allocate space. */
3507 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3511 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3513 BFD_ASSERT (sreloc
!= NULL
);
3515 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3521 /* Allocate space in .plt, .got and associated reloc sections for
3522 local dynamic relocs. */
3525 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3527 struct elf_link_hash_entry
*h
3528 = (struct elf_link_hash_entry
*) *slot
;
3530 if (h
->type
!= STT_GNU_IFUNC
3534 || h
->root
.type
!= bfd_link_hash_defined
)
3537 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3540 /* Find any dynamic relocs that apply to read-only sections. */
3543 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3546 struct elf_x86_64_link_hash_entry
*eh
;
3547 struct elf_dyn_relocs
*p
;
3549 /* Skip local IFUNC symbols. */
3550 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3553 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3554 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3556 asection
*s
= p
->sec
->output_section
;
3558 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3560 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3562 info
->flags
|= DF_TEXTREL
;
3564 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3565 || info
->error_textrel
)
3566 /* xgettext:c-format */
3567 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3568 p
->sec
->owner
, h
->root
.root
.string
,
3571 /* Not an error, just cut short the traversal. */
3578 /* Convert load via the GOT slot to load immediate. */
3581 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3582 struct bfd_link_info
*link_info
)
3584 Elf_Internal_Shdr
*symtab_hdr
;
3585 Elf_Internal_Rela
*internal_relocs
;
3586 Elf_Internal_Rela
*irel
, *irelend
;
3588 struct elf_x86_64_link_hash_table
*htab
;
3589 bfd_boolean changed
;
3590 bfd_signed_vma
*local_got_refcounts
;
3592 /* Don't even try to convert non-ELF outputs. */
3593 if (!is_elf_hash_table (link_info
->hash
))
3596 /* Nothing to do if there is no need or no output. */
3597 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3598 || sec
->need_convert_load
== 0
3599 || bfd_is_abs_section (sec
->output_section
))
3602 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3604 /* Load the relocations for this section. */
3605 internal_relocs
= (_bfd_elf_link_read_relocs
3606 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3607 link_info
->keep_memory
));
3608 if (internal_relocs
== NULL
)
3612 htab
= elf_x86_64_hash_table (link_info
);
3613 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3615 /* Get the section contents. */
3616 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3617 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3620 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3624 irelend
= internal_relocs
+ sec
->reloc_count
;
3625 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3627 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3628 unsigned int r_symndx
;
3629 struct elf_link_hash_entry
*h
;
3630 bfd_boolean converted
;
3632 if (r_type
!= R_X86_64_GOTPCRELX
3633 && r_type
!= R_X86_64_REX_GOTPCRELX
3634 && r_type
!= R_X86_64_GOTPCREL
)
3637 r_symndx
= htab
->r_sym (irel
->r_info
);
3638 if (r_symndx
< symtab_hdr
->sh_info
)
3639 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3640 (const Elf_Internal_Rela
*) irel
,
3644 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3645 while (h
->root
.type
== bfd_link_hash_indirect
3646 || h
->root
.type
== bfd_link_hash_warning
)
3647 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3650 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3651 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3655 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3656 &converted
, link_info
))
3661 changed
= converted
;
3664 if (h
->got
.refcount
> 0)
3665 h
->got
.refcount
-= 1;
3669 if (local_got_refcounts
!= NULL
3670 && local_got_refcounts
[r_symndx
] > 0)
3671 local_got_refcounts
[r_symndx
] -= 1;
3676 if (contents
!= NULL
3677 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3679 if (!changed
&& !link_info
->keep_memory
)
3683 /* Cache the section contents for elf_link_input_bfd. */
3684 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3688 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3691 free (internal_relocs
);
3693 elf_section_data (sec
)->relocs
= internal_relocs
;
3699 if (contents
!= NULL
3700 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3702 if (internal_relocs
!= NULL
3703 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3704 free (internal_relocs
);
3708 /* Set the sizes of the dynamic sections. */
3711 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3712 struct bfd_link_info
*info
)
3714 struct elf_x86_64_link_hash_table
*htab
;
3719 const struct elf_backend_data
*bed
;
3721 htab
= elf_x86_64_hash_table (info
);
3724 bed
= get_elf_backend_data (output_bfd
);
3726 dynobj
= htab
->elf
.dynobj
;
3730 /* Set up .got offsets for local syms, and space for local dynamic
3732 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3734 bfd_signed_vma
*local_got
;
3735 bfd_signed_vma
*end_local_got
;
3736 char *local_tls_type
;
3737 bfd_vma
*local_tlsdesc_gotent
;
3738 bfd_size_type locsymcount
;
3739 Elf_Internal_Shdr
*symtab_hdr
;
3742 if (! is_x86_64_elf (ibfd
))
3745 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3747 struct elf_dyn_relocs
*p
;
3749 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3752 for (p
= (struct elf_dyn_relocs
*)
3753 (elf_section_data (s
)->local_dynrel
);
3757 if (!bfd_is_abs_section (p
->sec
)
3758 && bfd_is_abs_section (p
->sec
->output_section
))
3760 /* Input section has been discarded, either because
3761 it is a copy of a linkonce section or due to
3762 linker script /DISCARD/, so we'll be discarding
3765 else if (p
->count
!= 0)
3767 srel
= elf_section_data (p
->sec
)->sreloc
;
3768 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3769 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3770 && (info
->flags
& DF_TEXTREL
) == 0)
3772 info
->flags
|= DF_TEXTREL
;
3773 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3774 || info
->error_textrel
)
3775 /* xgettext:c-format */
3776 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3777 p
->sec
->owner
, p
->sec
);
3783 local_got
= elf_local_got_refcounts (ibfd
);
3787 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3788 locsymcount
= symtab_hdr
->sh_info
;
3789 end_local_got
= local_got
+ locsymcount
;
3790 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3791 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3793 srel
= htab
->elf
.srelgot
;
3794 for (; local_got
< end_local_got
;
3795 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3797 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3800 if (GOT_TLS_GDESC_P (*local_tls_type
))
3802 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3803 - elf_x86_64_compute_jump_table_size (htab
);
3804 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3805 *local_got
= (bfd_vma
) -2;
3807 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3808 || GOT_TLS_GD_P (*local_tls_type
))
3810 *local_got
= s
->size
;
3811 s
->size
+= GOT_ENTRY_SIZE
;
3812 if (GOT_TLS_GD_P (*local_tls_type
))
3813 s
->size
+= GOT_ENTRY_SIZE
;
3815 if (bfd_link_pic (info
)
3816 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3817 || *local_tls_type
== GOT_TLS_IE
)
3819 if (GOT_TLS_GDESC_P (*local_tls_type
))
3821 htab
->elf
.srelplt
->size
3822 += bed
->s
->sizeof_rela
;
3823 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3825 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3826 || GOT_TLS_GD_P (*local_tls_type
))
3827 srel
->size
+= bed
->s
->sizeof_rela
;
3831 *local_got
= (bfd_vma
) -1;
3835 if (htab
->tls_ld_got
.refcount
> 0)
3837 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3839 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3840 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3841 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3844 htab
->tls_ld_got
.offset
= -1;
3846 /* Allocate global sym .plt and .got entries, and space for global
3847 sym dynamic relocs. */
3848 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3851 /* Allocate .plt and .got entries, and space for local symbols. */
3852 htab_traverse (htab
->loc_hash_table
,
3853 elf_x86_64_allocate_local_dynrelocs
,
3856 /* For every jump slot reserved in the sgotplt, reloc_count is
3857 incremented. However, when we reserve space for TLS descriptors,
3858 it's not incremented, so in order to compute the space reserved
3859 for them, it suffices to multiply the reloc count by the jump
3862 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3863 so that R_X86_64_IRELATIVE entries come last. */
3864 if (htab
->elf
.srelplt
)
3866 htab
->sgotplt_jump_table_size
3867 = elf_x86_64_compute_jump_table_size (htab
);
3868 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3870 else if (htab
->elf
.irelplt
)
3871 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3873 if (htab
->tlsdesc_plt
)
3875 /* If we're not using lazy TLS relocations, don't generate the
3876 PLT and GOT entries they require. */
3877 if ((info
->flags
& DF_BIND_NOW
))
3878 htab
->tlsdesc_plt
= 0;
3881 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3882 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3883 /* Reserve room for the initial entry.
3884 FIXME: we could probably do away with it in this case. */
3885 if (htab
->elf
.splt
->size
== 0)
3886 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
3887 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3888 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
3892 if (htab
->elf
.sgotplt
)
3894 /* Don't allocate .got.plt section if there are no GOT nor PLT
3895 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3896 if ((htab
->elf
.hgot
== NULL
3897 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3898 && (htab
->elf
.sgotplt
->size
3899 == get_elf_backend_data (output_bfd
)->got_header_size
)
3900 && (htab
->elf
.splt
== NULL
3901 || htab
->elf
.splt
->size
== 0)
3902 && (htab
->elf
.sgot
== NULL
3903 || htab
->elf
.sgot
->size
== 0)
3904 && (htab
->elf
.iplt
== NULL
3905 || htab
->elf
.iplt
->size
== 0)
3906 && (htab
->elf
.igotplt
== NULL
3907 || htab
->elf
.igotplt
->size
== 0))
3908 htab
->elf
.sgotplt
->size
= 0;
3911 if (_bfd_elf_eh_frame_present (info
))
3913 if (htab
->plt_eh_frame
!= NULL
3914 && htab
->elf
.splt
!= NULL
3915 && htab
->elf
.splt
->size
!= 0
3916 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
3917 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
3919 if (htab
->plt_got_eh_frame
!= NULL
3920 && htab
->plt_got
!= NULL
3921 && htab
->plt_got
->size
!= 0
3922 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
3923 htab
->plt_got_eh_frame
->size
3924 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3926 /* Unwind info for the second PLT and .plt.got sections are
3928 if (htab
->plt_second_eh_frame
!= NULL
3929 && htab
->plt_second
!= NULL
3930 && htab
->plt_second
->size
!= 0
3931 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
3932 htab
->plt_second_eh_frame
->size
3933 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3936 /* We now have determined the sizes of the various dynamic sections.
3937 Allocate memory for them. */
3939 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3941 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3944 if (s
== htab
->elf
.splt
3945 || s
== htab
->elf
.sgot
3946 || s
== htab
->elf
.sgotplt
3947 || s
== htab
->elf
.iplt
3948 || s
== htab
->elf
.igotplt
3949 || s
== htab
->plt_second
3950 || s
== htab
->plt_got
3951 || s
== htab
->plt_eh_frame
3952 || s
== htab
->plt_got_eh_frame
3953 || s
== htab
->plt_second_eh_frame
3954 || s
== htab
->elf
.sdynbss
3955 || s
== htab
->elf
.sdynrelro
)
3957 /* Strip this section if we don't need it; see the
3960 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3962 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3965 /* We use the reloc_count field as a counter if we need
3966 to copy relocs into the output file. */
3967 if (s
!= htab
->elf
.srelplt
)
3972 /* It's not one of our sections, so don't allocate space. */
3978 /* If we don't need this section, strip it from the
3979 output file. This is mostly to handle .rela.bss and
3980 .rela.plt. We must create both sections in
3981 create_dynamic_sections, because they must be created
3982 before the linker maps input sections to output
3983 sections. The linker does that before
3984 adjust_dynamic_symbol is called, and it is that
3985 function which decides whether anything needs to go
3986 into these sections. */
3988 s
->flags
|= SEC_EXCLUDE
;
3992 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3995 /* Allocate memory for the section contents. We use bfd_zalloc
3996 here in case unused entries are not reclaimed before the
3997 section's contents are written out. This should not happen,
3998 but this way if it does, we get a R_X86_64_NONE reloc instead
4000 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
4001 if (s
->contents
== NULL
)
4005 if (htab
->plt_eh_frame
!= NULL
4006 && htab
->plt_eh_frame
->contents
!= NULL
)
4008 memcpy (htab
->plt_eh_frame
->contents
,
4009 htab
->plt
.eh_frame_plt
, htab
->plt_eh_frame
->size
);
4010 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
4011 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
4014 if (htab
->plt_got_eh_frame
!= NULL
4015 && htab
->plt_got_eh_frame
->contents
!= NULL
)
4017 memcpy (htab
->plt_got_eh_frame
->contents
,
4018 htab
->non_lazy_plt
->eh_frame_plt
,
4019 htab
->plt_got_eh_frame
->size
);
4020 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
4021 (htab
->plt_got_eh_frame
->contents
4022 + PLT_FDE_LEN_OFFSET
));
4025 if (htab
->plt_second_eh_frame
!= NULL
4026 && htab
->plt_second_eh_frame
->contents
!= NULL
)
4028 memcpy (htab
->plt_second_eh_frame
->contents
,
4029 htab
->non_lazy_plt
->eh_frame_plt
,
4030 htab
->plt_second_eh_frame
->size
);
4031 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
4032 (htab
->plt_second_eh_frame
->contents
4033 + PLT_FDE_LEN_OFFSET
));
4036 if (htab
->elf
.dynamic_sections_created
)
4038 /* Add some entries to the .dynamic section. We fill in the
4039 values later, in elf_x86_64_finish_dynamic_sections, but we
4040 must add the entries now so that we get the correct size for
4041 the .dynamic section. The DT_DEBUG entry is filled in by the
4042 dynamic linker and used by the debugger. */
4043 #define add_dynamic_entry(TAG, VAL) \
4044 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4046 if (bfd_link_executable (info
))
4048 if (!add_dynamic_entry (DT_DEBUG
, 0))
4052 if (htab
->elf
.splt
->size
!= 0)
4054 /* DT_PLTGOT is used by prelink even if there is no PLT
4056 if (!add_dynamic_entry (DT_PLTGOT
, 0))
4060 if (htab
->elf
.srelplt
->size
!= 0)
4062 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
4063 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
4064 || !add_dynamic_entry (DT_JMPREL
, 0))
4068 if (htab
->tlsdesc_plt
4069 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
4070 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
4075 if (!add_dynamic_entry (DT_RELA
, 0)
4076 || !add_dynamic_entry (DT_RELASZ
, 0)
4077 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
4080 /* If any dynamic relocs apply to a read-only section,
4081 then we need a DT_TEXTREL entry. */
4082 if ((info
->flags
& DF_TEXTREL
) == 0)
4083 elf_link_hash_traverse (&htab
->elf
,
4084 elf_x86_64_readonly_dynrelocs
,
4087 if ((info
->flags
& DF_TEXTREL
) != 0)
4089 if (htab
->readonly_dynrelocs_against_ifunc
)
4091 info
->callbacks
->einfo
4092 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
4093 bfd_set_error (bfd_error_bad_value
);
4097 if (!add_dynamic_entry (DT_TEXTREL
, 0))
4102 #undef add_dynamic_entry
4108 elf_x86_64_always_size_sections (bfd
*output_bfd
,
4109 struct bfd_link_info
*info
)
4111 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
4115 struct elf_link_hash_entry
*tlsbase
;
4117 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
4118 "_TLS_MODULE_BASE_",
4119 FALSE
, FALSE
, FALSE
);
4121 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
4123 struct elf_x86_64_link_hash_table
*htab
;
4124 struct bfd_link_hash_entry
*bh
= NULL
;
4125 const struct elf_backend_data
*bed
4126 = get_elf_backend_data (output_bfd
);
4128 htab
= elf_x86_64_hash_table (info
);
4132 if (!(_bfd_generic_link_add_one_symbol
4133 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
4134 tls_sec
, 0, NULL
, FALSE
,
4135 bed
->collect
, &bh
)))
4138 htab
->tls_module_base
= bh
;
4140 tlsbase
= (struct elf_link_hash_entry
*)bh
;
4141 tlsbase
->def_regular
= 1;
4142 tlsbase
->other
= STV_HIDDEN
;
4143 tlsbase
->root
.linker_def
= 1;
4144 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4151 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4152 executables. Rather than setting it to the beginning of the TLS
4153 section, we have to set it to the end. This function may be called
4154 multiple times, it is idempotent. */
4157 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4159 struct elf_x86_64_link_hash_table
*htab
;
4160 struct bfd_link_hash_entry
*base
;
4162 if (!bfd_link_executable (info
))
4165 htab
= elf_x86_64_hash_table (info
);
4169 base
= htab
->tls_module_base
;
4173 base
->u
.def
.value
= htab
->elf
.tls_size
;
4176 /* Return the base VMA address which should be subtracted from real addresses
4177 when resolving @dtpoff relocation.
4178 This is PT_TLS segment p_vaddr. */
4181 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4183 /* If tls_sec is NULL, we should have signalled an error already. */
4184 if (elf_hash_table (info
)->tls_sec
== NULL
)
4186 return elf_hash_table (info
)->tls_sec
->vma
;
4189 /* Return the relocation value for @tpoff relocation
4190 if STT_TLS virtual address is ADDRESS. */
4193 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4195 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4196 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4197 bfd_vma static_tls_size
;
4199 /* If tls_segment is NULL, we should have signalled an error already. */
4200 if (htab
->tls_sec
== NULL
)
4203 /* Consider special static TLS alignment requirements. */
4204 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4205 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4208 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4212 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4214 /* Opcode Instruction
4217 0x0f 0x8x conditional jump */
4219 && (contents
[offset
- 1] == 0xe8
4220 || contents
[offset
- 1] == 0xe9))
4222 && contents
[offset
- 2] == 0x0f
4223 && (contents
[offset
- 1] & 0xf0) == 0x80));
4226 /* Relocate an x86_64 ELF section. */
4229 elf_x86_64_relocate_section (bfd
*output_bfd
,
4230 struct bfd_link_info
*info
,
4232 asection
*input_section
,
4234 Elf_Internal_Rela
*relocs
,
4235 Elf_Internal_Sym
*local_syms
,
4236 asection
**local_sections
)
4238 struct elf_x86_64_link_hash_table
*htab
;
4239 Elf_Internal_Shdr
*symtab_hdr
;
4240 struct elf_link_hash_entry
**sym_hashes
;
4241 bfd_vma
*local_got_offsets
;
4242 bfd_vma
*local_tlsdesc_gotents
;
4243 Elf_Internal_Rela
*rel
;
4244 Elf_Internal_Rela
*wrel
;
4245 Elf_Internal_Rela
*relend
;
4246 unsigned int plt_entry_size
;
4248 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4250 /* Skip if check_relocs failed. */
4251 if (input_section
->check_relocs_failed
)
4254 htab
= elf_x86_64_hash_table (info
);
4257 plt_entry_size
= htab
->plt
.plt_entry_size
;
4258 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4259 sym_hashes
= elf_sym_hashes (input_bfd
);
4260 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4261 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4263 elf_x86_64_set_tls_module_base (info
);
4265 rel
= wrel
= relocs
;
4266 relend
= relocs
+ input_section
->reloc_count
;
4267 for (; rel
< relend
; wrel
++, rel
++)
4269 unsigned int r_type
;
4270 reloc_howto_type
*howto
;
4271 unsigned long r_symndx
;
4272 struct elf_link_hash_entry
*h
;
4273 struct elf_x86_64_link_hash_entry
*eh
;
4274 Elf_Internal_Sym
*sym
;
4276 bfd_vma off
, offplt
, plt_offset
;
4278 bfd_boolean unresolved_reloc
;
4279 bfd_reloc_status_type r
;
4281 asection
*base_got
, *resolved_plt
;
4283 bfd_boolean resolved_to_zero
;
4284 bfd_boolean relative_reloc
;
4286 r_type
= ELF32_R_TYPE (rel
->r_info
);
4287 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4288 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4295 if (r_type
>= (int) R_X86_64_standard
)
4296 return _bfd_unrecognized_reloc (input_bfd
, input_section
, r_type
);
4298 if (r_type
!= (int) R_X86_64_32
4299 || ABI_64_P (output_bfd
))
4300 howto
= x86_64_elf_howto_table
+ r_type
;
4302 howto
= (x86_64_elf_howto_table
4303 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4304 r_symndx
= htab
->r_sym (rel
->r_info
);
4308 unresolved_reloc
= FALSE
;
4309 if (r_symndx
< symtab_hdr
->sh_info
)
4311 sym
= local_syms
+ r_symndx
;
4312 sec
= local_sections
[r_symndx
];
4314 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4316 st_size
= sym
->st_size
;
4318 /* Relocate against local STT_GNU_IFUNC symbol. */
4319 if (!bfd_link_relocatable (info
)
4320 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4322 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4327 /* Set STT_GNU_IFUNC symbol value. */
4328 h
->root
.u
.def
.value
= sym
->st_value
;
4329 h
->root
.u
.def
.section
= sec
;
4334 bfd_boolean warned ATTRIBUTE_UNUSED
;
4335 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4337 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4338 r_symndx
, symtab_hdr
, sym_hashes
,
4340 unresolved_reloc
, warned
, ignored
);
4344 if (sec
!= NULL
&& discarded_section (sec
))
4346 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4347 contents
+ rel
->r_offset
);
4348 wrel
->r_offset
= rel
->r_offset
;
4352 /* For ld -r, remove relocations in debug sections against
4353 sections defined in discarded sections. Not done for
4354 eh_frame editing code expects to be present. */
4355 if (bfd_link_relocatable (info
)
4356 && (input_section
->flags
& SEC_DEBUGGING
))
4362 if (bfd_link_relocatable (info
))
4369 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4371 if (r_type
== R_X86_64_64
)
4373 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4374 zero-extend it to 64bit if addend is zero. */
4375 r_type
= R_X86_64_32
;
4376 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4378 else if (r_type
== R_X86_64_SIZE64
)
4380 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4381 zero-extend it to 64bit if addend is zero. */
4382 r_type
= R_X86_64_SIZE32
;
4383 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4387 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4389 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4390 it here if it is defined in a non-shared object. */
4392 && h
->type
== STT_GNU_IFUNC
4398 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4400 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4401 sections because such sections are not SEC_ALLOC and
4402 thus ld.so will not process them. */
4403 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4413 case R_X86_64_GOTPCREL
:
4414 case R_X86_64_GOTPCRELX
:
4415 case R_X86_64_REX_GOTPCRELX
:
4416 case R_X86_64_GOTPCREL64
:
4417 base_got
= htab
->elf
.sgot
;
4418 off
= h
->got
.offset
;
4420 if (base_got
== NULL
)
4423 if (off
== (bfd_vma
) -1)
4425 /* We can't use h->got.offset here to save state, or
4426 even just remember the offset, as finish_dynamic_symbol
4427 would use that as offset into .got. */
4429 if (h
->plt
.offset
== (bfd_vma
) -1)
4432 if (htab
->elf
.splt
!= NULL
)
4434 plt_index
= (h
->plt
.offset
/ plt_entry_size
4435 - htab
->plt
.has_plt0
);
4436 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4437 base_got
= htab
->elf
.sgotplt
;
4441 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4442 off
= plt_index
* GOT_ENTRY_SIZE
;
4443 base_got
= htab
->elf
.igotplt
;
4446 if (h
->dynindx
== -1
4450 /* This references the local defitionion. We must
4451 initialize this entry in the global offset table.
4452 Since the offset must always be a multiple of 8,
4453 we use the least significant bit to record
4454 whether we have initialized it already.
4456 When doing a dynamic link, we create a .rela.got
4457 relocation entry to initialize the value. This
4458 is done in the finish_dynamic_symbol routine. */
4463 bfd_put_64 (output_bfd
, relocation
,
4464 base_got
->contents
+ off
);
4465 /* Note that this is harmless for the GOTPLT64
4466 case, as -1 | 1 still is -1. */
4472 relocation
= (base_got
->output_section
->vma
4473 + base_got
->output_offset
+ off
);
4478 if (h
->plt
.offset
== (bfd_vma
) -1)
4480 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4481 if (r_type
== htab
->pointer_r_type
4482 && (input_section
->flags
& SEC_CODE
) == 0)
4483 goto do_ifunc_pointer
;
4484 goto bad_ifunc_reloc
;
4487 /* STT_GNU_IFUNC symbol must go through PLT. */
4488 if (htab
->elf
.splt
!= NULL
)
4490 if (htab
->plt_second
!= NULL
)
4492 resolved_plt
= htab
->plt_second
;
4493 plt_offset
= eh
->plt_second
.offset
;
4497 resolved_plt
= htab
->elf
.splt
;
4498 plt_offset
= h
->plt
.offset
;
4503 resolved_plt
= htab
->elf
.iplt
;
4504 plt_offset
= h
->plt
.offset
;
4507 relocation
= (resolved_plt
->output_section
->vma
4508 + resolved_plt
->output_offset
+ plt_offset
);
4514 if (h
->root
.root
.string
)
4515 name
= h
->root
.root
.string
;
4517 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4520 /* xgettext:c-format */
4521 (_("%B: relocation %s against STT_GNU_IFUNC "
4522 "symbol `%s' isn't supported"), input_bfd
,
4524 bfd_set_error (bfd_error_bad_value
);
4528 if (bfd_link_pic (info
))
4533 if (ABI_64_P (output_bfd
))
4538 if (rel
->r_addend
!= 0)
4540 if (h
->root
.root
.string
)
4541 name
= h
->root
.root
.string
;
4543 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4546 /* xgettext:c-format */
4547 (_("%B: relocation %s against STT_GNU_IFUNC "
4548 "symbol `%s' has non-zero addend: %Ld"),
4549 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4550 bfd_set_error (bfd_error_bad_value
);
4554 /* Generate dynamic relcoation only when there is a
4555 non-GOT reference in a shared object or there is no
4557 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4558 || h
->plt
.offset
== (bfd_vma
) -1)
4560 Elf_Internal_Rela outrel
;
4563 /* Need a dynamic relocation to get the real function
4565 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4569 if (outrel
.r_offset
== (bfd_vma
) -1
4570 || outrel
.r_offset
== (bfd_vma
) -2)
4573 outrel
.r_offset
+= (input_section
->output_section
->vma
4574 + input_section
->output_offset
);
4576 if (h
->dynindx
== -1
4578 || bfd_link_executable (info
))
4580 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
4581 h
->root
.root
.string
,
4582 h
->root
.u
.def
.section
->owner
);
4584 /* This symbol is resolved locally. */
4585 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4586 outrel
.r_addend
= (h
->root
.u
.def
.value
4587 + h
->root
.u
.def
.section
->output_section
->vma
4588 + h
->root
.u
.def
.section
->output_offset
);
4592 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4593 outrel
.r_addend
= 0;
4596 /* Dynamic relocations are stored in
4597 1. .rela.ifunc section in PIC object.
4598 2. .rela.got section in dynamic executable.
4599 3. .rela.iplt section in static executable. */
4600 if (bfd_link_pic (info
))
4601 sreloc
= htab
->elf
.irelifunc
;
4602 else if (htab
->elf
.splt
!= NULL
)
4603 sreloc
= htab
->elf
.srelgot
;
4605 sreloc
= htab
->elf
.irelplt
;
4606 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4608 /* If this reloc is against an external symbol, we
4609 do not want to fiddle with the addend. Otherwise,
4610 we need to include the symbol value so that it
4611 becomes an addend for the dynamic reloc. For an
4612 internal symbol, we have updated addend. */
4617 case R_X86_64_PC32_BND
:
4619 case R_X86_64_PLT32
:
4620 case R_X86_64_PLT32_BND
:
4625 resolved_to_zero
= (eh
!= NULL
4626 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4630 /* When generating a shared object, the relocations handled here are
4631 copied into the output file to be resolved at run time. */
4634 case R_X86_64_GOT32
:
4635 case R_X86_64_GOT64
:
4636 /* Relocation is to the entry for this symbol in the global
4638 case R_X86_64_GOTPCREL
:
4639 case R_X86_64_GOTPCRELX
:
4640 case R_X86_64_REX_GOTPCRELX
:
4641 case R_X86_64_GOTPCREL64
:
4642 /* Use global offset table entry as symbol value. */
4643 case R_X86_64_GOTPLT64
:
4644 /* This is obsolete and treated the same as GOT64. */
4645 base_got
= htab
->elf
.sgot
;
4647 if (htab
->elf
.sgot
== NULL
)
4650 relative_reloc
= FALSE
;
4655 off
= h
->got
.offset
;
4657 && h
->plt
.offset
!= (bfd_vma
)-1
4658 && off
== (bfd_vma
)-1)
4660 /* We can't use h->got.offset here to save
4661 state, or even just remember the offset, as
4662 finish_dynamic_symbol would use that as offset into
4664 bfd_vma plt_index
= (h
->plt
.offset
/ plt_entry_size
4665 - htab
->plt
.has_plt0
);
4666 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4667 base_got
= htab
->elf
.sgotplt
;
4670 dyn
= htab
->elf
.dynamic_sections_created
;
4672 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4673 || (bfd_link_pic (info
)
4674 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4675 || (ELF_ST_VISIBILITY (h
->other
)
4676 && h
->root
.type
== bfd_link_hash_undefweak
))
4678 /* This is actually a static link, or it is a -Bsymbolic
4679 link and the symbol is defined locally, or the symbol
4680 was forced to be local because of a version file. We
4681 must initialize this entry in the global offset table.
4682 Since the offset must always be a multiple of 8, we
4683 use the least significant bit to record whether we
4684 have initialized it already.
4686 When doing a dynamic link, we create a .rela.got
4687 relocation entry to initialize the value. This is
4688 done in the finish_dynamic_symbol routine. */
4693 bfd_put_64 (output_bfd
, relocation
,
4694 base_got
->contents
+ off
);
4695 /* Note that this is harmless for the GOTPLT64 case,
4696 as -1 | 1 still is -1. */
4699 if (h
->dynindx
== -1
4701 && h
->root
.type
!= bfd_link_hash_undefweak
4702 && bfd_link_pic (info
))
4704 /* If this symbol isn't dynamic in PIC,
4705 generate R_X86_64_RELATIVE here. */
4706 eh
->no_finish_dynamic_symbol
= 1;
4707 relative_reloc
= TRUE
;
4712 unresolved_reloc
= FALSE
;
4716 if (local_got_offsets
== NULL
)
4719 off
= local_got_offsets
[r_symndx
];
4721 /* The offset must always be a multiple of 8. We use
4722 the least significant bit to record whether we have
4723 already generated the necessary reloc. */
4728 bfd_put_64 (output_bfd
, relocation
,
4729 base_got
->contents
+ off
);
4730 local_got_offsets
[r_symndx
] |= 1;
4732 if (bfd_link_pic (info
))
4733 relative_reloc
= TRUE
;
4740 Elf_Internal_Rela outrel
;
4742 /* We need to generate a R_X86_64_RELATIVE reloc
4743 for the dynamic linker. */
4744 s
= htab
->elf
.srelgot
;
4748 outrel
.r_offset
= (base_got
->output_section
->vma
4749 + base_got
->output_offset
4751 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4752 outrel
.r_addend
= relocation
;
4753 elf_append_rela (output_bfd
, s
, &outrel
);
4756 if (off
>= (bfd_vma
) -2)
4759 relocation
= base_got
->output_section
->vma
4760 + base_got
->output_offset
+ off
;
4761 if (r_type
!= R_X86_64_GOTPCREL
4762 && r_type
!= R_X86_64_GOTPCRELX
4763 && r_type
!= R_X86_64_REX_GOTPCRELX
4764 && r_type
!= R_X86_64_GOTPCREL64
)
4765 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4766 - htab
->elf
.sgotplt
->output_offset
;
4770 case R_X86_64_GOTOFF64
:
4771 /* Relocation is relative to the start of the global offset
4774 /* Check to make sure it isn't a protected function or data
4775 symbol for shared library since it may not be local when
4776 used as function address or with copy relocation. We also
4777 need to make sure that a symbol is referenced locally. */
4778 if (bfd_link_pic (info
) && h
)
4780 if (!h
->def_regular
)
4784 switch (ELF_ST_VISIBILITY (h
->other
))
4787 v
= _("hidden symbol");
4790 v
= _("internal symbol");
4793 v
= _("protected symbol");
4801 /* xgettext:c-format */
4802 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
4803 " `%s' can not be used when making a shared object"),
4804 input_bfd
, v
, h
->root
.root
.string
);
4805 bfd_set_error (bfd_error_bad_value
);
4808 else if (!bfd_link_executable (info
)
4809 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4810 && (h
->type
== STT_FUNC
4811 || h
->type
== STT_OBJECT
)
4812 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4815 /* xgettext:c-format */
4816 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
4817 " `%s' can not be used when making a shared object"),
4819 h
->type
== STT_FUNC
? "function" : "data",
4820 h
->root
.root
.string
);
4821 bfd_set_error (bfd_error_bad_value
);
4826 /* Note that sgot is not involved in this
4827 calculation. We always want the start of .got.plt. If we
4828 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4829 permitted by the ABI, we might have to change this
4831 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4832 + htab
->elf
.sgotplt
->output_offset
;
4835 case R_X86_64_GOTPC32
:
4836 case R_X86_64_GOTPC64
:
4837 /* Use global offset table as symbol value. */
4838 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4839 + htab
->elf
.sgotplt
->output_offset
;
4840 unresolved_reloc
= FALSE
;
4843 case R_X86_64_PLTOFF64
:
4844 /* Relocation is PLT entry relative to GOT. For local
4845 symbols it's the symbol itself relative to GOT. */
4847 /* See PLT32 handling. */
4848 && (h
->plt
.offset
!= (bfd_vma
) -1
4849 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
4850 && htab
->elf
.splt
!= NULL
)
4852 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4854 /* Use the GOT PLT. */
4855 resolved_plt
= htab
->plt_got
;
4856 plt_offset
= eh
->plt_got
.offset
;
4858 else if (htab
->plt_second
!= NULL
)
4860 resolved_plt
= htab
->plt_second
;
4861 plt_offset
= eh
->plt_second
.offset
;
4865 resolved_plt
= htab
->elf
.splt
;
4866 plt_offset
= h
->plt
.offset
;
4869 relocation
= (resolved_plt
->output_section
->vma
4870 + resolved_plt
->output_offset
4872 unresolved_reloc
= FALSE
;
4875 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4876 + htab
->elf
.sgotplt
->output_offset
;
4879 case R_X86_64_PLT32
:
4880 case R_X86_64_PLT32_BND
:
4881 /* Relocation is to the entry for this symbol in the
4882 procedure linkage table. */
4884 /* Resolve a PLT32 reloc against a local symbol directly,
4885 without using the procedure linkage table. */
4889 if ((h
->plt
.offset
== (bfd_vma
) -1
4890 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4891 || htab
->elf
.splt
== NULL
)
4893 /* We didn't make a PLT entry for this symbol. This
4894 happens when statically linking PIC code, or when
4895 using -Bsymbolic. */
4899 if (h
->plt
.offset
!= (bfd_vma
) -1)
4901 if (htab
->plt_second
!= NULL
)
4903 resolved_plt
= htab
->plt_second
;
4904 plt_offset
= eh
->plt_second
.offset
;
4908 resolved_plt
= htab
->elf
.splt
;
4909 plt_offset
= h
->plt
.offset
;
4914 /* Use the GOT PLT. */
4915 resolved_plt
= htab
->plt_got
;
4916 plt_offset
= eh
->plt_got
.offset
;
4919 relocation
= (resolved_plt
->output_section
->vma
4920 + resolved_plt
->output_offset
4922 unresolved_reloc
= FALSE
;
4925 case R_X86_64_SIZE32
:
4926 case R_X86_64_SIZE64
:
4927 /* Set to symbol size. */
4928 relocation
= st_size
;
4934 case R_X86_64_PC32_BND
:
4935 /* Don't complain about -fPIC if the symbol is undefined when
4936 building executable unless it is unresolved weak symbol. */
4937 if ((input_section
->flags
& SEC_ALLOC
) != 0
4938 && (input_section
->flags
& SEC_READONLY
) != 0
4940 && ((bfd_link_executable (info
)
4941 && h
->root
.type
== bfd_link_hash_undefweak
4942 && !resolved_to_zero
)
4943 || bfd_link_dll (info
)))
4945 bfd_boolean fail
= FALSE
;
4947 = ((r_type
== R_X86_64_PC32
4948 || r_type
== R_X86_64_PC32_BND
)
4949 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4951 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4953 /* Symbol is referenced locally. Make sure it is
4954 defined locally or for a branch. */
4955 fail
= (!(h
->def_regular
|| ELF_COMMON_DEF_P (h
))
4958 else if (!(bfd_link_pie (info
)
4959 && (h
->needs_copy
|| eh
->needs_copy
)))
4961 /* Symbol doesn't need copy reloc and isn't referenced
4962 locally. We only allow branch to symbol with
4963 non-default visibility. */
4965 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4969 return elf_x86_64_need_pic (input_bfd
, input_section
,
4970 h
, NULL
, NULL
, howto
);
4979 /* FIXME: The ABI says the linker should make sure the value is
4980 the same when it's zeroextended to 64 bit. */
4983 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4986 /* Don't copy a pc-relative relocation into the output file
4987 if the symbol needs copy reloc or the symbol is undefined
4988 when building executable. Copy dynamic function pointer
4989 relocations. Don't generate dynamic relocations against
4990 resolved undefined weak symbols in PIE. */
4991 if ((bfd_link_pic (info
)
4992 && !(bfd_link_pie (info
)
4996 || h
->root
.type
== bfd_link_hash_undefined
)
4997 && (IS_X86_64_PCREL_TYPE (r_type
)
4998 || r_type
== R_X86_64_SIZE32
4999 || r_type
== R_X86_64_SIZE64
))
5001 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5002 && !resolved_to_zero
)
5003 || h
->root
.type
!= bfd_link_hash_undefweak
))
5004 && ((! IS_X86_64_PCREL_TYPE (r_type
)
5005 && r_type
!= R_X86_64_SIZE32
5006 && r_type
!= R_X86_64_SIZE64
)
5007 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
5008 || (ELIMINATE_COPY_RELOCS
5009 && !bfd_link_pic (info
)
5013 || eh
->func_pointer_refcount
> 0
5014 || (h
->root
.type
== bfd_link_hash_undefweak
5015 && !resolved_to_zero
))
5016 && ((h
->def_dynamic
&& !h
->def_regular
)
5017 /* Undefined weak symbol is bound locally when
5019 || h
->root
.type
== bfd_link_hash_undefined
)))
5021 Elf_Internal_Rela outrel
;
5022 bfd_boolean skip
, relocate
;
5025 /* When generating a shared object, these relocations
5026 are copied into the output file to be resolved at run
5032 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5034 if (outrel
.r_offset
== (bfd_vma
) -1)
5036 else if (outrel
.r_offset
== (bfd_vma
) -2)
5037 skip
= TRUE
, relocate
= TRUE
;
5039 outrel
.r_offset
+= (input_section
->output_section
->vma
5040 + input_section
->output_offset
);
5043 memset (&outrel
, 0, sizeof outrel
);
5045 /* h->dynindx may be -1 if this symbol was marked to
5049 && (IS_X86_64_PCREL_TYPE (r_type
)
5050 || !(bfd_link_executable (info
)
5051 || SYMBOLIC_BIND (info
, h
))
5052 || ! h
->def_regular
))
5054 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
5055 outrel
.r_addend
= rel
->r_addend
;
5059 /* This symbol is local, or marked to become local.
5060 When relocation overflow check is disabled, we
5061 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
5062 if (r_type
== htab
->pointer_r_type
5063 || (r_type
== R_X86_64_32
5064 && info
->no_reloc_overflow_check
))
5067 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5068 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5070 else if (r_type
== R_X86_64_64
5071 && !ABI_64_P (output_bfd
))
5074 outrel
.r_info
= htab
->r_info (0,
5075 R_X86_64_RELATIVE64
);
5076 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5077 /* Check addend overflow. */
5078 if ((outrel
.r_addend
& 0x80000000)
5079 != (rel
->r_addend
& 0x80000000))
5082 int addend
= rel
->r_addend
;
5083 if (h
&& h
->root
.root
.string
)
5084 name
= h
->root
.root
.string
;
5086 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
5089 /* xgettext:c-format */
5090 (_("%B: addend %s%#x in relocation %s against "
5091 "symbol `%s' at %#Lx in section `%A' is "
5093 input_bfd
, addend
< 0 ? "-" : "", addend
,
5094 howto
->name
, name
, rel
->r_offset
, input_section
);
5095 bfd_set_error (bfd_error_bad_value
);
5103 if (bfd_is_abs_section (sec
))
5105 else if (sec
== NULL
|| sec
->owner
== NULL
)
5107 bfd_set_error (bfd_error_bad_value
);
5114 /* We are turning this relocation into one
5115 against a section symbol. It would be
5116 proper to subtract the symbol's value,
5117 osec->vma, from the emitted reloc addend,
5118 but ld.so expects buggy relocs. */
5119 osec
= sec
->output_section
;
5120 sindx
= elf_section_data (osec
)->dynindx
;
5123 asection
*oi
= htab
->elf
.text_index_section
;
5124 sindx
= elf_section_data (oi
)->dynindx
;
5126 BFD_ASSERT (sindx
!= 0);
5129 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
5130 outrel
.r_addend
= relocation
+ rel
->r_addend
;
5134 sreloc
= elf_section_data (input_section
)->sreloc
;
5136 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
5138 r
= bfd_reloc_notsupported
;
5139 goto check_relocation_error
;
5142 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5144 /* If this reloc is against an external symbol, we do
5145 not want to fiddle with the addend. Otherwise, we
5146 need to include the symbol value so that it becomes
5147 an addend for the dynamic reloc. */
5154 case R_X86_64_TLSGD
:
5155 case R_X86_64_GOTPC32_TLSDESC
:
5156 case R_X86_64_TLSDESC_CALL
:
5157 case R_X86_64_GOTTPOFF
:
5158 tls_type
= GOT_UNKNOWN
;
5159 if (h
== NULL
&& local_got_offsets
)
5160 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
5162 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
5164 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5165 input_section
, contents
,
5166 symtab_hdr
, sym_hashes
,
5167 &r_type
, tls_type
, rel
,
5168 relend
, h
, r_symndx
, TRUE
))
5171 if (r_type
== R_X86_64_TPOFF32
)
5173 bfd_vma roff
= rel
->r_offset
;
5175 BFD_ASSERT (! unresolved_reloc
);
5177 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5179 /* GD->LE transition. For 64bit, change
5180 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5181 .word 0x6666; rex64; call __tls_get_addr@PLT
5183 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5185 call *__tls_get_addr@GOTPCREL(%rip)
5186 which may be converted to
5187 addr32 call __tls_get_addr
5190 leaq foo@tpoff(%rax), %rax
5192 leaq foo@tlsgd(%rip), %rdi
5193 .word 0x6666; rex64; call __tls_get_addr@PLT
5195 leaq foo@tlsgd(%rip), %rdi
5197 call *__tls_get_addr@GOTPCREL(%rip)
5198 which may be converted to
5199 addr32 call __tls_get_addr
5202 leaq foo@tpoff(%rax), %rax
5203 For largepic, change:
5204 leaq foo@tlsgd(%rip), %rdi
5205 movabsq $__tls_get_addr@pltoff, %rax
5210 leaq foo@tpoff(%rax), %rax
5211 nopw 0x0(%rax,%rax,1) */
5213 if (ABI_64_P (output_bfd
))
5215 if (contents
[roff
+ 5] == 0xb8)
5217 memcpy (contents
+ roff
- 3,
5218 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5219 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5223 memcpy (contents
+ roff
- 4,
5224 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5228 memcpy (contents
+ roff
- 3,
5229 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5231 bfd_put_32 (output_bfd
,
5232 elf_x86_64_tpoff (info
, relocation
),
5233 contents
+ roff
+ 8 + largepic
);
5234 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5235 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5240 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5242 /* GDesc -> LE transition.
5243 It's originally something like:
5244 leaq x@tlsdesc(%rip), %rax
5247 movl $x@tpoff, %rax. */
5249 unsigned int val
, type
;
5251 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5252 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5253 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5254 contents
+ roff
- 3);
5255 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5256 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5257 contents
+ roff
- 1);
5258 bfd_put_32 (output_bfd
,
5259 elf_x86_64_tpoff (info
, relocation
),
5263 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5265 /* GDesc -> LE transition.
5270 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5271 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5274 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5276 /* IE->LE transition:
5277 For 64bit, originally it can be one of:
5278 movq foo@gottpoff(%rip), %reg
5279 addq foo@gottpoff(%rip), %reg
5282 leaq foo(%reg), %reg
5284 For 32bit, originally it can be one of:
5285 movq foo@gottpoff(%rip), %reg
5286 addl foo@gottpoff(%rip), %reg
5289 leal foo(%reg), %reg
5292 unsigned int val
, type
, reg
;
5295 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5298 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5299 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5305 bfd_put_8 (output_bfd
, 0x49,
5306 contents
+ roff
- 3);
5307 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5308 bfd_put_8 (output_bfd
, 0x41,
5309 contents
+ roff
- 3);
5310 bfd_put_8 (output_bfd
, 0xc7,
5311 contents
+ roff
- 2);
5312 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5313 contents
+ roff
- 1);
5317 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5320 bfd_put_8 (output_bfd
, 0x49,
5321 contents
+ roff
- 3);
5322 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5323 bfd_put_8 (output_bfd
, 0x41,
5324 contents
+ roff
- 3);
5325 bfd_put_8 (output_bfd
, 0x81,
5326 contents
+ roff
- 2);
5327 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5328 contents
+ roff
- 1);
5332 /* addq/addl -> leaq/leal */
5334 bfd_put_8 (output_bfd
, 0x4d,
5335 contents
+ roff
- 3);
5336 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5337 bfd_put_8 (output_bfd
, 0x45,
5338 contents
+ roff
- 3);
5339 bfd_put_8 (output_bfd
, 0x8d,
5340 contents
+ roff
- 2);
5341 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5342 contents
+ roff
- 1);
5344 bfd_put_32 (output_bfd
,
5345 elf_x86_64_tpoff (info
, relocation
),
5353 if (htab
->elf
.sgot
== NULL
)
5358 off
= h
->got
.offset
;
5359 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5363 if (local_got_offsets
== NULL
)
5366 off
= local_got_offsets
[r_symndx
];
5367 offplt
= local_tlsdesc_gotents
[r_symndx
];
5374 Elf_Internal_Rela outrel
;
5378 if (htab
->elf
.srelgot
== NULL
)
5381 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5383 if (GOT_TLS_GDESC_P (tls_type
))
5385 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5386 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5387 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5388 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5389 + htab
->elf
.sgotplt
->output_offset
5391 + htab
->sgotplt_jump_table_size
);
5392 sreloc
= htab
->elf
.srelplt
;
5394 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5396 outrel
.r_addend
= 0;
5397 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5400 sreloc
= htab
->elf
.srelgot
;
5402 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5403 + htab
->elf
.sgot
->output_offset
+ off
);
5405 if (GOT_TLS_GD_P (tls_type
))
5406 dr_type
= R_X86_64_DTPMOD64
;
5407 else if (GOT_TLS_GDESC_P (tls_type
))
5410 dr_type
= R_X86_64_TPOFF64
;
5412 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5413 outrel
.r_addend
= 0;
5414 if ((dr_type
== R_X86_64_TPOFF64
5415 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5416 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5417 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5419 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5421 if (GOT_TLS_GD_P (tls_type
))
5425 BFD_ASSERT (! unresolved_reloc
);
5426 bfd_put_64 (output_bfd
,
5427 relocation
- elf_x86_64_dtpoff_base (info
),
5428 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5432 bfd_put_64 (output_bfd
, 0,
5433 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5434 outrel
.r_info
= htab
->r_info (indx
,
5436 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5437 elf_append_rela (output_bfd
, sreloc
,
5446 local_got_offsets
[r_symndx
] |= 1;
5449 if (off
>= (bfd_vma
) -2
5450 && ! GOT_TLS_GDESC_P (tls_type
))
5452 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5454 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5455 || r_type
== R_X86_64_TLSDESC_CALL
)
5456 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5457 + htab
->elf
.sgotplt
->output_offset
5458 + offplt
+ htab
->sgotplt_jump_table_size
;
5460 relocation
= htab
->elf
.sgot
->output_section
->vma
5461 + htab
->elf
.sgot
->output_offset
+ off
;
5462 unresolved_reloc
= FALSE
;
5466 bfd_vma roff
= rel
->r_offset
;
5468 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5470 /* GD->IE transition. For 64bit, change
5471 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5472 .word 0x6666; rex64; call __tls_get_addr@PLT
5474 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5476 call *__tls_get_addr@GOTPCREL(%rip
5477 which may be converted to
5478 addr32 call __tls_get_addr
5481 addq foo@gottpoff(%rip), %rax
5483 leaq foo@tlsgd(%rip), %rdi
5484 .word 0x6666; rex64; call __tls_get_addr@PLT
5486 leaq foo@tlsgd(%rip), %rdi
5488 call *__tls_get_addr@GOTPCREL(%rip)
5489 which may be converted to
5490 addr32 call __tls_get_addr
5493 addq foo@gottpoff(%rip), %rax
5494 For largepic, change:
5495 leaq foo@tlsgd(%rip), %rdi
5496 movabsq $__tls_get_addr@pltoff, %rax
5501 addq foo@gottpoff(%rax), %rax
5502 nopw 0x0(%rax,%rax,1) */
5504 if (ABI_64_P (output_bfd
))
5506 if (contents
[roff
+ 5] == 0xb8)
5508 memcpy (contents
+ roff
- 3,
5509 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5510 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5514 memcpy (contents
+ roff
- 4,
5515 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5519 memcpy (contents
+ roff
- 3,
5520 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5523 relocation
= (htab
->elf
.sgot
->output_section
->vma
5524 + htab
->elf
.sgot
->output_offset
+ off
5527 - input_section
->output_section
->vma
5528 - input_section
->output_offset
5530 bfd_put_32 (output_bfd
, relocation
,
5531 contents
+ roff
+ 8 + largepic
);
5532 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5537 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5539 /* GDesc -> IE transition.
5540 It's originally something like:
5541 leaq x@tlsdesc(%rip), %rax
5544 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5546 /* Now modify the instruction as appropriate. To
5547 turn a leaq into a movq in the form we use it, it
5548 suffices to change the second byte from 0x8d to
5550 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5552 bfd_put_32 (output_bfd
,
5553 htab
->elf
.sgot
->output_section
->vma
5554 + htab
->elf
.sgot
->output_offset
+ off
5556 - input_section
->output_section
->vma
5557 - input_section
->output_offset
5562 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5564 /* GDesc -> IE transition.
5571 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5572 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5580 case R_X86_64_TLSLD
:
5581 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5582 input_section
, contents
,
5583 symtab_hdr
, sym_hashes
,
5584 &r_type
, GOT_UNKNOWN
, rel
,
5585 relend
, h
, r_symndx
, TRUE
))
5588 if (r_type
!= R_X86_64_TLSLD
)
5590 /* LD->LE transition:
5591 leaq foo@tlsld(%rip), %rdi
5592 call __tls_get_addr@PLT
5593 For 64bit, we change it into:
5594 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5595 For 32bit, we change it into:
5596 nopl 0x0(%rax); movl %fs:0, %eax
5598 leaq foo@tlsld(%rip), %rdi;
5599 call *__tls_get_addr@GOTPCREL(%rip)
5600 which may be converted to
5601 addr32 call __tls_get_addr
5602 For 64bit, we change it into:
5603 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5604 For 32bit, we change it into:
5605 nopw 0x0(%rax); movl %fs:0, %eax
5606 For largepic, change:
5607 leaq foo@tlsgd(%rip), %rdi
5608 movabsq $__tls_get_addr@pltoff, %rax
5612 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5615 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5616 if (ABI_64_P (output_bfd
))
5618 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5619 memcpy (contents
+ rel
->r_offset
- 3,
5620 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5621 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5622 else if (contents
[rel
->r_offset
+ 4] == 0xff
5623 || contents
[rel
->r_offset
+ 4] == 0x67)
5624 memcpy (contents
+ rel
->r_offset
- 3,
5625 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5628 memcpy (contents
+ rel
->r_offset
- 3,
5629 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5633 if (contents
[rel
->r_offset
+ 4] == 0xff)
5634 memcpy (contents
+ rel
->r_offset
- 3,
5635 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5638 memcpy (contents
+ rel
->r_offset
- 3,
5639 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5641 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5642 and R_X86_64_PLTOFF64. */
5648 if (htab
->elf
.sgot
== NULL
)
5651 off
= htab
->tls_ld_got
.offset
;
5656 Elf_Internal_Rela outrel
;
5658 if (htab
->elf
.srelgot
== NULL
)
5661 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5662 + htab
->elf
.sgot
->output_offset
+ off
);
5664 bfd_put_64 (output_bfd
, 0,
5665 htab
->elf
.sgot
->contents
+ off
);
5666 bfd_put_64 (output_bfd
, 0,
5667 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5668 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5669 outrel
.r_addend
= 0;
5670 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5672 htab
->tls_ld_got
.offset
|= 1;
5674 relocation
= htab
->elf
.sgot
->output_section
->vma
5675 + htab
->elf
.sgot
->output_offset
+ off
;
5676 unresolved_reloc
= FALSE
;
5679 case R_X86_64_DTPOFF32
:
5680 if (!bfd_link_executable (info
)
5681 || (input_section
->flags
& SEC_CODE
) == 0)
5682 relocation
-= elf_x86_64_dtpoff_base (info
);
5684 relocation
= elf_x86_64_tpoff (info
, relocation
);
5687 case R_X86_64_TPOFF32
:
5688 case R_X86_64_TPOFF64
:
5689 BFD_ASSERT (bfd_link_executable (info
));
5690 relocation
= elf_x86_64_tpoff (info
, relocation
);
5693 case R_X86_64_DTPOFF64
:
5694 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5695 relocation
-= elf_x86_64_dtpoff_base (info
);
5702 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5703 because such sections are not SEC_ALLOC and thus ld.so will
5704 not process them. */
5705 if (unresolved_reloc
5706 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5708 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5709 rel
->r_offset
) != (bfd_vma
) -1)
5712 /* xgettext:c-format */
5713 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
5718 h
->root
.root
.string
);
5723 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5724 contents
, rel
->r_offset
,
5725 relocation
, rel
->r_addend
);
5727 check_relocation_error
:
5728 if (r
!= bfd_reloc_ok
)
5733 name
= h
->root
.root
.string
;
5736 name
= bfd_elf_string_from_elf_section (input_bfd
,
5737 symtab_hdr
->sh_link
,
5742 name
= bfd_section_name (input_bfd
, sec
);
5745 if (r
== bfd_reloc_overflow
)
5746 (*info
->callbacks
->reloc_overflow
)
5747 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5748 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5752 /* xgettext:c-format */
5753 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
5754 input_bfd
, input_section
,
5755 rel
->r_offset
, name
, (int) r
);
5766 Elf_Internal_Shdr
*rel_hdr
;
5767 size_t deleted
= rel
- wrel
;
5769 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5770 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5771 if (rel_hdr
->sh_size
== 0)
5773 /* It is too late to remove an empty reloc section. Leave
5775 ??? What is wrong with an empty section??? */
5776 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5779 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5780 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5781 input_section
->reloc_count
-= deleted
;
5787 /* Finish up dynamic symbol handling. We set the contents of various
5788 dynamic sections here. */
5791 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5792 struct bfd_link_info
*info
,
5793 struct elf_link_hash_entry
*h
,
5794 Elf_Internal_Sym
*sym
)
5796 struct elf_x86_64_link_hash_table
*htab
;
5797 bfd_boolean use_plt_second
;
5798 struct elf_x86_64_link_hash_entry
*eh
;
5799 bfd_boolean local_undefweak
;
5801 htab
= elf_x86_64_hash_table (info
);
5805 /* Use the second PLT section only if there is .plt section. */
5806 use_plt_second
= htab
->elf
.splt
!= NULL
&& htab
->plt_second
!= NULL
;
5808 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5809 if (eh
->no_finish_dynamic_symbol
)
5812 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5813 resolved undefined weak symbols in executable so that their
5814 references have value 0 at run-time. */
5815 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5819 if (h
->plt
.offset
!= (bfd_vma
) -1)
5822 bfd_vma got_offset
, plt_offset
;
5823 Elf_Internal_Rela rela
;
5825 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5826 const struct elf_backend_data
*bed
;
5827 bfd_vma plt_got_pcrel_offset
;
5829 /* When building a static executable, use .iplt, .igot.plt and
5830 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5831 if (htab
->elf
.splt
!= NULL
)
5833 plt
= htab
->elf
.splt
;
5834 gotplt
= htab
->elf
.sgotplt
;
5835 relplt
= htab
->elf
.srelplt
;
5839 plt
= htab
->elf
.iplt
;
5840 gotplt
= htab
->elf
.igotplt
;
5841 relplt
= htab
->elf
.irelplt
;
5844 /* This symbol has an entry in the procedure linkage table. Set
5846 if ((h
->dynindx
== -1
5848 && !((h
->forced_local
|| bfd_link_executable (info
))
5850 && h
->type
== STT_GNU_IFUNC
))
5856 /* Get the index in the procedure linkage table which
5857 corresponds to this symbol. This is the index of this symbol
5858 in all the symbols for which we are making plt entries. The
5859 first entry in the procedure linkage table is reserved.
5861 Get the offset into the .got table of the entry that
5862 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5863 bytes. The first three are reserved for the dynamic linker.
5865 For static executables, we don't reserve anything. */
5867 if (plt
== htab
->elf
.splt
)
5869 got_offset
= (h
->plt
.offset
/ htab
->plt
.plt_entry_size
5870 - htab
->plt
.has_plt0
);
5871 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5875 got_offset
= h
->plt
.offset
/ htab
->plt
.plt_entry_size
;
5876 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5879 /* Fill in the entry in the procedure linkage table. */
5880 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
5881 htab
->plt
.plt_entry_size
);
5884 memcpy (htab
->plt_second
->contents
+ eh
->plt_second
.offset
,
5885 htab
->non_lazy_plt
->plt_entry
,
5886 htab
->non_lazy_plt
->plt_entry_size
);
5888 resolved_plt
= htab
->plt_second
;
5889 plt_offset
= eh
->plt_second
.offset
;
5894 plt_offset
= h
->plt
.offset
;
5897 /* Insert the relocation positions of the plt section. */
5899 /* Put offset the PC-relative instruction referring to the GOT entry,
5900 subtracting the size of that instruction. */
5901 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5902 + gotplt
->output_offset
5904 - resolved_plt
->output_section
->vma
5905 - resolved_plt
->output_offset
5907 - htab
->plt
.plt_got_insn_size
);
5909 /* Check PC-relative offset overflow in PLT entry. */
5910 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5911 /* xgettext:c-format */
5912 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5913 output_bfd
, h
->root
.root
.string
);
5915 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5916 (resolved_plt
->contents
+ plt_offset
5917 + htab
->plt
.plt_got_offset
));
5919 /* Fill in the entry in the global offset table, initially this
5920 points to the second part of the PLT entry. Leave the entry
5921 as zero for undefined weak symbol in PIE. No PLT relocation
5922 against undefined weak symbol in PIE. */
5923 if (!local_undefweak
)
5925 if (htab
->plt
.has_plt0
)
5926 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5927 + plt
->output_offset
5929 + htab
->lazy_plt
->plt_lazy_offset
),
5930 gotplt
->contents
+ got_offset
);
5932 /* Fill in the entry in the .rela.plt section. */
5933 rela
.r_offset
= (gotplt
->output_section
->vma
5934 + gotplt
->output_offset
5936 if (h
->dynindx
== -1
5937 || ((bfd_link_executable (info
)
5938 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5940 && h
->type
== STT_GNU_IFUNC
))
5942 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
5943 h
->root
.root
.string
,
5944 h
->root
.u
.def
.section
->owner
);
5946 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5947 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5948 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5949 rela
.r_addend
= (h
->root
.u
.def
.value
5950 + h
->root
.u
.def
.section
->output_section
->vma
5951 + h
->root
.u
.def
.section
->output_offset
);
5952 /* R_X86_64_IRELATIVE comes last. */
5953 plt_index
= htab
->next_irelative_index
--;
5957 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5959 plt_index
= htab
->next_jump_slot_index
++;
5962 /* Don't fill the second and third slots in PLT entry for
5963 static executables nor without PLT0. */
5964 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
5967 = h
->plt
.offset
+ htab
->lazy_plt
->plt_plt_insn_end
;
5969 /* Put relocation index. */
5970 bfd_put_32 (output_bfd
, plt_index
,
5971 (plt
->contents
+ h
->plt
.offset
5972 + htab
->lazy_plt
->plt_reloc_offset
));
5974 /* Put offset for jmp .PLT0 and check for overflow. We don't
5975 check relocation index for overflow since branch displacement
5976 will overflow first. */
5977 if (plt0_offset
> 0x80000000)
5978 /* xgettext:c-format */
5979 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5980 output_bfd
, h
->root
.root
.string
);
5981 bfd_put_32 (output_bfd
, - plt0_offset
,
5982 (plt
->contents
+ h
->plt
.offset
5983 + htab
->lazy_plt
->plt_plt_offset
));
5986 bed
= get_elf_backend_data (output_bfd
);
5987 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5988 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5991 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5993 bfd_vma got_offset
, plt_offset
;
5994 asection
*plt
, *got
;
5995 bfd_boolean got_after_plt
;
5996 int32_t got_pcrel_offset
;
5998 /* Set the entry in the GOT procedure linkage table. */
5999 plt
= htab
->plt_got
;
6000 got
= htab
->elf
.sgot
;
6001 got_offset
= h
->got
.offset
;
6003 if (got_offset
== (bfd_vma
) -1
6004 || (h
->type
== STT_GNU_IFUNC
&& h
->def_regular
)
6009 /* Use the non-lazy PLT entry template for the GOT PLT since they
6010 are the identical. */
6011 /* Fill in the entry in the GOT procedure linkage table. */
6012 plt_offset
= eh
->plt_got
.offset
;
6013 memcpy (plt
->contents
+ plt_offset
,
6014 htab
->non_lazy_plt
->plt_entry
,
6015 htab
->non_lazy_plt
->plt_entry_size
);
6017 /* Put offset the PC-relative instruction referring to the GOT
6018 entry, subtracting the size of that instruction. */
6019 got_pcrel_offset
= (got
->output_section
->vma
6020 + got
->output_offset
6022 - plt
->output_section
->vma
6023 - plt
->output_offset
6025 - htab
->non_lazy_plt
->plt_got_insn_size
);
6027 /* Check PC-relative offset overflow in GOT PLT entry. */
6028 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
6029 if ((got_after_plt
&& got_pcrel_offset
< 0)
6030 || (!got_after_plt
&& got_pcrel_offset
> 0))
6031 /* xgettext:c-format */
6032 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
6033 output_bfd
, h
->root
.root
.string
);
6035 bfd_put_32 (output_bfd
, got_pcrel_offset
,
6036 (plt
->contents
+ plt_offset
6037 + htab
->non_lazy_plt
->plt_got_offset
));
6040 if (!local_undefweak
6042 && (h
->plt
.offset
!= (bfd_vma
) -1
6043 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
6045 /* Mark the symbol as undefined, rather than as defined in
6046 the .plt section. Leave the value if there were any
6047 relocations where pointer equality matters (this is a clue
6048 for the dynamic linker, to make function pointer
6049 comparisons work between an application and shared
6050 library), otherwise set it to zero. If a function is only
6051 called from a binary, there is no need to slow down
6052 shared libraries because of that. */
6053 sym
->st_shndx
= SHN_UNDEF
;
6054 if (!h
->pointer_equality_needed
)
6058 /* Don't generate dynamic GOT relocation against undefined weak
6059 symbol in executable. */
6060 if (h
->got
.offset
!= (bfd_vma
) -1
6061 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
6062 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
6063 && !local_undefweak
)
6065 Elf_Internal_Rela rela
;
6066 asection
*relgot
= htab
->elf
.srelgot
;
6068 /* This symbol has an entry in the global offset table. Set it
6070 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
6073 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
6074 + htab
->elf
.sgot
->output_offset
6075 + (h
->got
.offset
&~ (bfd_vma
) 1));
6077 /* If this is a static link, or it is a -Bsymbolic link and the
6078 symbol is defined locally or was forced to be local because
6079 of a version file, we just want to emit a RELATIVE reloc.
6080 The entry in the global offset table will already have been
6081 initialized in the relocate_section function. */
6083 && h
->type
== STT_GNU_IFUNC
)
6085 if (h
->plt
.offset
== (bfd_vma
) -1)
6087 /* STT_GNU_IFUNC is referenced without PLT. */
6088 if (htab
->elf
.splt
== NULL
)
6090 /* use .rel[a].iplt section to store .got relocations
6091 in static executable. */
6092 relgot
= htab
->elf
.irelplt
;
6094 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
6096 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
6098 h
->root
.root
.string
,
6099 h
->root
.u
.def
.section
->owner
);
6101 rela
.r_info
= htab
->r_info (0,
6102 R_X86_64_IRELATIVE
);
6103 rela
.r_addend
= (h
->root
.u
.def
.value
6104 + h
->root
.u
.def
.section
->output_section
->vma
6105 + h
->root
.u
.def
.section
->output_offset
);
6110 else if (bfd_link_pic (info
))
6112 /* Generate R_X86_64_GLOB_DAT. */
6120 if (!h
->pointer_equality_needed
)
6123 /* For non-shared object, we can't use .got.plt, which
6124 contains the real function addres if we need pointer
6125 equality. We load the GOT entry with the PLT entry. */
6126 if (htab
->plt_second
!= NULL
)
6128 plt
= htab
->plt_second
;
6129 plt_offset
= eh
->plt_second
.offset
;
6133 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
6134 plt_offset
= h
->plt
.offset
;
6136 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
6137 + plt
->output_offset
6139 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6143 else if (bfd_link_pic (info
)
6144 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6146 if (!h
->def_regular
)
6148 BFD_ASSERT((h
->got
.offset
& 1) != 0);
6149 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
6150 rela
.r_addend
= (h
->root
.u
.def
.value
6151 + h
->root
.u
.def
.section
->output_section
->vma
6152 + h
->root
.u
.def
.section
->output_offset
);
6156 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6158 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6159 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6160 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6164 elf_append_rela (output_bfd
, relgot
, &rela
);
6169 Elf_Internal_Rela rela
;
6172 /* This symbol needs a copy reloc. Set it up. */
6174 if (h
->dynindx
== -1
6175 || (h
->root
.type
!= bfd_link_hash_defined
6176 && h
->root
.type
!= bfd_link_hash_defweak
)
6177 || htab
->elf
.srelbss
== NULL
6178 || htab
->elf
.sreldynrelro
== NULL
)
6181 rela
.r_offset
= (h
->root
.u
.def
.value
6182 + h
->root
.u
.def
.section
->output_section
->vma
6183 + h
->root
.u
.def
.section
->output_offset
);
6184 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6186 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6187 s
= htab
->elf
.sreldynrelro
;
6189 s
= htab
->elf
.srelbss
;
6190 elf_append_rela (output_bfd
, s
, &rela
);
6196 /* Finish up local dynamic symbol handling. We set the contents of
6197 various dynamic sections here. */
6200 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6202 struct elf_link_hash_entry
*h
6203 = (struct elf_link_hash_entry
*) *slot
;
6204 struct bfd_link_info
*info
6205 = (struct bfd_link_info
*) inf
;
6207 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6211 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6212 here since undefined weak symbol may not be dynamic and may not be
6213 called for elf_x86_64_finish_dynamic_symbol. */
6216 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6219 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6220 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6222 if (h
->root
.type
!= bfd_link_hash_undefweak
6223 || h
->dynindx
!= -1)
6226 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6230 /* Used to decide how to sort relocs in an optimal manner for the
6231 dynamic linker, before writing them out. */
6233 static enum elf_reloc_type_class
6234 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6235 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6236 const Elf_Internal_Rela
*rela
)
6238 bfd
*abfd
= info
->output_bfd
;
6239 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6240 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6242 if (htab
->elf
.dynsym
!= NULL
6243 && htab
->elf
.dynsym
->contents
!= NULL
)
6245 /* Check relocation against STT_GNU_IFUNC symbol if there are
6247 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6248 if (r_symndx
!= STN_UNDEF
)
6250 Elf_Internal_Sym sym
;
6251 if (!bed
->s
->swap_symbol_in (abfd
,
6252 (htab
->elf
.dynsym
->contents
6253 + r_symndx
* bed
->s
->sizeof_sym
),
6257 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6258 return reloc_class_ifunc
;
6262 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6264 case R_X86_64_IRELATIVE
:
6265 return reloc_class_ifunc
;
6266 case R_X86_64_RELATIVE
:
6267 case R_X86_64_RELATIVE64
:
6268 return reloc_class_relative
;
6269 case R_X86_64_JUMP_SLOT
:
6270 return reloc_class_plt
;
6272 return reloc_class_copy
;
6274 return reloc_class_normal
;
6278 /* Finish up the dynamic sections. */
6281 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6282 struct bfd_link_info
*info
)
6284 struct elf_x86_64_link_hash_table
*htab
;
6288 htab
= elf_x86_64_hash_table (info
);
6292 dynobj
= htab
->elf
.dynobj
;
6293 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6295 if (htab
->elf
.dynamic_sections_created
)
6297 bfd_byte
*dyncon
, *dynconend
;
6298 const struct elf_backend_data
*bed
;
6299 bfd_size_type sizeof_dyn
;
6301 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6304 bed
= get_elf_backend_data (dynobj
);
6305 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6306 dyncon
= sdyn
->contents
;
6307 dynconend
= sdyn
->contents
+ sdyn
->size
;
6308 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6310 Elf_Internal_Dyn dyn
;
6313 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6321 s
= htab
->elf
.sgotplt
;
6322 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6326 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6330 s
= htab
->elf
.srelplt
->output_section
;
6331 dyn
.d_un
.d_val
= s
->size
;
6334 case DT_TLSDESC_PLT
:
6336 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6337 + htab
->tlsdesc_plt
;
6340 case DT_TLSDESC_GOT
:
6342 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6343 + htab
->tlsdesc_got
;
6347 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6350 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6352 elf_section_data (htab
->elf
.splt
->output_section
)
6353 ->this_hdr
.sh_entsize
= htab
->plt
.plt_entry_size
;
6355 if (htab
->plt
.has_plt0
)
6357 /* Fill in the special first entry in the procedure linkage
6359 memcpy (htab
->elf
.splt
->contents
,
6360 htab
->lazy_plt
->plt0_entry
,
6361 htab
->lazy_plt
->plt_entry_size
);
6362 /* Add offset for pushq GOT+8(%rip), since the instruction
6363 uses 6 bytes subtract this value. */
6364 bfd_put_32 (output_bfd
,
6365 (htab
->elf
.sgotplt
->output_section
->vma
6366 + htab
->elf
.sgotplt
->output_offset
6368 - htab
->elf
.splt
->output_section
->vma
6369 - htab
->elf
.splt
->output_offset
6371 (htab
->elf
.splt
->contents
6372 + htab
->lazy_plt
->plt0_got1_offset
));
6373 /* Add offset for the PC-relative instruction accessing
6374 GOT+16, subtracting the offset to the end of that
6376 bfd_put_32 (output_bfd
,
6377 (htab
->elf
.sgotplt
->output_section
->vma
6378 + htab
->elf
.sgotplt
->output_offset
6380 - htab
->elf
.splt
->output_section
->vma
6381 - htab
->elf
.splt
->output_offset
6382 - htab
->lazy_plt
->plt0_got2_insn_end
),
6383 (htab
->elf
.splt
->contents
6384 + htab
->lazy_plt
->plt0_got2_offset
));
6386 if (htab
->tlsdesc_plt
)
6388 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6389 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6391 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6392 htab
->lazy_plt
->plt0_entry
,
6393 htab
->lazy_plt
->plt_entry_size
);
6395 /* Add offset for pushq GOT+8(%rip), since the
6396 instruction uses 6 bytes subtract this value. */
6397 bfd_put_32 (output_bfd
,
6398 (htab
->elf
.sgotplt
->output_section
->vma
6399 + htab
->elf
.sgotplt
->output_offset
6401 - htab
->elf
.splt
->output_section
->vma
6402 - htab
->elf
.splt
->output_offset
6405 (htab
->elf
.splt
->contents
6407 + htab
->lazy_plt
->plt0_got1_offset
));
6408 /* Add offset for the PC-relative instruction accessing
6409 GOT+TDG, where TDG stands for htab->tlsdesc_got,
6410 subtracting the offset to the end of that
6412 bfd_put_32 (output_bfd
,
6413 (htab
->elf
.sgot
->output_section
->vma
6414 + htab
->elf
.sgot
->output_offset
6416 - htab
->elf
.splt
->output_section
->vma
6417 - htab
->elf
.splt
->output_offset
6419 - htab
->lazy_plt
->plt0_got2_insn_end
),
6420 (htab
->elf
.splt
->contents
6422 + htab
->lazy_plt
->plt0_got2_offset
));
6428 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
6429 elf_section_data (htab
->plt_got
->output_section
)
6430 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6432 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
6433 elf_section_data (htab
->plt_second
->output_section
)
6434 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
6436 /* GOT is always created in setup_gnu_properties. But it may not be
6438 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
6440 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6443 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6447 /* Set the first entry in the global offset table to the address of
6448 the dynamic section. */
6450 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6452 bfd_put_64 (output_bfd
,
6453 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6454 htab
->elf
.sgotplt
->contents
);
6455 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6456 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6457 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6458 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6459 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6461 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
6465 /* Adjust .eh_frame for .plt section. */
6466 if (htab
->plt_eh_frame
!= NULL
6467 && htab
->plt_eh_frame
->contents
!= NULL
)
6469 if (htab
->elf
.splt
!= NULL
6470 && htab
->elf
.splt
->size
!= 0
6471 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6472 && htab
->elf
.splt
->output_section
!= NULL
6473 && htab
->plt_eh_frame
->output_section
!= NULL
)
6475 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6476 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6477 + htab
->plt_eh_frame
->output_offset
6478 + PLT_FDE_START_OFFSET
;
6479 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6480 htab
->plt_eh_frame
->contents
6481 + PLT_FDE_START_OFFSET
);
6483 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6485 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6487 htab
->plt_eh_frame
->contents
))
6492 /* Adjust .eh_frame for .plt.got section. */
6493 if (htab
->plt_got_eh_frame
!= NULL
6494 && htab
->plt_got_eh_frame
->contents
!= NULL
)
6496 if (htab
->plt_got
!= NULL
6497 && htab
->plt_got
->size
!= 0
6498 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
6499 && htab
->plt_got
->output_section
!= NULL
6500 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
6502 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
6503 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
6504 + htab
->plt_got_eh_frame
->output_offset
6505 + PLT_FDE_START_OFFSET
;
6506 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6507 htab
->plt_got_eh_frame
->contents
6508 + PLT_FDE_START_OFFSET
);
6510 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6512 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6513 htab
->plt_got_eh_frame
,
6514 htab
->plt_got_eh_frame
->contents
))
6519 /* Adjust .eh_frame for the second PLT section. */
6520 if (htab
->plt_second_eh_frame
!= NULL
6521 && htab
->plt_second_eh_frame
->contents
!= NULL
)
6523 if (htab
->plt_second
!= NULL
6524 && htab
->plt_second
->size
!= 0
6525 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
6526 && htab
->plt_second
->output_section
!= NULL
6527 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
6529 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
6530 bfd_vma eh_frame_start
6531 = (htab
->plt_second_eh_frame
->output_section
->vma
6532 + htab
->plt_second_eh_frame
->output_offset
6533 + PLT_FDE_START_OFFSET
);
6534 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6535 htab
->plt_second_eh_frame
->contents
6536 + PLT_FDE_START_OFFSET
);
6538 if (htab
->plt_second_eh_frame
->sec_info_type
6539 == SEC_INFO_TYPE_EH_FRAME
)
6541 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6542 htab
->plt_second_eh_frame
,
6543 htab
->plt_second_eh_frame
->contents
))
6548 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6549 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6552 /* Fill PLT entries for undefined weak symbols in PIE. */
6553 if (bfd_link_pie (info
))
6554 bfd_hash_traverse (&info
->hash
->table
,
6555 elf_x86_64_pie_finish_undefweak_symbol
,
6561 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6562 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6563 It has to be done before elf_link_sort_relocs is called so that
6564 dynamic relocations are properly sorted. */
6567 elf_x86_64_output_arch_local_syms
6568 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6569 struct bfd_link_info
*info
,
6570 void *flaginfo ATTRIBUTE_UNUSED
,
6571 int (*func
) (void *, const char *,
6574 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6576 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6580 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6581 htab_traverse (htab
->loc_hash_table
,
6582 elf_x86_64_finish_local_dynamic_symbol
,
6588 /* Sort relocs into address order. */
6591 compare_relocs (const void *ap
, const void *bp
)
6593 const arelent
*a
= * (const arelent
**) ap
;
6594 const arelent
*b
= * (const arelent
**) bp
;
6596 if (a
->address
> b
->address
)
6598 else if (a
->address
< b
->address
)
6604 enum elf_x86_64_plt_type
6608 plt_second
= 1 << 1,
6612 struct elf_x86_64_plt
6617 enum elf_x86_64_plt_type type
;
6618 unsigned int plt_got_offset
;
6619 unsigned int plt_got_insn_size
;
6620 unsigned int plt_entry_size
;
6624 /* Forward declaration. */
6625 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
;
6627 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
6628 dynamic relocations. */
6631 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6632 long symcount ATTRIBUTE_UNUSED
,
6633 asymbol
**syms ATTRIBUTE_UNUSED
,
6638 long size
, count
, i
, n
, len
;
6640 unsigned int plt_got_offset
, plt_entry_size
, plt_got_insn_size
;
6642 bfd_byte
*plt_contents
;
6643 long dynrelcount
, relsize
;
6644 arelent
**dynrelbuf
, *p
;
6645 const struct elf_x86_64_lazy_plt_layout
*lazy_plt
;
6646 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_plt
;
6647 const struct elf_x86_64_lazy_plt_layout
*lazy_bnd_plt
;
6648 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_bnd_plt
;
6649 const struct elf_x86_64_lazy_plt_layout
*lazy_ibt_plt
;
6650 const struct elf_x86_64_non_lazy_plt_layout
*non_lazy_ibt_plt
;
6653 enum elf_x86_64_plt_type plt_type
;
6654 struct elf_x86_64_plt plts
[] =
6656 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0, 0 },
6657 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 },
6658 { ".plt.sec", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6659 { ".plt.bnd", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
6660 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 }
6665 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
6668 if (dynsymcount
<= 0)
6671 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
6675 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
6676 if (dynrelbuf
== NULL
)
6679 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
6682 /* Sort the relocs by address. */
6683 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*), compare_relocs
);
6685 if (get_elf_x86_64_backend_data (abfd
)->os
== is_normal
)
6687 lazy_plt
= &elf_x86_64_lazy_plt
;
6688 non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
6689 lazy_bnd_plt
= &elf_x86_64_lazy_bnd_plt
;
6690 non_lazy_bnd_plt
= &elf_x86_64_non_lazy_bnd_plt
;
6691 if (ABI_64_P (abfd
))
6693 lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
6694 non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
6698 lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
6699 non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
6704 lazy_plt
= &elf_x86_64_nacl_plt
;
6705 non_lazy_plt
= NULL
;
6706 lazy_bnd_plt
= NULL
;
6707 non_lazy_bnd_plt
= NULL
;
6708 lazy_ibt_plt
= NULL
;
6709 non_lazy_ibt_plt
= NULL
;
6713 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6715 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
6719 /* Get the PLT section contents. */
6720 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6721 if (plt_contents
== NULL
)
6723 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6724 plt_contents
, 0, plt
->size
))
6726 free (plt_contents
);
6730 /* Check what kind of PLT it is. */
6731 plt_type
= plt_unknown
;
6732 if (plts
[j
].type
== plt_unknown
)
6734 /* Match lazy PLT first. Need to check the first two
6736 if ((memcmp (plt_contents
, lazy_plt
->plt0_entry
,
6737 lazy_plt
->plt0_got1_offset
) == 0)
6738 && (memcmp (plt_contents
+ 6, lazy_plt
->plt0_entry
+ 6,
6740 plt_type
= plt_lazy
;
6741 else if (lazy_bnd_plt
!= NULL
6742 && (memcmp (plt_contents
, lazy_bnd_plt
->plt0_entry
,
6743 lazy_bnd_plt
->plt0_got1_offset
) == 0)
6744 && (memcmp (plt_contents
+ 6,
6745 lazy_bnd_plt
->plt0_entry
+ 6, 3) == 0))
6747 plt_type
= plt_lazy
| plt_second
;
6748 /* The fist entry in the lazy IBT PLT is the same as the
6750 if ((memcmp (plt_contents
+ lazy_ibt_plt
->plt_entry_size
,
6751 lazy_ibt_plt
->plt_entry
,
6752 lazy_ibt_plt
->plt_got_offset
) == 0))
6753 lazy_plt
= lazy_ibt_plt
;
6755 lazy_plt
= lazy_bnd_plt
;
6759 if (non_lazy_plt
!= NULL
6760 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
))
6762 /* Match non-lazy PLT. */
6763 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
6764 non_lazy_plt
->plt_got_offset
) == 0)
6765 plt_type
= plt_non_lazy
;
6768 if (plt_type
== plt_unknown
|| plt_type
== plt_second
)
6770 if (non_lazy_bnd_plt
!= NULL
6771 && (memcmp (plt_contents
, non_lazy_bnd_plt
->plt_entry
,
6772 non_lazy_bnd_plt
->plt_got_offset
) == 0))
6774 /* Match BND PLT. */
6775 plt_type
= plt_second
;
6776 non_lazy_plt
= non_lazy_bnd_plt
;
6778 else if (non_lazy_ibt_plt
!= NULL
6779 && (memcmp (plt_contents
,
6780 non_lazy_ibt_plt
->plt_entry
,
6781 non_lazy_ibt_plt
->plt_got_offset
) == 0))
6783 /* Match IBT PLT. */
6784 plt_type
= plt_second
;
6785 non_lazy_plt
= non_lazy_ibt_plt
;
6789 if (plt_type
== plt_unknown
)
6793 plts
[j
].type
= plt_type
;
6795 if ((plt_type
& plt_lazy
))
6797 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
6798 plts
[j
].plt_got_insn_size
= lazy_plt
->plt_got_insn_size
;
6799 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
6800 /* Skip PLT0 in lazy PLT. */
6805 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
6806 plts
[j
].plt_got_insn_size
= non_lazy_plt
->plt_got_insn_size
;
6807 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
6811 /* Skip lazy PLT when the second PLT is used. */
6812 if (plt_type
== (plt_lazy
| plt_second
))
6816 n
= plt
->size
/ plts
[j
].plt_entry_size
;
6821 plts
[j
].contents
= plt_contents
;
6824 size
= count
* sizeof (asymbol
);
6826 /* Allocate space for @plt suffixes. */
6828 for (i
= 0; i
< dynrelcount
; i
++)
6831 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
6833 size
+= sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd
);
6836 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
6840 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6841 if (plts
[j
].contents
!= NULL
)
6842 free (plts
[j
].contents
);
6847 /* Check for each PLT section. */
6848 names
= (char *) (s
+ count
);
6851 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6852 if ((plt_contents
= plts
[j
].contents
) != NULL
)
6857 plt_got_offset
= plts
[j
].plt_got_offset
;
6858 plt_got_insn_size
= plts
[j
].plt_got_insn_size
;
6859 plt_entry_size
= plts
[j
].plt_entry_size
;
6863 if ((plts
[j
].type
& plt_lazy
))
6865 /* Skip PLT0 in lazy PLT. */
6867 offset
= plt_entry_size
;
6875 /* Check each PLT entry against dynamic relocations. */
6876 for (; k
< plts
[j
].count
; k
++)
6882 /* Get the PC-relative offset, a signed 32-bit integer. */
6883 off
= H_GET_32 (abfd
, (plt_contents
+ offset
6885 got_vma
= plt
->vma
+ offset
+ off
+ plt_got_insn_size
;
6887 /* Binary search. */
6891 while ((min
+ 1) < max
)
6895 mid
= (min
+ max
) / 2;
6897 if (got_vma
> r
->address
)
6899 else if (got_vma
< r
->address
)
6908 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6909 if (got_vma
== p
->address
6911 && (p
->howto
->type
== R_X86_64_JUMP_SLOT
6912 || p
->howto
->type
== R_X86_64_GLOB_DAT
6913 || p
->howto
->type
== R_X86_64_IRELATIVE
))
6915 *s
= **p
->sym_ptr_ptr
;
6916 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6917 set. Since we are defining a symbol, ensure one
6919 if ((s
->flags
& BSF_LOCAL
) == 0)
6920 s
->flags
|= BSF_GLOBAL
;
6921 s
->flags
|= BSF_SYNTHETIC
;
6922 /* This is no longer a section symbol. */
6923 s
->flags
&= ~BSF_SECTION_SYM
;
6925 s
->the_bfd
= plt
->owner
;
6929 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
6930 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
6936 memcpy (names
, "+0x", sizeof ("+0x") - 1);
6937 names
+= sizeof ("+0x") - 1;
6938 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
6939 for (a
= buf
; *a
== '0'; ++a
)
6942 memcpy (names
, a
, size
);
6945 memcpy (names
, "@plt", sizeof ("@plt"));
6946 names
+= sizeof ("@plt");
6950 offset
+= plt_entry_size
;
6954 /* PLT entries with R_X86_64_TLSDESC relocations are skipped. */
6960 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6961 if (plts
[j
].contents
!= NULL
)
6962 free (plts
[j
].contents
);
6969 /* Handle an x86-64 specific section when reading an object file. This
6970 is called when elfcode.h finds a section with an unknown type. */
6973 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6974 const char *name
, int shindex
)
6976 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6979 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6985 /* Hook called by the linker routine which adds symbols from an object
6986 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6990 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6991 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6992 Elf_Internal_Sym
*sym
,
6993 const char **namep ATTRIBUTE_UNUSED
,
6994 flagword
*flagsp ATTRIBUTE_UNUSED
,
7000 switch (sym
->st_shndx
)
7002 case SHN_X86_64_LCOMMON
:
7003 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
7006 lcomm
= bfd_make_section_with_flags (abfd
,
7010 | SEC_LINKER_CREATED
));
7013 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
7016 *valp
= sym
->st_size
;
7024 /* Given a BFD section, try to locate the corresponding ELF section
7028 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
7029 asection
*sec
, int *index_return
)
7031 if (sec
== &_bfd_elf_large_com_section
)
7033 *index_return
= SHN_X86_64_LCOMMON
;
7039 /* Process a symbol. */
7042 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
7045 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
7047 switch (elfsym
->internal_elf_sym
.st_shndx
)
7049 case SHN_X86_64_LCOMMON
:
7050 asym
->section
= &_bfd_elf_large_com_section
;
7051 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
7052 /* Common symbol doesn't set BSF_GLOBAL. */
7053 asym
->flags
&= ~BSF_GLOBAL
;
7059 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
7061 return (sym
->st_shndx
== SHN_COMMON
7062 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
7066 elf_x86_64_common_section_index (asection
*sec
)
7068 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
7071 return SHN_X86_64_LCOMMON
;
7075 elf_x86_64_common_section (asection
*sec
)
7077 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
7078 return bfd_com_section_ptr
;
7080 return &_bfd_elf_large_com_section
;
7084 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
7085 const Elf_Internal_Sym
*sym
,
7090 const asection
*oldsec
)
7092 /* A normal common symbol and a large common symbol result in a
7093 normal common symbol. We turn the large common symbol into a
7096 && h
->root
.type
== bfd_link_hash_common
7098 && bfd_is_com_section (*psec
)
7101 if (sym
->st_shndx
== SHN_COMMON
7102 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
7104 h
->root
.u
.c
.p
->section
7105 = bfd_make_section_old_way (oldbfd
, "COMMON");
7106 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
7108 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
7109 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
7110 *psec
= bfd_com_section_ptr
;
7117 elf_x86_64_additional_program_headers (bfd
*abfd
,
7118 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7123 /* Check to see if we need a large readonly segment. */
7124 s
= bfd_get_section_by_name (abfd
, ".lrodata");
7125 if (s
&& (s
->flags
& SEC_LOAD
))
7128 /* Check to see if we need a large data segment. Since .lbss sections
7129 is placed right after the .bss section, there should be no need for
7130 a large data segment just because of .lbss. */
7131 s
= bfd_get_section_by_name (abfd
, ".ldata");
7132 if (s
&& (s
->flags
& SEC_LOAD
))
7138 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
7141 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
7143 if (h
->plt
.offset
!= (bfd_vma
) -1
7145 && !h
->pointer_equality_needed
)
7148 return _bfd_elf_hash_symbol (h
);
7151 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
7154 elf_x86_64_relocs_compatible (const bfd_target
*input
,
7155 const bfd_target
*output
)
7157 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
7158 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
7159 && _bfd_elf_relocs_compatible (input
, output
));
7162 /* Parse x86-64 GNU properties. */
7164 static enum elf_property_kind
7165 elf_x86_64_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
7166 bfd_byte
*ptr
, unsigned int datasz
)
7172 case GNU_PROPERTY_X86_ISA_1_USED
:
7173 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
7174 case GNU_PROPERTY_X86_FEATURE_1_AND
:
7178 ((type
== GNU_PROPERTY_X86_ISA_1_USED
7179 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
7180 : (type
== GNU_PROPERTY_X86_ISA_1_NEEDED
7181 ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
7182 : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
7184 return property_corrupt
;
7186 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
7187 /* Combine properties of the same type. */
7188 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
7189 prop
->pr_kind
= property_number
;
7193 return property_ignored
;
7196 return property_number
;
7199 /* Merge x86-64 GNU property BPROP with APROP. If APROP isn't NULL,
7200 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
7201 should be merged with ABFD. */
7204 elf_x86_64_merge_gnu_properties (struct bfd_link_info
*info
,
7205 bfd
*abfd ATTRIBUTE_UNUSED
,
7206 elf_property
*aprop
,
7207 elf_property
*bprop
)
7209 unsigned int number
, features
;
7210 bfd_boolean updated
= FALSE
;
7211 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
7215 case GNU_PROPERTY_X86_ISA_1_USED
:
7216 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
7217 if (aprop
!= NULL
&& bprop
!= NULL
)
7219 number
= aprop
->u
.number
;
7220 aprop
->u
.number
= number
| bprop
->u
.number
;
7221 updated
= number
!= (unsigned int) aprop
->u
.number
;
7225 /* Return TRUE if APROP is NULL to indicate that BPROP should
7226 be added to ABFD. */
7227 updated
= aprop
== NULL
;
7231 case GNU_PROPERTY_X86_FEATURE_1_AND
:
7232 /* Only one of APROP and BPROP can be NULL:
7233 1. APROP & BPROP when both APROP and BPROP aren't NULL.
7234 2. If APROP is NULL, remove x86 feature.
7235 3. Otherwise, do nothing.
7237 if (aprop
!= NULL
&& bprop
!= NULL
)
7241 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7243 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7244 number
= aprop
->u
.number
;
7245 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7246 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7247 aprop
->u
.number
= (number
& bprop
->u
.number
) | features
;
7248 updated
= number
!= (unsigned int) aprop
->u
.number
;
7249 /* Remove the property if all feature bits are cleared. */
7250 if (aprop
->u
.number
== 0)
7251 aprop
->pr_kind
= property_remove
;
7257 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7259 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7262 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7263 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7266 number
= aprop
->u
.number
;
7267 aprop
->u
.number
= number
| features
;
7268 updated
= number
!= (unsigned int) aprop
->u
.number
;
7272 bprop
->u
.number
|= features
;
7276 else if (aprop
!= NULL
)
7278 aprop
->pr_kind
= property_remove
;
7285 /* Never should happen. */
7292 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
7293 with GNU properties if found. Otherwise, return NULL. */
7296 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info
*info
)
7298 bfd_boolean normal_target
;
7299 bfd_boolean lazy_plt
;
7300 asection
*sec
, *pltsec
;
7302 bfd_boolean use_ibt_plt
;
7303 unsigned int plt_alignment
, features
;
7304 struct elf_x86_64_link_hash_table
*htab
;
7311 features
= GNU_PROPERTY_X86_FEATURE_1_IBT
;
7313 features
|= GNU_PROPERTY_X86_FEATURE_1_SHSTK
;
7315 /* Find a normal input file with GNU property note. */
7316 for (pbfd
= info
->input_bfds
;
7318 pbfd
= pbfd
->link
.next
)
7319 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
7320 && bfd_count_sections (pbfd
) != 0)
7324 if (elf_properties (pbfd
) != NULL
)
7332 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
7333 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */
7334 prop
= _bfd_elf_get_property (ebfd
,
7335 GNU_PROPERTY_X86_FEATURE_1_AND
,
7337 prop
->u
.number
|= features
;
7338 prop
->pr_kind
= property_number
;
7340 /* Create the GNU property note section if needed. */
7343 sec
= bfd_make_section_with_flags (ebfd
,
7344 NOTE_GNU_PROPERTY_SECTION_NAME
,
7352 info
->callbacks
->einfo (_("%F: failed to create GNU property section\n"));
7354 if (!bfd_set_section_alignment (ebfd
, sec
,
7355 ABI_64_P (ebfd
) ? 3 : 2))
7358 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
7362 elf_section_type (sec
) = SHT_NOTE
;
7366 /* Check GNU_PROPERTY_NO_COPY_ON_PROTECTED. */
7367 for (; pbfd
!= NULL
; pbfd
= pbfd
->link
.next
)
7368 if (bfd_get_flavour (pbfd
) == bfd_target_elf_flavour
7370 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
7372 elf_property_list
*p
;
7374 /* The property list is sorted in order of type. */
7375 for (p
= elf_properties (pbfd
); p
!= NULL
; p
= p
->next
)
7377 if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7378 == p
->property
.pr_type
)
7380 /* Clear extern_protected_data if
7381 GNU_PROPERTY_NO_COPY_ON_PROTECTED is
7382 set on any input relocatable file. */
7383 info
->extern_protected_data
= FALSE
;
7386 else if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7387 < p
->property
.pr_type
)
7393 pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
7395 if (bfd_link_relocatable (info
))
7398 htab
= elf_x86_64_hash_table (info
);
7402 use_ibt_plt
= info
->ibtplt
|| info
->ibt
;
7403 if (!use_ibt_plt
&& pbfd
!= NULL
)
7405 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */
7406 elf_property_list
*p
;
7408 /* The property list is sorted in order of type. */
7409 for (p
= elf_properties (pbfd
); p
; p
= p
->next
)
7411 if (GNU_PROPERTY_X86_FEATURE_1_AND
== p
->property
.pr_type
)
7413 use_ibt_plt
= !!(p
->property
.u
.number
7414 & GNU_PROPERTY_X86_FEATURE_1_IBT
);
7417 else if (GNU_PROPERTY_X86_FEATURE_1_AND
< p
->property
.pr_type
)
7422 dynobj
= htab
->elf
.dynobj
;
7424 /* Set htab->elf.dynobj here so that there is no need to check and
7425 set it in check_relocs. */
7430 htab
->elf
.dynobj
= pbfd
;
7437 /* Find a normal input file to hold linker created
7439 for (abfd
= info
->input_bfds
;
7441 abfd
= abfd
->link
.next
)
7442 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
7444 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
7446 htab
->elf
.dynobj
= abfd
;
7453 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
7454 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
7455 canonical function address. */
7456 htab
->plt
.has_plt0
= 1;
7458 if (get_elf_x86_64_backend_data (info
->output_bfd
)->os
7463 if (ABI_64_P (dynobj
))
7465 htab
->lazy_plt
= &elf_x86_64_lazy_ibt_plt
;
7466 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_ibt_plt
;
7470 htab
->lazy_plt
= &elf_x32_lazy_ibt_plt
;
7471 htab
->non_lazy_plt
= &elf_x32_non_lazy_ibt_plt
;
7474 else if (info
->bndplt
)
7476 htab
->lazy_plt
= &elf_x86_64_lazy_bnd_plt
;
7477 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_bnd_plt
;
7481 htab
->lazy_plt
= &elf_x86_64_lazy_plt
;
7482 htab
->non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
7484 normal_target
= TRUE
;
7488 htab
->lazy_plt
= &elf_x86_64_nacl_plt
;
7489 htab
->non_lazy_plt
= NULL
;
7490 normal_target
= FALSE
;
7493 pltsec
= htab
->elf
.splt
;
7495 /* If the non-lazy PLT is available, use it for all PLT entries if
7496 there are no PLT0 or no .plt section. */
7497 if (htab
->non_lazy_plt
!= NULL
7498 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
7502 = htab
->non_lazy_plt
->plt_entry
;
7503 htab
->plt
.plt_entry_size
7504 = htab
->non_lazy_plt
->plt_entry_size
;
7505 htab
->plt
.plt_got_offset
7506 = htab
->non_lazy_plt
->plt_got_offset
;
7507 htab
->plt
.plt_got_insn_size
7508 = htab
->non_lazy_plt
->plt_got_insn_size
;
7509 htab
->plt
.eh_frame_plt_size
7510 = htab
->non_lazy_plt
->eh_frame_plt_size
;
7511 htab
->plt
.eh_frame_plt
7512 = htab
->non_lazy_plt
->eh_frame_plt
;
7518 = htab
->lazy_plt
->plt_entry
;
7519 htab
->plt
.plt_entry_size
7520 = htab
->lazy_plt
->plt_entry_size
;
7521 htab
->plt
.plt_got_offset
7522 = htab
->lazy_plt
->plt_got_offset
;
7523 htab
->plt
.plt_got_insn_size
7524 = htab
->lazy_plt
->plt_got_insn_size
;
7525 htab
->plt
.eh_frame_plt_size
7526 = htab
->lazy_plt
->eh_frame_plt_size
;
7527 htab
->plt
.eh_frame_plt
7528 = htab
->lazy_plt
->eh_frame_plt
;
7531 /* Return if there are no normal input files. */
7535 /* Since create_dynamic_sections isn't always called, but GOT
7536 relocations need GOT relocations, create them here so that we
7537 don't need to do it in check_relocs. */
7538 if (htab
->elf
.sgot
== NULL
7539 && !_bfd_elf_create_got_section (dynobj
, info
))
7540 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
7542 /* Align .got and .got.plt sections to their entry size. Do it here
7543 instead of in create_dynamic_sections so that they are always
7544 properly aligned even if create_dynamic_sections isn't called. */
7545 sec
= htab
->elf
.sgot
;
7546 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7547 goto error_alignment
;
7549 sec
= htab
->elf
.sgotplt
;
7550 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7551 goto error_alignment
;
7553 /* Create the ifunc sections here so that check_relocs can be
7555 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
7556 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
7558 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
7562 /* Whe creating executable, set the contents of the .interp
7563 section to the interpreter. */
7564 if (bfd_link_executable (info
) && !info
->nointerp
)
7566 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
7569 s
->size
= htab
->dynamic_interpreter_size
;
7570 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
7574 /* Don't change PLT section alignment for NaCl since it uses
7575 64-byte PLT entry and sets PLT section alignment to 32
7576 bytes. Don't create additional PLT sections for NaCl. */
7579 const struct elf_backend_data
*bed
7580 = get_elf_backend_data (dynobj
);
7581 flagword pltflags
= (bed
->dynamic_sec_flags
7586 unsigned int non_lazy_plt_alignment
7587 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
7590 if (!bfd_set_section_alignment (sec
->owner
, sec
,
7592 goto error_alignment
;
7594 /* Create the GOT procedure linkage table. */
7595 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7599 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
7601 if (!bfd_set_section_alignment (dynobj
, sec
,
7602 non_lazy_plt_alignment
))
7603 goto error_alignment
;
7605 htab
->plt_got
= sec
;
7613 /* Create the second PLT for Intel IBT support. IBT
7614 PLT is supported only for non-NaCl target and is
7615 is needed only for lazy binding. */
7616 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7620 info
->callbacks
->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
7622 if (!bfd_set_section_alignment (dynobj
, sec
,
7624 goto error_alignment
;
7626 else if (info
->bndplt
&& ABI_64_P (dynobj
))
7628 /* Create the second PLT for Intel MPX support. MPX
7629 PLT is supported only for non-NaCl target in 64-bit
7630 mode and is needed only for lazy binding. */
7631 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7635 info
->callbacks
->einfo (_("%F: failed to create BND PLT section\n"));
7637 if (!bfd_set_section_alignment (dynobj
, sec
,
7638 non_lazy_plt_alignment
))
7639 goto error_alignment
;
7642 htab
->plt_second
= sec
;
7646 if (!info
->no_ld_generated_unwind_info
)
7648 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
7649 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7650 | SEC_LINKER_CREATED
);
7652 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7656 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
7658 if (!bfd_set_section_alignment (dynobj
, sec
,
7659 ABI_64_P (dynobj
) ? 3 : 2))
7660 goto error_alignment
;
7662 htab
->plt_eh_frame
= sec
;
7664 if (htab
->plt_got
!= NULL
)
7666 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7670 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
7672 if (!bfd_set_section_alignment (dynobj
, sec
,
7673 ABI_64_P (dynobj
) ? 3 : 2))
7674 goto error_alignment
;
7676 htab
->plt_got_eh_frame
= sec
;
7679 if (htab
->plt_second
!= NULL
)
7681 sec
= bfd_make_section_anyway_with_flags (dynobj
,
7685 info
->callbacks
->einfo (_("%F: failed to create BND PLT .eh_frame section\n"));
7687 if (!bfd_set_section_alignment (dynobj
, sec
, 3))
7688 goto error_alignment
;
7690 htab
->plt_second_eh_frame
= sec
;
7697 /* The .iplt section is used for IFUNC symbols in static
7699 sec
= htab
->elf
.iplt
;
7701 && !bfd_set_section_alignment (sec
->owner
, sec
,
7703 goto error_alignment
;
7710 elf_x86_64_link_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
)
7712 if (!bfd_link_relocatable (info
))
7714 /* Check for __tls_get_addr reference. */
7715 struct elf_link_hash_entry
*h
;
7716 h
= elf_link_hash_lookup (elf_hash_table (info
), "__tls_get_addr",
7717 FALSE
, FALSE
, FALSE
);
7719 ((struct elf_x86_64_link_hash_entry
*) h
)->tls_get_addr
= 1;
7722 /* Invoke the regular ELF backend linker to do all the work. */
7723 return _bfd_elf_link_check_relocs (abfd
, info
);
7726 static const struct bfd_elf_special_section
7727 elf_x86_64_special_sections
[]=
7729 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7730 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7731 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
7732 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7733 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
7734 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
7735 { NULL
, 0, 0, 0, 0 }
7738 #define TARGET_LITTLE_SYM x86_64_elf64_vec
7739 #define TARGET_LITTLE_NAME "elf64-x86-64"
7740 #define ELF_ARCH bfd_arch_i386
7741 #define ELF_TARGET_ID X86_64_ELF_DATA
7742 #define ELF_MACHINE_CODE EM_X86_64
7743 #define ELF_MAXPAGESIZE 0x200000
7744 #define ELF_MINPAGESIZE 0x1000
7745 #define ELF_COMMONPAGESIZE 0x1000
7747 #define elf_backend_can_gc_sections 1
7748 #define elf_backend_can_refcount 1
7749 #define elf_backend_want_got_plt 1
7750 #define elf_backend_plt_readonly 1
7751 #define elf_backend_want_plt_sym 0
7752 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
7753 #define elf_backend_rela_normal 1
7754 #define elf_backend_plt_alignment 4
7755 #define elf_backend_extern_protected_data 1
7756 #define elf_backend_caches_rawsize 1
7757 #define elf_backend_dtrel_excludes_plt 1
7758 #define elf_backend_want_dynrelro 1
7760 #define elf_info_to_howto elf_x86_64_info_to_howto
7762 #define bfd_elf64_bfd_link_hash_table_create \
7763 elf_x86_64_link_hash_table_create
7764 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
7765 #define bfd_elf64_bfd_reloc_name_lookup \
7766 elf_x86_64_reloc_name_lookup
7768 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
7769 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
7770 #define elf_backend_check_relocs elf_x86_64_check_relocs
7771 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
7772 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
7773 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
7774 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
7775 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
7776 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
7777 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
7778 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
7780 #define elf_backend_write_core_note elf_x86_64_write_core_note
7782 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
7783 #define elf_backend_relocate_section elf_x86_64_relocate_section
7784 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
7785 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
7786 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
7787 #define elf_backend_object_p elf64_x86_64_elf_object_p
7788 #define bfd_elf64_mkobject elf_x86_64_mkobject
7789 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
7790 #define bfd_elf64_bfd_link_check_relocs elf_x86_64_link_check_relocs
7792 #define elf_backend_section_from_shdr \
7793 elf_x86_64_section_from_shdr
7795 #define elf_backend_section_from_bfd_section \
7796 elf_x86_64_elf_section_from_bfd_section
7797 #define elf_backend_add_symbol_hook \
7798 elf_x86_64_add_symbol_hook
7799 #define elf_backend_symbol_processing \
7800 elf_x86_64_symbol_processing
7801 #define elf_backend_common_section_index \
7802 elf_x86_64_common_section_index
7803 #define elf_backend_common_section \
7804 elf_x86_64_common_section
7805 #define elf_backend_common_definition \
7806 elf_x86_64_common_definition
7807 #define elf_backend_merge_symbol \
7808 elf_x86_64_merge_symbol
7809 #define elf_backend_special_sections \
7810 elf_x86_64_special_sections
7811 #define elf_backend_additional_program_headers \
7812 elf_x86_64_additional_program_headers
7813 #define elf_backend_hash_symbol \
7814 elf_x86_64_hash_symbol
7815 #define elf_backend_omit_section_dynsym \
7816 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
7817 #define elf_backend_fixup_symbol \
7818 elf_x86_64_fixup_symbol
7819 #define elf_backend_parse_gnu_properties \
7820 elf_x86_64_parse_gnu_properties
7821 #define elf_backend_merge_gnu_properties \
7822 elf_x86_64_merge_gnu_properties
7823 #define elf_backend_setup_gnu_properties \
7824 elf_x86_64_link_setup_gnu_properties
7826 #include "elf64-target.h"
7828 /* CloudABI support. */
7830 #undef TARGET_LITTLE_SYM
7831 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
7832 #undef TARGET_LITTLE_NAME
7833 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
7836 #define ELF_OSABI ELFOSABI_CLOUDABI
7839 #define elf64_bed elf64_x86_64_cloudabi_bed
7841 #include "elf64-target.h"
7843 /* FreeBSD support. */
7845 #undef TARGET_LITTLE_SYM
7846 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
7847 #undef TARGET_LITTLE_NAME
7848 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
7851 #define ELF_OSABI ELFOSABI_FREEBSD
7854 #define elf64_bed elf64_x86_64_fbsd_bed
7856 #include "elf64-target.h"
7858 /* Solaris 2 support. */
7860 #undef TARGET_LITTLE_SYM
7861 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
7862 #undef TARGET_LITTLE_NAME
7863 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
7865 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
7866 objects won't be recognized. */
7870 #define elf64_bed elf64_x86_64_sol2_bed
7872 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
7874 #undef elf_backend_static_tls_alignment
7875 #define elf_backend_static_tls_alignment 16
7877 /* The Solaris 2 ABI requires a plt symbol on all platforms.
7879 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
7881 #undef elf_backend_want_plt_sym
7882 #define elf_backend_want_plt_sym 1
7884 #undef elf_backend_strtab_flags
7885 #define elf_backend_strtab_flags SHF_STRINGS
7888 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
7889 bfd
*obfd ATTRIBUTE_UNUSED
,
7890 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
7891 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
7893 /* PR 19938: FIXME: Need to add code for setting the sh_info
7894 and sh_link fields of Solaris specific section types. */
7898 #undef elf_backend_copy_special_section_fields
7899 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
7901 #include "elf64-target.h"
7903 /* Native Client support. */
7906 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
7908 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
7909 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
7913 #undef TARGET_LITTLE_SYM
7914 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
7915 #undef TARGET_LITTLE_NAME
7916 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
7918 #define elf64_bed elf64_x86_64_nacl_bed
7920 #undef ELF_MAXPAGESIZE
7921 #undef ELF_MINPAGESIZE
7922 #undef ELF_COMMONPAGESIZE
7923 #define ELF_MAXPAGESIZE 0x10000
7924 #define ELF_MINPAGESIZE 0x10000
7925 #define ELF_COMMONPAGESIZE 0x10000
7927 /* Restore defaults. */
7929 #undef elf_backend_static_tls_alignment
7930 #undef elf_backend_want_plt_sym
7931 #define elf_backend_want_plt_sym 0
7932 #undef elf_backend_strtab_flags
7933 #undef elf_backend_copy_special_section_fields
7935 /* NaCl uses substantially different PLT entries for the same effects. */
7937 #undef elf_backend_plt_alignment
7938 #define elf_backend_plt_alignment 5
7939 #define NACL_PLT_ENTRY_SIZE 64
7940 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
7942 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
7944 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
7945 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
7946 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7947 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7948 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7950 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
7951 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
7953 /* 32 bytes of nop to pad out to the standard size. */
7954 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7955 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7956 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7957 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7958 0x66, /* excess data16 prefix */
7962 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
7964 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
7965 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
7966 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
7967 0x41, 0xff, 0xe3, /* jmpq *%r11 */
7969 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
7970 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
7971 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7973 /* Lazy GOT entries point here (32-byte aligned). */
7974 0x68, /* pushq immediate */
7975 0, 0, 0, 0, /* replaced with index into relocation table. */
7976 0xe9, /* jmp relative */
7977 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
7979 /* 22 bytes of nop to pad out to the standard size. */
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) */
7982 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
7985 /* .eh_frame covering the .plt section. */
7987 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
7989 #if (PLT_CIE_LENGTH != 20 \
7990 || PLT_FDE_LENGTH != 36 \
7991 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
7992 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
7993 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
7995 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
7996 0, 0, 0, 0, /* CIE ID */
7997 1, /* CIE version */
7998 'z', 'R', 0, /* Augmentation string */
7999 1, /* Code alignment factor */
8000 0x78, /* Data alignment factor */
8001 16, /* Return address column */
8002 1, /* Augmentation size */
8003 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
8004 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
8005 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
8006 DW_CFA_nop
, DW_CFA_nop
,
8008 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
8009 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
8010 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
8011 0, 0, 0, 0, /* .plt size goes here */
8012 0, /* Augmentation size */
8013 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
8014 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
8015 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
8016 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
8017 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
8018 13, /* Block length */
8019 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
8020 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
8021 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
8022 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
8023 DW_CFA_nop
, DW_CFA_nop
8026 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt
=
8028 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
8029 elf_x86_64_nacl_plt_entry
, /* plt_entry */
8030 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
8031 2, /* plt0_got1_offset */
8032 9, /* plt0_got2_offset */
8033 13, /* plt0_got2_insn_end */
8034 3, /* plt_got_offset */
8035 33, /* plt_reloc_offset */
8036 38, /* plt_plt_offset */
8037 7, /* plt_got_insn_size */
8038 42, /* plt_plt_insn_end */
8039 32, /* plt_lazy_offset */
8040 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
8041 sizeof (elf_x86_64_nacl_eh_frame_plt
) /* eh_frame_plt_size */
8044 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
8049 #undef elf_backend_arch_data
8050 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
8052 #undef elf_backend_object_p
8053 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
8054 #undef elf_backend_modify_segment_map
8055 #define elf_backend_modify_segment_map nacl_modify_segment_map
8056 #undef elf_backend_modify_program_headers
8057 #define elf_backend_modify_program_headers nacl_modify_program_headers
8058 #undef elf_backend_final_write_processing
8059 #define elf_backend_final_write_processing nacl_final_write_processing
8061 #include "elf64-target.h"
8063 /* Native Client x32 support. */
8066 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
8068 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
8069 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
8073 #undef TARGET_LITTLE_SYM
8074 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
8075 #undef TARGET_LITTLE_NAME
8076 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
8078 #define elf32_bed elf32_x86_64_nacl_bed
8080 #define bfd_elf32_bfd_link_hash_table_create \
8081 elf_x86_64_link_hash_table_create
8082 #define bfd_elf32_bfd_reloc_type_lookup \
8083 elf_x86_64_reloc_type_lookup
8084 #define bfd_elf32_bfd_reloc_name_lookup \
8085 elf_x86_64_reloc_name_lookup
8086 #define bfd_elf32_mkobject \
8088 #define bfd_elf32_get_synthetic_symtab \
8089 elf_x86_64_get_synthetic_symtab
8090 #define bfd_elf32_bfd_link_check_relocs \
8091 elf_x86_64_link_check_relocs
8093 #undef elf_backend_object_p
8094 #define elf_backend_object_p \
8095 elf32_x86_64_nacl_elf_object_p
8097 #undef elf_backend_bfd_from_remote_memory
8098 #define elf_backend_bfd_from_remote_memory \
8099 _bfd_elf32_bfd_from_remote_memory
8101 #undef elf_backend_size_info
8102 #define elf_backend_size_info \
8103 _bfd_elf32_size_info
8105 #include "elf32-target.h"
8107 /* Restore defaults. */
8108 #undef elf_backend_object_p
8109 #define elf_backend_object_p elf64_x86_64_elf_object_p
8110 #undef elf_backend_bfd_from_remote_memory
8111 #undef elf_backend_size_info
8112 #undef elf_backend_modify_segment_map
8113 #undef elf_backend_modify_program_headers
8114 #undef elf_backend_final_write_processing
8116 /* Intel L1OM support. */
8119 elf64_l1om_elf_object_p (bfd
*abfd
)
8121 /* Set the right machine number for an L1OM elf64 file. */
8122 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
8126 #undef TARGET_LITTLE_SYM
8127 #define TARGET_LITTLE_SYM l1om_elf64_vec
8128 #undef TARGET_LITTLE_NAME
8129 #define TARGET_LITTLE_NAME "elf64-l1om"
8131 #define ELF_ARCH bfd_arch_l1om
8133 #undef ELF_MACHINE_CODE
8134 #define ELF_MACHINE_CODE EM_L1OM
8139 #define elf64_bed elf64_l1om_bed
8141 #undef elf_backend_object_p
8142 #define elf_backend_object_p elf64_l1om_elf_object_p
8144 /* Restore defaults. */
8145 #undef ELF_MAXPAGESIZE
8146 #undef ELF_MINPAGESIZE
8147 #undef ELF_COMMONPAGESIZE
8148 #define ELF_MAXPAGESIZE 0x200000
8149 #define ELF_MINPAGESIZE 0x1000
8150 #define ELF_COMMONPAGESIZE 0x1000
8151 #undef elf_backend_plt_alignment
8152 #define elf_backend_plt_alignment 4
8153 #undef elf_backend_arch_data
8154 #define elf_backend_arch_data &elf_x86_64_arch_bed
8156 #include "elf64-target.h"
8158 /* FreeBSD L1OM support. */
8160 #undef TARGET_LITTLE_SYM
8161 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
8162 #undef TARGET_LITTLE_NAME
8163 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
8166 #define ELF_OSABI ELFOSABI_FREEBSD
8169 #define elf64_bed elf64_l1om_fbsd_bed
8171 #include "elf64-target.h"
8173 /* Intel K1OM support. */
8176 elf64_k1om_elf_object_p (bfd
*abfd
)
8178 /* Set the right machine number for an K1OM elf64 file. */
8179 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
8183 #undef TARGET_LITTLE_SYM
8184 #define TARGET_LITTLE_SYM k1om_elf64_vec
8185 #undef TARGET_LITTLE_NAME
8186 #define TARGET_LITTLE_NAME "elf64-k1om"
8188 #define ELF_ARCH bfd_arch_k1om
8190 #undef ELF_MACHINE_CODE
8191 #define ELF_MACHINE_CODE EM_K1OM
8196 #define elf64_bed elf64_k1om_bed
8198 #undef elf_backend_object_p
8199 #define elf_backend_object_p elf64_k1om_elf_object_p
8201 #undef elf_backend_static_tls_alignment
8203 #undef elf_backend_want_plt_sym
8204 #define elf_backend_want_plt_sym 0
8206 #include "elf64-target.h"
8208 /* FreeBSD K1OM support. */
8210 #undef TARGET_LITTLE_SYM
8211 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
8212 #undef TARGET_LITTLE_NAME
8213 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
8216 #define ELF_OSABI ELFOSABI_FREEBSD
8219 #define elf64_bed elf64_k1om_fbsd_bed
8221 #include "elf64-target.h"
8223 /* 32bit x86-64 support. */
8225 #undef TARGET_LITTLE_SYM
8226 #define TARGET_LITTLE_SYM x86_64_elf32_vec
8227 #undef TARGET_LITTLE_NAME
8228 #define TARGET_LITTLE_NAME "elf32-x86-64"
8232 #define ELF_ARCH bfd_arch_i386
8234 #undef ELF_MACHINE_CODE
8235 #define ELF_MACHINE_CODE EM_X86_64
8239 #undef elf_backend_object_p
8240 #define elf_backend_object_p \
8241 elf32_x86_64_elf_object_p
8243 #undef elf_backend_bfd_from_remote_memory
8244 #define elf_backend_bfd_from_remote_memory \
8245 _bfd_elf32_bfd_from_remote_memory
8247 #undef elf_backend_size_info
8248 #define elf_backend_size_info \
8249 _bfd_elf32_size_info
8251 #include "elf32-target.h"