projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Enhance support for copying and stripping Solaris and ARM binaries.
[deliverable/binutils-gdb.git] / bfd / elf64-x86-64.c
... / ...
CommitLineData
1/* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22#include "sysdep.h"
23#include "bfd.h"
24#include "bfdlink.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
27#include "elf-nacl.h"
28#include "bfd_stdint.h"
29#include "objalloc.h"
30#include "hashtab.h"
31#include "dwarf2.h"
32#include "libiberty.h"
33
34#include "opcode/i386.h"
35#include "elf/x86-64.h"
36
37#ifdef CORE_HEADER
38#include <stdarg.h>
39#include CORE_HEADER
40#endif
41
42/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43#define MINUS_ONE (~ (bfd_vma) 0)
44
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. */
49
50#define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52
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. */
56static reloc_howto_type x86_64_elf_howto_table[] =
57{
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,
60 FALSE),
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,
63 FALSE),
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,
66 TRUE),
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,
69 FALSE),
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,
72 TRUE),
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,
75 FALSE),
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,
78 MINUS_ONE, FALSE),
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,
81 MINUS_ONE, FALSE),
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,
84 MINUS_ONE, FALSE),
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,
87 0xffffffff, TRUE),
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,
90 FALSE),
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,
93 FALSE),
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,
104 MINUS_ONE, FALSE),
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,
107 MINUS_ONE, FALSE),
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,
110 MINUS_ONE, FALSE),
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,
113 0xffffffff, TRUE),
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,
116 0xffffffff, TRUE),
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,
119 0xffffffff, FALSE),
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,
122 0xffffffff, TRUE),
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,
125 0xffffffff, FALSE),
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,
128 TRUE),
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,
137 FALSE),
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,
140 MINUS_ONE, TRUE),
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,
146 MINUS_ONE, FALSE),
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,
149 MINUS_ONE, FALSE),
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,
152 FALSE),
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,
155 FALSE),
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",
163 FALSE, 0, 0, FALSE),
164 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
165 complain_overflow_bitfield, bfd_elf_generic_reloc,
166 "R_X86_64_TLSDESC",
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,
170 MINUS_ONE, FALSE),
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,
173 MINUS_ONE, FALSE),
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,
176 TRUE),
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,
179 TRUE),
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,
182 0xffffffff, TRUE),
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,
185 0xffffffff, TRUE),
186
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)
193
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),
197
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,
201 FALSE),
202
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,
206 FALSE)
207};
208
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))
215
216/* Map BFD relocs to the x86_64 elf relocs. */
217struct elf_reloc_map
218{
219 bfd_reloc_code_real_type bfd_reloc_val;
220 unsigned char elf_reloc_val;
221};
222
223static const struct elf_reloc_map x86_64_reloc_map[] =
224{
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, },
269};
270
271static reloc_howto_type *
272elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
273{
274 unsigned i;
275
276 if (r_type == (unsigned int) R_X86_64_32)
277 {
278 if (ABI_64_P (abfd))
279 i = r_type;
280 else
281 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
282 }
283 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type >= (unsigned int) R_X86_64_max)
285 {
286 if (r_type >= (unsigned int) R_X86_64_standard)
287 {
288 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
289 abfd, (int) r_type);
290 r_type = R_X86_64_NONE;
291 }
292 i = r_type;
293 }
294 else
295 i = r_type - (unsigned int) R_X86_64_vt_offset;
296 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
297 return &x86_64_elf_howto_table[i];
298}
299
300/* Given a BFD reloc type, return a HOWTO structure. */
301static reloc_howto_type *
302elf_x86_64_reloc_type_lookup (bfd *abfd,
303 bfd_reloc_code_real_type code)
304{
305 unsigned int i;
306
307 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
308 i++)
309 {
310 if (x86_64_reloc_map[i].bfd_reloc_val == code)
311 return elf_x86_64_rtype_to_howto (abfd,
312 x86_64_reloc_map[i].elf_reloc_val);
313 }
314 return NULL;
315}
316
317static reloc_howto_type *
318elf_x86_64_reloc_name_lookup (bfd *abfd,
319 const char *r_name)
320{
321 unsigned int i;
322
323 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
324 {
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type *reloc
327 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
328 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
329 return reloc;
330 }
331
332 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
333 if (x86_64_elf_howto_table[i].name != NULL
334 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
335 return &x86_64_elf_howto_table[i];
336
337 return NULL;
338}
339
340/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
341
342static void
343elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
344 Elf_Internal_Rela *dst)
345{
346 unsigned r_type;
347
348 r_type = ELF32_R_TYPE (dst->r_info);
349 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
350 BFD_ASSERT (r_type == cache_ptr->howto->type);
351}
352\f
353/* Support for core dump NOTE sections. */
354static bfd_boolean
355elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
356{
357 int offset;
358 size_t size;
359
360 switch (note->descsz)
361 {
362 default:
363 return FALSE;
364
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
366 /* pr_cursig */
367 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
368
369 /* pr_pid */
370 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
371
372 /* pr_reg */
373 offset = 72;
374 size = 216;
375
376 break;
377
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
379 /* pr_cursig */
380 elf_tdata (abfd)->core->signal
381 = bfd_get_16 (abfd, note->descdata + 12);
382
383 /* pr_pid */
384 elf_tdata (abfd)->core->lwpid
385 = bfd_get_32 (abfd, note->descdata + 32);
386
387 /* pr_reg */
388 offset = 112;
389 size = 216;
390
391 break;
392 }
393
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
396 size, note->descpos + offset);
397}
398
399static bfd_boolean
400elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
401{
402 switch (note->descsz)
403 {
404 default:
405 return FALSE;
406
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd)->core->pid
409 = bfd_get_32 (abfd, note->descdata + 12);
410 elf_tdata (abfd)->core->program
411 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
412 elf_tdata (abfd)->core->command
413 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
414 break;
415
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd)->core->pid
418 = bfd_get_32 (abfd, note->descdata + 24);
419 elf_tdata (abfd)->core->program
420 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
421 elf_tdata (abfd)->core->command
422 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
423 }
424
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
428
429 {
430 char *command = elf_tdata (abfd)->core->command;
431 int n = strlen (command);
432
433 if (0 < n && command[n - 1] == ' ')
434 command[n - 1] = '\0';
435 }
436
437 return TRUE;
438}
439
440#ifdef CORE_HEADER
441static char *
442elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
443 int note_type, ...)
444{
445 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
446 va_list ap;
447 const char *fname, *psargs;
448 long pid;
449 int cursig;
450 const void *gregs;
451
452 switch (note_type)
453 {
454 default:
455 return NULL;
456
457 case NT_PRPSINFO:
458 va_start (ap, note_type);
459 fname = va_arg (ap, const char *);
460 psargs = va_arg (ap, const char *);
461 va_end (ap);
462
463 if (bed->s->elfclass == ELFCLASS32)
464 {
465 prpsinfo32_t data;
466 memset (&data, 0, sizeof (data));
467 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
468 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
469 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
470 &data, sizeof (data));
471 }
472 else
473 {
474 prpsinfo64_t data;
475 memset (&data, 0, sizeof (data));
476 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
477 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
478 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
479 &data, sizeof (data));
480 }
481 /* NOTREACHED */
482
483 case NT_PRSTATUS:
484 va_start (ap, note_type);
485 pid = va_arg (ap, long);
486 cursig = va_arg (ap, int);
487 gregs = va_arg (ap, const void *);
488 va_end (ap);
489
490 if (bed->s->elfclass == ELFCLASS32)
491 {
492 if (bed->elf_machine_code == EM_X86_64)
493 {
494 prstatusx32_t prstat;
495 memset (&prstat, 0, sizeof (prstat));
496 prstat.pr_pid = pid;
497 prstat.pr_cursig = cursig;
498 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
499 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
500 &prstat, sizeof (prstat));
501 }
502 else
503 {
504 prstatus32_t prstat;
505 memset (&prstat, 0, sizeof (prstat));
506 prstat.pr_pid = pid;
507 prstat.pr_cursig = cursig;
508 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
509 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
510 &prstat, sizeof (prstat));
511 }
512 }
513 else
514 {
515 prstatus64_t prstat;
516 memset (&prstat, 0, sizeof (prstat));
517 prstat.pr_pid = pid;
518 prstat.pr_cursig = cursig;
519 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
520 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
521 &prstat, sizeof (prstat));
522 }
523 }
524 /* NOTREACHED */
525}
526#endif
527\f
528/* Functions for the x86-64 ELF linker. */
529
530/* The name of the dynamic interpreter. This is put in the .interp
531 section. */
532
533#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534#define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
535
536/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
539 shared lib. */
540#define ELIMINATE_COPY_RELOCS 1
541
542/* The size in bytes of an entry in the global offset table. */
543
544#define GOT_ENTRY_SIZE 8
545
546/* The size in bytes of an entry in the procedure linkage table. */
547
548#define PLT_ENTRY_SIZE 16
549
550/* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
552
553static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
554{
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
558};
559
560/* Subsequent entries in a procedure linkage table look like this. */
561
562static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
563{
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
570};
571
572/* The first entry in a procedure linkage table with BND relocations
573 like this. */
574
575static const bfd_byte elf_x86_64_bnd_plt0_entry[PLT_ENTRY_SIZE] =
576{
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
580};
581
582/* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
584
585static const bfd_byte elf_x86_64_legacy_plt_entry[PLT_ENTRY_SIZE] =
586{
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
590};
591
592/* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
594
595static const bfd_byte elf_x86_64_bnd_plt_entry[PLT_ENTRY_SIZE] =
596{
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
600};
601
602/* Entries for legacy branches in the second procedure linkage table
603 look like this. */
604
605static const bfd_byte elf_x86_64_legacy_plt2_entry[8] =
606{
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
610};
611
612/* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
614
615static const bfd_byte elf_x86_64_bnd_plt2_entry[8] =
616{
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
619 0x90 /* nop */
620};
621
622/* .eh_frame covering the .plt section. */
623
624static const bfd_byte elf_x86_64_eh_frame_plt[] =
625{
626#define PLT_CIE_LENGTH 20
627#define PLT_FDE_LENGTH 36
628#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
632 1, /* CIE version */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
639 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop, DW_CFA_nop,
642
643 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
657 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
658 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
659};
660
661/* Architecture-specific backend data for x86-64. */
662
663struct elf_x86_64_backend_data
664{
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte *plt0_entry;
667 const bfd_byte *plt_entry;
668 unsigned int plt_entry_size; /* Size of each PLT entry. */
669
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset;
672 unsigned int plt0_got2_offset;
673
674 /* Offset of the end of the PC-relative instruction containing
675 plt0_got2_offset. */
676 unsigned int plt0_got2_insn_end;
677
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
682
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size;
685
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end;
688
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset;
691
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte *eh_frame_plt;
694 unsigned int eh_frame_plt_size;
695};
696
697#define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
699
700#define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
702
703#define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
705
706/* These are the standard parameters. */
707static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
708 {
709 elf_x86_64_plt0_entry, /* plt0_entry */
710 elf_x86_64_plt_entry, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
723 };
724
725static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed =
726 {
727 elf_x86_64_bnd_plt0_entry, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
741 };
742
743#define elf_backend_arch_data &elf_x86_64_arch_bed
744
745/* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
747 it isn't dynamic and
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
750 */
751#define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
758
759/* x86-64 ELF linker hash entry. */
760
761struct elf_x86_64_link_hash_entry
762{
763 struct elf_link_hash_entry elf;
764
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs *dyn_relocs;
767
768#define GOT_UNKNOWN 0
769#define GOT_NORMAL 1
770#define GOT_TLS_GD 2
771#define GOT_TLS_IE 3
772#define GOT_TLS_GDESC 4
773#define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775#define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777#define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779#define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type;
782
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy : 1;
789
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc : 1;
792
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc : 1;
795
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc : 1;
798
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount;
802
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got;
806
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
808 set. */
809 union gotplt_union plt_bnd;
810
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
813 bfd_vma tlsdesc_got;
814};
815
816#define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
818
819struct elf_x86_64_obj_tdata
820{
821 struct elf_obj_tdata root;
822
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type;
825
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma *local_tlsdesc_gotent;
828};
829
830#define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
832
833#define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
835
836#define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
838
839#define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
843
844static bfd_boolean
845elf_x86_64_mkobject (bfd *abfd)
846{
847 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
848 X86_64_ELF_DATA);
849}
850
851/* x86-64 ELF linker hash table. */
852
853struct elf_x86_64_link_hash_table
854{
855 struct elf_link_hash_table elf;
856
857 /* Short-cuts to get to dynamic linker sections. */
858 asection *interp;
859 asection *sdynbss;
860 asection *srelbss;
861 asection *plt_eh_frame;
862 asection *plt_bnd;
863 asection *plt_got;
864
865 union
866 {
867 bfd_signed_vma refcount;
868 bfd_vma offset;
869 } tls_ld_got;
870
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size;
873
874 /* Small local sym cache. */
875 struct sym_cache sym_cache;
876
877 bfd_vma (*r_info) (bfd_vma, bfd_vma);
878 bfd_vma (*r_sym) (bfd_vma);
879 unsigned int pointer_r_type;
880 const char *dynamic_interpreter;
881 int dynamic_interpreter_size;
882
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry *tls_module_base;
885
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table;
888 void * loc_hash_memory;
889
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
893 yet. */
894 bfd_vma tlsdesc_plt;
895 /* The offset into sgot of the GOT entry used by the PLT entry
896 above. */
897 bfd_vma tlsdesc_got;
898
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index;
903
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc;
907};
908
909/* Get the x86-64 ELF linker hash table from a link_info structure. */
910
911#define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
914
915#define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
917
918/* Create an entry in an x86-64 ELF linker hash table. */
919
920static struct bfd_hash_entry *
921elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
922 struct bfd_hash_table *table,
923 const char *string)
924{
925 /* Allocate the structure if it has not already been allocated by a
926 subclass. */
927 if (entry == NULL)
928 {
929 entry = (struct bfd_hash_entry *)
930 bfd_hash_allocate (table,
931 sizeof (struct elf_x86_64_link_hash_entry));
932 if (entry == NULL)
933 return entry;
934 }
935
936 /* Call the allocation method of the superclass. */
937 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
938 if (entry != NULL)
939 {
940 struct elf_x86_64_link_hash_entry *eh;
941
942 eh = (struct elf_x86_64_link_hash_entry *) entry;
943 eh->dyn_relocs = NULL;
944 eh->tls_type = GOT_UNKNOWN;
945 eh->needs_copy = 0;
946 eh->has_bnd_reloc = 0;
947 eh->has_got_reloc = 0;
948 eh->has_non_got_reloc = 0;
949 eh->func_pointer_refcount = 0;
950 eh->plt_bnd.offset = (bfd_vma) -1;
951 eh->plt_got.offset = (bfd_vma) -1;
952 eh->tlsdesc_got = (bfd_vma) -1;
953 }
954
955 return entry;
956}
957
958/* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
962
963static hashval_t
964elf_x86_64_local_htab_hash (const void *ptr)
965{
966 struct elf_link_hash_entry *h
967 = (struct elf_link_hash_entry *) ptr;
968 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
969}
970
971/* Compare local hash entries. */
972
973static int
974elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
975{
976 struct elf_link_hash_entry *h1
977 = (struct elf_link_hash_entry *) ptr1;
978 struct elf_link_hash_entry *h2
979 = (struct elf_link_hash_entry *) ptr2;
980
981 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
982}
983
984/* Find and/or create a hash entry for local symbol. */
985
986static struct elf_link_hash_entry *
987elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
988 bfd *abfd, const Elf_Internal_Rela *rel,
989 bfd_boolean create)
990{
991 struct elf_x86_64_link_hash_entry e, *ret;
992 asection *sec = abfd->sections;
993 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
994 htab->r_sym (rel->r_info));
995 void **slot;
996
997 e.elf.indx = sec->id;
998 e.elf.dynstr_index = htab->r_sym (rel->r_info);
999 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1000 create ? INSERT : NO_INSERT);
1001
1002 if (!slot)
1003 return NULL;
1004
1005 if (*slot)
1006 {
1007 ret = (struct elf_x86_64_link_hash_entry *) *slot;
1008 return &ret->elf;
1009 }
1010
1011 ret = (struct elf_x86_64_link_hash_entry *)
1012 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1013 sizeof (struct elf_x86_64_link_hash_entry));
1014 if (ret)
1015 {
1016 memset (ret, 0, sizeof (*ret));
1017 ret->elf.indx = sec->id;
1018 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
1019 ret->elf.dynindx = -1;
1020 ret->func_pointer_refcount = 0;
1021 ret->plt_got.offset = (bfd_vma) -1;
1022 *slot = ret;
1023 }
1024 return &ret->elf;
1025}
1026
1027/* Destroy an X86-64 ELF linker hash table. */
1028
1029static void
1030elf_x86_64_link_hash_table_free (bfd *obfd)
1031{
1032 struct elf_x86_64_link_hash_table *htab
1033 = (struct elf_x86_64_link_hash_table *) obfd->link.hash;
1034
1035 if (htab->loc_hash_table)
1036 htab_delete (htab->loc_hash_table);
1037 if (htab->loc_hash_memory)
1038 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1039 _bfd_elf_link_hash_table_free (obfd);
1040}
1041
1042/* Create an X86-64 ELF linker hash table. */
1043
1044static struct bfd_link_hash_table *
1045elf_x86_64_link_hash_table_create (bfd *abfd)
1046{
1047 struct elf_x86_64_link_hash_table *ret;
1048 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
1049
1050 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
1051 if (ret == NULL)
1052 return NULL;
1053
1054 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1055 elf_x86_64_link_hash_newfunc,
1056 sizeof (struct elf_x86_64_link_hash_entry),
1057 X86_64_ELF_DATA))
1058 {
1059 free (ret);
1060 return NULL;
1061 }
1062
1063 if (ABI_64_P (abfd))
1064 {
1065 ret->r_info = elf64_r_info;
1066 ret->r_sym = elf64_r_sym;
1067 ret->pointer_r_type = R_X86_64_64;
1068 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1069 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1070 }
1071 else
1072 {
1073 ret->r_info = elf32_r_info;
1074 ret->r_sym = elf32_r_sym;
1075 ret->pointer_r_type = R_X86_64_32;
1076 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1077 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1078 }
1079
1080 ret->loc_hash_table = htab_try_create (1024,
1081 elf_x86_64_local_htab_hash,
1082 elf_x86_64_local_htab_eq,
1083 NULL);
1084 ret->loc_hash_memory = objalloc_create ();
1085 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1086 {
1087 elf_x86_64_link_hash_table_free (abfd);
1088 return NULL;
1089 }
1090 ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free;
1091
1092 return &ret->elf.root;
1093}
1094
1095/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1097 hash table. */
1098
1099static bfd_boolean
1100elf_x86_64_create_dynamic_sections (bfd *dynobj,
1101 struct bfd_link_info *info)
1102{
1103 struct elf_x86_64_link_hash_table *htab;
1104
1105 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1106 return FALSE;
1107
1108 htab = elf_x86_64_hash_table (info);
1109 if (htab == NULL)
1110 return FALSE;
1111
1112 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1113 if (!htab->sdynbss)
1114 abort ();
1115
1116 if (bfd_link_executable (info))
1117 {
1118 /* Always allow copy relocs for building executables. */
1119 asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
1120 if (s == NULL)
1121 {
1122 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1123 s = bfd_make_section_anyway_with_flags (dynobj,
1124 ".rela.bss",
1125 (bed->dynamic_sec_flags
1126 | SEC_READONLY));
1127 if (s == NULL
1128 || ! bfd_set_section_alignment (dynobj, s,
1129 bed->s->log_file_align))
1130 return FALSE;
1131 }
1132 htab->srelbss = s;
1133 }
1134
1135 if (!info->no_ld_generated_unwind_info
1136 && htab->plt_eh_frame == NULL
1137 && htab->elf.splt != NULL)
1138 {
1139 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1140 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1141 | SEC_LINKER_CREATED);
1142 htab->plt_eh_frame
1143 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1144 if (htab->plt_eh_frame == NULL
1145 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
1146 return FALSE;
1147 }
1148 return TRUE;
1149}
1150
1151/* Copy the extra info we tack onto an elf_link_hash_entry. */
1152
1153static void
1154elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1155 struct elf_link_hash_entry *dir,
1156 struct elf_link_hash_entry *ind)
1157{
1158 struct elf_x86_64_link_hash_entry *edir, *eind;
1159
1160 edir = (struct elf_x86_64_link_hash_entry *) dir;
1161 eind = (struct elf_x86_64_link_hash_entry *) ind;
1162
1163 if (!edir->has_bnd_reloc)
1164 edir->has_bnd_reloc = eind->has_bnd_reloc;
1165
1166 if (!edir->has_got_reloc)
1167 edir->has_got_reloc = eind->has_got_reloc;
1168
1169 if (!edir->has_non_got_reloc)
1170 edir->has_non_got_reloc = eind->has_non_got_reloc;
1171
1172 if (eind->dyn_relocs != NULL)
1173 {
1174 if (edir->dyn_relocs != NULL)
1175 {
1176 struct elf_dyn_relocs **pp;
1177 struct elf_dyn_relocs *p;
1178
1179 /* Add reloc counts against the indirect sym to the direct sym
1180 list. Merge any entries against the same section. */
1181 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1182 {
1183 struct elf_dyn_relocs *q;
1184
1185 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1186 if (q->sec == p->sec)
1187 {
1188 q->pc_count += p->pc_count;
1189 q->count += p->count;
1190 *pp = p->next;
1191 break;
1192 }
1193 if (q == NULL)
1194 pp = &p->next;
1195 }
1196 *pp = edir->dyn_relocs;
1197 }
1198
1199 edir->dyn_relocs = eind->dyn_relocs;
1200 eind->dyn_relocs = NULL;
1201 }
1202
1203 if (ind->root.type == bfd_link_hash_indirect
1204 && dir->got.refcount <= 0)
1205 {
1206 edir->tls_type = eind->tls_type;
1207 eind->tls_type = GOT_UNKNOWN;
1208 }
1209
1210 if (ELIMINATE_COPY_RELOCS
1211 && ind->root.type != bfd_link_hash_indirect
1212 && dir->dynamic_adjusted)
1213 {
1214 /* If called to transfer flags for a weakdef during processing
1215 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1216 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1217 dir->ref_dynamic |= ind->ref_dynamic;
1218 dir->ref_regular |= ind->ref_regular;
1219 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1220 dir->needs_plt |= ind->needs_plt;
1221 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1222 }
1223 else
1224 {
1225 if (eind->func_pointer_refcount > 0)
1226 {
1227 edir->func_pointer_refcount += eind->func_pointer_refcount;
1228 eind->func_pointer_refcount = 0;
1229 }
1230
1231 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1232 }
1233}
1234
1235static bfd_boolean
1236elf64_x86_64_elf_object_p (bfd *abfd)
1237{
1238 /* Set the right machine number for an x86-64 elf64 file. */
1239 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1240 return TRUE;
1241}
1242
1243static bfd_boolean
1244elf32_x86_64_elf_object_p (bfd *abfd)
1245{
1246 /* Set the right machine number for an x86-64 elf32 file. */
1247 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1248 return TRUE;
1249}
1250
1251/* Return TRUE if the TLS access code sequence support transition
1252 from R_TYPE. */
1253
1254static bfd_boolean
1255elf_x86_64_check_tls_transition (bfd *abfd,
1256 struct bfd_link_info *info,
1257 asection *sec,
1258 bfd_byte *contents,
1259 Elf_Internal_Shdr *symtab_hdr,
1260 struct elf_link_hash_entry **sym_hashes,
1261 unsigned int r_type,
1262 const Elf_Internal_Rela *rel,
1263 const Elf_Internal_Rela *relend)
1264{
1265 unsigned int val;
1266 unsigned long r_symndx;
1267 bfd_boolean largepic = FALSE;
1268 struct elf_link_hash_entry *h;
1269 bfd_vma offset;
1270 struct elf_x86_64_link_hash_table *htab;
1271
1272 /* Get the section contents. */
1273 if (contents == NULL)
1274 {
1275 if (elf_section_data (sec)->this_hdr.contents != NULL)
1276 contents = elf_section_data (sec)->this_hdr.contents;
1277 else
1278 {
1279 /* FIXME: How to better handle error condition? */
1280 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1281 return FALSE;
1282
1283 /* Cache the section contents for elf_link_input_bfd. */
1284 elf_section_data (sec)->this_hdr.contents = contents;
1285 }
1286 }
1287
1288 htab = elf_x86_64_hash_table (info);
1289 offset = rel->r_offset;
1290 switch (r_type)
1291 {
1292 case R_X86_64_TLSGD:
1293 case R_X86_64_TLSLD:
1294 if ((rel + 1) >= relend)
1295 return FALSE;
1296
1297 if (r_type == R_X86_64_TLSGD)
1298 {
1299 /* Check transition from GD access model. For 64bit, only
1300 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1301 .word 0x6666; rex64; call __tls_get_addr
1302 can transit to different access model. For 32bit, only
1303 leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr
1305 can transit to different access model. For largepic
1306 we also support:
1307 leaq foo@tlsgd(%rip), %rdi
1308 movabsq $__tls_get_addr@pltoff, %rax
1309 addq $rbx, %rax
1310 call *%rax. */
1311
1312 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1313 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1314
1315 if ((offset + 12) > sec->size)
1316 return FALSE;
1317
1318 if (memcmp (contents + offset + 4, call, 4) != 0)
1319 {
1320 if (!ABI_64_P (abfd)
1321 || (offset + 19) > sec->size
1322 || offset < 3
1323 || memcmp (contents + offset - 3, leaq + 1, 3) != 0
1324 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1325 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1326 != 0)
1327 return FALSE;
1328 largepic = TRUE;
1329 }
1330 else if (ABI_64_P (abfd))
1331 {
1332 if (offset < 4
1333 || memcmp (contents + offset - 4, leaq, 4) != 0)
1334 return FALSE;
1335 }
1336 else
1337 {
1338 if (offset < 3
1339 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1340 return FALSE;
1341 }
1342 }
1343 else
1344 {
1345 /* Check transition from LD access model. Only
1346 leaq foo@tlsld(%rip), %rdi;
1347 call __tls_get_addr
1348 can transit to different access model. For largepic
1349 we also support:
1350 leaq foo@tlsld(%rip), %rdi
1351 movabsq $__tls_get_addr@pltoff, %rax
1352 addq $rbx, %rax
1353 call *%rax. */
1354
1355 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1356
1357 if (offset < 3 || (offset + 9) > sec->size)
1358 return FALSE;
1359
1360 if (memcmp (contents + offset - 3, lea, 3) != 0)
1361 return FALSE;
1362
1363 if (0xe8 != *(contents + offset + 4))
1364 {
1365 if (!ABI_64_P (abfd)
1366 || (offset + 19) > sec->size
1367 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1368 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1369 != 0)
1370 return FALSE;
1371 largepic = TRUE;
1372 }
1373 }
1374
1375 r_symndx = htab->r_sym (rel[1].r_info);
1376 if (r_symndx < symtab_hdr->sh_info)
1377 return FALSE;
1378
1379 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1380 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1381 may be versioned. */
1382 return (h != NULL
1383 && h->root.root.string != NULL
1384 && (largepic
1385 ? ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64
1386 : (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1387 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32))
1388 && (strncmp (h->root.root.string,
1389 "__tls_get_addr", 14) == 0));
1390
1391 case R_X86_64_GOTTPOFF:
1392 /* Check transition from IE access model:
1393 mov foo@gottpoff(%rip), %reg
1394 add foo@gottpoff(%rip), %reg
1395 */
1396
1397 /* Check REX prefix first. */
1398 if (offset >= 3 && (offset + 4) <= sec->size)
1399 {
1400 val = bfd_get_8 (abfd, contents + offset - 3);
1401 if (val != 0x48 && val != 0x4c)
1402 {
1403 /* X32 may have 0x44 REX prefix or no REX prefix. */
1404 if (ABI_64_P (abfd))
1405 return FALSE;
1406 }
1407 }
1408 else
1409 {
1410 /* X32 may not have any REX prefix. */
1411 if (ABI_64_P (abfd))
1412 return FALSE;
1413 if (offset < 2 || (offset + 3) > sec->size)
1414 return FALSE;
1415 }
1416
1417 val = bfd_get_8 (abfd, contents + offset - 2);
1418 if (val != 0x8b && val != 0x03)
1419 return FALSE;
1420
1421 val = bfd_get_8 (abfd, contents + offset - 1);
1422 return (val & 0xc7) == 5;
1423
1424 case R_X86_64_GOTPC32_TLSDESC:
1425 /* Check transition from GDesc access model:
1426 leaq x@tlsdesc(%rip), %rax
1427
1428 Make sure it's a leaq adding rip to a 32-bit offset
1429 into any register, although it's probably almost always
1430 going to be rax. */
1431
1432 if (offset < 3 || (offset + 4) > sec->size)
1433 return FALSE;
1434
1435 val = bfd_get_8 (abfd, contents + offset - 3);
1436 if ((val & 0xfb) != 0x48)
1437 return FALSE;
1438
1439 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1440 return FALSE;
1441
1442 val = bfd_get_8 (abfd, contents + offset - 1);
1443 return (val & 0xc7) == 0x05;
1444
1445 case R_X86_64_TLSDESC_CALL:
1446 /* Check transition from GDesc access model:
1447 call *x@tlsdesc(%rax)
1448 */
1449 if (offset + 2 <= sec->size)
1450 {
1451 /* Make sure that it's a call *x@tlsdesc(%rax). */
1452 static const unsigned char call[] = { 0xff, 0x10 };
1453 return memcmp (contents + offset, call, 2) == 0;
1454 }
1455
1456 return FALSE;
1457
1458 default:
1459 abort ();
1460 }
1461}
1462
1463/* Return TRUE if the TLS access transition is OK or no transition
1464 will be performed. Update R_TYPE if there is a transition. */
1465
1466static bfd_boolean
1467elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1468 asection *sec, bfd_byte *contents,
1469 Elf_Internal_Shdr *symtab_hdr,
1470 struct elf_link_hash_entry **sym_hashes,
1471 unsigned int *r_type, int tls_type,
1472 const Elf_Internal_Rela *rel,
1473 const Elf_Internal_Rela *relend,
1474 struct elf_link_hash_entry *h,
1475 unsigned long r_symndx)
1476{
1477 unsigned int from_type = *r_type;
1478 unsigned int to_type = from_type;
1479 bfd_boolean check = TRUE;
1480
1481 /* Skip TLS transition for functions. */
1482 if (h != NULL
1483 && (h->type == STT_FUNC
1484 || h->type == STT_GNU_IFUNC))
1485 return TRUE;
1486
1487 switch (from_type)
1488 {
1489 case R_X86_64_TLSGD:
1490 case R_X86_64_GOTPC32_TLSDESC:
1491 case R_X86_64_TLSDESC_CALL:
1492 case R_X86_64_GOTTPOFF:
1493 if (bfd_link_executable (info))
1494 {
1495 if (h == NULL)
1496 to_type = R_X86_64_TPOFF32;
1497 else
1498 to_type = R_X86_64_GOTTPOFF;
1499 }
1500
1501 /* When we are called from elf_x86_64_relocate_section,
1502 CONTENTS isn't NULL and there may be additional transitions
1503 based on TLS_TYPE. */
1504 if (contents != NULL)
1505 {
1506 unsigned int new_to_type = to_type;
1507
1508 if (bfd_link_executable (info)
1509 && h != NULL
1510 && h->dynindx == -1
1511 && tls_type == GOT_TLS_IE)
1512 new_to_type = R_X86_64_TPOFF32;
1513
1514 if (to_type == R_X86_64_TLSGD
1515 || to_type == R_X86_64_GOTPC32_TLSDESC
1516 || to_type == R_X86_64_TLSDESC_CALL)
1517 {
1518 if (tls_type == GOT_TLS_IE)
1519 new_to_type = R_X86_64_GOTTPOFF;
1520 }
1521
1522 /* We checked the transition before when we were called from
1523 elf_x86_64_check_relocs. We only want to check the new
1524 transition which hasn't been checked before. */
1525 check = new_to_type != to_type && from_type == to_type;
1526 to_type = new_to_type;
1527 }
1528
1529 break;
1530
1531 case R_X86_64_TLSLD:
1532 if (bfd_link_executable (info))
1533 to_type = R_X86_64_TPOFF32;
1534 break;
1535
1536 default:
1537 return TRUE;
1538 }
1539
1540 /* Return TRUE if there is no transition. */
1541 if (from_type == to_type)
1542 return TRUE;
1543
1544 /* Check if the transition can be performed. */
1545 if (check
1546 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1547 symtab_hdr, sym_hashes,
1548 from_type, rel, relend))
1549 {
1550 reloc_howto_type *from, *to;
1551 const char *name;
1552
1553 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1554 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1555
1556 if (h)
1557 name = h->root.root.string;
1558 else
1559 {
1560 struct elf_x86_64_link_hash_table *htab;
1561
1562 htab = elf_x86_64_hash_table (info);
1563 if (htab == NULL)
1564 name = "*unknown*";
1565 else
1566 {
1567 Elf_Internal_Sym *isym;
1568
1569 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1570 abfd, r_symndx);
1571 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1572 }
1573 }
1574
1575 (*_bfd_error_handler)
1576 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1577 "in section `%A' failed"),
1578 abfd, sec, from->name, to->name, name,
1579 (unsigned long) rel->r_offset);
1580 bfd_set_error (bfd_error_bad_value);
1581 return FALSE;
1582 }
1583
1584 *r_type = to_type;
1585 return TRUE;
1586}
1587
1588/* Rename some of the generic section flags to better document how they
1589 are used here. */
1590#define need_convert_load sec_flg0
1591#define check_relocs_failed sec_flg1
1592
1593static bfd_boolean
1594elf_x86_64_need_pic (bfd *input_bfd, asection *sec,
1595 struct elf_link_hash_entry *h,
1596 Elf_Internal_Shdr *symtab_hdr,
1597 Elf_Internal_Sym *isym,
1598 reloc_howto_type *howto)
1599{
1600 const char *v = "";
1601 const char *und = "";
1602 const char *pic = "";
1603
1604 const char *name;
1605 if (h)
1606 {
1607 name = h->root.root.string;
1608 switch (ELF_ST_VISIBILITY (h->other))
1609 {
1610 case STV_HIDDEN:
1611 v = _("hidden symbol ");
1612 break;
1613 case STV_INTERNAL:
1614 v = _("internal symbol ");
1615 break;
1616 case STV_PROTECTED:
1617 v = _("protected symbol ");
1618 break;
1619 default:
1620 v = _("symbol ");
1621 pic = _("; recompile with -fPIC");
1622 break;
1623 }
1624
1625 if (!h->def_regular && !h->def_dynamic)
1626 und = _("undefined ");
1627 }
1628 else
1629 {
1630 name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL);
1631 pic = _("; recompile with -fPIC");
1632 }
1633
1634 (*_bfd_error_handler) (_("%B: relocation %s against %s%s`%s' can "
1635 "not be used when making a shared object%s"),
1636 input_bfd, howto->name, und, v, name, pic);
1637 bfd_set_error (bfd_error_bad_value);
1638 sec->check_relocs_failed = 1;
1639 return FALSE;
1640}
1641
1642/* Look through the relocs for a section during the first phase, and
1643 calculate needed space in the global offset table, procedure
1644 linkage table, and dynamic reloc sections. */
1645
1646static bfd_boolean
1647elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1648 asection *sec,
1649 const Elf_Internal_Rela *relocs)
1650{
1651 struct elf_x86_64_link_hash_table *htab;
1652 Elf_Internal_Shdr *symtab_hdr;
1653 struct elf_link_hash_entry **sym_hashes;
1654 const Elf_Internal_Rela *rel;
1655 const Elf_Internal_Rela *rel_end;
1656 asection *sreloc;
1657 bfd_boolean use_plt_got;
1658
1659 if (bfd_link_relocatable (info))
1660 return TRUE;
1661
1662 BFD_ASSERT (is_x86_64_elf (abfd));
1663
1664 htab = elf_x86_64_hash_table (info);
1665 if (htab == NULL)
1666 return FALSE;
1667
1668 use_plt_got = get_elf_x86_64_backend_data (abfd) == &elf_x86_64_arch_bed;
1669
1670 symtab_hdr = &elf_symtab_hdr (abfd);
1671 sym_hashes = elf_sym_hashes (abfd);
1672
1673 sreloc = NULL;
1674
1675 rel_end = relocs + sec->reloc_count;
1676 for (rel = relocs; rel < rel_end; rel++)
1677 {
1678 unsigned int r_type;
1679 unsigned long r_symndx;
1680 struct elf_link_hash_entry *h;
1681 struct elf_x86_64_link_hash_entry *eh;
1682 Elf_Internal_Sym *isym;
1683 const char *name;
1684 bfd_boolean size_reloc;
1685
1686 r_symndx = htab->r_sym (rel->r_info);
1687 r_type = ELF32_R_TYPE (rel->r_info);
1688
1689 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1690 {
1691 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1692 abfd, r_symndx);
1693 return FALSE;
1694 }
1695
1696 if (r_symndx < symtab_hdr->sh_info)
1697 {
1698 /* A local symbol. */
1699 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1700 abfd, r_symndx);
1701 if (isym == NULL)
1702 return FALSE;
1703
1704 /* Check relocation against local STT_GNU_IFUNC symbol. */
1705 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1706 {
1707 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1708 TRUE);
1709 if (h == NULL)
1710 return FALSE;
1711
1712 /* Fake a STT_GNU_IFUNC symbol. */
1713 h->type = STT_GNU_IFUNC;
1714 h->def_regular = 1;
1715 h->ref_regular = 1;
1716 h->forced_local = 1;
1717 h->root.type = bfd_link_hash_defined;
1718 }
1719 else
1720 h = NULL;
1721 }
1722 else
1723 {
1724 isym = NULL;
1725 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1726 while (h->root.type == bfd_link_hash_indirect
1727 || h->root.type == bfd_link_hash_warning)
1728 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1729 }
1730
1731 /* Check invalid x32 relocations. */
1732 if (!ABI_64_P (abfd))
1733 switch (r_type)
1734 {
1735 default:
1736 break;
1737
1738 case R_X86_64_DTPOFF64:
1739 case R_X86_64_TPOFF64:
1740 case R_X86_64_PC64:
1741 case R_X86_64_GOTOFF64:
1742 case R_X86_64_GOT64:
1743 case R_X86_64_GOTPCREL64:
1744 case R_X86_64_GOTPC64:
1745 case R_X86_64_GOTPLT64:
1746 case R_X86_64_PLTOFF64:
1747 {
1748 if (h)
1749 name = h->root.root.string;
1750 else
1751 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1752 NULL);
1753 (*_bfd_error_handler)
1754 (_("%B: relocation %s against symbol `%s' isn't "
1755 "supported in x32 mode"), abfd,
1756 x86_64_elf_howto_table[r_type].name, name);
1757 bfd_set_error (bfd_error_bad_value);
1758 return FALSE;
1759 }
1760 break;
1761 }
1762
1763 if (h != NULL)
1764 {
1765 switch (r_type)
1766 {
1767 default:
1768 break;
1769
1770 case R_X86_64_PC32_BND:
1771 case R_X86_64_PLT32_BND:
1772 case R_X86_64_PC32:
1773 case R_X86_64_PLT32:
1774 case R_X86_64_32:
1775 case R_X86_64_64:
1776 /* MPX PLT is supported only if elf_x86_64_arch_bed
1777 is used in 64-bit mode. */
1778 if (ABI_64_P (abfd)
1779 && info->bndplt
1780 && (get_elf_x86_64_backend_data (abfd)
1781 == &elf_x86_64_arch_bed))
1782 {
1783 elf_x86_64_hash_entry (h)->has_bnd_reloc = 1;
1784
1785 /* Create the second PLT for Intel MPX support. */
1786 if (htab->plt_bnd == NULL)
1787 {
1788 unsigned int plt_bnd_align;
1789 const struct elf_backend_data *bed;
1790
1791 bed = get_elf_backend_data (info->output_bfd);
1792 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry) == 8
1793 && (sizeof (elf_x86_64_bnd_plt2_entry)
1794 == sizeof (elf_x86_64_legacy_plt2_entry)));
1795 plt_bnd_align = 3;
1796
1797 if (htab->elf.dynobj == NULL)
1798 htab->elf.dynobj = abfd;
1799 htab->plt_bnd
1800 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
1801 ".plt.bnd",
1802 (bed->dynamic_sec_flags
1803 | SEC_ALLOC
1804 | SEC_CODE
1805 | SEC_LOAD
1806 | SEC_READONLY));
1807 if (htab->plt_bnd == NULL
1808 || !bfd_set_section_alignment (htab->elf.dynobj,
1809 htab->plt_bnd,
1810 plt_bnd_align))
1811 return FALSE;
1812 }
1813 }
1814
1815 case R_X86_64_32S:
1816 case R_X86_64_PC64:
1817 case R_X86_64_GOTPCREL:
1818 case R_X86_64_GOTPCRELX:
1819 case R_X86_64_REX_GOTPCRELX:
1820 case R_X86_64_GOTPCREL64:
1821 if (htab->elf.dynobj == NULL)
1822 htab->elf.dynobj = abfd;
1823 /* Create the ifunc sections for static executables. */
1824 if (h->type == STT_GNU_IFUNC
1825 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1826 info))
1827 return FALSE;
1828 break;
1829 }
1830
1831 /* It is referenced by a non-shared object. */
1832 h->ref_regular = 1;
1833 h->root.non_ir_ref = 1;
1834
1835 if (h->type == STT_GNU_IFUNC)
1836 elf_tdata (info->output_bfd)->has_gnu_symbols
1837 |= elf_gnu_symbol_ifunc;
1838 }
1839
1840 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1841 symtab_hdr, sym_hashes,
1842 &r_type, GOT_UNKNOWN,
1843 rel, rel_end, h, r_symndx))
1844 return FALSE;
1845
1846 eh = (struct elf_x86_64_link_hash_entry *) h;
1847 switch (r_type)
1848 {
1849 case R_X86_64_TLSLD:
1850 htab->tls_ld_got.refcount += 1;
1851 goto create_got;
1852
1853 case R_X86_64_TPOFF32:
1854 if (!bfd_link_executable (info) && ABI_64_P (abfd))
1855 return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym,
1856 &x86_64_elf_howto_table[r_type]);
1857 if (eh != NULL)
1858 eh->has_got_reloc = 1;
1859 break;
1860
1861 case R_X86_64_GOTTPOFF:
1862 if (!bfd_link_executable (info))
1863 info->flags |= DF_STATIC_TLS;
1864 /* Fall through */
1865
1866 case R_X86_64_GOT32:
1867 case R_X86_64_GOTPCREL:
1868 case R_X86_64_GOTPCRELX:
1869 case R_X86_64_REX_GOTPCRELX:
1870 case R_X86_64_TLSGD:
1871 case R_X86_64_GOT64:
1872 case R_X86_64_GOTPCREL64:
1873 case R_X86_64_GOTPLT64:
1874 case R_X86_64_GOTPC32_TLSDESC:
1875 case R_X86_64_TLSDESC_CALL:
1876 /* This symbol requires a global offset table entry. */
1877 {
1878 int tls_type, old_tls_type;
1879
1880 switch (r_type)
1881 {
1882 default: tls_type = GOT_NORMAL; break;
1883 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1884 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1885 case R_X86_64_GOTPC32_TLSDESC:
1886 case R_X86_64_TLSDESC_CALL:
1887 tls_type = GOT_TLS_GDESC; break;
1888 }
1889
1890 if (h != NULL)
1891 {
1892 h->got.refcount += 1;
1893 old_tls_type = eh->tls_type;
1894 }
1895 else
1896 {
1897 bfd_signed_vma *local_got_refcounts;
1898
1899 /* This is a global offset table entry for a local symbol. */
1900 local_got_refcounts = elf_local_got_refcounts (abfd);
1901 if (local_got_refcounts == NULL)
1902 {
1903 bfd_size_type size;
1904
1905 size = symtab_hdr->sh_info;
1906 size *= sizeof (bfd_signed_vma)
1907 + sizeof (bfd_vma) + sizeof (char);
1908 local_got_refcounts = ((bfd_signed_vma *)
1909 bfd_zalloc (abfd, size));
1910 if (local_got_refcounts == NULL)
1911 return FALSE;
1912 elf_local_got_refcounts (abfd) = local_got_refcounts;
1913 elf_x86_64_local_tlsdesc_gotent (abfd)
1914 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1915 elf_x86_64_local_got_tls_type (abfd)
1916 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1917 }
1918 local_got_refcounts[r_symndx] += 1;
1919 old_tls_type
1920 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1921 }
1922
1923 /* If a TLS symbol is accessed using IE at least once,
1924 there is no point to use dynamic model for it. */
1925 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1926 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1927 || tls_type != GOT_TLS_IE))
1928 {
1929 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1930 tls_type = old_tls_type;
1931 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1932 && GOT_TLS_GD_ANY_P (tls_type))
1933 tls_type |= old_tls_type;
1934 else
1935 {
1936 if (h)
1937 name = h->root.root.string;
1938 else
1939 name = bfd_elf_sym_name (abfd, symtab_hdr,
1940 isym, NULL);
1941 (*_bfd_error_handler)
1942 (_("%B: '%s' accessed both as normal and thread local symbol"),
1943 abfd, name);
1944 bfd_set_error (bfd_error_bad_value);
1945 return FALSE;
1946 }
1947 }
1948
1949 if (old_tls_type != tls_type)
1950 {
1951 if (eh != NULL)
1952 eh->tls_type = tls_type;
1953 else
1954 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1955 }
1956 }
1957 /* Fall through */
1958
1959 case R_X86_64_GOTOFF64:
1960 case R_X86_64_GOTPC32:
1961 case R_X86_64_GOTPC64:
1962 create_got:
1963 if (eh != NULL)
1964 eh->has_got_reloc = 1;
1965 if (htab->elf.sgot == NULL)
1966 {
1967 if (htab->elf.dynobj == NULL)
1968 htab->elf.dynobj = abfd;
1969 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1970 info))
1971 return FALSE;
1972 }
1973 break;
1974
1975 case R_X86_64_PLT32:
1976 case R_X86_64_PLT32_BND:
1977 /* This symbol requires a procedure linkage table entry. We
1978 actually build the entry in adjust_dynamic_symbol,
1979 because this might be a case of linking PIC code which is
1980 never referenced by a dynamic object, in which case we
1981 don't need to generate a procedure linkage table entry
1982 after all. */
1983
1984 /* If this is a local symbol, we resolve it directly without
1985 creating a procedure linkage table entry. */
1986 if (h == NULL)
1987 continue;
1988
1989 eh->has_got_reloc = 1;
1990 h->needs_plt = 1;
1991 h->plt.refcount += 1;
1992 break;
1993
1994 case R_X86_64_PLTOFF64:
1995 /* This tries to form the 'address' of a function relative
1996 to GOT. For global symbols we need a PLT entry. */
1997 if (h != NULL)
1998 {
1999 h->needs_plt = 1;
2000 h->plt.refcount += 1;
2001 }
2002 goto create_got;
2003
2004 case R_X86_64_SIZE32:
2005 case R_X86_64_SIZE64:
2006 size_reloc = TRUE;
2007 goto do_size;
2008
2009 case R_X86_64_32:
2010 if (!ABI_64_P (abfd))
2011 goto pointer;
2012 case R_X86_64_8:
2013 case R_X86_64_16:
2014 case R_X86_64_32S:
2015 /* Check relocation overflow as these relocs may lead to
2016 run-time relocation overflow. Don't error out for
2017 sections we don't care about, such as debug sections or
2018 when relocation overflow check is disabled. */
2019 if (!info->no_reloc_overflow_check
2020 && (bfd_link_pic (info)
2021 || (bfd_link_executable (info)
2022 && h != NULL
2023 && !h->def_regular
2024 && h->def_dynamic
2025 && (sec->flags & SEC_READONLY) == 0))
2026 && (sec->flags & SEC_ALLOC) != 0)
2027 return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym,
2028 &x86_64_elf_howto_table[r_type]);
2029 /* Fall through. */
2030
2031 case R_X86_64_PC8:
2032 case R_X86_64_PC16:
2033 case R_X86_64_PC32:
2034 case R_X86_64_PC32_BND:
2035 case R_X86_64_PC64:
2036 case R_X86_64_64:
2037pointer:
2038 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2039 eh->has_non_got_reloc = 1;
2040 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2041 locally defined and undefined symbol may turn out to be
2042 a STT_GNU_IFUNC symbol later. */
2043 if (h != NULL
2044 && (bfd_link_executable (info)
2045 || ((h->type == STT_GNU_IFUNC
2046 || h->root.type == bfd_link_hash_undefweak
2047 || h->root.type == bfd_link_hash_undefined)
2048 && SYMBOLIC_BIND (info, h))))
2049 {
2050 /* If this reloc is in a read-only section, we might
2051 need a copy reloc. We can't check reliably at this
2052 stage whether the section is read-only, as input
2053 sections have not yet been mapped to output sections.
2054 Tentatively set the flag for now, and correct in
2055 adjust_dynamic_symbol. */
2056 h->non_got_ref = 1;
2057
2058 /* We may need a .plt entry if the function this reloc
2059 refers to is in a shared lib. */
2060 h->plt.refcount += 1;
2061 if (r_type == R_X86_64_PC32)
2062 {
2063 /* Since something like ".long foo - ." may be used
2064 as pointer, make sure that PLT is used if foo is
2065 a function defined in a shared library. */
2066 if ((sec->flags & SEC_CODE) == 0)
2067 h->pointer_equality_needed = 1;
2068 }
2069 else if (r_type != R_X86_64_PC32_BND
2070 && r_type != R_X86_64_PC64)
2071 {
2072 h->pointer_equality_needed = 1;
2073 /* At run-time, R_X86_64_64 can be resolved for both
2074 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2075 can only be resolved for x32. */
2076 if ((sec->flags & SEC_READONLY) == 0
2077 && (r_type == R_X86_64_64
2078 || (!ABI_64_P (abfd)
2079 && (r_type == R_X86_64_32
2080 || r_type == R_X86_64_32S))))
2081 eh->func_pointer_refcount += 1;
2082 }
2083 }
2084
2085 size_reloc = FALSE;
2086do_size:
2087 /* If we are creating a shared library, and this is a reloc
2088 against a global symbol, or a non PC relative reloc
2089 against a local symbol, then we need to copy the reloc
2090 into the shared library. However, if we are linking with
2091 -Bsymbolic, we do not need to copy a reloc against a
2092 global symbol which is defined in an object we are
2093 including in the link (i.e., DEF_REGULAR is set). At
2094 this point we have not seen all the input files, so it is
2095 possible that DEF_REGULAR is not set now but will be set
2096 later (it is never cleared). In case of a weak definition,
2097 DEF_REGULAR may be cleared later by a strong definition in
2098 a shared library. We account for that possibility below by
2099 storing information in the relocs_copied field of the hash
2100 table entry. A similar situation occurs when creating
2101 shared libraries and symbol visibility changes render the
2102 symbol local.
2103
2104 If on the other hand, we are creating an executable, we
2105 may need to keep relocations for symbols satisfied by a
2106 dynamic library if we manage to avoid copy relocs for the
2107 symbol. */
2108 if ((bfd_link_pic (info)
2109 && (sec->flags & SEC_ALLOC) != 0
2110 && (! IS_X86_64_PCREL_TYPE (r_type)
2111 || (h != NULL
2112 && (! (bfd_link_pie (info)
2113 || SYMBOLIC_BIND (info, h))
2114 || h->root.type == bfd_link_hash_defweak
2115 || !h->def_regular))))
2116 || (ELIMINATE_COPY_RELOCS
2117 && !bfd_link_pic (info)
2118 && (sec->flags & SEC_ALLOC) != 0
2119 && h != NULL
2120 && (h->root.type == bfd_link_hash_defweak
2121 || !h->def_regular)))
2122 {
2123 struct elf_dyn_relocs *p;
2124 struct elf_dyn_relocs **head;
2125
2126 /* We must copy these reloc types into the output file.
2127 Create a reloc section in dynobj and make room for
2128 this reloc. */
2129 if (sreloc == NULL)
2130 {
2131 if (htab->elf.dynobj == NULL)
2132 htab->elf.dynobj = abfd;
2133
2134 sreloc = _bfd_elf_make_dynamic_reloc_section
2135 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2136 abfd, /*rela?*/ TRUE);
2137
2138 if (sreloc == NULL)
2139 return FALSE;
2140 }
2141
2142 /* If this is a global symbol, we count the number of
2143 relocations we need for this symbol. */
2144 if (h != NULL)
2145 head = &eh->dyn_relocs;
2146 else
2147 {
2148 /* Track dynamic relocs needed for local syms too.
2149 We really need local syms available to do this
2150 easily. Oh well. */
2151 asection *s;
2152 void **vpp;
2153
2154 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2155 abfd, r_symndx);
2156 if (isym == NULL)
2157 return FALSE;
2158
2159 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2160 if (s == NULL)
2161 s = sec;
2162
2163 /* Beware of type punned pointers vs strict aliasing
2164 rules. */
2165 vpp = &(elf_section_data (s)->local_dynrel);
2166 head = (struct elf_dyn_relocs **)vpp;
2167 }
2168
2169 p = *head;
2170 if (p == NULL || p->sec != sec)
2171 {
2172 bfd_size_type amt = sizeof *p;
2173
2174 p = ((struct elf_dyn_relocs *)
2175 bfd_alloc (htab->elf.dynobj, amt));
2176 if (p == NULL)
2177 return FALSE;
2178 p->next = *head;
2179 *head = p;
2180 p->sec = sec;
2181 p->count = 0;
2182 p->pc_count = 0;
2183 }
2184
2185 p->count += 1;
2186 /* Count size relocation as PC-relative relocation. */
2187 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
2188 p->pc_count += 1;
2189 }
2190 break;
2191
2192 /* This relocation describes the C++ object vtable hierarchy.
2193 Reconstruct it for later use during GC. */
2194 case R_X86_64_GNU_VTINHERIT:
2195 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2196 return FALSE;
2197 break;
2198
2199 /* This relocation describes which C++ vtable entries are actually
2200 used. Record for later use during GC. */
2201 case R_X86_64_GNU_VTENTRY:
2202 BFD_ASSERT (h != NULL);
2203 if (h != NULL
2204 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2205 return FALSE;
2206 break;
2207
2208 default:
2209 break;
2210 }
2211
2212 if (use_plt_got
2213 && h != NULL
2214 && h->plt.refcount > 0
2215 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2216 || h->got.refcount > 0)
2217 && htab->plt_got == NULL)
2218 {
2219 /* Create the GOT procedure linkage table. */
2220 unsigned int plt_got_align;
2221 const struct elf_backend_data *bed;
2222
2223 bed = get_elf_backend_data (info->output_bfd);
2224 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry) == 8
2225 && (sizeof (elf_x86_64_bnd_plt2_entry)
2226 == sizeof (elf_x86_64_legacy_plt2_entry)));
2227 plt_got_align = 3;
2228
2229 if (htab->elf.dynobj == NULL)
2230 htab->elf.dynobj = abfd;
2231 htab->plt_got
2232 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2233 ".plt.got",
2234 (bed->dynamic_sec_flags
2235 | SEC_ALLOC
2236 | SEC_CODE
2237 | SEC_LOAD
2238 | SEC_READONLY));
2239 if (htab->plt_got == NULL
2240 || !bfd_set_section_alignment (htab->elf.dynobj,
2241 htab->plt_got,
2242 plt_got_align))
2243 return FALSE;
2244 }
2245
2246 if ((r_type == R_X86_64_GOTPCREL
2247 || r_type == R_X86_64_GOTPCRELX
2248 || r_type == R_X86_64_REX_GOTPCRELX)
2249 && (h == NULL || h->type != STT_GNU_IFUNC))
2250 sec->need_convert_load = 1;
2251 }
2252
2253 return TRUE;
2254}
2255
2256/* Return the section that should be marked against GC for a given
2257 relocation. */
2258
2259static asection *
2260elf_x86_64_gc_mark_hook (asection *sec,
2261 struct bfd_link_info *info,
2262 Elf_Internal_Rela *rel,
2263 struct elf_link_hash_entry *h,
2264 Elf_Internal_Sym *sym)
2265{
2266 if (h != NULL)
2267 switch (ELF32_R_TYPE (rel->r_info))
2268 {
2269 case R_X86_64_GNU_VTINHERIT:
2270 case R_X86_64_GNU_VTENTRY:
2271 return NULL;
2272 }
2273
2274 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2275}
2276
2277/* Remove undefined weak symbol from the dynamic symbol table if it
2278 is resolved to 0. */
2279
2280static bfd_boolean
2281elf_x86_64_fixup_symbol (struct bfd_link_info *info,
2282 struct elf_link_hash_entry *h)
2283{
2284 if (h->dynindx != -1
2285 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2286 elf_x86_64_hash_entry (h)))
2287 {
2288 h->dynindx = -1;
2289 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2290 h->dynstr_index);
2291 }
2292 return TRUE;
2293}
2294
2295/* Adjust a symbol defined by a dynamic object and referenced by a
2296 regular object. The current definition is in some section of the
2297 dynamic object, but we're not including those sections. We have to
2298 change the definition to something the rest of the link can
2299 understand. */
2300
2301static bfd_boolean
2302elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2303 struct elf_link_hash_entry *h)
2304{
2305 struct elf_x86_64_link_hash_table *htab;
2306 asection *s;
2307 struct elf_x86_64_link_hash_entry *eh;
2308 struct elf_dyn_relocs *p;
2309
2310 /* STT_GNU_IFUNC symbol must go through PLT. */
2311 if (h->type == STT_GNU_IFUNC)
2312 {
2313 /* All local STT_GNU_IFUNC references must be treate as local
2314 calls via local PLT. */
2315 if (h->ref_regular
2316 && SYMBOL_CALLS_LOCAL (info, h))
2317 {
2318 bfd_size_type pc_count = 0, count = 0;
2319 struct elf_dyn_relocs **pp;
2320
2321 eh = (struct elf_x86_64_link_hash_entry *) h;
2322 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2323 {
2324 pc_count += p->pc_count;
2325 p->count -= p->pc_count;
2326 p->pc_count = 0;
2327 count += p->count;
2328 if (p->count == 0)
2329 *pp = p->next;
2330 else
2331 pp = &p->next;
2332 }
2333
2334 if (pc_count || count)
2335 {
2336 h->needs_plt = 1;
2337 h->non_got_ref = 1;
2338 if (h->plt.refcount <= 0)
2339 h->plt.refcount = 1;
2340 else
2341 h->plt.refcount += 1;
2342 }
2343 }
2344
2345 if (h->plt.refcount <= 0)
2346 {
2347 h->plt.offset = (bfd_vma) -1;
2348 h->needs_plt = 0;
2349 }
2350 return TRUE;
2351 }
2352
2353 /* If this is a function, put it in the procedure linkage table. We
2354 will fill in the contents of the procedure linkage table later,
2355 when we know the address of the .got section. */
2356 if (h->type == STT_FUNC
2357 || h->needs_plt)
2358 {
2359 if (h->plt.refcount <= 0
2360 || SYMBOL_CALLS_LOCAL (info, h)
2361 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2362 && h->root.type == bfd_link_hash_undefweak))
2363 {
2364 /* This case can occur if we saw a PLT32 reloc in an input
2365 file, but the symbol was never referred to by a dynamic
2366 object, or if all references were garbage collected. In
2367 such a case, we don't actually need to build a procedure
2368 linkage table, and we can just do a PC32 reloc instead. */
2369 h->plt.offset = (bfd_vma) -1;
2370 h->needs_plt = 0;
2371 }
2372
2373 return TRUE;
2374 }
2375 else
2376 /* It's possible that we incorrectly decided a .plt reloc was
2377 needed for an R_X86_64_PC32 reloc to a non-function sym in
2378 check_relocs. We can't decide accurately between function and
2379 non-function syms in check-relocs; Objects loaded later in
2380 the link may change h->type. So fix it now. */
2381 h->plt.offset = (bfd_vma) -1;
2382
2383 /* If this is a weak symbol, and there is a real definition, the
2384 processor independent code will have arranged for us to see the
2385 real definition first, and we can just use the same value. */
2386 if (h->u.weakdef != NULL)
2387 {
2388 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2389 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2390 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2391 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2392 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2393 {
2394 eh = (struct elf_x86_64_link_hash_entry *) h;
2395 h->non_got_ref = h->u.weakdef->non_got_ref;
2396 eh->needs_copy = h->u.weakdef->needs_copy;
2397 }
2398 return TRUE;
2399 }
2400
2401 /* This is a reference to a symbol defined by a dynamic object which
2402 is not a function. */
2403
2404 /* If we are creating a shared library, we must presume that the
2405 only references to the symbol are via the global offset table.
2406 For such cases we need not do anything here; the relocations will
2407 be handled correctly by relocate_section. */
2408 if (!bfd_link_executable (info))
2409 return TRUE;
2410
2411 /* If there are no references to this symbol that do not use the
2412 GOT, we don't need to generate a copy reloc. */
2413 if (!h->non_got_ref)
2414 return TRUE;
2415
2416 /* If -z nocopyreloc was given, we won't generate them either. */
2417 if (info->nocopyreloc)
2418 {
2419 h->non_got_ref = 0;
2420 return TRUE;
2421 }
2422
2423 if (ELIMINATE_COPY_RELOCS)
2424 {
2425 eh = (struct elf_x86_64_link_hash_entry *) h;
2426 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2427 {
2428 s = p->sec->output_section;
2429 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2430 break;
2431 }
2432
2433 /* If we didn't find any dynamic relocs in read-only sections, then
2434 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2435 if (p == NULL)
2436 {
2437 h->non_got_ref = 0;
2438 return TRUE;
2439 }
2440 }
2441
2442 /* We must allocate the symbol in our .dynbss section, which will
2443 become part of the .bss section of the executable. There will be
2444 an entry for this symbol in the .dynsym section. The dynamic
2445 object will contain position independent code, so all references
2446 from the dynamic object to this symbol will go through the global
2447 offset table. The dynamic linker will use the .dynsym entry to
2448 determine the address it must put in the global offset table, so
2449 both the dynamic object and the regular object will refer to the
2450 same memory location for the variable. */
2451
2452 htab = elf_x86_64_hash_table (info);
2453 if (htab == NULL)
2454 return FALSE;
2455
2456 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2457 to copy the initial value out of the dynamic object and into the
2458 runtime process image. */
2459 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2460 {
2461 const struct elf_backend_data *bed;
2462 bed = get_elf_backend_data (info->output_bfd);
2463 htab->srelbss->size += bed->s->sizeof_rela;
2464 h->needs_copy = 1;
2465 }
2466
2467 s = htab->sdynbss;
2468
2469 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2470}
2471
2472/* Allocate space in .plt, .got and associated reloc sections for
2473 dynamic relocs. */
2474
2475static bfd_boolean
2476elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2477{
2478 struct bfd_link_info *info;
2479 struct elf_x86_64_link_hash_table *htab;
2480 struct elf_x86_64_link_hash_entry *eh;
2481 struct elf_dyn_relocs *p;
2482 const struct elf_backend_data *bed;
2483 unsigned int plt_entry_size;
2484 bfd_boolean resolved_to_zero;
2485
2486 if (h->root.type == bfd_link_hash_indirect)
2487 return TRUE;
2488
2489 eh = (struct elf_x86_64_link_hash_entry *) h;
2490
2491 info = (struct bfd_link_info *) inf;
2492 htab = elf_x86_64_hash_table (info);
2493 if (htab == NULL)
2494 return FALSE;
2495 bed = get_elf_backend_data (info->output_bfd);
2496 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2497
2498 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
2499
2500 /* We can't use the GOT PLT if pointer equality is needed since
2501 finish_dynamic_symbol won't clear symbol value and the dynamic
2502 linker won't update the GOT slot. We will get into an infinite
2503 loop at run-time. */
2504 if (htab->plt_got != NULL
2505 && h->type != STT_GNU_IFUNC
2506 && !h->pointer_equality_needed
2507 && h->plt.refcount > 0
2508 && h->got.refcount > 0)
2509 {
2510 /* Don't use the regular PLT if there are both GOT and GOTPLT
2511 reloctions. */
2512 h->plt.offset = (bfd_vma) -1;
2513
2514 /* Use the GOT PLT. */
2515 eh->plt_got.refcount = 1;
2516 }
2517
2518 /* Clear the reference count of function pointer relocations if
2519 symbol isn't a normal function. */
2520 if (h->type != STT_FUNC)
2521 eh->func_pointer_refcount = 0;
2522
2523 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2524 here if it is defined and referenced in a non-shared object. */
2525 if (h->type == STT_GNU_IFUNC
2526 && h->def_regular)
2527 {
2528 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2529 &eh->dyn_relocs,
2530 &htab->readonly_dynrelocs_against_ifunc,
2531 plt_entry_size,
2532 plt_entry_size,
2533 GOT_ENTRY_SIZE))
2534 {
2535 asection *s = htab->plt_bnd;
2536 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
2537 {
2538 /* Use the .plt.bnd section if it is created. */
2539 eh->plt_bnd.offset = s->size;
2540
2541 /* Make room for this entry in the .plt.bnd section. */
2542 s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2543 }
2544
2545 return TRUE;
2546 }
2547 else
2548 return FALSE;
2549 }
2550 /* Don't create the PLT entry if there are only function pointer
2551 relocations which can be resolved at run-time. */
2552 else if (htab->elf.dynamic_sections_created
2553 && (h->plt.refcount > eh->func_pointer_refcount
2554 || eh->plt_got.refcount > 0))
2555 {
2556 bfd_boolean use_plt_got;
2557
2558 /* Clear the reference count of function pointer relocations
2559 if PLT is used. */
2560 eh->func_pointer_refcount = 0;
2561
2562 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2563 {
2564 /* Don't use the regular PLT for DF_BIND_NOW. */
2565 h->plt.offset = (bfd_vma) -1;
2566
2567 /* Use the GOT PLT. */
2568 h->got.refcount = 1;
2569 eh->plt_got.refcount = 1;
2570 }
2571
2572 use_plt_got = eh->plt_got.refcount > 0;
2573
2574 /* Make sure this symbol is output as a dynamic symbol.
2575 Undefined weak syms won't yet be marked as dynamic. */
2576 if (h->dynindx == -1
2577 && !h->forced_local
2578 && !resolved_to_zero)
2579 {
2580 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2581 return FALSE;
2582 }
2583
2584 if (bfd_link_pic (info)
2585 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2586 {
2587 asection *s = htab->elf.splt;
2588 asection *bnd_s = htab->plt_bnd;
2589 asection *got_s = htab->plt_got;
2590
2591 /* If this is the first .plt entry, make room for the special
2592 first entry. The .plt section is used by prelink to undo
2593 prelinking for dynamic relocations. */
2594 if (s->size == 0)
2595 s->size = plt_entry_size;
2596
2597 if (use_plt_got)
2598 eh->plt_got.offset = got_s->size;
2599 else
2600 {
2601 h->plt.offset = s->size;
2602 if (bnd_s)
2603 eh->plt_bnd.offset = bnd_s->size;
2604 }
2605
2606 /* If this symbol is not defined in a regular file, and we are
2607 not generating a shared library, then set the symbol to this
2608 location in the .plt. This is required to make function
2609 pointers compare as equal between the normal executable and
2610 the shared library. */
2611 if (! bfd_link_pic (info)
2612 && !h->def_regular)
2613 {
2614 if (use_plt_got)
2615 {
2616 /* We need to make a call to the entry of the GOT PLT
2617 instead of regular PLT entry. */
2618 h->root.u.def.section = got_s;
2619 h->root.u.def.value = eh->plt_got.offset;
2620 }
2621 else
2622 {
2623 if (bnd_s)
2624 {
2625 /* We need to make a call to the entry of the second
2626 PLT instead of regular PLT entry. */
2627 h->root.u.def.section = bnd_s;
2628 h->root.u.def.value = eh->plt_bnd.offset;
2629 }
2630 else
2631 {
2632 h->root.u.def.section = s;
2633 h->root.u.def.value = h->plt.offset;
2634 }
2635 }
2636 }
2637
2638 /* Make room for this entry. */
2639 if (use_plt_got)
2640 got_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2641 else
2642 {
2643 s->size += plt_entry_size;
2644 if (bnd_s)
2645 bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2646
2647 /* We also need to make an entry in the .got.plt section,
2648 which will be placed in the .got section by the linker
2649 script. */
2650 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2651
2652 /* There should be no PLT relocation against resolved
2653 undefined weak symbol in executable. */
2654 if (!resolved_to_zero)
2655 {
2656 /* We also need to make an entry in the .rela.plt
2657 section. */
2658 htab->elf.srelplt->size += bed->s->sizeof_rela;
2659 htab->elf.srelplt->reloc_count++;
2660 }
2661 }
2662 }
2663 else
2664 {
2665 eh->plt_got.offset = (bfd_vma) -1;
2666 h->plt.offset = (bfd_vma) -1;
2667 h->needs_plt = 0;
2668 }
2669 }
2670 else
2671 {
2672 eh->plt_got.offset = (bfd_vma) -1;
2673 h->plt.offset = (bfd_vma) -1;
2674 h->needs_plt = 0;
2675 }
2676
2677 eh->tlsdesc_got = (bfd_vma) -1;
2678
2679 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2680 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2681 if (h->got.refcount > 0
2682 && bfd_link_executable (info)
2683 && h->dynindx == -1
2684 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2685 {
2686 h->got.offset = (bfd_vma) -1;
2687 }
2688 else if (h->got.refcount > 0)
2689 {
2690 asection *s;
2691 bfd_boolean dyn;
2692 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2693
2694 /* Make sure this symbol is output as a dynamic symbol.
2695 Undefined weak syms won't yet be marked as dynamic. */
2696 if (h->dynindx == -1
2697 && !h->forced_local
2698 && !resolved_to_zero)
2699 {
2700 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2701 return FALSE;
2702 }
2703
2704 if (GOT_TLS_GDESC_P (tls_type))
2705 {
2706 eh->tlsdesc_got = htab->elf.sgotplt->size
2707 - elf_x86_64_compute_jump_table_size (htab);
2708 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2709 h->got.offset = (bfd_vma) -2;
2710 }
2711 if (! GOT_TLS_GDESC_P (tls_type)
2712 || GOT_TLS_GD_P (tls_type))
2713 {
2714 s = htab->elf.sgot;
2715 h->got.offset = s->size;
2716 s->size += GOT_ENTRY_SIZE;
2717 if (GOT_TLS_GD_P (tls_type))
2718 s->size += GOT_ENTRY_SIZE;
2719 }
2720 dyn = htab->elf.dynamic_sections_created;
2721 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2722 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2723 relocation. No dynamic relocation against resolved undefined
2724 weak symbol in executable. */
2725 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2726 || tls_type == GOT_TLS_IE)
2727 htab->elf.srelgot->size += bed->s->sizeof_rela;
2728 else if (GOT_TLS_GD_P (tls_type))
2729 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2730 else if (! GOT_TLS_GDESC_P (tls_type)
2731 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2732 && !resolved_to_zero)
2733 || h->root.type != bfd_link_hash_undefweak)
2734 && (bfd_link_pic (info)
2735 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2736 htab->elf.srelgot->size += bed->s->sizeof_rela;
2737 if (GOT_TLS_GDESC_P (tls_type))
2738 {
2739 htab->elf.srelplt->size += bed->s->sizeof_rela;
2740 htab->tlsdesc_plt = (bfd_vma) -1;
2741 }
2742 }
2743 else
2744 h->got.offset = (bfd_vma) -1;
2745
2746 if (eh->dyn_relocs == NULL)
2747 return TRUE;
2748
2749 /* In the shared -Bsymbolic case, discard space allocated for
2750 dynamic pc-relative relocs against symbols which turn out to be
2751 defined in regular objects. For the normal shared case, discard
2752 space for pc-relative relocs that have become local due to symbol
2753 visibility changes. */
2754
2755 if (bfd_link_pic (info))
2756 {
2757 /* Relocs that use pc_count are those that appear on a call
2758 insn, or certain REL relocs that can generated via assembly.
2759 We want calls to protected symbols to resolve directly to the
2760 function rather than going via the plt. If people want
2761 function pointer comparisons to work as expected then they
2762 should avoid writing weird assembly. */
2763 if (SYMBOL_CALLS_LOCAL (info, h))
2764 {
2765 struct elf_dyn_relocs **pp;
2766
2767 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2768 {
2769 p->count -= p->pc_count;
2770 p->pc_count = 0;
2771 if (p->count == 0)
2772 *pp = p->next;
2773 else
2774 pp = &p->next;
2775 }
2776 }
2777
2778 /* Also discard relocs on undefined weak syms with non-default
2779 visibility or in PIE. */
2780 if (eh->dyn_relocs != NULL)
2781 {
2782 if (h->root.type == bfd_link_hash_undefweak)
2783 {
2784 /* Undefined weak symbol is never bound locally in shared
2785 library. */
2786 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2787 || resolved_to_zero)
2788 eh->dyn_relocs = NULL;
2789 else if (h->dynindx == -1
2790 && ! h->forced_local
2791 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2792 return FALSE;
2793 }
2794 /* For PIE, discard space for pc-relative relocs against
2795 symbols which turn out to need copy relocs. */
2796 else if (bfd_link_executable (info)
2797 && (h->needs_copy || eh->needs_copy)
2798 && h->def_dynamic
2799 && !h->def_regular)
2800 {
2801 struct elf_dyn_relocs **pp;
2802
2803 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2804 {
2805 if (p->pc_count != 0)
2806 *pp = p->next;
2807 else
2808 pp = &p->next;
2809 }
2810 }
2811 }
2812 }
2813 else if (ELIMINATE_COPY_RELOCS)
2814 {
2815 /* For the non-shared case, discard space for relocs against
2816 symbols which turn out to need copy relocs or are not
2817 dynamic. Keep dynamic relocations for run-time function
2818 pointer initialization. */
2819
2820 if ((!h->non_got_ref
2821 || eh->func_pointer_refcount > 0
2822 || (h->root.type == bfd_link_hash_undefweak
2823 && !resolved_to_zero))
2824 && ((h->def_dynamic
2825 && !h->def_regular)
2826 || (htab->elf.dynamic_sections_created
2827 && (h->root.type == bfd_link_hash_undefweak
2828 || h->root.type == bfd_link_hash_undefined))))
2829 {
2830 /* Make sure this symbol is output as a dynamic symbol.
2831 Undefined weak syms won't yet be marked as dynamic. */
2832 if (h->dynindx == -1
2833 && ! h->forced_local
2834 && ! resolved_to_zero
2835 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2836 return FALSE;
2837
2838 /* If that succeeded, we know we'll be keeping all the
2839 relocs. */
2840 if (h->dynindx != -1)
2841 goto keep;
2842 }
2843
2844 eh->dyn_relocs = NULL;
2845 eh->func_pointer_refcount = 0;
2846
2847 keep: ;
2848 }
2849
2850 /* Finally, allocate space. */
2851 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2852 {
2853 asection * sreloc;
2854
2855 sreloc = elf_section_data (p->sec)->sreloc;
2856
2857 BFD_ASSERT (sreloc != NULL);
2858
2859 sreloc->size += p->count * bed->s->sizeof_rela;
2860 }
2861
2862 return TRUE;
2863}
2864
2865/* Allocate space in .plt, .got and associated reloc sections for
2866 local dynamic relocs. */
2867
2868static bfd_boolean
2869elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2870{
2871 struct elf_link_hash_entry *h
2872 = (struct elf_link_hash_entry *) *slot;
2873
2874 if (h->type != STT_GNU_IFUNC
2875 || !h->def_regular
2876 || !h->ref_regular
2877 || !h->forced_local
2878 || h->root.type != bfd_link_hash_defined)
2879 abort ();
2880
2881 return elf_x86_64_allocate_dynrelocs (h, inf);
2882}
2883
2884/* Find any dynamic relocs that apply to read-only sections. */
2885
2886static bfd_boolean
2887elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2888 void * inf)
2889{
2890 struct elf_x86_64_link_hash_entry *eh;
2891 struct elf_dyn_relocs *p;
2892
2893 /* Skip local IFUNC symbols. */
2894 if (h->forced_local && h->type == STT_GNU_IFUNC)
2895 return TRUE;
2896
2897 eh = (struct elf_x86_64_link_hash_entry *) h;
2898 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2899 {
2900 asection *s = p->sec->output_section;
2901
2902 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2903 {
2904 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2905
2906 info->flags |= DF_TEXTREL;
2907
2908 if ((info->warn_shared_textrel && bfd_link_pic (info))
2909 || info->error_textrel)
2910 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2911 p->sec->owner, h->root.root.string,
2912 p->sec);
2913
2914 /* Not an error, just cut short the traversal. */
2915 return FALSE;
2916 }
2917 }
2918 return TRUE;
2919}
2920
2921/* With the local symbol, foo, we convert
2922 mov foo@GOTPCREL(%rip), %reg
2923 to
2924 lea foo(%rip), %reg
2925 and convert
2926 call/jmp *foo@GOTPCREL(%rip)
2927 to
2928 nop call foo/jmp foo nop
2929 When PIC is false, convert
2930 test %reg, foo@GOTPCREL(%rip)
2931 to
2932 test $foo, %reg
2933 and convert
2934 binop foo@GOTPCREL(%rip), %reg
2935 to
2936 binop $foo, %reg
2937 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2938 instructions. */
2939
2940static bfd_boolean
2941elf_x86_64_convert_load (bfd *abfd, asection *sec,
2942 struct bfd_link_info *link_info)
2943{
2944 Elf_Internal_Shdr *symtab_hdr;
2945 Elf_Internal_Rela *internal_relocs;
2946 Elf_Internal_Rela *irel, *irelend;
2947 bfd_byte *contents;
2948 struct elf_x86_64_link_hash_table *htab;
2949 bfd_boolean changed_contents;
2950 bfd_boolean changed_relocs;
2951 bfd_signed_vma *local_got_refcounts;
2952 bfd_vma maxpagesize;
2953 bfd_boolean is_pic;
2954 bfd_boolean require_reloc_pc32;
2955
2956 /* Don't even try to convert non-ELF outputs. */
2957 if (!is_elf_hash_table (link_info->hash))
2958 return FALSE;
2959
2960 /* Nothing to do if there is no need or no output. */
2961 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2962 || sec->need_convert_load == 0
2963 || bfd_is_abs_section (sec->output_section))
2964 return TRUE;
2965
2966 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2967
2968 /* Load the relocations for this section. */
2969 internal_relocs = (_bfd_elf_link_read_relocs
2970 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2971 link_info->keep_memory));
2972 if (internal_relocs == NULL)
2973 return FALSE;
2974
2975 htab = elf_x86_64_hash_table (link_info);
2976 changed_contents = FALSE;
2977 changed_relocs = FALSE;
2978 local_got_refcounts = elf_local_got_refcounts (abfd);
2979 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2980
2981 /* Get the section contents. */
2982 if (elf_section_data (sec)->this_hdr.contents != NULL)
2983 contents = elf_section_data (sec)->this_hdr.contents;
2984 else
2985 {
2986 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2987 goto error_return;
2988 }
2989
2990 is_pic = bfd_link_pic (link_info);
2991
2992 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
2993 --no-relax. */
2994 require_reloc_pc32
2995 = link_info->disable_target_specific_optimizations > 1;
2996
2997 irelend = internal_relocs + sec->reloc_count;
2998 for (irel = internal_relocs; irel < irelend; irel++)
2999 {
3000 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3001 unsigned int r_symndx = htab->r_sym (irel->r_info);
3002 unsigned int indx;
3003 struct elf_link_hash_entry *h;
3004 asection *tsec;
3005 char symtype;
3006 bfd_vma toff, roff;
3007 bfd_signed_vma raddend;
3008 unsigned int opcode;
3009 unsigned int modrm;
3010 bfd_boolean relocx;
3011 bfd_boolean to_reloc_pc32;
3012
3013 relocx = (r_type == R_X86_64_GOTPCRELX
3014 || r_type == R_X86_64_REX_GOTPCRELX);
3015 if (!relocx && r_type != R_X86_64_GOTPCREL)
3016 continue;
3017
3018 roff = irel->r_offset;
3019 if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
3020 continue;
3021
3022 raddend = irel->r_addend;
3023 /* Addend for 32-bit PC-relative relocation must be -4. */
3024 if (raddend != -4)
3025 continue;
3026
3027 opcode = bfd_get_8 (abfd, contents + roff - 2);
3028
3029 /* Convert mov to lea since it has been done for a while. */
3030 if (opcode != 0x8b)
3031 {
3032 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3033 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3034 test, xor instructions. */
3035 if (!relocx)
3036 continue;
3037 }
3038
3039 /* We convert only to R_X86_64_PC32:
3040 1. Branch.
3041 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3042 3. require_reloc_pc32 is true.
3043 4. PIC.
3044 */
3045 to_reloc_pc32 = (opcode == 0xff
3046 || !relocx
3047 || require_reloc_pc32
3048 || is_pic);
3049
3050 /* Get the symbol referred to by the reloc. */
3051 if (r_symndx < symtab_hdr->sh_info)
3052 {
3053 Elf_Internal_Sym *isym;
3054
3055 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3056 abfd, r_symndx);
3057
3058 symtype = ELF_ST_TYPE (isym->st_info);
3059
3060 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3061 relocation against undefined symbols. */
3062 if (symtype == STT_GNU_IFUNC || isym->st_shndx == SHN_UNDEF)
3063 continue;
3064
3065 if (isym->st_shndx == SHN_ABS)
3066 tsec = bfd_abs_section_ptr;
3067 else if (isym->st_shndx == SHN_COMMON)
3068 tsec = bfd_com_section_ptr;
3069 else if (isym->st_shndx == SHN_X86_64_LCOMMON)
3070 tsec = &_bfd_elf_large_com_section;
3071 else
3072 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3073
3074 h = NULL;
3075 toff = isym->st_value;
3076 }
3077 else
3078 {
3079 indx = r_symndx - symtab_hdr->sh_info;
3080 h = elf_sym_hashes (abfd)[indx];
3081 BFD_ASSERT (h != NULL);
3082
3083 while (h->root.type == bfd_link_hash_indirect
3084 || h->root.type == bfd_link_hash_warning)
3085 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3086
3087 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3088 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3089 since ld.so may use its link-time address. */
3090 if (h->type == STT_GNU_IFUNC)
3091 continue;
3092
3093 /* Undefined weak symbol is only bound locally in executable
3094 and its reference is resolved as 0 without relocation
3095 overflow. We can only perform this optimization for
3096 GOTPCRELX relocations since we need to modify REX byte.
3097 It is OK convert mov with R_X86_64_GOTPCREL to
3098 R_X86_64_PC32. */
3099 if ((relocx || opcode == 0x8b)
3100 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info,
3101 elf_x86_64_hash_entry (h)))
3102 {
3103 if (opcode == 0xff)
3104 {
3105 /* Skip for branch instructions since R_X86_64_PC32
3106 may overflow. */
3107 if (require_reloc_pc32)
3108 continue;
3109 }
3110 else if (relocx)
3111 {
3112 /* For non-branch instructions, we can convert to
3113 R_X86_64_32/R_X86_64_32S since we know if there
3114 is a REX byte. */
3115 to_reloc_pc32 = FALSE;
3116 }
3117
3118 /* Since we don't know the current PC when PIC is true,
3119 we can't convert to R_X86_64_PC32. */
3120 if (to_reloc_pc32 && is_pic)
3121 continue;
3122
3123 goto convert;
3124 }
3125 else if ((h->def_regular
3126 || h->root.type == bfd_link_hash_defined
3127 || h->root.type == bfd_link_hash_defweak)
3128 && h != htab->elf.hdynamic
3129 && SYMBOL_REFERENCES_LOCAL (link_info, h))
3130 {
3131 /* bfd_link_hash_new or bfd_link_hash_undefined is
3132 set by an assignment in a linker script in
3133 bfd_elf_record_link_assignment. */
3134 if (h->def_regular
3135 && (h->root.type == bfd_link_hash_new
3136 || h->root.type == bfd_link_hash_undefined))
3137 {
3138 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3139 if (require_reloc_pc32)
3140 continue;
3141 goto convert;
3142 }
3143 tsec = h->root.u.def.section;
3144 toff = h->root.u.def.value;
3145 symtype = h->type;
3146 }
3147 else
3148 continue;
3149 }
3150
3151 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3152 if (!to_reloc_pc32)
3153 goto convert;
3154
3155 if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
3156 {
3157 /* At this stage in linking, no SEC_MERGE symbol has been
3158 adjusted, so all references to such symbols need to be
3159 passed through _bfd_merged_section_offset. (Later, in
3160 relocate_section, all SEC_MERGE symbols *except* for
3161 section symbols have been adjusted.)
3162
3163 gas may reduce relocations against symbols in SEC_MERGE
3164 sections to a relocation against the section symbol when
3165 the original addend was zero. When the reloc is against
3166 a section symbol we should include the addend in the
3167 offset passed to _bfd_merged_section_offset, since the
3168 location of interest is the original symbol. On the
3169 other hand, an access to "sym+addend" where "sym" is not
3170 a section symbol should not include the addend; Such an
3171 access is presumed to be an offset from "sym"; The
3172 location of interest is just "sym". */
3173 if (symtype == STT_SECTION)
3174 toff += raddend;
3175
3176 toff = _bfd_merged_section_offset (abfd, &tsec,
3177 elf_section_data (tsec)->sec_info,
3178 toff);
3179
3180 if (symtype != STT_SECTION)
3181 toff += raddend;
3182 }
3183 else
3184 toff += raddend;
3185
3186 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3187 if (tsec->output_section == sec->output_section)
3188 {
3189 if ((toff - roff + 0x80000000) > 0xffffffff)
3190 continue;
3191 }
3192 else
3193 {
3194 bfd_signed_vma distance;
3195
3196 /* At this point, we don't know the load addresses of TSEC
3197 section nor SEC section. We estimate the distrance between
3198 SEC and TSEC. We store the estimated distances in the
3199 compressed_size field of the output section, which is only
3200 used to decompress the compressed input section. */
3201 if (sec->output_section->compressed_size == 0)
3202 {
3203 asection *asect;
3204 bfd_size_type size = 0;
3205 for (asect = link_info->output_bfd->sections;
3206 asect != NULL;
3207 asect = asect->next)
3208 /* Skip debug sections since compressed_size is used to
3209 compress debug sections. */
3210 if ((asect->flags & SEC_DEBUGGING) == 0)
3211 {
3212 asection *i;
3213 for (i = asect->map_head.s;
3214 i != NULL;
3215 i = i->map_head.s)
3216 {
3217 size = align_power (size, i->alignment_power);
3218 size += i->size;
3219 }
3220 asect->compressed_size = size;
3221 }
3222 }
3223
3224 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3225 after SEC. */
3226 distance = (tsec->output_section->compressed_size
3227 - sec->output_section->compressed_size);
3228 if (distance < 0)
3229 continue;
3230
3231 /* Take PT_GNU_RELRO segment into account by adding
3232 maxpagesize. */
3233 if ((toff + distance + maxpagesize - roff + 0x80000000)
3234 > 0xffffffff)
3235 continue;
3236 }
3237
3238convert:
3239 if (opcode == 0xff)
3240 {
3241 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3242 unsigned int nop;
3243 unsigned int disp;
3244 bfd_vma nop_offset;
3245
3246 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3247 R_X86_64_PC32. */
3248 modrm = bfd_get_8 (abfd, contents + roff - 1);
3249 if (modrm == 0x25)
3250 {
3251 /* Convert to "jmp foo nop". */
3252 modrm = 0xe9;
3253 nop = NOP_OPCODE;
3254 nop_offset = irel->r_offset + 3;
3255 disp = bfd_get_32 (abfd, contents + irel->r_offset);
3256 irel->r_offset -= 1;
3257 bfd_put_32 (abfd, disp, contents + irel->r_offset);
3258 }
3259 else
3260 {
3261 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3262 is a nop prefix. */
3263 modrm = 0xe8;
3264 nop = link_info->call_nop_byte;
3265 if (link_info->call_nop_as_suffix)
3266 {
3267 nop_offset = irel->r_offset + 3;
3268 disp = bfd_get_32 (abfd, contents + irel->r_offset);
3269 irel->r_offset -= 1;
3270 bfd_put_32 (abfd, disp, contents + irel->r_offset);
3271 }
3272 else
3273 nop_offset = irel->r_offset - 2;
3274 }
3275 bfd_put_8 (abfd, nop, contents + nop_offset);
3276 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
3277 r_type = R_X86_64_PC32;
3278 }
3279 else
3280 {
3281 unsigned int rex;
3282 unsigned int rex_mask = REX_R;
3283
3284 if (r_type == R_X86_64_REX_GOTPCRELX)
3285 rex = bfd_get_8 (abfd, contents + roff - 3);
3286 else
3287 rex = 0;
3288
3289 if (opcode == 0x8b)
3290 {
3291 if (to_reloc_pc32)
3292 {
3293 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3294 "lea foo(%rip), %reg". */
3295 opcode = 0x8d;
3296 r_type = R_X86_64_PC32;
3297 }
3298 else
3299 {
3300 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3301 "mov $foo, %reg". */
3302 opcode = 0xc7;
3303 modrm = bfd_get_8 (abfd, contents + roff - 1);
3304 modrm = 0xc0 | (modrm & 0x38) >> 3;
3305 if ((rex & REX_W) != 0
3306 && ABI_64_P (link_info->output_bfd))
3307 {
3308 /* Keep the REX_W bit in REX byte for LP64. */
3309 r_type = R_X86_64_32S;
3310 goto rewrite_modrm_rex;
3311 }
3312 else
3313 {
3314 /* If the REX_W bit in REX byte isn't needed,
3315 use R_X86_64_32 and clear the W bit to avoid
3316 sign-extend imm32 to imm64. */
3317 r_type = R_X86_64_32;
3318 /* Clear the W bit in REX byte. */
3319 rex_mask |= REX_W;
3320 goto rewrite_modrm_rex;
3321 }
3322 }
3323 }
3324 else
3325 {
3326 /* R_X86_64_PC32 isn't supported. */
3327 if (to_reloc_pc32)
3328 continue;
3329
3330 modrm = bfd_get_8 (abfd, contents + roff - 1);
3331 if (opcode == 0x85)
3332 {
3333 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3334 "test $foo, %reg". */
3335 modrm = 0xc0 | (modrm & 0x38) >> 3;
3336 opcode = 0xf7;
3337 }
3338 else
3339 {
3340 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3341 "binop $foo, %reg". */
3342 modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
3343 opcode = 0x81;
3344 }
3345
3346 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3347 overflow when sign-extending imm32 to imm64. */
3348 r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32;
3349
3350rewrite_modrm_rex:
3351 bfd_put_8 (abfd, modrm, contents + roff - 1);
3352
3353 if (rex)
3354 {
3355 /* Move the R bit to the B bit in REX byte. */
3356 rex = (rex & ~rex_mask) | (rex & REX_R) >> 2;
3357 bfd_put_8 (abfd, rex, contents + roff - 3);
3358 }
3359
3360 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3361 irel->r_addend = 0;
3362 }
3363
3364 bfd_put_8 (abfd, opcode, contents + roff - 2);
3365 }
3366
3367 irel->r_info = htab->r_info (r_symndx, r_type);
3368 changed_contents = TRUE;
3369 changed_relocs = TRUE;
3370
3371 if (h)
3372 {
3373 if (h->got.refcount > 0)
3374 h->got.refcount -= 1;
3375 }
3376 else
3377 {
3378 if (local_got_refcounts != NULL
3379 && local_got_refcounts[r_symndx] > 0)
3380 local_got_refcounts[r_symndx] -= 1;
3381 }
3382 }
3383
3384 if (contents != NULL
3385 && elf_section_data (sec)->this_hdr.contents != contents)
3386 {
3387 if (!changed_contents && !link_info->keep_memory)
3388 free (contents);
3389 else
3390 {
3391 /* Cache the section contents for elf_link_input_bfd. */
3392 elf_section_data (sec)->this_hdr.contents = contents;
3393 }
3394 }
3395
3396 if (elf_section_data (sec)->relocs != internal_relocs)
3397 {
3398 if (!changed_relocs)
3399 free (internal_relocs);
3400 else
3401 elf_section_data (sec)->relocs = internal_relocs;
3402 }
3403
3404 return TRUE;
3405
3406 error_return:
3407 if (contents != NULL
3408 && elf_section_data (sec)->this_hdr.contents != contents)
3409 free (contents);
3410 if (internal_relocs != NULL
3411 && elf_section_data (sec)->relocs != internal_relocs)
3412 free (internal_relocs);
3413 return FALSE;
3414}
3415
3416/* Set the sizes of the dynamic sections. */
3417
3418static bfd_boolean
3419elf_x86_64_size_dynamic_sections (bfd *output_bfd,
3420 struct bfd_link_info *info)
3421{
3422 struct elf_x86_64_link_hash_table *htab;
3423 bfd *dynobj;
3424 asection *s;
3425 bfd_boolean relocs;
3426 bfd *ibfd;
3427 const struct elf_backend_data *bed;
3428
3429 htab = elf_x86_64_hash_table (info);
3430 if (htab == NULL)
3431 return FALSE;
3432 bed = get_elf_backend_data (output_bfd);
3433
3434 dynobj = htab->elf.dynobj;
3435 if (dynobj == NULL)
3436 abort ();
3437
3438 if (htab->elf.dynamic_sections_created)
3439 {
3440 /* Set the contents of the .interp section to the interpreter. */
3441 if (bfd_link_executable (info) && !info->nointerp)
3442 {
3443 s = bfd_get_linker_section (dynobj, ".interp");
3444 if (s == NULL)
3445 abort ();
3446 s->size = htab->dynamic_interpreter_size;
3447 s->contents = (unsigned char *) htab->dynamic_interpreter;
3448 htab->interp = s;
3449 }
3450 }
3451
3452 /* Set up .got offsets for local syms, and space for local dynamic
3453 relocs. */
3454 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3455 {
3456 bfd_signed_vma *local_got;
3457 bfd_signed_vma *end_local_got;
3458 char *local_tls_type;
3459 bfd_vma *local_tlsdesc_gotent;
3460 bfd_size_type locsymcount;
3461 Elf_Internal_Shdr *symtab_hdr;
3462 asection *srel;
3463
3464 if (! is_x86_64_elf (ibfd))
3465 continue;
3466
3467 for (s = ibfd->sections; s != NULL; s = s->next)
3468 {
3469 struct elf_dyn_relocs *p;
3470
3471 if (!elf_x86_64_convert_load (ibfd, s, info))
3472 return FALSE;
3473
3474 for (p = (struct elf_dyn_relocs *)
3475 (elf_section_data (s)->local_dynrel);
3476 p != NULL;
3477 p = p->next)
3478 {
3479 if (!bfd_is_abs_section (p->sec)
3480 && bfd_is_abs_section (p->sec->output_section))
3481 {
3482 /* Input section has been discarded, either because
3483 it is a copy of a linkonce section or due to
3484 linker script /DISCARD/, so we'll be discarding
3485 the relocs too. */
3486 }
3487 else if (p->count != 0)
3488 {
3489 srel = elf_section_data (p->sec)->sreloc;
3490 srel->size += p->count * bed->s->sizeof_rela;
3491 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3492 && (info->flags & DF_TEXTREL) == 0)
3493 {
3494 info->flags |= DF_TEXTREL;
3495 if ((info->warn_shared_textrel && bfd_link_pic (info))
3496 || info->error_textrel)
3497 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3498 p->sec->owner, p->sec);
3499 }
3500 }
3501 }
3502 }
3503
3504 local_got = elf_local_got_refcounts (ibfd);
3505 if (!local_got)
3506 continue;
3507
3508 symtab_hdr = &elf_symtab_hdr (ibfd);
3509 locsymcount = symtab_hdr->sh_info;
3510 end_local_got = local_got + locsymcount;
3511 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3512 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3513 s = htab->elf.sgot;
3514 srel = htab->elf.srelgot;
3515 for (; local_got < end_local_got;
3516 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3517 {
3518 *local_tlsdesc_gotent = (bfd_vma) -1;
3519 if (*local_got > 0)
3520 {
3521 if (GOT_TLS_GDESC_P (*local_tls_type))
3522 {
3523 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3524 - elf_x86_64_compute_jump_table_size (htab);
3525 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3526 *local_got = (bfd_vma) -2;
3527 }
3528 if (! GOT_TLS_GDESC_P (*local_tls_type)
3529 || GOT_TLS_GD_P (*local_tls_type))
3530 {
3531 *local_got = s->size;
3532 s->size += GOT_ENTRY_SIZE;
3533 if (GOT_TLS_GD_P (*local_tls_type))
3534 s->size += GOT_ENTRY_SIZE;
3535 }
3536 if (bfd_link_pic (info)
3537 || GOT_TLS_GD_ANY_P (*local_tls_type)
3538 || *local_tls_type == GOT_TLS_IE)
3539 {
3540 if (GOT_TLS_GDESC_P (*local_tls_type))
3541 {
3542 htab->elf.srelplt->size
3543 += bed->s->sizeof_rela;
3544 htab->tlsdesc_plt = (bfd_vma) -1;
3545 }
3546 if (! GOT_TLS_GDESC_P (*local_tls_type)
3547 || GOT_TLS_GD_P (*local_tls_type))
3548 srel->size += bed->s->sizeof_rela;
3549 }
3550 }
3551 else
3552 *local_got = (bfd_vma) -1;
3553 }
3554 }
3555
3556 if (htab->tls_ld_got.refcount > 0)
3557 {
3558 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3559 relocs. */
3560 htab->tls_ld_got.offset = htab->elf.sgot->size;
3561 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3562 htab->elf.srelgot->size += bed->s->sizeof_rela;
3563 }
3564 else
3565 htab->tls_ld_got.offset = -1;
3566
3567 /* Allocate global sym .plt and .got entries, and space for global
3568 sym dynamic relocs. */
3569 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3570 info);
3571
3572 /* Allocate .plt and .got entries, and space for local symbols. */
3573 htab_traverse (htab->loc_hash_table,
3574 elf_x86_64_allocate_local_dynrelocs,
3575 info);
3576
3577 /* For every jump slot reserved in the sgotplt, reloc_count is
3578 incremented. However, when we reserve space for TLS descriptors,
3579 it's not incremented, so in order to compute the space reserved
3580 for them, it suffices to multiply the reloc count by the jump
3581 slot size.
3582
3583 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3584 so that R_X86_64_IRELATIVE entries come last. */
3585 if (htab->elf.srelplt)
3586 {
3587 htab->sgotplt_jump_table_size
3588 = elf_x86_64_compute_jump_table_size (htab);
3589 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3590 }
3591 else if (htab->elf.irelplt)
3592 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3593
3594 if (htab->tlsdesc_plt)
3595 {
3596 /* If we're not using lazy TLS relocations, don't generate the
3597 PLT and GOT entries they require. */
3598 if ((info->flags & DF_BIND_NOW))
3599 htab->tlsdesc_plt = 0;
3600 else
3601 {
3602 htab->tlsdesc_got = htab->elf.sgot->size;
3603 htab->elf.sgot->size += GOT_ENTRY_SIZE;
3604 /* Reserve room for the initial entry.
3605 FIXME: we could probably do away with it in this case. */
3606 if (htab->elf.splt->size == 0)
3607 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3608 htab->tlsdesc_plt = htab->elf.splt->size;
3609 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3610 }
3611 }
3612
3613 if (htab->elf.sgotplt)
3614 {
3615 /* Don't allocate .got.plt section if there are no GOT nor PLT
3616 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3617 if ((htab->elf.hgot == NULL
3618 || !htab->elf.hgot->ref_regular_nonweak)
3619 && (htab->elf.sgotplt->size
3620 == get_elf_backend_data (output_bfd)->got_header_size)
3621 && (htab->elf.splt == NULL
3622 || htab->elf.splt->size == 0)
3623 && (htab->elf.sgot == NULL
3624 || htab->elf.sgot->size == 0)
3625 && (htab->elf.iplt == NULL
3626 || htab->elf.iplt->size == 0)
3627 && (htab->elf.igotplt == NULL
3628 || htab->elf.igotplt->size == 0))
3629 htab->elf.sgotplt->size = 0;
3630 }
3631
3632 if (htab->plt_eh_frame != NULL
3633 && htab->elf.splt != NULL
3634 && htab->elf.splt->size != 0
3635 && !bfd_is_abs_section (htab->elf.splt->output_section)
3636 && _bfd_elf_eh_frame_present (info))
3637 {
3638 const struct elf_x86_64_backend_data *arch_data
3639 = get_elf_x86_64_arch_data (bed);
3640 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3641 }
3642
3643 /* We now have determined the sizes of the various dynamic sections.
3644 Allocate memory for them. */
3645 relocs = FALSE;
3646 for (s = dynobj->sections; s != NULL; s = s->next)
3647 {
3648 if ((s->flags & SEC_LINKER_CREATED) == 0)
3649 continue;
3650
3651 if (s == htab->elf.splt
3652 || s == htab->elf.sgot
3653 || s == htab->elf.sgotplt
3654 || s == htab->elf.iplt
3655 || s == htab->elf.igotplt
3656 || s == htab->plt_bnd
3657 || s == htab->plt_got
3658 || s == htab->plt_eh_frame
3659 || s == htab->sdynbss)
3660 {
3661 /* Strip this section if we don't need it; see the
3662 comment below. */
3663 }
3664 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3665 {
3666 if (s->size != 0 && s != htab->elf.srelplt)
3667 relocs = TRUE;
3668
3669 /* We use the reloc_count field as a counter if we need
3670 to copy relocs into the output file. */
3671 if (s != htab->elf.srelplt)
3672 s->reloc_count = 0;
3673 }
3674 else
3675 {
3676 /* It's not one of our sections, so don't allocate space. */
3677 continue;
3678 }
3679
3680 if (s->size == 0)
3681 {
3682 /* If we don't need this section, strip it from the
3683 output file. This is mostly to handle .rela.bss and
3684 .rela.plt. We must create both sections in
3685 create_dynamic_sections, because they must be created
3686 before the linker maps input sections to output
3687 sections. The linker does that before
3688 adjust_dynamic_symbol is called, and it is that
3689 function which decides whether anything needs to go
3690 into these sections. */
3691
3692 s->flags |= SEC_EXCLUDE;
3693 continue;
3694 }
3695
3696 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3697 continue;
3698
3699 /* Allocate memory for the section contents. We use bfd_zalloc
3700 here in case unused entries are not reclaimed before the
3701 section's contents are written out. This should not happen,
3702 but this way if it does, we get a R_X86_64_NONE reloc instead
3703 of garbage. */
3704 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3705 if (s->contents == NULL)
3706 return FALSE;
3707 }
3708
3709 if (htab->plt_eh_frame != NULL
3710 && htab->plt_eh_frame->contents != NULL)
3711 {
3712 const struct elf_x86_64_backend_data *arch_data
3713 = get_elf_x86_64_arch_data (bed);
3714
3715 memcpy (htab->plt_eh_frame->contents,
3716 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3717 bfd_put_32 (dynobj, htab->elf.splt->size,
3718 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3719 }
3720
3721 if (htab->elf.dynamic_sections_created)
3722 {
3723 /* Add some entries to the .dynamic section. We fill in the
3724 values later, in elf_x86_64_finish_dynamic_sections, but we
3725 must add the entries now so that we get the correct size for
3726 the .dynamic section. The DT_DEBUG entry is filled in by the
3727 dynamic linker and used by the debugger. */
3728#define add_dynamic_entry(TAG, VAL) \
3729 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3730
3731 if (bfd_link_executable (info))
3732 {
3733 if (!add_dynamic_entry (DT_DEBUG, 0))
3734 return FALSE;
3735 }
3736
3737 if (htab->elf.splt->size != 0)
3738 {
3739 /* DT_PLTGOT is used by prelink even if there is no PLT
3740 relocation. */
3741 if (!add_dynamic_entry (DT_PLTGOT, 0))
3742 return FALSE;
3743
3744 if (htab->elf.srelplt->size != 0)
3745 {
3746 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3747 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3748 || !add_dynamic_entry (DT_JMPREL, 0))
3749 return FALSE;
3750 }
3751
3752 if (htab->tlsdesc_plt
3753 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3754 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3755 return FALSE;
3756 }
3757
3758 if (relocs)
3759 {
3760 if (!add_dynamic_entry (DT_RELA, 0)
3761 || !add_dynamic_entry (DT_RELASZ, 0)
3762 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3763 return FALSE;
3764
3765 /* If any dynamic relocs apply to a read-only section,
3766 then we need a DT_TEXTREL entry. */
3767 if ((info->flags & DF_TEXTREL) == 0)
3768 elf_link_hash_traverse (&htab->elf,
3769 elf_x86_64_readonly_dynrelocs,
3770 info);
3771
3772 if ((info->flags & DF_TEXTREL) != 0)
3773 {
3774 if (htab->readonly_dynrelocs_against_ifunc)
3775 {
3776 info->callbacks->einfo
3777 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3778 bfd_set_error (bfd_error_bad_value);
3779 return FALSE;
3780 }
3781
3782 if (!add_dynamic_entry (DT_TEXTREL, 0))
3783 return FALSE;
3784 }
3785 }
3786 }
3787#undef add_dynamic_entry
3788
3789 return TRUE;
3790}
3791
3792static bfd_boolean
3793elf_x86_64_always_size_sections (bfd *output_bfd,
3794 struct bfd_link_info *info)
3795{
3796 asection *tls_sec = elf_hash_table (info)->tls_sec;
3797
3798 if (tls_sec)
3799 {
3800 struct elf_link_hash_entry *tlsbase;
3801
3802 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3803 "_TLS_MODULE_BASE_",
3804 FALSE, FALSE, FALSE);
3805
3806 if (tlsbase && tlsbase->type == STT_TLS)
3807 {
3808 struct elf_x86_64_link_hash_table *htab;
3809 struct bfd_link_hash_entry *bh = NULL;
3810 const struct elf_backend_data *bed
3811 = get_elf_backend_data (output_bfd);
3812
3813 htab = elf_x86_64_hash_table (info);
3814 if (htab == NULL)
3815 return FALSE;
3816
3817 if (!(_bfd_generic_link_add_one_symbol
3818 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3819 tls_sec, 0, NULL, FALSE,
3820 bed->collect, &bh)))
3821 return FALSE;
3822
3823 htab->tls_module_base = bh;
3824
3825 tlsbase = (struct elf_link_hash_entry *)bh;
3826 tlsbase->def_regular = 1;
3827 tlsbase->other = STV_HIDDEN;
3828 tlsbase->root.linker_def = 1;
3829 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3830 }
3831 }
3832
3833 return TRUE;
3834}
3835
3836/* _TLS_MODULE_BASE_ needs to be treated especially when linking
3837 executables. Rather than setting it to the beginning of the TLS
3838 section, we have to set it to the end. This function may be called
3839 multiple times, it is idempotent. */
3840
3841static void
3842elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3843{
3844 struct elf_x86_64_link_hash_table *htab;
3845 struct bfd_link_hash_entry *base;
3846
3847 if (!bfd_link_executable (info))
3848 return;
3849
3850 htab = elf_x86_64_hash_table (info);
3851 if (htab == NULL)
3852 return;
3853
3854 base = htab->tls_module_base;
3855 if (base == NULL)
3856 return;
3857
3858 base->u.def.value = htab->elf.tls_size;
3859}
3860
3861/* Return the base VMA address which should be subtracted from real addresses
3862 when resolving @dtpoff relocation.
3863 This is PT_TLS segment p_vaddr. */
3864
3865static bfd_vma
3866elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3867{
3868 /* If tls_sec is NULL, we should have signalled an error already. */
3869 if (elf_hash_table (info)->tls_sec == NULL)
3870 return 0;
3871 return elf_hash_table (info)->tls_sec->vma;
3872}
3873
3874/* Return the relocation value for @tpoff relocation
3875 if STT_TLS virtual address is ADDRESS. */
3876
3877static bfd_vma
3878elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3879{
3880 struct elf_link_hash_table *htab = elf_hash_table (info);
3881 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3882 bfd_vma static_tls_size;
3883
3884 /* If tls_segment is NULL, we should have signalled an error already. */
3885 if (htab->tls_sec == NULL)
3886 return 0;
3887
3888 /* Consider special static TLS alignment requirements. */
3889 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3890 return address - static_tls_size - htab->tls_sec->vma;
3891}
3892
3893/* Is the instruction before OFFSET in CONTENTS a 32bit relative
3894 branch? */
3895
3896static bfd_boolean
3897is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3898{
3899 /* Opcode Instruction
3900 0xe8 call
3901 0xe9 jump
3902 0x0f 0x8x conditional jump */
3903 return ((offset > 0
3904 && (contents [offset - 1] == 0xe8
3905 || contents [offset - 1] == 0xe9))
3906 || (offset > 1
3907 && contents [offset - 2] == 0x0f
3908 && (contents [offset - 1] & 0xf0) == 0x80));
3909}
3910
3911/* Relocate an x86_64 ELF section. */
3912
3913static bfd_boolean
3914elf_x86_64_relocate_section (bfd *output_bfd,
3915 struct bfd_link_info *info,
3916 bfd *input_bfd,
3917 asection *input_section,
3918 bfd_byte *contents,
3919 Elf_Internal_Rela *relocs,
3920 Elf_Internal_Sym *local_syms,
3921 asection **local_sections)
3922{
3923 struct elf_x86_64_link_hash_table *htab;
3924 Elf_Internal_Shdr *symtab_hdr;
3925 struct elf_link_hash_entry **sym_hashes;
3926 bfd_vma *local_got_offsets;
3927 bfd_vma *local_tlsdesc_gotents;
3928 Elf_Internal_Rela *rel;
3929 Elf_Internal_Rela *wrel;
3930 Elf_Internal_Rela *relend;
3931 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3932
3933 BFD_ASSERT (is_x86_64_elf (input_bfd));
3934
3935 /* Skip if check_relocs failed. */
3936 if (input_section->check_relocs_failed)
3937 return FALSE;
3938
3939 htab = elf_x86_64_hash_table (info);
3940 if (htab == NULL)
3941 return FALSE;
3942 symtab_hdr = &elf_symtab_hdr (input_bfd);
3943 sym_hashes = elf_sym_hashes (input_bfd);
3944 local_got_offsets = elf_local_got_offsets (input_bfd);
3945 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3946
3947 elf_x86_64_set_tls_module_base (info);
3948
3949 rel = wrel = relocs;
3950 relend = relocs + input_section->reloc_count;
3951 for (; rel < relend; wrel++, rel++)
3952 {
3953 unsigned int r_type;
3954 reloc_howto_type *howto;
3955 unsigned long r_symndx;
3956 struct elf_link_hash_entry *h;
3957 struct elf_x86_64_link_hash_entry *eh;
3958 Elf_Internal_Sym *sym;
3959 asection *sec;
3960 bfd_vma off, offplt, plt_offset;
3961 bfd_vma relocation;
3962 bfd_boolean unresolved_reloc;
3963 bfd_reloc_status_type r;
3964 int tls_type;
3965 asection *base_got, *resolved_plt;
3966 bfd_vma st_size;
3967 bfd_boolean resolved_to_zero;
3968
3969 r_type = ELF32_R_TYPE (rel->r_info);
3970 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3971 || r_type == (int) R_X86_64_GNU_VTENTRY)
3972 {
3973 if (wrel != rel)
3974 *wrel = *rel;
3975 continue;
3976 }
3977
3978 if (r_type >= (int) R_X86_64_standard)
3979 {
3980 (*_bfd_error_handler)
3981 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3982 input_bfd, input_section, r_type);
3983 bfd_set_error (bfd_error_bad_value);
3984 return FALSE;
3985 }
3986
3987 if (r_type != (int) R_X86_64_32
3988 || ABI_64_P (output_bfd))
3989 howto = x86_64_elf_howto_table + r_type;
3990 else
3991 howto = (x86_64_elf_howto_table
3992 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3993 r_symndx = htab->r_sym (rel->r_info);
3994 h = NULL;
3995 sym = NULL;
3996 sec = NULL;
3997 unresolved_reloc = FALSE;
3998 if (r_symndx < symtab_hdr->sh_info)
3999 {
4000 sym = local_syms + r_symndx;
4001 sec = local_sections[r_symndx];
4002
4003 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
4004 &sec, rel);
4005 st_size = sym->st_size;
4006
4007 /* Relocate against local STT_GNU_IFUNC symbol. */
4008 if (!bfd_link_relocatable (info)
4009 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4010 {
4011 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
4012 rel, FALSE);
4013 if (h == NULL)
4014 abort ();
4015
4016 /* Set STT_GNU_IFUNC symbol value. */
4017 h->root.u.def.value = sym->st_value;
4018 h->root.u.def.section = sec;
4019 }
4020 }
4021 else
4022 {
4023 bfd_boolean warned ATTRIBUTE_UNUSED;
4024 bfd_boolean ignored ATTRIBUTE_UNUSED;
4025
4026 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4027 r_symndx, symtab_hdr, sym_hashes,
4028 h, sec, relocation,
4029 unresolved_reloc, warned, ignored);
4030 st_size = h->size;
4031 }
4032
4033 if (sec != NULL && discarded_section (sec))
4034 {
4035 _bfd_clear_contents (howto, input_bfd, input_section,
4036 contents + rel->r_offset);
4037 wrel->r_offset = rel->r_offset;
4038 wrel->r_info = 0;
4039 wrel->r_addend = 0;
4040
4041 /* For ld -r, remove relocations in debug sections against
4042 sections defined in discarded sections. Not done for
4043 eh_frame editing code expects to be present. */
4044 if (bfd_link_relocatable (info)
4045 && (input_section->flags & SEC_DEBUGGING))
4046 wrel--;
4047
4048 continue;
4049 }
4050
4051 if (bfd_link_relocatable (info))
4052 {
4053 if (wrel != rel)
4054 *wrel = *rel;
4055 continue;
4056 }
4057
4058 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
4059 {
4060 if (r_type == R_X86_64_64)
4061 {
4062 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4063 zero-extend it to 64bit if addend is zero. */
4064 r_type = R_X86_64_32;
4065 memset (contents + rel->r_offset + 4, 0, 4);
4066 }
4067 else if (r_type == R_X86_64_SIZE64)
4068 {
4069 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4070 zero-extend it to 64bit if addend is zero. */
4071 r_type = R_X86_64_SIZE32;
4072 memset (contents + rel->r_offset + 4, 0, 4);
4073 }
4074 }
4075
4076 eh = (struct elf_x86_64_link_hash_entry *) h;
4077
4078 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4079 it here if it is defined in a non-shared object. */
4080 if (h != NULL
4081 && h->type == STT_GNU_IFUNC
4082 && h->def_regular)
4083 {
4084 bfd_vma plt_index;
4085 const char *name;
4086
4087 if ((input_section->flags & SEC_ALLOC) == 0)
4088 {
4089 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4090 sections because such sections are not SEC_ALLOC and
4091 thus ld.so will not process them. */
4092 if ((input_section->flags & SEC_DEBUGGING) != 0)
4093 continue;
4094 abort ();
4095 }
4096 else if (h->plt.offset == (bfd_vma) -1)
4097 abort ();
4098
4099 /* STT_GNU_IFUNC symbol must go through PLT. */
4100 if (htab->elf.splt != NULL)
4101 {
4102 if (htab->plt_bnd != NULL)
4103 {
4104 resolved_plt = htab->plt_bnd;
4105 plt_offset = eh->plt_bnd.offset;
4106 }
4107 else
4108 {
4109 resolved_plt = htab->elf.splt;
4110 plt_offset = h->plt.offset;
4111 }
4112 }
4113 else
4114 {
4115 resolved_plt = htab->elf.iplt;
4116 plt_offset = h->plt.offset;
4117 }
4118
4119 relocation = (resolved_plt->output_section->vma
4120 + resolved_plt->output_offset + plt_offset);
4121
4122 switch (r_type)
4123 {
4124 default:
4125 if (h->root.root.string)
4126 name = h->root.root.string;
4127 else
4128 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4129 NULL);
4130 (*_bfd_error_handler)
4131 (_("%B: relocation %s against STT_GNU_IFUNC "
4132 "symbol `%s' isn't handled by %s"), input_bfd,
4133 howto->name, name, __FUNCTION__);
4134 bfd_set_error (bfd_error_bad_value);
4135 return FALSE;
4136
4137 case R_X86_64_32S:
4138 if (bfd_link_pic (info))
4139 abort ();
4140 goto do_relocation;
4141
4142 case R_X86_64_32:
4143 if (ABI_64_P (output_bfd))
4144 goto do_relocation;
4145 /* FALLTHROUGH */
4146 case R_X86_64_64:
4147 if (rel->r_addend != 0)
4148 {
4149 if (h->root.root.string)
4150 name = h->root.root.string;
4151 else
4152 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4153 sym, NULL);
4154 (*_bfd_error_handler)
4155 (_("%B: relocation %s against STT_GNU_IFUNC "
4156 "symbol `%s' has non-zero addend: %d"),
4157 input_bfd, howto->name, name, rel->r_addend);
4158 bfd_set_error (bfd_error_bad_value);
4159 return FALSE;
4160 }
4161
4162 /* Generate dynamic relcoation only when there is a
4163 non-GOT reference in a shared object. */
4164 if (bfd_link_pic (info) && h->non_got_ref)
4165 {
4166 Elf_Internal_Rela outrel;
4167 asection *sreloc;
4168
4169 /* Need a dynamic relocation to get the real function
4170 address. */
4171 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4172 info,
4173 input_section,
4174 rel->r_offset);
4175 if (outrel.r_offset == (bfd_vma) -1
4176 || outrel.r_offset == (bfd_vma) -2)
4177 abort ();
4178
4179 outrel.r_offset += (input_section->output_section->vma
4180 + input_section->output_offset);
4181
4182 if (h->dynindx == -1
4183 || h->forced_local
4184 || bfd_link_executable (info))
4185 {
4186 /* This symbol is resolved locally. */
4187 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4188 outrel.r_addend = (h->root.u.def.value
4189 + h->root.u.def.section->output_section->vma
4190 + h->root.u.def.section->output_offset);
4191 }
4192 else
4193 {
4194 outrel.r_info = htab->r_info (h->dynindx, r_type);
4195 outrel.r_addend = 0;
4196 }
4197
4198 sreloc = htab->elf.irelifunc;
4199 elf_append_rela (output_bfd, sreloc, &outrel);
4200
4201 /* If this reloc is against an external symbol, we
4202 do not want to fiddle with the addend. Otherwise,
4203 we need to include the symbol value so that it
4204 becomes an addend for the dynamic reloc. For an
4205 internal symbol, we have updated addend. */
4206 continue;
4207 }
4208 /* FALLTHROUGH */
4209 case R_X86_64_PC32:
4210 case R_X86_64_PC32_BND:
4211 case R_X86_64_PC64:
4212 case R_X86_64_PLT32:
4213 case R_X86_64_PLT32_BND:
4214 goto do_relocation;
4215
4216 case R_X86_64_GOTPCREL:
4217 case R_X86_64_GOTPCRELX:
4218 case R_X86_64_REX_GOTPCRELX:
4219 case R_X86_64_GOTPCREL64:
4220 base_got = htab->elf.sgot;
4221 off = h->got.offset;
4222
4223 if (base_got == NULL)
4224 abort ();
4225
4226 if (off == (bfd_vma) -1)
4227 {
4228 /* We can't use h->got.offset here to save state, or
4229 even just remember the offset, as finish_dynamic_symbol
4230 would use that as offset into .got. */
4231
4232 if (htab->elf.splt != NULL)
4233 {
4234 plt_index = h->plt.offset / plt_entry_size - 1;
4235 off = (plt_index + 3) * GOT_ENTRY_SIZE;
4236 base_got = htab->elf.sgotplt;
4237 }
4238 else
4239 {
4240 plt_index = h->plt.offset / plt_entry_size;
4241 off = plt_index * GOT_ENTRY_SIZE;
4242 base_got = htab->elf.igotplt;
4243 }
4244
4245 if (h->dynindx == -1
4246 || h->forced_local
4247 || info->symbolic)
4248 {
4249 /* This references the local defitionion. We must
4250 initialize this entry in the global offset table.
4251 Since the offset must always be a multiple of 8,
4252 we use the least significant bit to record
4253 whether we have initialized it already.
4254
4255 When doing a dynamic link, we create a .rela.got
4256 relocation entry to initialize the value. This
4257 is done in the finish_dynamic_symbol routine. */
4258 if ((off & 1) != 0)
4259 off &= ~1;
4260 else
4261 {
4262 bfd_put_64 (output_bfd, relocation,
4263 base_got->contents + off);
4264 /* Note that this is harmless for the GOTPLT64
4265 case, as -1 | 1 still is -1. */
4266 h->got.offset |= 1;
4267 }
4268 }
4269 }
4270
4271 relocation = (base_got->output_section->vma
4272 + base_got->output_offset + off);
4273
4274 goto do_relocation;
4275 }
4276 }
4277
4278 resolved_to_zero = (eh != NULL
4279 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
4280
4281 /* When generating a shared object, the relocations handled here are
4282 copied into the output file to be resolved at run time. */
4283 switch (r_type)
4284 {
4285 case R_X86_64_GOT32:
4286 case R_X86_64_GOT64:
4287 /* Relocation is to the entry for this symbol in the global
4288 offset table. */
4289 case R_X86_64_GOTPCREL:
4290 case R_X86_64_GOTPCRELX:
4291 case R_X86_64_REX_GOTPCRELX:
4292 case R_X86_64_GOTPCREL64:
4293 /* Use global offset table entry as symbol value. */
4294 case R_X86_64_GOTPLT64:
4295 /* This is obsolete and treated the the same as GOT64. */
4296 base_got = htab->elf.sgot;
4297
4298 if (htab->elf.sgot == NULL)
4299 abort ();
4300
4301 if (h != NULL)
4302 {
4303 bfd_boolean dyn;
4304
4305 off = h->got.offset;
4306 if (h->needs_plt
4307 && h->plt.offset != (bfd_vma)-1
4308 && off == (bfd_vma)-1)
4309 {
4310 /* We can't use h->got.offset here to save
4311 state, or even just remember the offset, as
4312 finish_dynamic_symbol would use that as offset into
4313 .got. */
4314 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
4315 off = (plt_index + 3) * GOT_ENTRY_SIZE;
4316 base_got = htab->elf.sgotplt;
4317 }
4318
4319 dyn = htab->elf.dynamic_sections_created;
4320
4321 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
4322 || (bfd_link_pic (info)
4323 && SYMBOL_REFERENCES_LOCAL (info, h))
4324 || (ELF_ST_VISIBILITY (h->other)
4325 && h->root.type == bfd_link_hash_undefweak))
4326 {
4327 /* This is actually a static link, or it is a -Bsymbolic
4328 link and the symbol is defined locally, or the symbol
4329 was forced to be local because of a version file. We
4330 must initialize this entry in the global offset table.
4331 Since the offset must always be a multiple of 8, we
4332 use the least significant bit to record whether we
4333 have initialized it already.
4334
4335 When doing a dynamic link, we create a .rela.got
4336 relocation entry to initialize the value. This is
4337 done in the finish_dynamic_symbol routine. */
4338 if ((off & 1) != 0)
4339 off &= ~1;
4340 else
4341 {
4342 bfd_put_64 (output_bfd, relocation,
4343 base_got->contents + off);
4344 /* Note that this is harmless for the GOTPLT64 case,
4345 as -1 | 1 still is -1. */
4346 h->got.offset |= 1;
4347 }
4348 }
4349 else
4350 unresolved_reloc = FALSE;
4351 }
4352 else
4353 {
4354 if (local_got_offsets == NULL)
4355 abort ();
4356
4357 off = local_got_offsets[r_symndx];
4358
4359 /* The offset must always be a multiple of 8. We use
4360 the least significant bit to record whether we have
4361 already generated the necessary reloc. */
4362 if ((off & 1) != 0)
4363 off &= ~1;
4364 else
4365 {
4366 bfd_put_64 (output_bfd, relocation,
4367 base_got->contents + off);
4368
4369 if (bfd_link_pic (info))
4370 {
4371 asection *s;
4372 Elf_Internal_Rela outrel;
4373
4374 /* We need to generate a R_X86_64_RELATIVE reloc
4375 for the dynamic linker. */
4376 s = htab->elf.srelgot;
4377 if (s == NULL)
4378 abort ();
4379
4380 outrel.r_offset = (base_got->output_section->vma
4381 + base_got->output_offset
4382 + off);
4383 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4384 outrel.r_addend = relocation;
4385 elf_append_rela (output_bfd, s, &outrel);
4386 }
4387
4388 local_got_offsets[r_symndx] |= 1;
4389 }
4390 }
4391
4392 if (off >= (bfd_vma) -2)
4393 abort ();
4394
4395 relocation = base_got->output_section->vma
4396 + base_got->output_offset + off;
4397 if (r_type != R_X86_64_GOTPCREL
4398 && r_type != R_X86_64_GOTPCRELX
4399 && r_type != R_X86_64_REX_GOTPCRELX
4400 && r_type != R_X86_64_GOTPCREL64)
4401 relocation -= htab->elf.sgotplt->output_section->vma
4402 - htab->elf.sgotplt->output_offset;
4403
4404 break;
4405
4406 case R_X86_64_GOTOFF64:
4407 /* Relocation is relative to the start of the global offset
4408 table. */
4409
4410 /* Check to make sure it isn't a protected function or data
4411 symbol for shared library since it may not be local when
4412 used as function address or with copy relocation. We also
4413 need to make sure that a symbol is referenced locally. */
4414 if (bfd_link_pic (info) && h)
4415 {
4416 if (!h->def_regular)
4417 {
4418 const char *v;
4419
4420 switch (ELF_ST_VISIBILITY (h->other))
4421 {
4422 case STV_HIDDEN:
4423 v = _("hidden symbol");
4424 break;
4425 case STV_INTERNAL:
4426 v = _("internal symbol");
4427 break;
4428 case STV_PROTECTED:
4429 v = _("protected symbol");
4430 break;
4431 default:
4432 v = _("symbol");
4433 break;
4434 }
4435
4436 (*_bfd_error_handler)
4437 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4438 input_bfd, v, h->root.root.string);
4439 bfd_set_error (bfd_error_bad_value);
4440 return FALSE;
4441 }
4442 else if (!bfd_link_executable (info)
4443 && !SYMBOL_REFERENCES_LOCAL (info, h)
4444 && (h->type == STT_FUNC
4445 || h->type == STT_OBJECT)
4446 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4447 {
4448 (*_bfd_error_handler)
4449 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4450 input_bfd,
4451 h->type == STT_FUNC ? "function" : "data",
4452 h->root.root.string);
4453 bfd_set_error (bfd_error_bad_value);
4454 return FALSE;
4455 }
4456 }
4457
4458 /* Note that sgot is not involved in this
4459 calculation. We always want the start of .got.plt. If we
4460 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4461 permitted by the ABI, we might have to change this
4462 calculation. */
4463 relocation -= htab->elf.sgotplt->output_section->vma
4464 + htab->elf.sgotplt->output_offset;
4465 break;
4466
4467 case R_X86_64_GOTPC32:
4468 case R_X86_64_GOTPC64:
4469 /* Use global offset table as symbol value. */
4470 relocation = htab->elf.sgotplt->output_section->vma
4471 + htab->elf.sgotplt->output_offset;
4472 unresolved_reloc = FALSE;
4473 break;
4474
4475 case R_X86_64_PLTOFF64:
4476 /* Relocation is PLT entry relative to GOT. For local
4477 symbols it's the symbol itself relative to GOT. */
4478 if (h != NULL
4479 /* See PLT32 handling. */
4480 && h->plt.offset != (bfd_vma) -1
4481 && htab->elf.splt != NULL)
4482 {
4483 if (htab->plt_bnd != NULL)
4484 {
4485 resolved_plt = htab->plt_bnd;
4486 plt_offset = eh->plt_bnd.offset;
4487 }
4488 else
4489 {
4490 resolved_plt = htab->elf.splt;
4491 plt_offset = h->plt.offset;
4492 }
4493
4494 relocation = (resolved_plt->output_section->vma
4495 + resolved_plt->output_offset
4496 + plt_offset);
4497 unresolved_reloc = FALSE;
4498 }
4499
4500 relocation -= htab->elf.sgotplt->output_section->vma
4501 + htab->elf.sgotplt->output_offset;
4502 break;
4503
4504 case R_X86_64_PLT32:
4505 case R_X86_64_PLT32_BND:
4506 /* Relocation is to the entry for this symbol in the
4507 procedure linkage table. */
4508
4509 /* Resolve a PLT32 reloc against a local symbol directly,
4510 without using the procedure linkage table. */
4511 if (h == NULL)
4512 break;
4513
4514 if ((h->plt.offset == (bfd_vma) -1
4515 && eh->plt_got.offset == (bfd_vma) -1)
4516 || htab->elf.splt == NULL)
4517 {
4518 /* We didn't make a PLT entry for this symbol. This
4519 happens when statically linking PIC code, or when
4520 using -Bsymbolic. */
4521 break;
4522 }
4523
4524 if (h->plt.offset != (bfd_vma) -1)
4525 {
4526 if (htab->plt_bnd != NULL)
4527 {
4528 resolved_plt = htab->plt_bnd;
4529 plt_offset = eh->plt_bnd.offset;
4530 }
4531 else
4532 {
4533 resolved_plt = htab->elf.splt;
4534 plt_offset = h->plt.offset;
4535 }
4536 }
4537 else
4538 {
4539 /* Use the GOT PLT. */
4540 resolved_plt = htab->plt_got;
4541 plt_offset = eh->plt_got.offset;
4542 }
4543
4544 relocation = (resolved_plt->output_section->vma
4545 + resolved_plt->output_offset
4546 + plt_offset);
4547 unresolved_reloc = FALSE;
4548 break;
4549
4550 case R_X86_64_SIZE32:
4551 case R_X86_64_SIZE64:
4552 /* Set to symbol size. */
4553 relocation = st_size;
4554 goto direct;
4555
4556 case R_X86_64_PC8:
4557 case R_X86_64_PC16:
4558 case R_X86_64_PC32:
4559 case R_X86_64_PC32_BND:
4560 /* Don't complain about -fPIC if the symbol is undefined when
4561 building executable unless it is unresolved weak symbol. */
4562 if ((input_section->flags & SEC_ALLOC) != 0
4563 && (input_section->flags & SEC_READONLY) != 0
4564 && h != NULL
4565 && ((bfd_link_executable (info)
4566 && h->root.type == bfd_link_hash_undefweak
4567 && !resolved_to_zero)
4568 || (bfd_link_pic (info)
4569 && !(bfd_link_pie (info)
4570 && h->root.type == bfd_link_hash_undefined))))
4571 {
4572 bfd_boolean fail = FALSE;
4573 bfd_boolean branch
4574 = ((r_type == R_X86_64_PC32
4575 || r_type == R_X86_64_PC32_BND)
4576 && is_32bit_relative_branch (contents, rel->r_offset));
4577
4578 if (SYMBOL_REFERENCES_LOCAL (info, h))
4579 {
4580 /* Symbol is referenced locally. Make sure it is
4581 defined locally or for a branch. */
4582 fail = !h->def_regular && !branch;
4583 }
4584 else if (!(bfd_link_pie (info)
4585 && (h->needs_copy || eh->needs_copy)))
4586 {
4587 /* Symbol doesn't need copy reloc and isn't referenced
4588 locally. We only allow branch to symbol with
4589 non-default visibility. */
4590 fail = (!branch
4591 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4592 }
4593
4594 if (fail)
4595 return elf_x86_64_need_pic (input_bfd, input_section,
4596 h, NULL, NULL, howto);
4597 }
4598 /* Fall through. */
4599
4600 case R_X86_64_8:
4601 case R_X86_64_16:
4602 case R_X86_64_32:
4603 case R_X86_64_PC64:
4604 case R_X86_64_64:
4605 /* FIXME: The ABI says the linker should make sure the value is
4606 the same when it's zeroextended to 64 bit. */
4607
4608direct:
4609 if ((input_section->flags & SEC_ALLOC) == 0)
4610 break;
4611
4612 /* Don't copy a pc-relative relocation into the output file
4613 if the symbol needs copy reloc or the symbol is undefined
4614 when building executable. Copy dynamic function pointer
4615 relocations. Don't generate dynamic relocations against
4616 resolved undefined weak symbols in PIE. */
4617 if ((bfd_link_pic (info)
4618 && !(bfd_link_pie (info)
4619 && h != NULL
4620 && (h->needs_copy
4621 || eh->needs_copy
4622 || h->root.type == bfd_link_hash_undefined)
4623 && IS_X86_64_PCREL_TYPE (r_type))
4624 && (h == NULL
4625 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4626 && !resolved_to_zero)
4627 || h->root.type != bfd_link_hash_undefweak))
4628 && ((! IS_X86_64_PCREL_TYPE (r_type)
4629 && r_type != R_X86_64_SIZE32
4630 && r_type != R_X86_64_SIZE64)
4631 || ! SYMBOL_CALLS_LOCAL (info, h)))
4632 || (ELIMINATE_COPY_RELOCS
4633 && !bfd_link_pic (info)
4634 && h != NULL
4635 && h->dynindx != -1
4636 && (!h->non_got_ref
4637 || eh->func_pointer_refcount > 0
4638 || (h->root.type == bfd_link_hash_undefweak
4639 && !resolved_to_zero))
4640 && ((h->def_dynamic && !h->def_regular)
4641 /* Undefined weak symbol is bound locally when
4642 PIC is false. */
4643 || h->root.type == bfd_link_hash_undefined)))
4644 {
4645 Elf_Internal_Rela outrel;
4646 bfd_boolean skip, relocate;
4647 asection *sreloc;
4648
4649 /* When generating a shared object, these relocations
4650 are copied into the output file to be resolved at run
4651 time. */
4652 skip = FALSE;
4653 relocate = FALSE;
4654
4655 outrel.r_offset =
4656 _bfd_elf_section_offset (output_bfd, info, input_section,
4657 rel->r_offset);
4658 if (outrel.r_offset == (bfd_vma) -1)
4659 skip = TRUE;
4660 else if (outrel.r_offset == (bfd_vma) -2)
4661 skip = TRUE, relocate = TRUE;
4662
4663 outrel.r_offset += (input_section->output_section->vma
4664 + input_section->output_offset);
4665
4666 if (skip)
4667 memset (&outrel, 0, sizeof outrel);
4668
4669 /* h->dynindx may be -1 if this symbol was marked to
4670 become local. */
4671 else if (h != NULL
4672 && h->dynindx != -1
4673 && (IS_X86_64_PCREL_TYPE (r_type)
4674 || !(bfd_link_executable (info)
4675 || SYMBOLIC_BIND (info, h))
4676 || ! h->def_regular))
4677 {
4678 outrel.r_info = htab->r_info (h->dynindx, r_type);
4679 outrel.r_addend = rel->r_addend;
4680 }
4681 else
4682 {
4683 /* This symbol is local, or marked to become local.
4684 When relocation overflow check is disabled, we
4685 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4686 if (r_type == htab->pointer_r_type
4687 || (r_type == R_X86_64_32
4688 && info->no_reloc_overflow_check))
4689 {
4690 relocate = TRUE;
4691 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4692 outrel.r_addend = relocation + rel->r_addend;
4693 }
4694 else if (r_type == R_X86_64_64
4695 && !ABI_64_P (output_bfd))
4696 {
4697 relocate = TRUE;
4698 outrel.r_info = htab->r_info (0,
4699 R_X86_64_RELATIVE64);
4700 outrel.r_addend = relocation + rel->r_addend;
4701 /* Check addend overflow. */
4702 if ((outrel.r_addend & 0x80000000)
4703 != (rel->r_addend & 0x80000000))
4704 {
4705 const char *name;
4706 int addend = rel->r_addend;
4707 if (h && h->root.root.string)
4708 name = h->root.root.string;
4709 else
4710 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4711 sym, NULL);
4712 if (addend < 0)
4713 (*_bfd_error_handler)
4714 (_("%B: addend -0x%x in relocation %s against "
4715 "symbol `%s' at 0x%lx in section `%A' is "
4716 "out of range"),
4717 input_bfd, input_section, addend,
4718 howto->name, name,
4719 (unsigned long) rel->r_offset);
4720 else
4721 (*_bfd_error_handler)
4722 (_("%B: addend 0x%x in relocation %s against "
4723 "symbol `%s' at 0x%lx in section `%A' is "
4724 "out of range"),
4725 input_bfd, input_section, addend,
4726 howto->name, name,
4727 (unsigned long) rel->r_offset);
4728 bfd_set_error (bfd_error_bad_value);
4729 return FALSE;
4730 }
4731 }
4732 else
4733 {
4734 long sindx;
4735
4736 if (bfd_is_abs_section (sec))
4737 sindx = 0;
4738 else if (sec == NULL || sec->owner == NULL)
4739 {
4740 bfd_set_error (bfd_error_bad_value);
4741 return FALSE;
4742 }
4743 else
4744 {
4745 asection *osec;
4746
4747 /* We are turning this relocation into one
4748 against a section symbol. It would be
4749 proper to subtract the symbol's value,
4750 osec->vma, from the emitted reloc addend,
4751 but ld.so expects buggy relocs. */
4752 osec = sec->output_section;
4753 sindx = elf_section_data (osec)->dynindx;
4754 if (sindx == 0)
4755 {
4756 asection *oi = htab->elf.text_index_section;
4757 sindx = elf_section_data (oi)->dynindx;
4758 }
4759 BFD_ASSERT (sindx != 0);
4760 }
4761
4762 outrel.r_info = htab->r_info (sindx, r_type);
4763 outrel.r_addend = relocation + rel->r_addend;
4764 }
4765 }
4766
4767 sreloc = elf_section_data (input_section)->sreloc;
4768
4769 if (sreloc == NULL || sreloc->contents == NULL)
4770 {
4771 r = bfd_reloc_notsupported;
4772 goto check_relocation_error;
4773 }
4774
4775 elf_append_rela (output_bfd, sreloc, &outrel);
4776
4777 /* If this reloc is against an external symbol, we do
4778 not want to fiddle with the addend. Otherwise, we
4779 need to include the symbol value so that it becomes
4780 an addend for the dynamic reloc. */
4781 if (! relocate)
4782 continue;
4783 }
4784
4785 break;
4786
4787 case R_X86_64_TLSGD:
4788 case R_X86_64_GOTPC32_TLSDESC:
4789 case R_X86_64_TLSDESC_CALL:
4790 case R_X86_64_GOTTPOFF:
4791 tls_type = GOT_UNKNOWN;
4792 if (h == NULL && local_got_offsets)
4793 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4794 else if (h != NULL)
4795 tls_type = elf_x86_64_hash_entry (h)->tls_type;
4796
4797 if (! elf_x86_64_tls_transition (info, input_bfd,
4798 input_section, contents,
4799 symtab_hdr, sym_hashes,
4800 &r_type, tls_type, rel,
4801 relend, h, r_symndx))
4802 return FALSE;
4803
4804 if (r_type == R_X86_64_TPOFF32)
4805 {
4806 bfd_vma roff = rel->r_offset;
4807
4808 BFD_ASSERT (! unresolved_reloc);
4809
4810 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4811 {
4812 /* GD->LE transition. For 64bit, change
4813 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4814 .word 0x6666; rex64; call __tls_get_addr
4815 into:
4816 movq %fs:0, %rax
4817 leaq foo@tpoff(%rax), %rax
4818 For 32bit, change
4819 leaq foo@tlsgd(%rip), %rdi
4820 .word 0x6666; rex64; call __tls_get_addr
4821 into:
4822 movl %fs:0, %eax
4823 leaq foo@tpoff(%rax), %rax
4824 For largepic, change:
4825 leaq foo@tlsgd(%rip), %rdi
4826 movabsq $__tls_get_addr@pltoff, %rax
4827 addq %rbx, %rax
4828 call *%rax
4829 into:
4830 movq %fs:0, %rax
4831 leaq foo@tpoff(%rax), %rax
4832 nopw 0x0(%rax,%rax,1) */
4833 int largepic = 0;
4834 if (ABI_64_P (output_bfd)
4835 && contents[roff + 5] == (bfd_byte) '\xb8')
4836 {
4837 memcpy (contents + roff - 3,
4838 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4839 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4840 largepic = 1;
4841 }
4842 else if (ABI_64_P (output_bfd))
4843 memcpy (contents + roff - 4,
4844 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4845 16);
4846 else
4847 memcpy (contents + roff - 3,
4848 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4849 15);
4850 bfd_put_32 (output_bfd,
4851 elf_x86_64_tpoff (info, relocation),
4852 contents + roff + 8 + largepic);
4853 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4854 rel++;
4855 wrel++;
4856 continue;
4857 }
4858 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4859 {
4860 /* GDesc -> LE transition.
4861 It's originally something like:
4862 leaq x@tlsdesc(%rip), %rax
4863
4864 Change it to:
4865 movl $x@tpoff, %rax. */
4866
4867 unsigned int val, type;
4868
4869 type = bfd_get_8 (input_bfd, contents + roff - 3);
4870 val = bfd_get_8 (input_bfd, contents + roff - 1);
4871 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4872 contents + roff - 3);
4873 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4874 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4875 contents + roff - 1);
4876 bfd_put_32 (output_bfd,
4877 elf_x86_64_tpoff (info, relocation),
4878 contents + roff);
4879 continue;
4880 }
4881 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4882 {
4883 /* GDesc -> LE transition.
4884 It's originally:
4885 call *(%rax)
4886 Turn it into:
4887 xchg %ax,%ax. */
4888 bfd_put_8 (output_bfd, 0x66, contents + roff);
4889 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4890 continue;
4891 }
4892 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4893 {
4894 /* IE->LE transition:
4895 For 64bit, originally it can be one of:
4896 movq foo@gottpoff(%rip), %reg
4897 addq foo@gottpoff(%rip), %reg
4898 We change it into:
4899 movq $foo, %reg
4900 leaq foo(%reg), %reg
4901 addq $foo, %reg.
4902 For 32bit, originally it can be one of:
4903 movq foo@gottpoff(%rip), %reg
4904 addl foo@gottpoff(%rip), %reg
4905 We change it into:
4906 movq $foo, %reg
4907 leal foo(%reg), %reg
4908 addl $foo, %reg. */
4909
4910 unsigned int val, type, reg;
4911
4912 if (roff >= 3)
4913 val = bfd_get_8 (input_bfd, contents + roff - 3);
4914 else
4915 val = 0;
4916 type = bfd_get_8 (input_bfd, contents + roff - 2);
4917 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4918 reg >>= 3;
4919 if (type == 0x8b)
4920 {
4921 /* movq */
4922 if (val == 0x4c)
4923 bfd_put_8 (output_bfd, 0x49,
4924 contents + roff - 3);
4925 else if (!ABI_64_P (output_bfd) && val == 0x44)
4926 bfd_put_8 (output_bfd, 0x41,
4927 contents + roff - 3);
4928 bfd_put_8 (output_bfd, 0xc7,
4929 contents + roff - 2);
4930 bfd_put_8 (output_bfd, 0xc0 | reg,
4931 contents + roff - 1);
4932 }
4933 else if (reg == 4)
4934 {
4935 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4936 is special */
4937 if (val == 0x4c)
4938 bfd_put_8 (output_bfd, 0x49,
4939 contents + roff - 3);
4940 else if (!ABI_64_P (output_bfd) && val == 0x44)
4941 bfd_put_8 (output_bfd, 0x41,
4942 contents + roff - 3);
4943 bfd_put_8 (output_bfd, 0x81,
4944 contents + roff - 2);
4945 bfd_put_8 (output_bfd, 0xc0 | reg,
4946 contents + roff - 1);
4947 }
4948 else
4949 {
4950 /* addq/addl -> leaq/leal */
4951 if (val == 0x4c)
4952 bfd_put_8 (output_bfd, 0x4d,
4953 contents + roff - 3);
4954 else if (!ABI_64_P (output_bfd) && val == 0x44)
4955 bfd_put_8 (output_bfd, 0x45,
4956 contents + roff - 3);
4957 bfd_put_8 (output_bfd, 0x8d,
4958 contents + roff - 2);
4959 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4960 contents + roff - 1);
4961 }
4962 bfd_put_32 (output_bfd,
4963 elf_x86_64_tpoff (info, relocation),
4964 contents + roff);
4965 continue;
4966 }
4967 else
4968 BFD_ASSERT (FALSE);
4969 }
4970
4971 if (htab->elf.sgot == NULL)
4972 abort ();
4973
4974 if (h != NULL)
4975 {
4976 off = h->got.offset;
4977 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4978 }
4979 else
4980 {
4981 if (local_got_offsets == NULL)
4982 abort ();
4983
4984 off = local_got_offsets[r_symndx];
4985 offplt = local_tlsdesc_gotents[r_symndx];
4986 }
4987
4988 if ((off & 1) != 0)
4989 off &= ~1;
4990 else
4991 {
4992 Elf_Internal_Rela outrel;
4993 int dr_type, indx;
4994 asection *sreloc;
4995
4996 if (htab->elf.srelgot == NULL)
4997 abort ();
4998
4999 indx = h && h->dynindx != -1 ? h->dynindx : 0;
5000
5001 if (GOT_TLS_GDESC_P (tls_type))
5002 {
5003 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
5004 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
5005 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
5006 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
5007 + htab->elf.sgotplt->output_offset
5008 + offplt
5009 + htab->sgotplt_jump_table_size);
5010 sreloc = htab->elf.srelplt;
5011 if (indx == 0)
5012 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5013 else
5014 outrel.r_addend = 0;
5015 elf_append_rela (output_bfd, sreloc, &outrel);
5016 }
5017
5018 sreloc = htab->elf.srelgot;
5019
5020 outrel.r_offset = (htab->elf.sgot->output_section->vma
5021 + htab->elf.sgot->output_offset + off);
5022
5023 if (GOT_TLS_GD_P (tls_type))
5024 dr_type = R_X86_64_DTPMOD64;
5025 else if (GOT_TLS_GDESC_P (tls_type))
5026 goto dr_done;
5027 else
5028 dr_type = R_X86_64_TPOFF64;
5029
5030 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
5031 outrel.r_addend = 0;
5032 if ((dr_type == R_X86_64_TPOFF64
5033 || dr_type == R_X86_64_TLSDESC) && indx == 0)
5034 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5035 outrel.r_info = htab->r_info (indx, dr_type);
5036
5037 elf_append_rela (output_bfd, sreloc, &outrel);
5038
5039 if (GOT_TLS_GD_P (tls_type))
5040 {
5041 if (indx == 0)
5042 {
5043 BFD_ASSERT (! unresolved_reloc);
5044 bfd_put_64 (output_bfd,
5045 relocation - elf_x86_64_dtpoff_base (info),
5046 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5047 }
5048 else
5049 {
5050 bfd_put_64 (output_bfd, 0,
5051 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5052 outrel.r_info = htab->r_info (indx,
5053 R_X86_64_DTPOFF64);
5054 outrel.r_offset += GOT_ENTRY_SIZE;
5055 elf_append_rela (output_bfd, sreloc,
5056 &outrel);
5057 }
5058 }
5059
5060 dr_done:
5061 if (h != NULL)
5062 h->got.offset |= 1;
5063 else
5064 local_got_offsets[r_symndx] |= 1;
5065 }
5066
5067 if (off >= (bfd_vma) -2
5068 && ! GOT_TLS_GDESC_P (tls_type))
5069 abort ();
5070 if (r_type == ELF32_R_TYPE (rel->r_info))
5071 {
5072 if (r_type == R_X86_64_GOTPC32_TLSDESC
5073 || r_type == R_X86_64_TLSDESC_CALL)
5074 relocation = htab->elf.sgotplt->output_section->vma
5075 + htab->elf.sgotplt->output_offset
5076 + offplt + htab->sgotplt_jump_table_size;
5077 else
5078 relocation = htab->elf.sgot->output_section->vma
5079 + htab->elf.sgot->output_offset + off;
5080 unresolved_reloc = FALSE;
5081 }
5082 else
5083 {
5084 bfd_vma roff = rel->r_offset;
5085
5086 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
5087 {
5088 /* GD->IE transition. For 64bit, change
5089 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5090 .word 0x6666; rex64; call __tls_get_addr@plt
5091 into:
5092 movq %fs:0, %rax
5093 addq foo@gottpoff(%rip), %rax
5094 For 32bit, change
5095 leaq foo@tlsgd(%rip), %rdi
5096 .word 0x6666; rex64; call __tls_get_addr@plt
5097 into:
5098 movl %fs:0, %eax
5099 addq foo@gottpoff(%rip), %rax
5100 For largepic, change:
5101 leaq foo@tlsgd(%rip), %rdi
5102 movabsq $__tls_get_addr@pltoff, %rax
5103 addq %rbx, %rax
5104 call *%rax
5105 into:
5106 movq %fs:0, %rax
5107 addq foo@gottpoff(%rax), %rax
5108 nopw 0x0(%rax,%rax,1) */
5109 int largepic = 0;
5110 if (ABI_64_P (output_bfd)
5111 && contents[roff + 5] == (bfd_byte) '\xb8')
5112 {
5113 memcpy (contents + roff - 3,
5114 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5115 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5116 largepic = 1;
5117 }
5118 else if (ABI_64_P (output_bfd))
5119 memcpy (contents + roff - 4,
5120 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5121 16);
5122 else
5123 memcpy (contents + roff - 3,
5124 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5125 15);
5126
5127 relocation = (htab->elf.sgot->output_section->vma
5128 + htab->elf.sgot->output_offset + off
5129 - roff
5130 - largepic
5131 - input_section->output_section->vma
5132 - input_section->output_offset
5133 - 12);
5134 bfd_put_32 (output_bfd, relocation,
5135 contents + roff + 8 + largepic);
5136 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5137 rel++;
5138 wrel++;
5139 continue;
5140 }
5141 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5142 {
5143 /* GDesc -> IE transition.
5144 It's originally something like:
5145 leaq x@tlsdesc(%rip), %rax
5146
5147 Change it to:
5148 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5149
5150 /* Now modify the instruction as appropriate. To
5151 turn a leaq into a movq in the form we use it, it
5152 suffices to change the second byte from 0x8d to
5153 0x8b. */
5154 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
5155
5156 bfd_put_32 (output_bfd,
5157 htab->elf.sgot->output_section->vma
5158 + htab->elf.sgot->output_offset + off
5159 - rel->r_offset
5160 - input_section->output_section->vma
5161 - input_section->output_offset
5162 - 4,
5163 contents + roff);
5164 continue;
5165 }
5166 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5167 {
5168 /* GDesc -> IE transition.
5169 It's originally:
5170 call *(%rax)
5171
5172 Change it to:
5173 xchg %ax, %ax. */
5174
5175 bfd_put_8 (output_bfd, 0x66, contents + roff);
5176 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5177 continue;
5178 }
5179 else
5180 BFD_ASSERT (FALSE);
5181 }
5182 break;
5183
5184 case R_X86_64_TLSLD:
5185 if (! elf_x86_64_tls_transition (info, input_bfd,
5186 input_section, contents,
5187 symtab_hdr, sym_hashes,
5188 &r_type, GOT_UNKNOWN,
5189 rel, relend, h, r_symndx))
5190 return FALSE;
5191
5192 if (r_type != R_X86_64_TLSLD)
5193 {
5194 /* LD->LE transition:
5195 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5196 For 64bit, we change it into:
5197 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5198 For 32bit, we change it into:
5199 nopl 0x0(%rax); movl %fs:0, %eax.
5200 For largepic, change:
5201 leaq foo@tlsgd(%rip), %rdi
5202 movabsq $__tls_get_addr@pltoff, %rax
5203 addq %rbx, %rax
5204 call *%rax
5205 into:
5206 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5207 movq %fs:0, %eax */
5208
5209 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
5210 if (ABI_64_P (output_bfd)
5211 && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
5212 memcpy (contents + rel->r_offset - 3,
5213 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5214 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5215 else if (ABI_64_P (output_bfd))
5216 memcpy (contents + rel->r_offset - 3,
5217 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5218 else
5219 memcpy (contents + rel->r_offset - 3,
5220 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5221 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5222 rel++;
5223 wrel++;
5224 continue;
5225 }
5226
5227 if (htab->elf.sgot == NULL)
5228 abort ();
5229
5230 off = htab->tls_ld_got.offset;
5231 if (off & 1)
5232 off &= ~1;
5233 else
5234 {
5235 Elf_Internal_Rela outrel;
5236
5237 if (htab->elf.srelgot == NULL)
5238 abort ();
5239
5240 outrel.r_offset = (htab->elf.sgot->output_section->vma
5241 + htab->elf.sgot->output_offset + off);
5242
5243 bfd_put_64 (output_bfd, 0,
5244 htab->elf.sgot->contents + off);
5245 bfd_put_64 (output_bfd, 0,
5246 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5247 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
5248 outrel.r_addend = 0;
5249 elf_append_rela (output_bfd, htab->elf.srelgot,
5250 &outrel);
5251 htab->tls_ld_got.offset |= 1;
5252 }
5253 relocation = htab->elf.sgot->output_section->vma
5254 + htab->elf.sgot->output_offset + off;
5255 unresolved_reloc = FALSE;
5256 break;
5257
5258 case R_X86_64_DTPOFF32:
5259 if (!bfd_link_executable (info)
5260 || (input_section->flags & SEC_CODE) == 0)
5261 relocation -= elf_x86_64_dtpoff_base (info);
5262 else
5263 relocation = elf_x86_64_tpoff (info, relocation);
5264 break;
5265
5266 case R_X86_64_TPOFF32:
5267 case R_X86_64_TPOFF64:
5268 BFD_ASSERT (bfd_link_executable (info));
5269 relocation = elf_x86_64_tpoff (info, relocation);
5270 break;
5271
5272 case R_X86_64_DTPOFF64:
5273 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
5274 relocation -= elf_x86_64_dtpoff_base (info);
5275 break;
5276
5277 default:
5278 break;
5279 }
5280
5281 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5282 because such sections are not SEC_ALLOC and thus ld.so will
5283 not process them. */
5284 if (unresolved_reloc
5285 && !((input_section->flags & SEC_DEBUGGING) != 0
5286 && h->def_dynamic)
5287 && _bfd_elf_section_offset (output_bfd, info, input_section,
5288 rel->r_offset) != (bfd_vma) -1)
5289 {
5290 (*_bfd_error_handler)
5291 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5292 input_bfd,
5293 input_section,
5294 (long) rel->r_offset,
5295 howto->name,
5296 h->root.root.string);
5297 return FALSE;
5298 }
5299
5300do_relocation:
5301 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5302 contents, rel->r_offset,
5303 relocation, rel->r_addend);
5304
5305check_relocation_error:
5306 if (r != bfd_reloc_ok)
5307 {
5308 const char *name;
5309
5310 if (h != NULL)
5311 name = h->root.root.string;
5312 else
5313 {
5314 name = bfd_elf_string_from_elf_section (input_bfd,
5315 symtab_hdr->sh_link,
5316 sym->st_name);
5317 if (name == NULL)
5318 return FALSE;
5319 if (*name == '\0')
5320 name = bfd_section_name (input_bfd, sec);
5321 }
5322
5323 if (r == bfd_reloc_overflow)
5324 {
5325 if (! ((*info->callbacks->reloc_overflow)
5326 (info, (h ? &h->root : NULL), name, howto->name,
5327 (bfd_vma) 0, input_bfd, input_section,
5328 rel->r_offset)))
5329 return FALSE;
5330 }
5331 else
5332 {
5333 (*_bfd_error_handler)
5334 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5335 input_bfd, input_section,
5336 (long) rel->r_offset, name, (int) r);
5337 return FALSE;
5338 }
5339 }
5340
5341 if (wrel != rel)
5342 *wrel = *rel;
5343 }
5344
5345 if (wrel != rel)
5346 {
5347 Elf_Internal_Shdr *rel_hdr;
5348 size_t deleted = rel - wrel;
5349
5350 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5351 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5352 if (rel_hdr->sh_size == 0)
5353 {
5354 /* It is too late to remove an empty reloc section. Leave
5355 one NONE reloc.
5356 ??? What is wrong with an empty section??? */
5357 rel_hdr->sh_size = rel_hdr->sh_entsize;
5358 deleted -= 1;
5359 }
5360 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5361 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5362 input_section->reloc_count -= deleted;
5363 }
5364
5365 return TRUE;
5366}
5367
5368/* Finish up dynamic symbol handling. We set the contents of various
5369 dynamic sections here. */
5370
5371static bfd_boolean
5372elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
5373 struct bfd_link_info *info,
5374 struct elf_link_hash_entry *h,
5375 Elf_Internal_Sym *sym)
5376{
5377 struct elf_x86_64_link_hash_table *htab;
5378 const struct elf_x86_64_backend_data *abed;
5379 bfd_boolean use_plt_bnd;
5380 struct elf_x86_64_link_hash_entry *eh;
5381 bfd_boolean local_undefweak;
5382
5383 htab = elf_x86_64_hash_table (info);
5384 if (htab == NULL)
5385 return FALSE;
5386
5387 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5388 section only if there is .plt section. */
5389 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
5390 abed = (use_plt_bnd
5391 ? &elf_x86_64_bnd_arch_bed
5392 : get_elf_x86_64_backend_data (output_bfd));
5393
5394 eh = (struct elf_x86_64_link_hash_entry *) h;
5395
5396 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5397 resolved undefined weak symbols in executable so that their
5398 references have value 0 at run-time. */
5399 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
5400
5401 if (h->plt.offset != (bfd_vma) -1)
5402 {
5403 bfd_vma plt_index;
5404 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
5405 bfd_vma plt_plt_insn_end, plt_got_insn_size;
5406 Elf_Internal_Rela rela;
5407 bfd_byte *loc;
5408 asection *plt, *gotplt, *relplt, *resolved_plt;
5409 const struct elf_backend_data *bed;
5410 bfd_vma plt_got_pcrel_offset;
5411
5412 /* When building a static executable, use .iplt, .igot.plt and
5413 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5414 if (htab->elf.splt != NULL)
5415 {
5416 plt = htab->elf.splt;
5417 gotplt = htab->elf.sgotplt;
5418 relplt = htab->elf.srelplt;
5419 }
5420 else
5421 {
5422 plt = htab->elf.iplt;
5423 gotplt = htab->elf.igotplt;
5424 relplt = htab->elf.irelplt;
5425 }
5426
5427 /* This symbol has an entry in the procedure linkage table. Set
5428 it up. */
5429 if ((h->dynindx == -1
5430 && !local_undefweak
5431 && !((h->forced_local || bfd_link_executable (info))
5432 && h->def_regular
5433 && h->type == STT_GNU_IFUNC))
5434 || plt == NULL
5435 || gotplt == NULL
5436 || relplt == NULL)
5437 abort ();
5438
5439 /* Get the index in the procedure linkage table which
5440 corresponds to this symbol. This is the index of this symbol
5441 in all the symbols for which we are making plt entries. The
5442 first entry in the procedure linkage table is reserved.
5443
5444 Get the offset into the .got table of the entry that
5445 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5446 bytes. The first three are reserved for the dynamic linker.
5447
5448 For static executables, we don't reserve anything. */
5449
5450 if (plt == htab->elf.splt)
5451 {
5452 got_offset = h->plt.offset / abed->plt_entry_size - 1;
5453 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
5454 }
5455 else
5456 {
5457 got_offset = h->plt.offset / abed->plt_entry_size;
5458 got_offset = got_offset * GOT_ENTRY_SIZE;
5459 }
5460
5461 plt_plt_insn_end = abed->plt_plt_insn_end;
5462 plt_plt_offset = abed->plt_plt_offset;
5463 plt_got_insn_size = abed->plt_got_insn_size;
5464 plt_got_offset = abed->plt_got_offset;
5465 if (use_plt_bnd)
5466 {
5467 /* Use the second PLT with BND relocations. */
5468 const bfd_byte *plt_entry, *plt2_entry;
5469
5470 if (eh->has_bnd_reloc)
5471 {
5472 plt_entry = elf_x86_64_bnd_plt_entry;
5473 plt2_entry = elf_x86_64_bnd_plt2_entry;
5474 }
5475 else
5476 {
5477 plt_entry = elf_x86_64_legacy_plt_entry;
5478 plt2_entry = elf_x86_64_legacy_plt2_entry;
5479
5480 /* Subtract 1 since there is no BND prefix. */
5481 plt_plt_insn_end -= 1;
5482 plt_plt_offset -= 1;
5483 plt_got_insn_size -= 1;
5484 plt_got_offset -= 1;
5485 }
5486
5487 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
5488 == sizeof (elf_x86_64_legacy_plt_entry));
5489
5490 /* Fill in the entry in the procedure linkage table. */
5491 memcpy (plt->contents + h->plt.offset,
5492 plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
5493 /* Fill in the entry in the second PLT. */
5494 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
5495 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5496
5497 resolved_plt = htab->plt_bnd;
5498 plt_offset = eh->plt_bnd.offset;
5499 }
5500 else
5501 {
5502 /* Fill in the entry in the procedure linkage table. */
5503 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
5504 abed->plt_entry_size);
5505
5506 resolved_plt = plt;
5507 plt_offset = h->plt.offset;
5508 }
5509
5510 /* Insert the relocation positions of the plt section. */
5511
5512 /* Put offset the PC-relative instruction referring to the GOT entry,
5513 subtracting the size of that instruction. */
5514 plt_got_pcrel_offset = (gotplt->output_section->vma
5515 + gotplt->output_offset
5516 + got_offset
5517 - resolved_plt->output_section->vma
5518 - resolved_plt->output_offset
5519 - plt_offset
5520 - plt_got_insn_size);
5521
5522 /* Check PC-relative offset overflow in PLT entry. */
5523 if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
5524 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5525 output_bfd, h->root.root.string);
5526
5527 bfd_put_32 (output_bfd, plt_got_pcrel_offset,
5528 resolved_plt->contents + plt_offset + plt_got_offset);
5529
5530 /* Fill in the entry in the global offset table, initially this
5531 points to the second part of the PLT entry. Leave the entry
5532 as zero for undefined weak symbol in PIE. No PLT relocation
5533 against undefined weak symbol in PIE. */
5534 if (!local_undefweak)
5535 {
5536 bfd_put_64 (output_bfd, (plt->output_section->vma
5537 + plt->output_offset
5538 + h->plt.offset
5539 + abed->plt_lazy_offset),
5540 gotplt->contents + got_offset);
5541
5542 /* Fill in the entry in the .rela.plt section. */
5543 rela.r_offset = (gotplt->output_section->vma
5544 + gotplt->output_offset
5545 + got_offset);
5546 if (h->dynindx == -1
5547 || ((bfd_link_executable (info)
5548 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5549 && h->def_regular
5550 && h->type == STT_GNU_IFUNC))
5551 {
5552 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5553 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5554 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
5555 rela.r_addend = (h->root.u.def.value
5556 + h->root.u.def.section->output_section->vma
5557 + h->root.u.def.section->output_offset);
5558 /* R_X86_64_IRELATIVE comes last. */
5559 plt_index = htab->next_irelative_index--;
5560 }
5561 else
5562 {
5563 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
5564 rela.r_addend = 0;
5565 plt_index = htab->next_jump_slot_index++;
5566 }
5567
5568 /* Don't fill PLT entry for static executables. */
5569 if (plt == htab->elf.splt)
5570 {
5571 bfd_vma plt0_offset = h->plt.offset + plt_plt_insn_end;
5572
5573 /* Put relocation index. */
5574 bfd_put_32 (output_bfd, plt_index,
5575 (plt->contents + h->plt.offset
5576 + abed->plt_reloc_offset));
5577
5578 /* Put offset for jmp .PLT0 and check for overflow. We don't
5579 check relocation index for overflow since branch displacement
5580 will overflow first. */
5581 if (plt0_offset > 0x80000000)
5582 info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5583 output_bfd, h->root.root.string);
5584 bfd_put_32 (output_bfd, - plt0_offset,
5585 plt->contents + h->plt.offset + plt_plt_offset);
5586 }
5587
5588 bed = get_elf_backend_data (output_bfd);
5589 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
5590 bed->s->swap_reloca_out (output_bfd, &rela, loc);
5591 }
5592 }
5593 else if (eh->plt_got.offset != (bfd_vma) -1)
5594 {
5595 bfd_vma got_offset, plt_offset, plt_got_offset, plt_got_insn_size;
5596 asection *plt, *got;
5597 bfd_boolean got_after_plt;
5598 int32_t got_pcrel_offset;
5599 const bfd_byte *got_plt_entry;
5600
5601 /* Set the entry in the GOT procedure linkage table. */
5602 plt = htab->plt_got;
5603 got = htab->elf.sgot;
5604 got_offset = h->got.offset;
5605
5606 if (got_offset == (bfd_vma) -1
5607 || h->type == STT_GNU_IFUNC
5608 || plt == NULL
5609 || got == NULL)
5610 abort ();
5611
5612 /* Use the second PLT entry template for the GOT PLT since they
5613 are the identical. */
5614 plt_got_insn_size = elf_x86_64_bnd_arch_bed.plt_got_insn_size;
5615 plt_got_offset = elf_x86_64_bnd_arch_bed.plt_got_offset;
5616 if (eh->has_bnd_reloc)
5617 got_plt_entry = elf_x86_64_bnd_plt2_entry;
5618 else
5619 {
5620 got_plt_entry = elf_x86_64_legacy_plt2_entry;
5621
5622 /* Subtract 1 since there is no BND prefix. */
5623 plt_got_insn_size -= 1;
5624 plt_got_offset -= 1;
5625 }
5626
5627 /* Fill in the entry in the GOT procedure linkage table. */
5628 plt_offset = eh->plt_got.offset;
5629 memcpy (plt->contents + plt_offset,
5630 got_plt_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5631
5632 /* Put offset the PC-relative instruction referring to the GOT
5633 entry, subtracting the size of that instruction. */
5634 got_pcrel_offset = (got->output_section->vma
5635 + got->output_offset
5636 + got_offset
5637 - plt->output_section->vma
5638 - plt->output_offset
5639 - plt_offset
5640 - plt_got_insn_size);
5641
5642 /* Check PC-relative offset overflow in GOT PLT entry. */
5643 got_after_plt = got->output_section->vma > plt->output_section->vma;
5644 if ((got_after_plt && got_pcrel_offset < 0)
5645 || (!got_after_plt && got_pcrel_offset > 0))
5646 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5647 output_bfd, h->root.root.string);
5648
5649 bfd_put_32 (output_bfd, got_pcrel_offset,
5650 plt->contents + plt_offset + plt_got_offset);
5651 }
5652
5653 if (!local_undefweak
5654 && !h->def_regular
5655 && (h->plt.offset != (bfd_vma) -1
5656 || eh->plt_got.offset != (bfd_vma) -1))
5657 {
5658 /* Mark the symbol as undefined, rather than as defined in
5659 the .plt section. Leave the value if there were any
5660 relocations where pointer equality matters (this is a clue
5661 for the dynamic linker, to make function pointer
5662 comparisons work between an application and shared
5663 library), otherwise set it to zero. If a function is only
5664 called from a binary, there is no need to slow down
5665 shared libraries because of that. */
5666 sym->st_shndx = SHN_UNDEF;
5667 if (!h->pointer_equality_needed)
5668 sym->st_value = 0;
5669 }
5670
5671 /* Don't generate dynamic GOT relocation against undefined weak
5672 symbol in executable. */
5673 if (h->got.offset != (bfd_vma) -1
5674 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
5675 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE
5676 && !local_undefweak)
5677 {
5678 Elf_Internal_Rela rela;
5679
5680 /* This symbol has an entry in the global offset table. Set it
5681 up. */
5682 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5683 abort ();
5684
5685 rela.r_offset = (htab->elf.sgot->output_section->vma
5686 + htab->elf.sgot->output_offset
5687 + (h->got.offset &~ (bfd_vma) 1));
5688
5689 /* If this is a static link, or it is a -Bsymbolic link and the
5690 symbol is defined locally or was forced to be local because
5691 of a version file, we just want to emit a RELATIVE reloc.
5692 The entry in the global offset table will already have been
5693 initialized in the relocate_section function. */
5694 if (h->def_regular
5695 && h->type == STT_GNU_IFUNC)
5696 {
5697 if (bfd_link_pic (info))
5698 {
5699 /* Generate R_X86_64_GLOB_DAT. */
5700 goto do_glob_dat;
5701 }
5702 else
5703 {
5704 asection *plt;
5705
5706 if (!h->pointer_equality_needed)
5707 abort ();
5708
5709 /* For non-shared object, we can't use .got.plt, which
5710 contains the real function addres if we need pointer
5711 equality. We load the GOT entry with the PLT entry. */
5712 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5713 bfd_put_64 (output_bfd, (plt->output_section->vma
5714 + plt->output_offset
5715 + h->plt.offset),
5716 htab->elf.sgot->contents + h->got.offset);
5717 return TRUE;
5718 }
5719 }
5720 else if (bfd_link_pic (info)
5721 && SYMBOL_REFERENCES_LOCAL (info, h))
5722 {
5723 if (!h->def_regular)
5724 return FALSE;
5725 BFD_ASSERT((h->got.offset & 1) != 0);
5726 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5727 rela.r_addend = (h->root.u.def.value
5728 + h->root.u.def.section->output_section->vma
5729 + h->root.u.def.section->output_offset);
5730 }
5731 else
5732 {
5733 BFD_ASSERT((h->got.offset & 1) == 0);
5734do_glob_dat:
5735 bfd_put_64 (output_bfd, (bfd_vma) 0,
5736 htab->elf.sgot->contents + h->got.offset);
5737 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5738 rela.r_addend = 0;
5739 }
5740
5741 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5742 }
5743
5744 if (h->needs_copy)
5745 {
5746 Elf_Internal_Rela rela;
5747
5748 /* This symbol needs a copy reloc. Set it up. */
5749
5750 if (h->dynindx == -1
5751 || (h->root.type != bfd_link_hash_defined
5752 && h->root.type != bfd_link_hash_defweak)
5753 || htab->srelbss == NULL)
5754 abort ();
5755
5756 rela.r_offset = (h->root.u.def.value
5757 + h->root.u.def.section->output_section->vma
5758 + h->root.u.def.section->output_offset);
5759 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5760 rela.r_addend = 0;
5761 elf_append_rela (output_bfd, htab->srelbss, &rela);
5762 }
5763
5764 return TRUE;
5765}
5766
5767/* Finish up local dynamic symbol handling. We set the contents of
5768 various dynamic sections here. */
5769
5770static bfd_boolean
5771elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5772{
5773 struct elf_link_hash_entry *h
5774 = (struct elf_link_hash_entry *) *slot;
5775 struct bfd_link_info *info
5776 = (struct bfd_link_info *) inf;
5777
5778 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5779 info, h, NULL);
5780}
5781
5782/* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5783 here since undefined weak symbol may not be dynamic and may not be
5784 called for elf_x86_64_finish_dynamic_symbol. */
5785
5786static bfd_boolean
5787elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5788 void *inf)
5789{
5790 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5791 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5792
5793 if (h->root.type != bfd_link_hash_undefweak
5794 || h->dynindx != -1)
5795 return TRUE;
5796
5797 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5798 info, h, NULL);
5799}
5800
5801/* Used to decide how to sort relocs in an optimal manner for the
5802 dynamic linker, before writing them out. */
5803
5804static enum elf_reloc_type_class
5805elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
5806 const asection *rel_sec ATTRIBUTE_UNUSED,
5807 const Elf_Internal_Rela *rela)
5808{
5809 bfd *abfd = info->output_bfd;
5810 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5811 struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info);
5812
5813 if (htab->elf.dynsym != NULL
5814 && htab->elf.dynsym->contents != NULL)
5815 {
5816 /* Check relocation against STT_GNU_IFUNC symbol if there are
5817 dynamic symbols. */
5818 unsigned long r_symndx = htab->r_sym (rela->r_info);
5819 Elf_Internal_Sym sym;
5820 if (!bed->s->swap_symbol_in (abfd,
5821 (htab->elf.dynsym->contents
5822 + r_symndx * bed->s->sizeof_sym),
5823 0, &sym))
5824 abort ();
5825
5826 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5827 return reloc_class_ifunc;
5828 }
5829
5830 switch ((int) ELF32_R_TYPE (rela->r_info))
5831 {
5832 case R_X86_64_RELATIVE:
5833 case R_X86_64_RELATIVE64:
5834 return reloc_class_relative;
5835 case R_X86_64_JUMP_SLOT:
5836 return reloc_class_plt;
5837 case R_X86_64_COPY:
5838 return reloc_class_copy;
5839 default:
5840 return reloc_class_normal;
5841 }
5842}
5843
5844/* Finish up the dynamic sections. */
5845
5846static bfd_boolean
5847elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5848 struct bfd_link_info *info)
5849{
5850 struct elf_x86_64_link_hash_table *htab;
5851 bfd *dynobj;
5852 asection *sdyn;
5853 const struct elf_x86_64_backend_data *abed;
5854
5855 htab = elf_x86_64_hash_table (info);
5856 if (htab == NULL)
5857 return FALSE;
5858
5859 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5860 section only if there is .plt section. */
5861 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5862 ? &elf_x86_64_bnd_arch_bed
5863 : get_elf_x86_64_backend_data (output_bfd));
5864
5865 dynobj = htab->elf.dynobj;
5866 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5867
5868 if (htab->elf.dynamic_sections_created)
5869 {
5870 bfd_byte *dyncon, *dynconend;
5871 const struct elf_backend_data *bed;
5872 bfd_size_type sizeof_dyn;
5873
5874 if (sdyn == NULL || htab->elf.sgot == NULL)
5875 abort ();
5876
5877 bed = get_elf_backend_data (dynobj);
5878 sizeof_dyn = bed->s->sizeof_dyn;
5879 dyncon = sdyn->contents;
5880 dynconend = sdyn->contents + sdyn->size;
5881 for (; dyncon < dynconend; dyncon += sizeof_dyn)
5882 {
5883 Elf_Internal_Dyn dyn;
5884 asection *s;
5885
5886 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5887
5888 switch (dyn.d_tag)
5889 {
5890 default:
5891 continue;
5892
5893 case DT_PLTGOT:
5894 s = htab->elf.sgotplt;
5895 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5896 break;
5897
5898 case DT_JMPREL:
5899 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5900 break;
5901
5902 case DT_PLTRELSZ:
5903 s = htab->elf.srelplt->output_section;
5904 dyn.d_un.d_val = s->size;
5905 break;
5906
5907 case DT_RELASZ:
5908 /* The procedure linkage table relocs (DT_JMPREL) should
5909 not be included in the overall relocs (DT_RELA).
5910 Therefore, we override the DT_RELASZ entry here to
5911 make it not include the JMPREL relocs. Since the
5912 linker script arranges for .rela.plt to follow all
5913 other relocation sections, we don't have to worry
5914 about changing the DT_RELA entry. */
5915 if (htab->elf.srelplt != NULL)
5916 {
5917 s = htab->elf.srelplt->output_section;
5918 dyn.d_un.d_val -= s->size;
5919 }
5920 break;
5921
5922 case DT_TLSDESC_PLT:
5923 s = htab->elf.splt;
5924 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5925 + htab->tlsdesc_plt;
5926 break;
5927
5928 case DT_TLSDESC_GOT:
5929 s = htab->elf.sgot;
5930 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5931 + htab->tlsdesc_got;
5932 break;
5933 }
5934
5935 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5936 }
5937
5938 /* Fill in the special first entry in the procedure linkage table. */
5939 if (htab->elf.splt && htab->elf.splt->size > 0)
5940 {
5941 /* Fill in the first entry in the procedure linkage table. */
5942 memcpy (htab->elf.splt->contents,
5943 abed->plt0_entry, abed->plt_entry_size);
5944 /* Add offset for pushq GOT+8(%rip), since the instruction
5945 uses 6 bytes subtract this value. */
5946 bfd_put_32 (output_bfd,
5947 (htab->elf.sgotplt->output_section->vma
5948 + htab->elf.sgotplt->output_offset
5949 + 8
5950 - htab->elf.splt->output_section->vma
5951 - htab->elf.splt->output_offset
5952 - 6),
5953 htab->elf.splt->contents + abed->plt0_got1_offset);
5954 /* Add offset for the PC-relative instruction accessing GOT+16,
5955 subtracting the offset to the end of that instruction. */
5956 bfd_put_32 (output_bfd,
5957 (htab->elf.sgotplt->output_section->vma
5958 + htab->elf.sgotplt->output_offset
5959 + 16
5960 - htab->elf.splt->output_section->vma
5961 - htab->elf.splt->output_offset
5962 - abed->plt0_got2_insn_end),
5963 htab->elf.splt->contents + abed->plt0_got2_offset);
5964
5965 elf_section_data (htab->elf.splt->output_section)
5966 ->this_hdr.sh_entsize = abed->plt_entry_size;
5967
5968 if (htab->tlsdesc_plt)
5969 {
5970 bfd_put_64 (output_bfd, (bfd_vma) 0,
5971 htab->elf.sgot->contents + htab->tlsdesc_got);
5972
5973 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5974 abed->plt0_entry, abed->plt_entry_size);
5975
5976 /* Add offset for pushq GOT+8(%rip), since the
5977 instruction uses 6 bytes subtract this value. */
5978 bfd_put_32 (output_bfd,
5979 (htab->elf.sgotplt->output_section->vma
5980 + htab->elf.sgotplt->output_offset
5981 + 8
5982 - htab->elf.splt->output_section->vma
5983 - htab->elf.splt->output_offset
5984 - htab->tlsdesc_plt
5985 - 6),
5986 htab->elf.splt->contents
5987 + htab->tlsdesc_plt + abed->plt0_got1_offset);
5988 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5989 where TGD stands for htab->tlsdesc_got, subtracting the offset
5990 to the end of that instruction. */
5991 bfd_put_32 (output_bfd,
5992 (htab->elf.sgot->output_section->vma
5993 + htab->elf.sgot->output_offset
5994 + htab->tlsdesc_got
5995 - htab->elf.splt->output_section->vma
5996 - htab->elf.splt->output_offset
5997 - htab->tlsdesc_plt
5998 - abed->plt0_got2_insn_end),
5999 htab->elf.splt->contents
6000 + htab->tlsdesc_plt + abed->plt0_got2_offset);
6001 }
6002 }
6003 }
6004
6005 if (htab->plt_bnd != NULL)
6006 elf_section_data (htab->plt_bnd->output_section)
6007 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
6008
6009 if (htab->elf.sgotplt)
6010 {
6011 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
6012 {
6013 (*_bfd_error_handler)
6014 (_("discarded output section: `%A'"), htab->elf.sgotplt);
6015 return FALSE;
6016 }
6017
6018 /* Fill in the first three entries in the global offset table. */
6019 if (htab->elf.sgotplt->size > 0)
6020 {
6021 /* Set the first entry in the global offset table to the address of
6022 the dynamic section. */
6023 if (sdyn == NULL)
6024 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
6025 else
6026 bfd_put_64 (output_bfd,
6027 sdyn->output_section->vma + sdyn->output_offset,
6028 htab->elf.sgotplt->contents);
6029 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6030 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
6031 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
6032 }
6033
6034 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
6035 GOT_ENTRY_SIZE;
6036 }
6037
6038 /* Adjust .eh_frame for .plt section. */
6039 if (htab->plt_eh_frame != NULL
6040 && htab->plt_eh_frame->contents != NULL)
6041 {
6042 if (htab->elf.splt != NULL
6043 && htab->elf.splt->size != 0
6044 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
6045 && htab->elf.splt->output_section != NULL
6046 && htab->plt_eh_frame->output_section != NULL)
6047 {
6048 bfd_vma plt_start = htab->elf.splt->output_section->vma;
6049 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
6050 + htab->plt_eh_frame->output_offset
6051 + PLT_FDE_START_OFFSET;
6052 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
6053 htab->plt_eh_frame->contents
6054 + PLT_FDE_START_OFFSET);
6055 }
6056 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
6057 {
6058 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
6059 htab->plt_eh_frame,
6060 htab->plt_eh_frame->contents))
6061 return FALSE;
6062 }
6063 }
6064
6065 if (htab->elf.sgot && htab->elf.sgot->size > 0)
6066 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
6067 = GOT_ENTRY_SIZE;
6068
6069 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6070 htab_traverse (htab->loc_hash_table,
6071 elf_x86_64_finish_local_dynamic_symbol,
6072 info);
6073
6074 /* Fill PLT entries for undefined weak symbols in PIE. */
6075 if (bfd_link_pie (info))
6076 bfd_hash_traverse (&info->hash->table,
6077 elf_x86_64_pie_finish_undefweak_symbol,
6078 info);
6079
6080 return TRUE;
6081}
6082
6083/* Return an array of PLT entry symbol values. */
6084
6085static bfd_vma *
6086elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
6087 asection *relplt)
6088{
6089 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6090 arelent *p;
6091 long count, i;
6092 bfd_vma *plt_sym_val;
6093 bfd_vma plt_offset;
6094 bfd_byte *plt_contents;
6095 const struct elf_x86_64_backend_data *bed;
6096 Elf_Internal_Shdr *hdr;
6097 asection *plt_bnd;
6098
6099 /* Get the .plt section contents. PLT passed down may point to the
6100 .plt.bnd section. Make sure that PLT always points to the .plt
6101 section. */
6102 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
6103 if (plt_bnd)
6104 {
6105 if (plt != plt_bnd)
6106 abort ();
6107 plt = bfd_get_section_by_name (abfd, ".plt");
6108 if (plt == NULL)
6109 abort ();
6110 bed = &elf_x86_64_bnd_arch_bed;
6111 }
6112 else
6113 bed = get_elf_x86_64_backend_data (abfd);
6114
6115 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
6116 if (plt_contents == NULL)
6117 return NULL;
6118 if (!bfd_get_section_contents (abfd, (asection *) plt,
6119 plt_contents, 0, plt->size))
6120 {
6121bad_return:
6122 free (plt_contents);
6123 return NULL;
6124 }
6125
6126 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6127 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
6128 goto bad_return;
6129
6130 hdr = &elf_section_data (relplt)->this_hdr;
6131 count = relplt->size / hdr->sh_entsize;
6132
6133 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
6134 if (plt_sym_val == NULL)
6135 goto bad_return;
6136
6137 for (i = 0; i < count; i++)
6138 plt_sym_val[i] = -1;
6139
6140 plt_offset = bed->plt_entry_size;
6141 p = relplt->relocation;
6142 for (i = 0; i < count; i++, p++)
6143 {
6144 long reloc_index;
6145
6146 /* Skip unknown relocation. */
6147 if (p->howto == NULL)
6148 continue;
6149
6150 if (p->howto->type != R_X86_64_JUMP_SLOT
6151 && p->howto->type != R_X86_64_IRELATIVE)
6152 continue;
6153
6154 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
6155 + bed->plt_reloc_offset));
6156 if (reloc_index < count)
6157 {
6158 if (plt_bnd)
6159 {
6160 /* This is the index in .plt section. */
6161 long plt_index = plt_offset / bed->plt_entry_size;
6162 /* Store VMA + the offset in .plt.bnd section. */
6163 plt_sym_val[reloc_index] =
6164 (plt_bnd->vma
6165 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
6166 }
6167 else
6168 plt_sym_val[reloc_index] = plt->vma + plt_offset;
6169 }
6170 plt_offset += bed->plt_entry_size;
6171
6172 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6173 section. */
6174 if (plt_offset >= plt->size)
6175 break;
6176 }
6177
6178 free (plt_contents);
6179
6180 return plt_sym_val;
6181}
6182
6183/* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6184 support. */
6185
6186static long
6187elf_x86_64_get_synthetic_symtab (bfd *abfd,
6188 long symcount,
6189 asymbol **syms,
6190 long dynsymcount,
6191 asymbol **dynsyms,
6192 asymbol **ret)
6193{
6194 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6195 as PLT if it exists. */
6196 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
6197 if (plt == NULL)
6198 plt = bfd_get_section_by_name (abfd, ".plt");
6199 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
6200 dynsymcount, dynsyms, ret,
6201 plt,
6202 elf_x86_64_get_plt_sym_val);
6203}
6204
6205/* Handle an x86-64 specific section when reading an object file. This
6206 is called when elfcode.h finds a section with an unknown type. */
6207
6208static bfd_boolean
6209elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
6210 const char *name, int shindex)
6211{
6212 if (hdr->sh_type != SHT_X86_64_UNWIND)
6213 return FALSE;
6214
6215 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6216 return FALSE;
6217
6218 return TRUE;
6219}
6220
6221/* Hook called by the linker routine which adds symbols from an object
6222 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6223 of .bss. */
6224
6225static bfd_boolean
6226elf_x86_64_add_symbol_hook (bfd *abfd,
6227 struct bfd_link_info *info,
6228 Elf_Internal_Sym *sym,
6229 const char **namep ATTRIBUTE_UNUSED,
6230 flagword *flagsp ATTRIBUTE_UNUSED,
6231 asection **secp,
6232 bfd_vma *valp)
6233{
6234 asection *lcomm;
6235
6236 switch (sym->st_shndx)
6237 {
6238 case SHN_X86_64_LCOMMON:
6239 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
6240 if (lcomm == NULL)
6241 {
6242 lcomm = bfd_make_section_with_flags (abfd,
6243 "LARGE_COMMON",
6244 (SEC_ALLOC
6245 | SEC_IS_COMMON
6246 | SEC_LINKER_CREATED));
6247 if (lcomm == NULL)
6248 return FALSE;
6249 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
6250 }
6251 *secp = lcomm;
6252 *valp = sym->st_size;
6253 return TRUE;
6254 }
6255
6256 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
6257 && (abfd->flags & DYNAMIC) == 0
6258 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
6259 elf_tdata (info->output_bfd)->has_gnu_symbols
6260 |= elf_gnu_symbol_unique;
6261
6262 return TRUE;
6263}
6264
6265
6266/* Given a BFD section, try to locate the corresponding ELF section
6267 index. */
6268
6269static bfd_boolean
6270elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6271 asection *sec, int *index_return)
6272{
6273 if (sec == &_bfd_elf_large_com_section)
6274 {
6275 *index_return = SHN_X86_64_LCOMMON;
6276 return TRUE;
6277 }
6278 return FALSE;
6279}
6280
6281/* Process a symbol. */
6282
6283static void
6284elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6285 asymbol *asym)
6286{
6287 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6288
6289 switch (elfsym->internal_elf_sym.st_shndx)
6290 {
6291 case SHN_X86_64_LCOMMON:
6292 asym->section = &_bfd_elf_large_com_section;
6293 asym->value = elfsym->internal_elf_sym.st_size;
6294 /* Common symbol doesn't set BSF_GLOBAL. */
6295 asym->flags &= ~BSF_GLOBAL;
6296 break;
6297 }
6298}
6299
6300static bfd_boolean
6301elf_x86_64_common_definition (Elf_Internal_Sym *sym)
6302{
6303 return (sym->st_shndx == SHN_COMMON
6304 || sym->st_shndx == SHN_X86_64_LCOMMON);
6305}
6306
6307static unsigned int
6308elf_x86_64_common_section_index (asection *sec)
6309{
6310 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6311 return SHN_COMMON;
6312 else
6313 return SHN_X86_64_LCOMMON;
6314}
6315
6316static asection *
6317elf_x86_64_common_section (asection *sec)
6318{
6319 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6320 return bfd_com_section_ptr;
6321 else
6322 return &_bfd_elf_large_com_section;
6323}
6324
6325static bfd_boolean
6326elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
6327 const Elf_Internal_Sym *sym,
6328 asection **psec,
6329 bfd_boolean newdef,
6330 bfd_boolean olddef,
6331 bfd *oldbfd,
6332 const asection *oldsec)
6333{
6334 /* A normal common symbol and a large common symbol result in a
6335 normal common symbol. We turn the large common symbol into a
6336 normal one. */
6337 if (!olddef
6338 && h->root.type == bfd_link_hash_common
6339 && !newdef
6340 && bfd_is_com_section (*psec)
6341 && oldsec != *psec)
6342 {
6343 if (sym->st_shndx == SHN_COMMON
6344 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
6345 {
6346 h->root.u.c.p->section
6347 = bfd_make_section_old_way (oldbfd, "COMMON");
6348 h->root.u.c.p->section->flags = SEC_ALLOC;
6349 }
6350 else if (sym->st_shndx == SHN_X86_64_LCOMMON
6351 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
6352 *psec = bfd_com_section_ptr;
6353 }
6354
6355 return TRUE;
6356}
6357
6358static int
6359elf_x86_64_additional_program_headers (bfd *abfd,
6360 struct bfd_link_info *info ATTRIBUTE_UNUSED)
6361{
6362 asection *s;
6363 int count = 0;
6364
6365 /* Check to see if we need a large readonly segment. */
6366 s = bfd_get_section_by_name (abfd, ".lrodata");
6367 if (s && (s->flags & SEC_LOAD))
6368 count++;
6369
6370 /* Check to see if we need a large data segment. Since .lbss sections
6371 is placed right after the .bss section, there should be no need for
6372 a large data segment just because of .lbss. */
6373 s = bfd_get_section_by_name (abfd, ".ldata");
6374 if (s && (s->flags & SEC_LOAD))
6375 count++;
6376
6377 return count;
6378}
6379
6380/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6381
6382static bfd_boolean
6383elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
6384{
6385 if (h->plt.offset != (bfd_vma) -1
6386 && !h->def_regular
6387 && !h->pointer_equality_needed)
6388 return FALSE;
6389
6390 return _bfd_elf_hash_symbol (h);
6391}
6392
6393/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6394
6395static bfd_boolean
6396elf_x86_64_relocs_compatible (const bfd_target *input,
6397 const bfd_target *output)
6398{
6399 return ((xvec_get_elf_backend_data (input)->s->elfclass
6400 == xvec_get_elf_backend_data (output)->s->elfclass)
6401 && _bfd_elf_relocs_compatible (input, output));
6402}
6403
6404static const struct bfd_elf_special_section
6405 elf_x86_64_special_sections[]=
6406{
6407 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6408 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6409 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
6410 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6411 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6412 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6413 { NULL, 0, 0, 0, 0 }
6414};
6415
6416#define TARGET_LITTLE_SYM x86_64_elf64_vec
6417#define TARGET_LITTLE_NAME "elf64-x86-64"
6418#define ELF_ARCH bfd_arch_i386
6419#define ELF_TARGET_ID X86_64_ELF_DATA
6420#define ELF_MACHINE_CODE EM_X86_64
6421#define ELF_MAXPAGESIZE 0x200000
6422#define ELF_MINPAGESIZE 0x1000
6423#define ELF_COMMONPAGESIZE 0x1000
6424
6425#define elf_backend_can_gc_sections 1
6426#define elf_backend_can_refcount 1
6427#define elf_backend_want_got_plt 1
6428#define elf_backend_plt_readonly 1
6429#define elf_backend_want_plt_sym 0
6430#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6431#define elf_backend_rela_normal 1
6432#define elf_backend_plt_alignment 4
6433#define elf_backend_extern_protected_data 1
6434
6435#define elf_info_to_howto elf_x86_64_info_to_howto
6436
6437#define bfd_elf64_bfd_link_hash_table_create \
6438 elf_x86_64_link_hash_table_create
6439#define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6440#define bfd_elf64_bfd_reloc_name_lookup \
6441 elf_x86_64_reloc_name_lookup
6442
6443#define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6444#define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6445#define elf_backend_check_relocs elf_x86_64_check_relocs
6446#define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6447#define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6448#define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6449#define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6450#define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6451#define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6452#define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6453#ifdef CORE_HEADER
6454#define elf_backend_write_core_note elf_x86_64_write_core_note
6455#endif
6456#define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6457#define elf_backend_relocate_section elf_x86_64_relocate_section
6458#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6459#define elf_backend_always_size_sections elf_x86_64_always_size_sections
6460#define elf_backend_init_index_section _bfd_elf_init_1_index_section
6461#define elf_backend_object_p elf64_x86_64_elf_object_p
6462#define bfd_elf64_mkobject elf_x86_64_mkobject
6463#define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6464
6465#define elf_backend_section_from_shdr \
6466 elf_x86_64_section_from_shdr
6467
6468#define elf_backend_section_from_bfd_section \
6469 elf_x86_64_elf_section_from_bfd_section
6470#define elf_backend_add_symbol_hook \
6471 elf_x86_64_add_symbol_hook
6472#define elf_backend_symbol_processing \
6473 elf_x86_64_symbol_processing
6474#define elf_backend_common_section_index \
6475 elf_x86_64_common_section_index
6476#define elf_backend_common_section \
6477 elf_x86_64_common_section
6478#define elf_backend_common_definition \
6479 elf_x86_64_common_definition
6480#define elf_backend_merge_symbol \
6481 elf_x86_64_merge_symbol
6482#define elf_backend_special_sections \
6483 elf_x86_64_special_sections
6484#define elf_backend_additional_program_headers \
6485 elf_x86_64_additional_program_headers
6486#define elf_backend_hash_symbol \
6487 elf_x86_64_hash_symbol
6488#define elf_backend_omit_section_dynsym \
6489 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6490#define elf_backend_fixup_symbol \
6491 elf_x86_64_fixup_symbol
6492
6493#include "elf64-target.h"
6494
6495/* CloudABI support. */
6496
6497#undef TARGET_LITTLE_SYM
6498#define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6499#undef TARGET_LITTLE_NAME
6500#define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6501
6502#undef ELF_OSABI
6503#define ELF_OSABI ELFOSABI_CLOUDABI
6504
6505#undef elf64_bed
6506#define elf64_bed elf64_x86_64_cloudabi_bed
6507
6508#include "elf64-target.h"
6509
6510/* FreeBSD support. */
6511
6512#undef TARGET_LITTLE_SYM
6513#define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6514#undef TARGET_LITTLE_NAME
6515#define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6516
6517#undef ELF_OSABI
6518#define ELF_OSABI ELFOSABI_FREEBSD
6519
6520#undef elf64_bed
6521#define elf64_bed elf64_x86_64_fbsd_bed
6522
6523#include "elf64-target.h"
6524
6525/* Solaris 2 support. */
6526
6527#undef TARGET_LITTLE_SYM
6528#define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6529#undef TARGET_LITTLE_NAME
6530#define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6531
6532/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6533 objects won't be recognized. */
6534#undef ELF_OSABI
6535
6536#undef elf64_bed
6537#define elf64_bed elf64_x86_64_sol2_bed
6538
6539/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6540 boundary. */
6541#undef elf_backend_static_tls_alignment
6542#define elf_backend_static_tls_alignment 16
6543
6544/* The Solaris 2 ABI requires a plt symbol on all platforms.
6545
6546 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6547 File, p.63. */
6548#undef elf_backend_want_plt_sym
6549#define elf_backend_want_plt_sym 1
6550
6551#undef elf_backend_strtab_flags
6552#define elf_backend_strtab_flags SHF_STRINGS
6553
6554static bfd_boolean
6555elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
6556 bfd *obfd ATTRIBUTE_UNUSED,
6557 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
6558 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
6559{
6560 /* PR 19938: FIXME: Need to add code for setting the sh_info
6561 and sh_link fields of Solaris specific section types. */
6562 return FALSE;
6563}
6564
6565#undef elf_backend_copy_special_section_fields
6566#define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6567
6568#include "elf64-target.h"
6569
6570/* Native Client support. */
6571
6572static bfd_boolean
6573elf64_x86_64_nacl_elf_object_p (bfd *abfd)
6574{
6575 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6576 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
6577 return TRUE;
6578}
6579
6580#undef TARGET_LITTLE_SYM
6581#define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6582#undef TARGET_LITTLE_NAME
6583#define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6584#undef elf64_bed
6585#define elf64_bed elf64_x86_64_nacl_bed
6586
6587#undef ELF_MAXPAGESIZE
6588#undef ELF_MINPAGESIZE
6589#undef ELF_COMMONPAGESIZE
6590#define ELF_MAXPAGESIZE 0x10000
6591#define ELF_MINPAGESIZE 0x10000
6592#define ELF_COMMONPAGESIZE 0x10000
6593
6594/* Restore defaults. */
6595#undef ELF_OSABI
6596#undef elf_backend_static_tls_alignment
6597#undef elf_backend_want_plt_sym
6598#define elf_backend_want_plt_sym 0
6599#undef elf_backend_strtab_flags
6600#undef elf_backend_copy_special_section_fields
6601
6602/* NaCl uses substantially different PLT entries for the same effects. */
6603
6604#undef elf_backend_plt_alignment
6605#define elf_backend_plt_alignment 5
6606#define NACL_PLT_ENTRY_SIZE 64
6607#define NACLMASK 0xe0 /* 32-byte alignment mask. */
6608
6609static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
6610 {
6611 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6612 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6613 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
6614 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6615 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6616
6617 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6618 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6619
6620 /* 32 bytes of nop to pad out to the standard size. */
6621 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6622 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6623 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6624 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6625 0x66, /* excess data32 prefix */
6626 0x90 /* nop */
6627 };
6628
6629static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6630 {
6631 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6632 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
6633 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6634 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6635
6636 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6637 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6638 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6639
6640 /* Lazy GOT entries point here (32-byte aligned). */
6641 0x68, /* pushq immediate */
6642 0, 0, 0, 0, /* replaced with index into relocation table. */
6643 0xe9, /* jmp relative */
6644 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6645
6646 /* 22 bytes of nop to pad out to the standard size. */
6647 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6648 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6649 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6650 };
6651
6652/* .eh_frame covering the .plt section. */
6653
6654static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
6655 {
6656#if (PLT_CIE_LENGTH != 20 \
6657 || PLT_FDE_LENGTH != 36 \
6658 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6659 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6660# error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6661#endif
6662 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6663 0, 0, 0, 0, /* CIE ID */
6664 1, /* CIE version */
6665 'z', 'R', 0, /* Augmentation string */
6666 1, /* Code alignment factor */
6667 0x78, /* Data alignment factor */
6668 16, /* Return address column */
6669 1, /* Augmentation size */
6670 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6671 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6672 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6673 DW_CFA_nop, DW_CFA_nop,
6674
6675 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6676 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
6677 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6678 0, 0, 0, 0, /* .plt size goes here */
6679 0, /* Augmentation size */
6680 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
6681 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6682 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
6683 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6684 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6685 13, /* Block length */
6686 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
6687 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
6688 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6689 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
6690 DW_CFA_nop, DW_CFA_nop
6691 };
6692
6693static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
6694 {
6695 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
6696 elf_x86_64_nacl_plt_entry, /* plt_entry */
6697 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6698 2, /* plt0_got1_offset */
6699 9, /* plt0_got2_offset */
6700 13, /* plt0_got2_insn_end */
6701 3, /* plt_got_offset */
6702 33, /* plt_reloc_offset */
6703 38, /* plt_plt_offset */
6704 7, /* plt_got_insn_size */
6705 42, /* plt_plt_insn_end */
6706 32, /* plt_lazy_offset */
6707 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
6708 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
6709 };
6710
6711#undef elf_backend_arch_data
6712#define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6713
6714#undef elf_backend_object_p
6715#define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6716#undef elf_backend_modify_segment_map
6717#define elf_backend_modify_segment_map nacl_modify_segment_map
6718#undef elf_backend_modify_program_headers
6719#define elf_backend_modify_program_headers nacl_modify_program_headers
6720#undef elf_backend_final_write_processing
6721#define elf_backend_final_write_processing nacl_final_write_processing
6722
6723#include "elf64-target.h"
6724
6725/* Native Client x32 support. */
6726
6727static bfd_boolean
6728elf32_x86_64_nacl_elf_object_p (bfd *abfd)
6729{
6730 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6731 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
6732 return TRUE;
6733}
6734
6735#undef TARGET_LITTLE_SYM
6736#define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6737#undef TARGET_LITTLE_NAME
6738#define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6739#undef elf32_bed
6740#define elf32_bed elf32_x86_64_nacl_bed
6741
6742#define bfd_elf32_bfd_link_hash_table_create \
6743 elf_x86_64_link_hash_table_create
6744#define bfd_elf32_bfd_reloc_type_lookup \
6745 elf_x86_64_reloc_type_lookup
6746#define bfd_elf32_bfd_reloc_name_lookup \
6747 elf_x86_64_reloc_name_lookup
6748#define bfd_elf32_mkobject \
6749 elf_x86_64_mkobject
6750#define bfd_elf32_get_synthetic_symtab \
6751 elf_x86_64_get_synthetic_symtab
6752
6753#undef elf_backend_object_p
6754#define elf_backend_object_p \
6755 elf32_x86_64_nacl_elf_object_p
6756
6757#undef elf_backend_bfd_from_remote_memory
6758#define elf_backend_bfd_from_remote_memory \
6759 _bfd_elf32_bfd_from_remote_memory
6760
6761#undef elf_backend_size_info
6762#define elf_backend_size_info \
6763 _bfd_elf32_size_info
6764
6765#include "elf32-target.h"
6766
6767/* Restore defaults. */
6768#undef elf_backend_object_p
6769#define elf_backend_object_p elf64_x86_64_elf_object_p
6770#undef elf_backend_bfd_from_remote_memory
6771#undef elf_backend_size_info
6772#undef elf_backend_modify_segment_map
6773#undef elf_backend_modify_program_headers
6774#undef elf_backend_final_write_processing
6775
6776/* Intel L1OM support. */
6777
6778static bfd_boolean
6779elf64_l1om_elf_object_p (bfd *abfd)
6780{
6781 /* Set the right machine number for an L1OM elf64 file. */
6782 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6783 return TRUE;
6784}
6785
6786#undef TARGET_LITTLE_SYM
6787#define TARGET_LITTLE_SYM l1om_elf64_vec
6788#undef TARGET_LITTLE_NAME
6789#define TARGET_LITTLE_NAME "elf64-l1om"
6790#undef ELF_ARCH
6791#define ELF_ARCH bfd_arch_l1om
6792
6793#undef ELF_MACHINE_CODE
6794#define ELF_MACHINE_CODE EM_L1OM
6795
6796#undef ELF_OSABI
6797
6798#undef elf64_bed
6799#define elf64_bed elf64_l1om_bed
6800
6801#undef elf_backend_object_p
6802#define elf_backend_object_p elf64_l1om_elf_object_p
6803
6804/* Restore defaults. */
6805#undef ELF_MAXPAGESIZE
6806#undef ELF_MINPAGESIZE
6807#undef ELF_COMMONPAGESIZE
6808#define ELF_MAXPAGESIZE 0x200000
6809#define ELF_MINPAGESIZE 0x1000
6810#define ELF_COMMONPAGESIZE 0x1000
6811#undef elf_backend_plt_alignment
6812#define elf_backend_plt_alignment 4
6813#undef elf_backend_arch_data
6814#define elf_backend_arch_data &elf_x86_64_arch_bed
6815
6816#include "elf64-target.h"
6817
6818/* FreeBSD L1OM support. */
6819
6820#undef TARGET_LITTLE_SYM
6821#define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6822#undef TARGET_LITTLE_NAME
6823#define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6824
6825#undef ELF_OSABI
6826#define ELF_OSABI ELFOSABI_FREEBSD
6827
6828#undef elf64_bed
6829#define elf64_bed elf64_l1om_fbsd_bed
6830
6831#include "elf64-target.h"
6832
6833/* Intel K1OM support. */
6834
6835static bfd_boolean
6836elf64_k1om_elf_object_p (bfd *abfd)
6837{
6838 /* Set the right machine number for an K1OM elf64 file. */
6839 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6840 return TRUE;
6841}
6842
6843#undef TARGET_LITTLE_SYM
6844#define TARGET_LITTLE_SYM k1om_elf64_vec
6845#undef TARGET_LITTLE_NAME
6846#define TARGET_LITTLE_NAME "elf64-k1om"
6847#undef ELF_ARCH
6848#define ELF_ARCH bfd_arch_k1om
6849
6850#undef ELF_MACHINE_CODE
6851#define ELF_MACHINE_CODE EM_K1OM
6852
6853#undef ELF_OSABI
6854
6855#undef elf64_bed
6856#define elf64_bed elf64_k1om_bed
6857
6858#undef elf_backend_object_p
6859#define elf_backend_object_p elf64_k1om_elf_object_p
6860
6861#undef elf_backend_static_tls_alignment
6862
6863#undef elf_backend_want_plt_sym
6864#define elf_backend_want_plt_sym 0
6865
6866#include "elf64-target.h"
6867
6868/* FreeBSD K1OM support. */
6869
6870#undef TARGET_LITTLE_SYM
6871#define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6872#undef TARGET_LITTLE_NAME
6873#define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6874
6875#undef ELF_OSABI
6876#define ELF_OSABI ELFOSABI_FREEBSD
6877
6878#undef elf64_bed
6879#define elf64_bed elf64_k1om_fbsd_bed
6880
6881#include "elf64-target.h"
6882
6883/* 32bit x86-64 support. */
6884
6885#undef TARGET_LITTLE_SYM
6886#define TARGET_LITTLE_SYM x86_64_elf32_vec
6887#undef TARGET_LITTLE_NAME
6888#define TARGET_LITTLE_NAME "elf32-x86-64"
6889#undef elf32_bed
6890
6891#undef ELF_ARCH
6892#define ELF_ARCH bfd_arch_i386
6893
6894#undef ELF_MACHINE_CODE
6895#define ELF_MACHINE_CODE EM_X86_64
6896
6897#undef ELF_OSABI
6898
6899#undef elf_backend_object_p
6900#define elf_backend_object_p \
6901 elf32_x86_64_elf_object_p
6902
6903#undef elf_backend_bfd_from_remote_memory
6904#define elf_backend_bfd_from_remote_memory \
6905 _bfd_elf32_bfd_from_remote_memory
6906
6907#undef elf_backend_size_info
6908#define elf_backend_size_info \
6909 _bfd_elf32_size_info
6910
6911#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.057745 seconds and 4 git commands to generate.