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