projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
x86: Remove func_pointer_refcount
[deliverable/binutils-gdb.git] / bfd / elf64-x86-64.c
1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2017 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 "elfxx-x86.h"
23 #include "elf-nacl.h"
24 #include "dwarf2.h"
25 #include "libiberty.h"
26
27 #include "opcode/i386.h"
28 #include "elf/x86-64.h"
29
30 #ifdef CORE_HEADER
31 #include <stdarg.h>
32 #include CORE_HEADER
33 #endif
34
35 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
36 #define MINUS_ONE (~ (bfd_vma) 0)
37
38 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
39 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
40 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
41 since they are the same. */
42
43 /* The relocation "howto" table. Order of fields:
44 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
45 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
46 static reloc_howto_type x86_64_elf_howto_table[] =
47 {
48 HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
49 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
50 FALSE),
51 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
52 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
53 FALSE),
54 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
55 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
56 TRUE),
57 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
58 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
59 FALSE),
60 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
61 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
62 TRUE),
63 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
65 FALSE),
66 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
68 MINUS_ONE, FALSE),
69 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
71 MINUS_ONE, FALSE),
72 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
74 MINUS_ONE, FALSE),
75 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
76 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
77 0xffffffff, TRUE),
78 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
79 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
80 FALSE),
81 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
82 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
83 FALSE),
84 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
86 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
88 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
90 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
91 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
92 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
94 MINUS_ONE, FALSE),
95 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
97 MINUS_ONE, FALSE),
98 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
100 MINUS_ONE, FALSE),
101 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
102 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
103 0xffffffff, TRUE),
104 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
105 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
106 0xffffffff, TRUE),
107 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
108 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
109 0xffffffff, FALSE),
110 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
112 0xffffffff, TRUE),
113 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
114 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
115 0xffffffff, FALSE),
116 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
118 TRUE),
119 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
121 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
122 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
123 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
124 FALSE, 0xffffffff, 0xffffffff, TRUE),
125 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
126 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
127 FALSE),
128 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
129 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
130 MINUS_ONE, TRUE),
131 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
132 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
133 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
134 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
135 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
136 MINUS_ONE, FALSE),
137 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
138 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
139 MINUS_ONE, FALSE),
140 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
141 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
142 FALSE),
143 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
144 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
145 FALSE),
146 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
147 complain_overflow_bitfield, bfd_elf_generic_reloc,
148 "R_X86_64_GOTPC32_TLSDESC",
149 FALSE, 0xffffffff, 0xffffffff, TRUE),
150 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
151 complain_overflow_dont, bfd_elf_generic_reloc,
152 "R_X86_64_TLSDESC_CALL",
153 FALSE, 0, 0, FALSE),
154 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
155 complain_overflow_bitfield, bfd_elf_generic_reloc,
156 "R_X86_64_TLSDESC",
157 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
158 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
159 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
160 MINUS_ONE, FALSE),
161 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
162 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
163 MINUS_ONE, FALSE),
164 HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
165 bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff,
166 TRUE),
167 HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
168 bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff,
169 TRUE),
170 HOWTO(R_X86_64_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
171 bfd_elf_generic_reloc, "R_X86_64_GOTPCRELX", FALSE, 0xffffffff,
172 0xffffffff, TRUE),
173 HOWTO(R_X86_64_REX_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
174 bfd_elf_generic_reloc, "R_X86_64_REX_GOTPCRELX", FALSE, 0xffffffff,
175 0xffffffff, TRUE),
176
177 /* We have a gap in the reloc numbers here.
178 R_X86_64_standard counts the number up to this point, and
179 R_X86_64_vt_offset is the value to subtract from a reloc type of
180 R_X86_64_GNU_VT* to form an index into this table. */
181 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
182 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
183
184 /* GNU extension to record C++ vtable hierarchy. */
185 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
186 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
187
188 /* GNU extension to record C++ vtable member usage. */
189 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
190 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
191 FALSE),
192
193 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
194 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
195 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
196 FALSE)
197 };
198
199 /* Set if a relocation is converted from a GOTPCREL relocation. */
200 #define R_X86_64_converted_reloc_bit (1 << 7)
201
202 #define X86_PCREL_TYPE_P(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 #define X86_SIZE_TYPE_P(TYPE) \
210 ((TYPE) == R_X86_64_SIZE32 || (TYPE) == R_X86_64_SIZE64)
211
212 /* Map BFD relocs to the x86_64 elf relocs. */
213 struct elf_reloc_map
214 {
215 bfd_reloc_code_real_type bfd_reloc_val;
216 unsigned char elf_reloc_val;
217 };
218
219 static const struct elf_reloc_map x86_64_reloc_map[] =
220 {
221 { BFD_RELOC_NONE, R_X86_64_NONE, },
222 { BFD_RELOC_64, R_X86_64_64, },
223 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
224 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
225 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
226 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
227 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
228 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
229 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
230 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
231 { BFD_RELOC_32, R_X86_64_32, },
232 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
233 { BFD_RELOC_16, R_X86_64_16, },
234 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
235 { BFD_RELOC_8, R_X86_64_8, },
236 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
237 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
238 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
239 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
240 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
241 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
242 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
243 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
244 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
245 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
246 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
247 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
248 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
249 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
250 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
251 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
252 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
253 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, },
254 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, },
255 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
256 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
257 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
258 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
259 { BFD_RELOC_X86_64_PC32_BND, R_X86_64_PC32_BND, },
260 { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND, },
261 { BFD_RELOC_X86_64_GOTPCRELX, R_X86_64_GOTPCRELX, },
262 { BFD_RELOC_X86_64_REX_GOTPCRELX, R_X86_64_REX_GOTPCRELX, },
263 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
264 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
265 };
266
267 static reloc_howto_type *
268 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
269 {
270 unsigned i;
271
272 if (r_type == (unsigned int) R_X86_64_32)
273 {
274 if (ABI_64_P (abfd))
275 i = r_type;
276 else
277 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
278 }
279 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
280 || r_type >= (unsigned int) R_X86_64_max)
281 {
282 if (r_type >= (unsigned int) R_X86_64_standard)
283 {
284 /* xgettext:c-format */
285 _bfd_error_handler (_("%B: invalid relocation type %d"),
286 abfd, (int) r_type);
287 r_type = R_X86_64_NONE;
288 }
289 i = r_type;
290 }
291 else
292 i = r_type - (unsigned int) R_X86_64_vt_offset;
293 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
294 return &x86_64_elf_howto_table[i];
295 }
296
297 /* Given a BFD reloc type, return a HOWTO structure. */
298 static reloc_howto_type *
299 elf_x86_64_reloc_type_lookup (bfd *abfd,
300 bfd_reloc_code_real_type code)
301 {
302 unsigned int i;
303
304 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
305 i++)
306 {
307 if (x86_64_reloc_map[i].bfd_reloc_val == code)
308 return elf_x86_64_rtype_to_howto (abfd,
309 x86_64_reloc_map[i].elf_reloc_val);
310 }
311 return NULL;
312 }
313
314 static reloc_howto_type *
315 elf_x86_64_reloc_name_lookup (bfd *abfd,
316 const char *r_name)
317 {
318 unsigned int i;
319
320 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
321 {
322 /* Get x32 R_X86_64_32. */
323 reloc_howto_type *reloc
324 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
325 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
326 return reloc;
327 }
328
329 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
330 if (x86_64_elf_howto_table[i].name != NULL
331 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
332 return &x86_64_elf_howto_table[i];
333
334 return NULL;
335 }
336
337 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
338
339 static void
340 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
341 Elf_Internal_Rela *dst)
342 {
343 unsigned r_type;
344
345 r_type = ELF32_R_TYPE (dst->r_info);
346 if (r_type != (unsigned int) R_X86_64_GNU_VTINHERIT
347 && r_type != (unsigned int) R_X86_64_GNU_VTENTRY)
348 r_type &= ~R_X86_64_converted_reloc_bit;
349 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
350
351 BFD_ASSERT (r_type == cache_ptr->howto->type || cache_ptr->howto->type == R_X86_64_NONE);
352 }
353 \f
354 /* Support for core dump NOTE sections. */
355 static bfd_boolean
356 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
357 {
358 int offset;
359 size_t size;
360
361 switch (note->descsz)
362 {
363 default:
364 return FALSE;
365
366 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 /* pr_cursig */
368 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
369
370 /* pr_pid */
371 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
372
373 /* pr_reg */
374 offset = 72;
375 size = 216;
376
377 break;
378
379 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 /* pr_cursig */
381 elf_tdata (abfd)->core->signal
382 = bfd_get_16 (abfd, note->descdata + 12);
383
384 /* pr_pid */
385 elf_tdata (abfd)->core->lwpid
386 = bfd_get_32 (abfd, note->descdata + 32);
387
388 /* pr_reg */
389 offset = 112;
390 size = 216;
391
392 break;
393 }
394
395 /* Make a ".reg/999" section. */
396 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
397 size, note->descpos + offset);
398 }
399
400 static bfd_boolean
401 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
402 {
403 switch (note->descsz)
404 {
405 default:
406 return FALSE;
407
408 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
409 elf_tdata (abfd)->core->pid
410 = bfd_get_32 (abfd, note->descdata + 12);
411 elf_tdata (abfd)->core->program
412 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
413 elf_tdata (abfd)->core->command
414 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
415 break;
416
417 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
418 elf_tdata (abfd)->core->pid
419 = bfd_get_32 (abfd, note->descdata + 24);
420 elf_tdata (abfd)->core->program
421 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
422 elf_tdata (abfd)->core->command
423 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
424 }
425
426 /* Note that for some reason, a spurious space is tacked
427 onto the end of the args in some (at least one anyway)
428 implementations, so strip it off if it exists. */
429
430 {
431 char *command = elf_tdata (abfd)->core->command;
432 int n = strlen (command);
433
434 if (0 < n && command[n - 1] == ' ')
435 command[n - 1] = '\0';
436 }
437
438 return TRUE;
439 }
440
441 #ifdef CORE_HEADER
442 static char *
443 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
444 int note_type, ...)
445 {
446 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
447 va_list ap;
448 const char *fname, *psargs;
449 long pid;
450 int cursig;
451 const void *gregs;
452
453 switch (note_type)
454 {
455 default:
456 return NULL;
457
458 case NT_PRPSINFO:
459 va_start (ap, note_type);
460 fname = va_arg (ap, const char *);
461 psargs = va_arg (ap, const char *);
462 va_end (ap);
463
464 if (bed->s->elfclass == ELFCLASS32)
465 {
466 prpsinfo32_t data;
467 memset (&data, 0, sizeof (data));
468 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
469 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
470 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
471 &data, sizeof (data));
472 }
473 else
474 {
475 prpsinfo64_t data;
476 memset (&data, 0, sizeof (data));
477 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
478 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
479 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
480 &data, sizeof (data));
481 }
482 /* NOTREACHED */
483
484 case NT_PRSTATUS:
485 va_start (ap, note_type);
486 pid = va_arg (ap, long);
487 cursig = va_arg (ap, int);
488 gregs = va_arg (ap, const void *);
489 va_end (ap);
490
491 if (bed->s->elfclass == ELFCLASS32)
492 {
493 if (bed->elf_machine_code == EM_X86_64)
494 {
495 prstatusx32_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 else
504 {
505 prstatus32_t prstat;
506 memset (&prstat, 0, sizeof (prstat));
507 prstat.pr_pid = pid;
508 prstat.pr_cursig = cursig;
509 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
510 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
511 &prstat, sizeof (prstat));
512 }
513 }
514 else
515 {
516 prstatus64_t prstat;
517 memset (&prstat, 0, sizeof (prstat));
518 prstat.pr_pid = pid;
519 prstat.pr_cursig = cursig;
520 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
521 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
522 &prstat, sizeof (prstat));
523 }
524 }
525 /* NOTREACHED */
526 }
527 #endif
528 \f
529 /* Functions for the x86-64 ELF linker. */
530
531 /* The size in bytes of an entry in the global offset table. */
532
533 #define GOT_ENTRY_SIZE 8
534
535 /* The size in bytes of an entry in the lazy procedure linkage table. */
536
537 #define LAZY_PLT_ENTRY_SIZE 16
538
539 /* The size in bytes of an entry in the non-lazy procedure linkage
540 table. */
541
542 #define NON_LAZY_PLT_ENTRY_SIZE 8
543
544 /* The first entry in a lazy procedure linkage table looks like this.
545 See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
546 works. */
547
548 static const bfd_byte elf_x86_64_lazy_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
549 {
550 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
551 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
552 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
553 };
554
555 /* Subsequent entries in a lazy procedure linkage table look like this. */
556
557 static const bfd_byte elf_x86_64_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
558 {
559 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
560 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
561 0x68, /* pushq immediate */
562 0, 0, 0, 0, /* replaced with index into relocation table. */
563 0xe9, /* jmp relative */
564 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
565 };
566
567 /* The first entry in a lazy procedure linkage table with BND prefix
568 like this. */
569
570 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
571 {
572 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
573 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
574 0x0f, 0x1f, 0 /* nopl (%rax) */
575 };
576
577 /* Subsequent entries for branches with BND prefx in a lazy procedure
578 linkage table look like this. */
579
580 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry[LAZY_PLT_ENTRY_SIZE] =
581 {
582 0x68, 0, 0, 0, 0, /* pushq immediate */
583 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
584 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
585 };
586
587 /* The first entry in the IBT-enabled lazy procedure linkage table is the
588 the same as the lazy PLT with BND prefix so that bound registers are
589 preserved when control is passed to dynamic linker. Subsequent
590 entries for a IBT-enabled lazy procedure linkage table look like
591 this. */
592
593 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
594 {
595 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
596 0x68, 0, 0, 0, 0, /* pushq immediate */
597 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
598 0x90 /* nop */
599 };
600
601 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
602 is the same as the normal lazy PLT. Subsequent entries for an
603 x32 IBT-enabled lazy procedure linkage table look like this. */
604
605 static const bfd_byte elf_x32_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
606 {
607 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
608 0x68, 0, 0, 0, 0, /* pushq immediate */
609 0xe9, 0, 0, 0, 0, /* jmpq relative */
610 0x66, 0x90 /* xchg %ax,%ax */
611 };
612
613 /* Entries in the non-lazey procedure linkage table look like this. */
614
615 static const bfd_byte elf_x86_64_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
616 {
617 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
619 0x66, 0x90 /* xchg %ax,%ax */
620 };
621
622 /* Entries for branches with BND prefix in the non-lazey procedure
623 linkage table look like this. */
624
625 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
626 {
627 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
628 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
629 0x90 /* nop */
630 };
631
632 /* Entries for branches with IBT-enabled in the non-lazey procedure
633 linkage table look like this. They have the same size as the lazy
634 PLT entry. */
635
636 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
637 {
638 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
639 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
640 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
641 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */
642 };
643
644 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
645 linkage table look like this. They have the same size as the lazy
646 PLT entry. */
647
648 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
649 {
650 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
651 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
652 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
654 };
655
656 /* .eh_frame covering the lazy .plt section. */
657
658 static const bfd_byte elf_x86_64_eh_frame_lazy_plt[] =
659 {
660 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
661 0, 0, 0, 0, /* CIE ID */
662 1, /* CIE version */
663 'z', 'R', 0, /* Augmentation string */
664 1, /* Code alignment factor */
665 0x78, /* Data alignment factor */
666 16, /* Return address column */
667 1, /* Augmentation size */
668 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
669 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
670 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
671 DW_CFA_nop, DW_CFA_nop,
672
673 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
674 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
675 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
676 0, 0, 0, 0, /* .plt size goes here */
677 0, /* Augmentation size */
678 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
679 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
680 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
681 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
682 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
683 11, /* Block length */
684 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
685 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
686 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
687 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
688 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
689 };
690
691 /* .eh_frame covering the lazy BND .plt section. */
692
693 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt[] =
694 {
695 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
696 0, 0, 0, 0, /* CIE ID */
697 1, /* CIE version */
698 'z', 'R', 0, /* Augmentation string */
699 1, /* Code alignment factor */
700 0x78, /* Data alignment factor */
701 16, /* Return address column */
702 1, /* Augmentation size */
703 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
704 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
705 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
706 DW_CFA_nop, DW_CFA_nop,
707
708 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
709 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
710 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
711 0, 0, 0, 0, /* .plt size goes here */
712 0, /* Augmentation size */
713 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
714 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
715 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
716 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
717 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
718 11, /* Block length */
719 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
720 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
721 DW_OP_lit15, DW_OP_and, DW_OP_lit5, DW_OP_ge,
722 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
723 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
724 };
725
726 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
727
728 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt[] =
729 {
730 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
731 0, 0, 0, 0, /* CIE ID */
732 1, /* CIE version */
733 'z', 'R', 0, /* Augmentation string */
734 1, /* Code alignment factor */
735 0x78, /* Data alignment factor */
736 16, /* Return address column */
737 1, /* Augmentation size */
738 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
739 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
740 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
741 DW_CFA_nop, DW_CFA_nop,
742
743 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
744 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
745 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
746 0, 0, 0, 0, /* .plt size goes here */
747 0, /* Augmentation size */
748 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
749 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
750 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
751 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
752 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
753 11, /* Block length */
754 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
755 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
756 DW_OP_lit15, DW_OP_and, DW_OP_lit10, DW_OP_ge,
757 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
758 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
759 };
760
761 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled. */
762
763 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt[] =
764 {
765 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
766 0, 0, 0, 0, /* CIE ID */
767 1, /* CIE version */
768 'z', 'R', 0, /* Augmentation string */
769 1, /* Code alignment factor */
770 0x78, /* Data alignment factor */
771 16, /* Return address column */
772 1, /* Augmentation size */
773 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
774 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
775 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
776 DW_CFA_nop, DW_CFA_nop,
777
778 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
779 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
780 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
781 0, 0, 0, 0, /* .plt size goes here */
782 0, /* Augmentation size */
783 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
784 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
785 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
786 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
787 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
788 11, /* Block length */
789 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
790 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
791 DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
792 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
793 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
794 };
795
796 /* .eh_frame covering the non-lazy .plt section. */
797
798 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt[] =
799 {
800 #define PLT_GOT_FDE_LENGTH 20
801 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
802 0, 0, 0, 0, /* CIE ID */
803 1, /* CIE version */
804 'z', 'R', 0, /* Augmentation string */
805 1, /* Code alignment factor */
806 0x78, /* Data alignment factor */
807 16, /* Return address column */
808 1, /* Augmentation size */
809 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
810 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
811 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
812 DW_CFA_nop, DW_CFA_nop,
813
814 PLT_GOT_FDE_LENGTH, 0, 0, 0, /* FDE length */
815 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
816 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
817 0, 0, 0, 0, /* non-lazy .plt size goes here */
818 0, /* Augmentation size */
819 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop,
820 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
821 };
822
823 /* These are the standard parameters. */
824 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_plt =
825 {
826 elf_x86_64_lazy_plt0_entry, /* plt0_entry */
827 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
828 elf_x86_64_lazy_plt_entry, /* plt_entry */
829 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
830 2, /* plt0_got1_offset */
831 8, /* plt0_got2_offset */
832 12, /* plt0_got2_insn_end */
833 2, /* plt_got_offset */
834 7, /* plt_reloc_offset */
835 12, /* plt_plt_offset */
836 6, /* plt_got_insn_size */
837 LAZY_PLT_ENTRY_SIZE, /* plt_plt_insn_end */
838 6, /* plt_lazy_offset */
839 elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */
840 elf_x86_64_lazy_plt_entry, /* pic_plt_entry */
841 elf_x86_64_eh_frame_lazy_plt, /* eh_frame_plt */
842 sizeof (elf_x86_64_eh_frame_lazy_plt) /* eh_frame_plt_size */
843 };
844
845 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_plt =
846 {
847 elf_x86_64_non_lazy_plt_entry, /* plt_entry */
848 elf_x86_64_non_lazy_plt_entry, /* pic_plt_entry */
849 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
850 2, /* plt_got_offset */
851 6, /* plt_got_insn_size */
852 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
853 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
854 };
855
856 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_bnd_plt =
857 {
858 elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */
859 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
860 elf_x86_64_lazy_bnd_plt_entry, /* plt_entry */
861 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
862 2, /* plt0_got1_offset */
863 1+8, /* plt0_got2_offset */
864 1+12, /* plt0_got2_insn_end */
865 1+2, /* plt_got_offset */
866 1, /* plt_reloc_offset */
867 7, /* plt_plt_offset */
868 1+6, /* plt_got_insn_size */
869 11, /* plt_plt_insn_end */
870 0, /* plt_lazy_offset */
871 elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */
872 elf_x86_64_lazy_bnd_plt_entry, /* pic_plt_entry */
873 elf_x86_64_eh_frame_lazy_bnd_plt, /* eh_frame_plt */
874 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt) /* eh_frame_plt_size */
875 };
876
877 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt =
878 {
879 elf_x86_64_non_lazy_bnd_plt_entry, /* plt_entry */
880 elf_x86_64_non_lazy_bnd_plt_entry, /* pic_plt_entry */
881 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
882 1+2, /* plt_got_offset */
883 1+6, /* plt_got_insn_size */
884 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
885 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
886 };
887
888 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_ibt_plt =
889 {
890 elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */
891 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
892 elf_x86_64_lazy_ibt_plt_entry, /* plt_entry */
893 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
894 2, /* plt0_got1_offset */
895 1+8, /* plt0_got2_offset */
896 1+12, /* plt0_got2_insn_end */
897 4+1+2, /* plt_got_offset */
898 4+1, /* plt_reloc_offset */
899 4+1+6, /* plt_plt_offset */
900 4+1+6, /* plt_got_insn_size */
901 4+1+5+5, /* plt_plt_insn_end */
902 0, /* plt_lazy_offset */
903 elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */
904 elf_x86_64_lazy_ibt_plt_entry, /* pic_plt_entry */
905 elf_x86_64_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
906 sizeof (elf_x86_64_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
907 };
908
909 static const struct elf_x86_lazy_plt_layout elf_x32_lazy_ibt_plt =
910 {
911 elf_x86_64_lazy_plt0_entry, /* plt0_entry */
912 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
913 elf_x32_lazy_ibt_plt_entry, /* plt_entry */
914 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
915 2, /* plt0_got1_offset */
916 8, /* plt0_got2_offset */
917 12, /* plt0_got2_insn_end */
918 4+2, /* plt_got_offset */
919 4+1, /* plt_reloc_offset */
920 4+6, /* plt_plt_offset */
921 4+6, /* plt_got_insn_size */
922 4+5+5, /* plt_plt_insn_end */
923 0, /* plt_lazy_offset */
924 elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */
925 elf_x32_lazy_ibt_plt_entry, /* pic_plt_entry */
926 elf_x32_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
927 sizeof (elf_x32_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
928 };
929
930 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt =
931 {
932 elf_x86_64_non_lazy_ibt_plt_entry, /* plt_entry */
933 elf_x86_64_non_lazy_ibt_plt_entry, /* pic_plt_entry */
934 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
935 4+1+2, /* plt_got_offset */
936 4+1+6, /* plt_got_insn_size */
937 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
938 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
939 };
940
941 static const struct elf_x86_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt =
942 {
943 elf_x32_non_lazy_ibt_plt_entry, /* plt_entry */
944 elf_x32_non_lazy_ibt_plt_entry, /* pic_plt_entry */
945 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
946 4+2, /* plt_got_offset */
947 4+6, /* plt_got_insn_size */
948 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
949 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
950 };
951
952 static const struct elf_x86_backend_data elf_x86_64_arch_bed =
953 {
954 is_normal /* os */
955 };
956
957 #define elf_backend_arch_data &elf_x86_64_arch_bed
958
959 static bfd_boolean
960 elf64_x86_64_elf_object_p (bfd *abfd)
961 {
962 /* Set the right machine number for an x86-64 elf64 file. */
963 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
964 return TRUE;
965 }
966
967 static bfd_boolean
968 elf32_x86_64_elf_object_p (bfd *abfd)
969 {
970 /* Set the right machine number for an x86-64 elf32 file. */
971 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
972 return TRUE;
973 }
974
975 /* Return TRUE if the TLS access code sequence support transition
976 from R_TYPE. */
977
978 static bfd_boolean
979 elf_x86_64_check_tls_transition (bfd *abfd,
980 struct bfd_link_info *info,
981 asection *sec,
982 bfd_byte *contents,
983 Elf_Internal_Shdr *symtab_hdr,
984 struct elf_link_hash_entry **sym_hashes,
985 unsigned int r_type,
986 const Elf_Internal_Rela *rel,
987 const Elf_Internal_Rela *relend)
988 {
989 unsigned int val;
990 unsigned long r_symndx;
991 bfd_boolean largepic = FALSE;
992 struct elf_link_hash_entry *h;
993 bfd_vma offset;
994 struct elf_x86_link_hash_table *htab;
995 bfd_byte *call;
996 bfd_boolean indirect_call;
997
998 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
999 offset = rel->r_offset;
1000 switch (r_type)
1001 {
1002 case R_X86_64_TLSGD:
1003 case R_X86_64_TLSLD:
1004 if ((rel + 1) >= relend)
1005 return FALSE;
1006
1007 if (r_type == R_X86_64_TLSGD)
1008 {
1009 /* Check transition from GD access model. For 64bit, only
1010 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1011 .word 0x6666; rex64; call __tls_get_addr@PLT
1012 or
1013 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1014 .byte 0x66; rex64
1015 call *__tls_get_addr@GOTPCREL(%rip)
1016 which may be converted to
1017 addr32 call __tls_get_addr
1018 can transit to different access model. For 32bit, only
1019 leaq foo@tlsgd(%rip), %rdi
1020 .word 0x6666; rex64; call __tls_get_addr@PLT
1021 or
1022 leaq foo@tlsgd(%rip), %rdi
1023 .byte 0x66; rex64
1024 call *__tls_get_addr@GOTPCREL(%rip)
1025 which may be converted to
1026 addr32 call __tls_get_addr
1027 can transit to different access model. For largepic,
1028 we also support:
1029 leaq foo@tlsgd(%rip), %rdi
1030 movabsq $__tls_get_addr@pltoff, %rax
1031 addq $r15, %rax
1032 call *%rax
1033 or
1034 leaq foo@tlsgd(%rip), %rdi
1035 movabsq $__tls_get_addr@pltoff, %rax
1036 addq $rbx, %rax
1037 call *%rax */
1038
1039 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1040
1041 if ((offset + 12) > sec->size)
1042 return FALSE;
1043
1044 call = contents + offset + 4;
1045 if (call[0] != 0x66
1046 || !((call[1] == 0x48
1047 && call[2] == 0xff
1048 && call[3] == 0x15)
1049 || (call[1] == 0x48
1050 && call[2] == 0x67
1051 && call[3] == 0xe8)
1052 || (call[1] == 0x66
1053 && call[2] == 0x48
1054 && call[3] == 0xe8)))
1055 {
1056 if (!ABI_64_P (abfd)
1057 || (offset + 19) > sec->size
1058 || offset < 3
1059 || memcmp (call - 7, leaq + 1, 3) != 0
1060 || memcmp (call, "\x48\xb8", 2) != 0
1061 || call[11] != 0x01
1062 || call[13] != 0xff
1063 || call[14] != 0xd0
1064 || !((call[10] == 0x48 && call[12] == 0xd8)
1065 || (call[10] == 0x4c && call[12] == 0xf8)))
1066 return FALSE;
1067 largepic = TRUE;
1068 }
1069 else if (ABI_64_P (abfd))
1070 {
1071 if (offset < 4
1072 || memcmp (contents + offset - 4, leaq, 4) != 0)
1073 return FALSE;
1074 }
1075 else
1076 {
1077 if (offset < 3
1078 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1079 return FALSE;
1080 }
1081 indirect_call = call[2] == 0xff;
1082 }
1083 else
1084 {
1085 /* Check transition from LD access model. Only
1086 leaq foo@tlsld(%rip), %rdi;
1087 call __tls_get_addr@PLT
1088 or
1089 leaq foo@tlsld(%rip), %rdi;
1090 call *__tls_get_addr@GOTPCREL(%rip)
1091 which may be converted to
1092 addr32 call __tls_get_addr
1093 can transit to different access model. For largepic
1094 we also support:
1095 leaq foo@tlsld(%rip), %rdi
1096 movabsq $__tls_get_addr@pltoff, %rax
1097 addq $r15, %rax
1098 call *%rax
1099 or
1100 leaq foo@tlsld(%rip), %rdi
1101 movabsq $__tls_get_addr@pltoff, %rax
1102 addq $rbx, %rax
1103 call *%rax */
1104
1105 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1106
1107 if (offset < 3 || (offset + 9) > sec->size)
1108 return FALSE;
1109
1110 if (memcmp (contents + offset - 3, lea, 3) != 0)
1111 return FALSE;
1112
1113 call = contents + offset + 4;
1114 if (!(call[0] == 0xe8
1115 || (call[0] == 0xff && call[1] == 0x15)
1116 || (call[0] == 0x67 && call[1] == 0xe8)))
1117 {
1118 if (!ABI_64_P (abfd)
1119 || (offset + 19) > sec->size
1120 || memcmp (call, "\x48\xb8", 2) != 0
1121 || call[11] != 0x01
1122 || call[13] != 0xff
1123 || call[14] != 0xd0
1124 || !((call[10] == 0x48 && call[12] == 0xd8)
1125 || (call[10] == 0x4c && call[12] == 0xf8)))
1126 return FALSE;
1127 largepic = TRUE;
1128 }
1129 indirect_call = call[0] == 0xff;
1130 }
1131
1132 r_symndx = htab->r_sym (rel[1].r_info);
1133 if (r_symndx < symtab_hdr->sh_info)
1134 return FALSE;
1135
1136 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1137 if (h == NULL
1138 || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
1139 return FALSE;
1140 else
1141 {
1142 r_type = (ELF32_R_TYPE (rel[1].r_info)
1143 & ~R_X86_64_converted_reloc_bit);
1144 if (largepic)
1145 return r_type == R_X86_64_PLTOFF64;
1146 else if (indirect_call)
1147 return r_type == R_X86_64_GOTPCRELX;
1148 else
1149 return (r_type == R_X86_64_PC32 || r_type == R_X86_64_PLT32);
1150 }
1151
1152 case R_X86_64_GOTTPOFF:
1153 /* Check transition from IE access model:
1154 mov foo@gottpoff(%rip), %reg
1155 add foo@gottpoff(%rip), %reg
1156 */
1157
1158 /* Check REX prefix first. */
1159 if (offset >= 3 && (offset + 4) <= sec->size)
1160 {
1161 val = bfd_get_8 (abfd, contents + offset - 3);
1162 if (val != 0x48 && val != 0x4c)
1163 {
1164 /* X32 may have 0x44 REX prefix or no REX prefix. */
1165 if (ABI_64_P (abfd))
1166 return FALSE;
1167 }
1168 }
1169 else
1170 {
1171 /* X32 may not have any REX prefix. */
1172 if (ABI_64_P (abfd))
1173 return FALSE;
1174 if (offset < 2 || (offset + 3) > sec->size)
1175 return FALSE;
1176 }
1177
1178 val = bfd_get_8 (abfd, contents + offset - 2);
1179 if (val != 0x8b && val != 0x03)
1180 return FALSE;
1181
1182 val = bfd_get_8 (abfd, contents + offset - 1);
1183 return (val & 0xc7) == 5;
1184
1185 case R_X86_64_GOTPC32_TLSDESC:
1186 /* Check transition from GDesc access model:
1187 leaq x@tlsdesc(%rip), %rax
1188
1189 Make sure it's a leaq adding rip to a 32-bit offset
1190 into any register, although it's probably almost always
1191 going to be rax. */
1192
1193 if (offset < 3 || (offset + 4) > sec->size)
1194 return FALSE;
1195
1196 val = bfd_get_8 (abfd, contents + offset - 3);
1197 if ((val & 0xfb) != 0x48)
1198 return FALSE;
1199
1200 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1201 return FALSE;
1202
1203 val = bfd_get_8 (abfd, contents + offset - 1);
1204 return (val & 0xc7) == 0x05;
1205
1206 case R_X86_64_TLSDESC_CALL:
1207 /* Check transition from GDesc access model:
1208 call *x@tlsdesc(%rax)
1209 */
1210 if (offset + 2 <= sec->size)
1211 {
1212 /* Make sure that it's a call *x@tlsdesc(%rax). */
1213 call = contents + offset;
1214 return call[0] == 0xff && call[1] == 0x10;
1215 }
1216
1217 return FALSE;
1218
1219 default:
1220 abort ();
1221 }
1222 }
1223
1224 /* Return TRUE if the TLS access transition is OK or no transition
1225 will be performed. Update R_TYPE if there is a transition. */
1226
1227 static bfd_boolean
1228 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1229 asection *sec, bfd_byte *contents,
1230 Elf_Internal_Shdr *symtab_hdr,
1231 struct elf_link_hash_entry **sym_hashes,
1232 unsigned int *r_type, int tls_type,
1233 const Elf_Internal_Rela *rel,
1234 const Elf_Internal_Rela *relend,
1235 struct elf_link_hash_entry *h,
1236 unsigned long r_symndx,
1237 bfd_boolean from_relocate_section)
1238 {
1239 unsigned int from_type = *r_type;
1240 unsigned int to_type = from_type;
1241 bfd_boolean check = TRUE;
1242
1243 /* Skip TLS transition for functions. */
1244 if (h != NULL
1245 && (h->type == STT_FUNC
1246 || h->type == STT_GNU_IFUNC))
1247 return TRUE;
1248
1249 switch (from_type)
1250 {
1251 case R_X86_64_TLSGD:
1252 case R_X86_64_GOTPC32_TLSDESC:
1253 case R_X86_64_TLSDESC_CALL:
1254 case R_X86_64_GOTTPOFF:
1255 if (bfd_link_executable (info))
1256 {
1257 if (h == NULL)
1258 to_type = R_X86_64_TPOFF32;
1259 else
1260 to_type = R_X86_64_GOTTPOFF;
1261 }
1262
1263 /* When we are called from elf_x86_64_relocate_section, there may
1264 be additional transitions based on TLS_TYPE. */
1265 if (from_relocate_section)
1266 {
1267 unsigned int new_to_type = to_type;
1268
1269 if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
1270 new_to_type = R_X86_64_TPOFF32;
1271
1272 if (to_type == R_X86_64_TLSGD
1273 || to_type == R_X86_64_GOTPC32_TLSDESC
1274 || to_type == R_X86_64_TLSDESC_CALL)
1275 {
1276 if (tls_type == GOT_TLS_IE)
1277 new_to_type = R_X86_64_GOTTPOFF;
1278 }
1279
1280 /* We checked the transition before when we were called from
1281 elf_x86_64_check_relocs. We only want to check the new
1282 transition which hasn't been checked before. */
1283 check = new_to_type != to_type && from_type == to_type;
1284 to_type = new_to_type;
1285 }
1286
1287 break;
1288
1289 case R_X86_64_TLSLD:
1290 if (bfd_link_executable (info))
1291 to_type = R_X86_64_TPOFF32;
1292 break;
1293
1294 default:
1295 return TRUE;
1296 }
1297
1298 /* Return TRUE if there is no transition. */
1299 if (from_type == to_type)
1300 return TRUE;
1301
1302 /* Check if the transition can be performed. */
1303 if (check
1304 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1305 symtab_hdr, sym_hashes,
1306 from_type, rel, relend))
1307 {
1308 reloc_howto_type *from, *to;
1309 const char *name;
1310
1311 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1312 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1313
1314 if (h)
1315 name = h->root.root.string;
1316 else
1317 {
1318 struct elf_x86_link_hash_table *htab;
1319
1320 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
1321 if (htab == NULL)
1322 name = "*unknown*";
1323 else
1324 {
1325 Elf_Internal_Sym *isym;
1326
1327 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1328 abfd, r_symndx);
1329 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1330 }
1331 }
1332
1333 _bfd_error_handler
1334 /* xgettext:c-format */
1335 (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
1336 "in section `%A' failed"),
1337 abfd, from->name, to->name, name, rel->r_offset, sec);
1338 bfd_set_error (bfd_error_bad_value);
1339 return FALSE;
1340 }
1341
1342 *r_type = to_type;
1343 return TRUE;
1344 }
1345
1346 /* Rename some of the generic section flags to better document how they
1347 are used here. */
1348 #define check_relocs_failed sec_flg0
1349
1350 static bfd_boolean
1351 elf_x86_64_need_pic (struct bfd_link_info *info,
1352 bfd *input_bfd, asection *sec,
1353 struct elf_link_hash_entry *h,
1354 Elf_Internal_Shdr *symtab_hdr,
1355 Elf_Internal_Sym *isym,
1356 reloc_howto_type *howto)
1357 {
1358 const char *v = "";
1359 const char *und = "";
1360 const char *pic = "";
1361 const char *object;
1362
1363 const char *name;
1364 if (h)
1365 {
1366 name = h->root.root.string;
1367 switch (ELF_ST_VISIBILITY (h->other))
1368 {
1369 case STV_HIDDEN:
1370 v = _("hidden symbol ");
1371 break;
1372 case STV_INTERNAL:
1373 v = _("internal symbol ");
1374 break;
1375 case STV_PROTECTED:
1376 v = _("protected symbol ");
1377 break;
1378 default:
1379 if (((struct elf_x86_link_hash_entry *) h)->def_protected)
1380 v = _("protected symbol ");
1381 else
1382 v = _("symbol ");
1383 pic = _("; recompile with -fPIC");
1384 break;
1385 }
1386
1387 if (!h->def_regular && !h->def_dynamic)
1388 und = _("undefined ");
1389 }
1390 else
1391 {
1392 name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL);
1393 pic = _("; recompile with -fPIC");
1394 }
1395
1396 if (bfd_link_dll (info))
1397 object = _("a shared object");
1398 else if (bfd_link_pie (info))
1399 object = _("a PIE object");
1400 else
1401 object = _("a PDE object");
1402
1403 /* xgettext:c-format */
1404 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1405 "not be used when making %s%s"),
1406 input_bfd, howto->name, und, v, name,
1407 object, pic);
1408 bfd_set_error (bfd_error_bad_value);
1409 sec->check_relocs_failed = 1;
1410 return FALSE;
1411 }
1412
1413 /* With the local symbol, foo, we convert
1414 mov foo@GOTPCREL(%rip), %reg
1415 to
1416 lea foo(%rip), %reg
1417 and convert
1418 call/jmp *foo@GOTPCREL(%rip)
1419 to
1420 nop call foo/jmp foo nop
1421 When PIC is false, convert
1422 test %reg, foo@GOTPCREL(%rip)
1423 to
1424 test $foo, %reg
1425 and convert
1426 binop foo@GOTPCREL(%rip), %reg
1427 to
1428 binop $foo, %reg
1429 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1430 instructions. */
1431
1432 static bfd_boolean
1433 elf_x86_64_convert_load_reloc (bfd *abfd,
1434 bfd_byte *contents,
1435 unsigned int *r_type_p,
1436 Elf_Internal_Rela *irel,
1437 struct elf_link_hash_entry *h,
1438 bfd_boolean *converted,
1439 struct bfd_link_info *link_info)
1440 {
1441 struct elf_x86_link_hash_table *htab;
1442 bfd_boolean is_pic;
1443 bfd_boolean no_overflow;
1444 bfd_boolean relocx;
1445 bfd_boolean to_reloc_pc32;
1446 asection *tsec;
1447 bfd_signed_vma raddend;
1448 unsigned int opcode;
1449 unsigned int modrm;
1450 unsigned int r_type = *r_type_p;
1451 unsigned int r_symndx;
1452 bfd_vma roff = irel->r_offset;
1453
1454 if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
1455 return TRUE;
1456
1457 raddend = irel->r_addend;
1458 /* Addend for 32-bit PC-relative relocation must be -4. */
1459 if (raddend != -4)
1460 return TRUE;
1461
1462 htab = elf_x86_hash_table (link_info, X86_64_ELF_DATA);
1463 is_pic = bfd_link_pic (link_info);
1464
1465 relocx = (r_type == R_X86_64_GOTPCRELX
1466 || r_type == R_X86_64_REX_GOTPCRELX);
1467
1468 /* TRUE if --no-relax is used. */
1469 no_overflow = link_info->disable_target_specific_optimizations > 1;
1470
1471 r_symndx = htab->r_sym (irel->r_info);
1472
1473 opcode = bfd_get_8 (abfd, contents + roff - 2);
1474
1475 /* Convert mov to lea since it has been done for a while. */
1476 if (opcode != 0x8b)
1477 {
1478 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1479 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1480 test, xor instructions. */
1481 if (!relocx)
1482 return TRUE;
1483 }
1484
1485 /* We convert only to R_X86_64_PC32:
1486 1. Branch.
1487 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1488 3. no_overflow is true.
1489 4. PIC.
1490 */
1491 to_reloc_pc32 = (opcode == 0xff
1492 || !relocx
1493 || no_overflow
1494 || is_pic);
1495
1496 /* Get the symbol referred to by the reloc. */
1497 if (h == NULL)
1498 {
1499 Elf_Internal_Sym *isym
1500 = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
1501
1502 /* Skip relocation against undefined symbols. */
1503 if (isym->st_shndx == SHN_UNDEF)
1504 return TRUE;
1505
1506 if (isym->st_shndx == SHN_ABS)
1507 tsec = bfd_abs_section_ptr;
1508 else if (isym->st_shndx == SHN_COMMON)
1509 tsec = bfd_com_section_ptr;
1510 else if (isym->st_shndx == SHN_X86_64_LCOMMON)
1511 tsec = &_bfd_elf_large_com_section;
1512 else
1513 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1514 }
1515 else
1516 {
1517 /* Undefined weak symbol is only bound locally in executable
1518 and its reference is resolved as 0 without relocation
1519 overflow. We can only perform this optimization for
1520 GOTPCRELX relocations since we need to modify REX byte.
1521 It is OK convert mov with R_X86_64_GOTPCREL to
1522 R_X86_64_PC32. */
1523 bfd_boolean local_ref;
1524 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
1525
1526 /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */
1527 local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
1528 if ((relocx || opcode == 0x8b)
1529 && (h->root.type == bfd_link_hash_undefweak
1530 && !eh->linker_def
1531 && local_ref))
1532 {
1533 if (opcode == 0xff)
1534 {
1535 /* Skip for branch instructions since R_X86_64_PC32
1536 may overflow. */
1537 if (no_overflow)
1538 return TRUE;
1539 }
1540 else if (relocx)
1541 {
1542 /* For non-branch instructions, we can convert to
1543 R_X86_64_32/R_X86_64_32S since we know if there
1544 is a REX byte. */
1545 to_reloc_pc32 = FALSE;
1546 }
1547
1548 /* Since we don't know the current PC when PIC is true,
1549 we can't convert to R_X86_64_PC32. */
1550 if (to_reloc_pc32 && is_pic)
1551 return TRUE;
1552
1553 goto convert;
1554 }
1555 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1556 ld.so may use its link-time address. */
1557 else if (h->start_stop
1558 || eh->linker_def
1559 || ((h->def_regular
1560 || h->root.type == bfd_link_hash_defined
1561 || h->root.type == bfd_link_hash_defweak)
1562 && h != htab->elf.hdynamic
1563 && local_ref))
1564 {
1565 /* bfd_link_hash_new or bfd_link_hash_undefined is
1566 set by an assignment in a linker script in
1567 bfd_elf_record_link_assignment. start_stop is set
1568 on __start_SECNAME/__stop_SECNAME which mark section
1569 SECNAME. */
1570 if (h->start_stop
1571 || eh->linker_def
1572 || (h->def_regular
1573 && (h->root.type == bfd_link_hash_new
1574 || h->root.type == bfd_link_hash_undefined
1575 || ((h->root.type == bfd_link_hash_defined
1576 || h->root.type == bfd_link_hash_defweak)
1577 && h->root.u.def.section == bfd_und_section_ptr))))
1578 {
1579 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1580 if (no_overflow)
1581 return TRUE;
1582 goto convert;
1583 }
1584 tsec = h->root.u.def.section;
1585 }
1586 else
1587 return TRUE;
1588 }
1589
1590 /* Don't convert GOTPCREL relocation against large section. */
1591 if (elf_section_data (tsec) != NULL
1592 && (elf_section_flags (tsec) & SHF_X86_64_LARGE) != 0)
1593 return TRUE;
1594
1595 /* Skip since R_X86_64_PC32/R_X86_64_32/R_X86_64_32S may overflow. */
1596 if (no_overflow)
1597 return TRUE;
1598
1599 convert:
1600 if (opcode == 0xff)
1601 {
1602 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1603 unsigned int nop;
1604 unsigned int disp;
1605 bfd_vma nop_offset;
1606
1607 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1608 R_X86_64_PC32. */
1609 modrm = bfd_get_8 (abfd, contents + roff - 1);
1610 if (modrm == 0x25)
1611 {
1612 /* Convert to "jmp foo nop". */
1613 modrm = 0xe9;
1614 nop = NOP_OPCODE;
1615 nop_offset = irel->r_offset + 3;
1616 disp = bfd_get_32 (abfd, contents + irel->r_offset);
1617 irel->r_offset -= 1;
1618 bfd_put_32 (abfd, disp, contents + irel->r_offset);
1619 }
1620 else
1621 {
1622 struct elf_x86_link_hash_entry *eh
1623 = (struct elf_x86_link_hash_entry *) h;
1624
1625 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1626 is a nop prefix. */
1627 modrm = 0xe8;
1628 /* To support TLS optimization, always use addr32 prefix for
1629 "call *__tls_get_addr@GOTPCREL(%rip)". */
1630 if (eh && eh->tls_get_addr)
1631 {
1632 nop = 0x67;
1633 nop_offset = irel->r_offset - 2;
1634 }
1635 else
1636 {
1637 nop = link_info->call_nop_byte;
1638 if (link_info->call_nop_as_suffix)
1639 {
1640 nop_offset = irel->r_offset + 3;
1641 disp = bfd_get_32 (abfd, contents + irel->r_offset);
1642 irel->r_offset -= 1;
1643 bfd_put_32 (abfd, disp, contents + irel->r_offset);
1644 }
1645 else
1646 nop_offset = irel->r_offset - 2;
1647 }
1648 }
1649 bfd_put_8 (abfd, nop, contents + nop_offset);
1650 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1651 r_type = R_X86_64_PC32;
1652 }
1653 else
1654 {
1655 unsigned int rex;
1656 unsigned int rex_mask = REX_R;
1657
1658 if (r_type == R_X86_64_REX_GOTPCRELX)
1659 rex = bfd_get_8 (abfd, contents + roff - 3);
1660 else
1661 rex = 0;
1662
1663 if (opcode == 0x8b)
1664 {
1665 if (to_reloc_pc32)
1666 {
1667 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1668 "lea foo(%rip), %reg". */
1669 opcode = 0x8d;
1670 r_type = R_X86_64_PC32;
1671 }
1672 else
1673 {
1674 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1675 "mov $foo, %reg". */
1676 opcode = 0xc7;
1677 modrm = bfd_get_8 (abfd, contents + roff - 1);
1678 modrm = 0xc0 | (modrm & 0x38) >> 3;
1679 if ((rex & REX_W) != 0
1680 && ABI_64_P (link_info->output_bfd))
1681 {
1682 /* Keep the REX_W bit in REX byte for LP64. */
1683 r_type = R_X86_64_32S;
1684 goto rewrite_modrm_rex;
1685 }
1686 else
1687 {
1688 /* If the REX_W bit in REX byte isn't needed,
1689 use R_X86_64_32 and clear the W bit to avoid
1690 sign-extend imm32 to imm64. */
1691 r_type = R_X86_64_32;
1692 /* Clear the W bit in REX byte. */
1693 rex_mask |= REX_W;
1694 goto rewrite_modrm_rex;
1695 }
1696 }
1697 }
1698 else
1699 {
1700 /* R_X86_64_PC32 isn't supported. */
1701 if (to_reloc_pc32)
1702 return TRUE;
1703
1704 modrm = bfd_get_8 (abfd, contents + roff - 1);
1705 if (opcode == 0x85)
1706 {
1707 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1708 "test $foo, %reg". */
1709 modrm = 0xc0 | (modrm & 0x38) >> 3;
1710 opcode = 0xf7;
1711 }
1712 else
1713 {
1714 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
1715 "binop $foo, %reg". */
1716 modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
1717 opcode = 0x81;
1718 }
1719
1720 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
1721 overflow when sign-extending imm32 to imm64. */
1722 r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32;
1723
1724 rewrite_modrm_rex:
1725 bfd_put_8 (abfd, modrm, contents + roff - 1);
1726
1727 if (rex)
1728 {
1729 /* Move the R bit to the B bit in REX byte. */
1730 rex = (rex & ~rex_mask) | (rex & REX_R) >> 2;
1731 bfd_put_8 (abfd, rex, contents + roff - 3);
1732 }
1733
1734 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
1735 irel->r_addend = 0;
1736 }
1737
1738 bfd_put_8 (abfd, opcode, contents + roff - 2);
1739 }
1740
1741 *r_type_p = r_type;
1742 irel->r_info = htab->r_info (r_symndx,
1743 r_type | R_X86_64_converted_reloc_bit);
1744
1745 *converted = TRUE;
1746
1747 return TRUE;
1748 }
1749
1750 /* Look through the relocs for a section during the first phase, and
1751 calculate needed space in the global offset table, procedure
1752 linkage table, and dynamic reloc sections. */
1753
1754 static bfd_boolean
1755 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1756 asection *sec,
1757 const Elf_Internal_Rela *relocs)
1758 {
1759 struct elf_x86_link_hash_table *htab;
1760 Elf_Internal_Shdr *symtab_hdr;
1761 struct elf_link_hash_entry **sym_hashes;
1762 const Elf_Internal_Rela *rel;
1763 const Elf_Internal_Rela *rel_end;
1764 asection *sreloc;
1765 bfd_byte *contents;
1766 bfd_boolean converted;
1767
1768 if (bfd_link_relocatable (info))
1769 return TRUE;
1770
1771 /* Don't do anything special with non-loaded, non-alloced sections.
1772 In particular, any relocs in such sections should not affect GOT
1773 and PLT reference counting (ie. we don't allow them to create GOT
1774 or PLT entries), there's no possibility or desire to optimize TLS
1775 relocs, and there's not much point in propagating relocs to shared
1776 libs that the dynamic linker won't relocate. */
1777 if ((sec->flags & SEC_ALLOC) == 0)
1778 return TRUE;
1779
1780 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
1781 if (htab == NULL)
1782 {
1783 sec->check_relocs_failed = 1;
1784 return FALSE;
1785 }
1786
1787 BFD_ASSERT (is_x86_elf (abfd, htab));
1788
1789 /* Get the section contents. */
1790 if (elf_section_data (sec)->this_hdr.contents != NULL)
1791 contents = elf_section_data (sec)->this_hdr.contents;
1792 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1793 {
1794 sec->check_relocs_failed = 1;
1795 return FALSE;
1796 }
1797
1798 symtab_hdr = &elf_symtab_hdr (abfd);
1799 sym_hashes = elf_sym_hashes (abfd);
1800
1801 converted = FALSE;
1802
1803 sreloc = NULL;
1804
1805 rel_end = relocs + sec->reloc_count;
1806 for (rel = relocs; rel < rel_end; rel++)
1807 {
1808 unsigned int r_type;
1809 unsigned int r_symndx;
1810 struct elf_link_hash_entry *h;
1811 struct elf_x86_link_hash_entry *eh;
1812 Elf_Internal_Sym *isym;
1813 const char *name;
1814 bfd_boolean size_reloc;
1815 bfd_boolean converted_reloc;
1816
1817 r_symndx = htab->r_sym (rel->r_info);
1818 r_type = ELF32_R_TYPE (rel->r_info);
1819
1820 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1821 {
1822 /* xgettext:c-format */
1823 _bfd_error_handler (_("%B: bad symbol index: %d"),
1824 abfd, r_symndx);
1825 goto error_return;
1826 }
1827
1828 if (r_symndx < symtab_hdr->sh_info)
1829 {
1830 /* A local symbol. */
1831 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1832 abfd, r_symndx);
1833 if (isym == NULL)
1834 goto error_return;
1835
1836 /* Check relocation against local STT_GNU_IFUNC symbol. */
1837 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1838 {
1839 h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel,
1840 TRUE);
1841 if (h == NULL)
1842 goto error_return;
1843
1844 /* Fake a STT_GNU_IFUNC symbol. */
1845 h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1846 isym, NULL);
1847 h->type = STT_GNU_IFUNC;
1848 h->def_regular = 1;
1849 h->ref_regular = 1;
1850 h->forced_local = 1;
1851 h->root.type = bfd_link_hash_defined;
1852 }
1853 else
1854 h = NULL;
1855 }
1856 else
1857 {
1858 isym = NULL;
1859 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1860 while (h->root.type == bfd_link_hash_indirect
1861 || h->root.type == bfd_link_hash_warning)
1862 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1863 }
1864
1865 /* Check invalid x32 relocations. */
1866 if (!ABI_64_P (abfd))
1867 switch (r_type)
1868 {
1869 default:
1870 break;
1871
1872 case R_X86_64_DTPOFF64:
1873 case R_X86_64_TPOFF64:
1874 case R_X86_64_PC64:
1875 case R_X86_64_GOTOFF64:
1876 case R_X86_64_GOT64:
1877 case R_X86_64_GOTPCREL64:
1878 case R_X86_64_GOTPC64:
1879 case R_X86_64_GOTPLT64:
1880 case R_X86_64_PLTOFF64:
1881 {
1882 if (h)
1883 name = h->root.root.string;
1884 else
1885 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1886 NULL);
1887 _bfd_error_handler
1888 /* xgettext:c-format */
1889 (_("%B: relocation %s against symbol `%s' isn't "
1890 "supported in x32 mode"), abfd,
1891 x86_64_elf_howto_table[r_type].name, name);
1892 bfd_set_error (bfd_error_bad_value);
1893 goto error_return;
1894 }
1895 break;
1896 }
1897
1898 if (h != NULL)
1899 {
1900 /* It is referenced by a non-shared object. */
1901 h->ref_regular = 1;
1902 h->root.non_ir_ref_regular = 1;
1903
1904 if (h->type == STT_GNU_IFUNC)
1905 elf_tdata (info->output_bfd)->has_gnu_symbols
1906 |= elf_gnu_symbol_ifunc;
1907 }
1908
1909 converted_reloc = FALSE;
1910 if ((r_type == R_X86_64_GOTPCREL
1911 || r_type == R_X86_64_GOTPCRELX
1912 || r_type == R_X86_64_REX_GOTPCRELX)
1913 && (h == NULL || h->type != STT_GNU_IFUNC))
1914 {
1915 Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
1916 if (!elf_x86_64_convert_load_reloc (abfd, contents, &r_type,
1917 irel, h, &converted_reloc,
1918 info))
1919 goto error_return;
1920
1921 if (converted_reloc)
1922 converted = TRUE;
1923 }
1924
1925 if (! elf_x86_64_tls_transition (info, abfd, sec, contents,
1926 symtab_hdr, sym_hashes,
1927 &r_type, GOT_UNKNOWN,
1928 rel, rel_end, h, r_symndx, FALSE))
1929 goto error_return;
1930
1931 eh = (struct elf_x86_link_hash_entry *) h;
1932 switch (r_type)
1933 {
1934 case R_X86_64_TLSLD:
1935 htab->tls_ld_or_ldm_got.refcount = 1;
1936 goto create_got;
1937
1938 case R_X86_64_TPOFF32:
1939 if (!bfd_link_executable (info) && ABI_64_P (abfd))
1940 return elf_x86_64_need_pic (info, abfd, sec, h, symtab_hdr, isym,
1941 &x86_64_elf_howto_table[r_type]);
1942 if (eh != NULL)
1943 eh->zero_undefweak &= 0x2;
1944 break;
1945
1946 case R_X86_64_GOTTPOFF:
1947 if (!bfd_link_executable (info))
1948 info->flags |= DF_STATIC_TLS;
1949 /* Fall through */
1950
1951 case R_X86_64_GOT32:
1952 case R_X86_64_GOTPCREL:
1953 case R_X86_64_GOTPCRELX:
1954 case R_X86_64_REX_GOTPCRELX:
1955 case R_X86_64_TLSGD:
1956 case R_X86_64_GOT64:
1957 case R_X86_64_GOTPCREL64:
1958 case R_X86_64_GOTPLT64:
1959 case R_X86_64_GOTPC32_TLSDESC:
1960 case R_X86_64_TLSDESC_CALL:
1961 /* This symbol requires a global offset table entry. */
1962 {
1963 int tls_type, old_tls_type;
1964
1965 switch (r_type)
1966 {
1967 default: tls_type = GOT_NORMAL; break;
1968 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1969 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1970 case R_X86_64_GOTPC32_TLSDESC:
1971 case R_X86_64_TLSDESC_CALL:
1972 tls_type = GOT_TLS_GDESC; break;
1973 }
1974
1975 if (h != NULL)
1976 {
1977 h->got.refcount = 1;
1978 old_tls_type = eh->tls_type;
1979 }
1980 else
1981 {
1982 bfd_signed_vma *local_got_refcounts;
1983
1984 /* This is a global offset table entry for a local symbol. */
1985 local_got_refcounts = elf_local_got_refcounts (abfd);
1986 if (local_got_refcounts == NULL)
1987 {
1988 bfd_size_type size;
1989
1990 size = symtab_hdr->sh_info;
1991 size *= sizeof (bfd_signed_vma)
1992 + sizeof (bfd_vma) + sizeof (char);
1993 local_got_refcounts = ((bfd_signed_vma *)
1994 bfd_zalloc (abfd, size));
1995 if (local_got_refcounts == NULL)
1996 goto error_return;
1997 elf_local_got_refcounts (abfd) = local_got_refcounts;
1998 elf_x86_local_tlsdesc_gotent (abfd)
1999 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
2000 elf_x86_local_got_tls_type (abfd)
2001 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
2002 }
2003 local_got_refcounts[r_symndx] = 1;
2004 old_tls_type
2005 = elf_x86_local_got_tls_type (abfd) [r_symndx];
2006 }
2007
2008 /* If a TLS symbol is accessed using IE at least once,
2009 there is no point to use dynamic model for it. */
2010 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2011 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2012 || tls_type != GOT_TLS_IE))
2013 {
2014 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
2015 tls_type = old_tls_type;
2016 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2017 && GOT_TLS_GD_ANY_P (tls_type))
2018 tls_type |= old_tls_type;
2019 else
2020 {
2021 if (h)
2022 name = h->root.root.string;
2023 else
2024 name = bfd_elf_sym_name (abfd, symtab_hdr,
2025 isym, NULL);
2026 _bfd_error_handler
2027 /* xgettext:c-format */
2028 (_("%B: '%s' accessed both as normal and"
2029 " thread local symbol"),
2030 abfd, name);
2031 bfd_set_error (bfd_error_bad_value);
2032 goto error_return;
2033 }
2034 }
2035
2036 if (old_tls_type != tls_type)
2037 {
2038 if (eh != NULL)
2039 eh->tls_type = tls_type;
2040 else
2041 elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
2042 }
2043 }
2044 /* Fall through */
2045
2046 case R_X86_64_GOTOFF64:
2047 case R_X86_64_GOTPC32:
2048 case R_X86_64_GOTPC64:
2049 create_got:
2050 if (eh != NULL)
2051 eh->zero_undefweak &= 0x2;
2052 break;
2053
2054 case R_X86_64_PLT32:
2055 case R_X86_64_PLT32_BND:
2056 /* This symbol requires a procedure linkage table entry. We
2057 actually build the entry in adjust_dynamic_symbol,
2058 because this might be a case of linking PIC code which is
2059 never referenced by a dynamic object, in which case we
2060 don't need to generate a procedure linkage table entry
2061 after all. */
2062
2063 /* If this is a local symbol, we resolve it directly without
2064 creating a procedure linkage table entry. */
2065 if (h == NULL)
2066 continue;
2067
2068 eh->zero_undefweak &= 0x2;
2069 h->needs_plt = 1;
2070 h->plt.refcount = 1;
2071 break;
2072
2073 case R_X86_64_PLTOFF64:
2074 /* This tries to form the 'address' of a function relative
2075 to GOT. For global symbols we need a PLT entry. */
2076 if (h != NULL)
2077 {
2078 h->needs_plt = 1;
2079 h->plt.refcount = 1;
2080 }
2081 goto create_got;
2082
2083 case R_X86_64_SIZE32:
2084 case R_X86_64_SIZE64:
2085 size_reloc = TRUE;
2086 goto do_size;
2087
2088 case R_X86_64_32:
2089 if (!ABI_64_P (abfd))
2090 goto pointer;
2091 /* Fall through. */
2092 case R_X86_64_8:
2093 case R_X86_64_16:
2094 case R_X86_64_32S:
2095 /* Check relocation overflow as these relocs may lead to
2096 run-time relocation overflow. Don't error out for
2097 sections we don't care about, such as debug sections or
2098 when relocation overflow check is disabled. */
2099 if (!info->no_reloc_overflow_check
2100 && !converted_reloc
2101 && (bfd_link_pic (info)
2102 || (bfd_link_executable (info)
2103 && h != NULL
2104 && !h->def_regular
2105 && h->def_dynamic
2106 && (sec->flags & SEC_READONLY) == 0)))
2107 return elf_x86_64_need_pic (info, abfd, sec, h, symtab_hdr, isym,
2108 &x86_64_elf_howto_table[r_type]);
2109 /* Fall through. */
2110
2111 case R_X86_64_PC8:
2112 case R_X86_64_PC16:
2113 case R_X86_64_PC32:
2114 case R_X86_64_PC32_BND:
2115 case R_X86_64_PC64:
2116 case R_X86_64_64:
2117 pointer:
2118 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2119 eh->zero_undefweak |= 0x2;
2120 /* We are called after all symbols have been resolved. Only
2121 relocation against STT_GNU_IFUNC symbol must go through
2122 PLT. */
2123 if (h != NULL
2124 && (bfd_link_executable (info)
2125 || h->type == STT_GNU_IFUNC))
2126 {
2127 bfd_boolean func_pointer_ref = FALSE;
2128
2129 if (r_type == R_X86_64_PC32)
2130 {
2131 /* Since something like ".long foo - ." may be used
2132 as pointer, make sure that PLT is used if foo is
2133 a function defined in a shared library. */
2134 if ((sec->flags & SEC_CODE) == 0)
2135 h->pointer_equality_needed = 1;
2136 }
2137 else if (r_type != R_X86_64_PC32_BND
2138 && r_type != R_X86_64_PC64)
2139 {
2140 h->pointer_equality_needed = 1;
2141 /* At run-time, R_X86_64_64 can be resolved for both
2142 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2143 can only be resolved for x32. */
2144 if ((sec->flags & SEC_READONLY) == 0
2145 && (r_type == R_X86_64_64
2146 || (!ABI_64_P (abfd)
2147 && (r_type == R_X86_64_32
2148 || r_type == R_X86_64_32S))))
2149 func_pointer_ref = TRUE;
2150 }
2151
2152 if (!func_pointer_ref)
2153 {
2154 /* If this reloc is in a read-only section, we might
2155 need a copy reloc. We can't check reliably at this
2156 stage whether the section is read-only, as input
2157 sections have not yet been mapped to output sections.
2158 Tentatively set the flag for now, and correct in
2159 adjust_dynamic_symbol. */
2160 h->non_got_ref = 1;
2161
2162 /* We may need a .plt entry if the symbol is a function
2163 defined in a shared lib or is a function referenced
2164 from the code or read-only section. */
2165 if (!h->def_regular
2166 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2167 h->plt.refcount = 1;
2168 }
2169 }
2170
2171 size_reloc = FALSE;
2172 do_size:
2173 if (NEED_DYNAMIC_RELOCATION_P (info, h, sec, r_type,
2174 htab->pointer_r_type))
2175 {
2176 struct elf_dyn_relocs *p;
2177 struct elf_dyn_relocs **head;
2178
2179 /* We must copy these reloc types into the output file.
2180 Create a reloc section in dynobj and make room for
2181 this reloc. */
2182 if (sreloc == NULL)
2183 {
2184 sreloc = _bfd_elf_make_dynamic_reloc_section
2185 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2186 abfd, /*rela?*/ TRUE);
2187
2188 if (sreloc == NULL)
2189 goto error_return;
2190 }
2191
2192 /* If this is a global symbol, we count the number of
2193 relocations we need for this symbol. */
2194 if (h != NULL)
2195 head = &eh->dyn_relocs;
2196 else
2197 {
2198 /* Track dynamic relocs needed for local syms too.
2199 We really need local syms available to do this
2200 easily. Oh well. */
2201 asection *s;
2202 void **vpp;
2203
2204 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2205 abfd, r_symndx);
2206 if (isym == NULL)
2207 goto error_return;
2208
2209 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2210 if (s == NULL)
2211 s = sec;
2212
2213 /* Beware of type punned pointers vs strict aliasing
2214 rules. */
2215 vpp = &(elf_section_data (s)->local_dynrel);
2216 head = (struct elf_dyn_relocs **)vpp;
2217 }
2218
2219 p = *head;
2220 if (p == NULL || p->sec != sec)
2221 {
2222 bfd_size_type amt = sizeof *p;
2223
2224 p = ((struct elf_dyn_relocs *)
2225 bfd_alloc (htab->elf.dynobj, amt));
2226 if (p == NULL)
2227 goto error_return;
2228 p->next = *head;
2229 *head = p;
2230 p->sec = sec;
2231 p->count = 0;
2232 p->pc_count = 0;
2233 }
2234
2235 p->count += 1;
2236 /* Count size relocation as PC-relative relocation. */
2237 if (X86_PCREL_TYPE_P (r_type) || size_reloc)
2238 p->pc_count += 1;
2239 }
2240 break;
2241
2242 /* This relocation describes the C++ object vtable hierarchy.
2243 Reconstruct it for later use during GC. */
2244 case R_X86_64_GNU_VTINHERIT:
2245 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2246 goto error_return;
2247 break;
2248
2249 /* This relocation describes which C++ vtable entries are actually
2250 used. Record for later use during GC. */
2251 case R_X86_64_GNU_VTENTRY:
2252 BFD_ASSERT (h != NULL);
2253 if (h != NULL
2254 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2255 goto error_return;
2256 break;
2257
2258 default:
2259 break;
2260 }
2261 }
2262
2263 if (elf_section_data (sec)->this_hdr.contents != contents)
2264 {
2265 if (!converted && !info->keep_memory)
2266 free (contents);
2267 else
2268 {
2269 /* Cache the section contents for elf_link_input_bfd if any
2270 load is converted or --no-keep-memory isn't used. */
2271 elf_section_data (sec)->this_hdr.contents = contents;
2272 }
2273 }
2274
2275 /* Cache relocations if any load is converted. */
2276 if (elf_section_data (sec)->relocs != relocs && converted)
2277 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
2278
2279 return TRUE;
2280
2281 error_return:
2282 if (elf_section_data (sec)->this_hdr.contents != contents)
2283 free (contents);
2284 sec->check_relocs_failed = 1;
2285 return FALSE;
2286 }
2287
2288 /* Return the relocation value for @tpoff relocation
2289 if STT_TLS virtual address is ADDRESS. */
2290
2291 static bfd_vma
2292 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2293 {
2294 struct elf_link_hash_table *htab = elf_hash_table (info);
2295 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2296 bfd_vma static_tls_size;
2297
2298 /* If tls_segment is NULL, we should have signalled an error already. */
2299 if (htab->tls_sec == NULL)
2300 return 0;
2301
2302 /* Consider special static TLS alignment requirements. */
2303 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2304 return address - static_tls_size - htab->tls_sec->vma;
2305 }
2306
2307 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2308 branch? */
2309
2310 static bfd_boolean
2311 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2312 {
2313 /* Opcode Instruction
2314 0xe8 call
2315 0xe9 jump
2316 0x0f 0x8x conditional jump */
2317 return ((offset > 0
2318 && (contents [offset - 1] == 0xe8
2319 || contents [offset - 1] == 0xe9))
2320 || (offset > 1
2321 && contents [offset - 2] == 0x0f
2322 && (contents [offset - 1] & 0xf0) == 0x80));
2323 }
2324
2325 /* Relocate an x86_64 ELF section. */
2326
2327 static bfd_boolean
2328 elf_x86_64_relocate_section (bfd *output_bfd,
2329 struct bfd_link_info *info,
2330 bfd *input_bfd,
2331 asection *input_section,
2332 bfd_byte *contents,
2333 Elf_Internal_Rela *relocs,
2334 Elf_Internal_Sym *local_syms,
2335 asection **local_sections)
2336 {
2337 struct elf_x86_link_hash_table *htab;
2338 Elf_Internal_Shdr *symtab_hdr;
2339 struct elf_link_hash_entry **sym_hashes;
2340 bfd_vma *local_got_offsets;
2341 bfd_vma *local_tlsdesc_gotents;
2342 Elf_Internal_Rela *rel;
2343 Elf_Internal_Rela *wrel;
2344 Elf_Internal_Rela *relend;
2345 unsigned int plt_entry_size;
2346
2347 /* Skip if check_relocs failed. */
2348 if (input_section->check_relocs_failed)
2349 return FALSE;
2350
2351 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
2352 if (htab == NULL)
2353 return FALSE;
2354
2355 BFD_ASSERT (is_x86_elf (input_bfd, htab));
2356
2357 plt_entry_size = htab->plt.plt_entry_size;
2358 symtab_hdr = &elf_symtab_hdr (input_bfd);
2359 sym_hashes = elf_sym_hashes (input_bfd);
2360 local_got_offsets = elf_local_got_offsets (input_bfd);
2361 local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2362
2363 _bfd_x86_elf_set_tls_module_base (info);
2364
2365 rel = wrel = relocs;
2366 relend = relocs + input_section->reloc_count;
2367 for (; rel < relend; wrel++, rel++)
2368 {
2369 unsigned int r_type, r_type_tls;
2370 reloc_howto_type *howto;
2371 unsigned long r_symndx;
2372 struct elf_link_hash_entry *h;
2373 struct elf_x86_link_hash_entry *eh;
2374 Elf_Internal_Sym *sym;
2375 asection *sec;
2376 bfd_vma off, offplt, plt_offset;
2377 bfd_vma relocation;
2378 bfd_boolean unresolved_reloc;
2379 bfd_reloc_status_type r;
2380 int tls_type;
2381 asection *base_got, *resolved_plt;
2382 bfd_vma st_size;
2383 bfd_boolean resolved_to_zero;
2384 bfd_boolean relative_reloc;
2385 bfd_boolean converted_reloc;
2386 bfd_boolean need_copy_reloc_in_pie;
2387
2388 r_type = ELF32_R_TYPE (rel->r_info);
2389 if (r_type == (int) R_X86_64_GNU_VTINHERIT
2390 || r_type == (int) R_X86_64_GNU_VTENTRY)
2391 {
2392 if (wrel != rel)
2393 *wrel = *rel;
2394 continue;
2395 }
2396
2397 converted_reloc = (r_type & R_X86_64_converted_reloc_bit) != 0;
2398 r_type &= ~R_X86_64_converted_reloc_bit;
2399
2400 if (r_type >= (int) R_X86_64_standard)
2401 return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2402
2403 if (r_type != (int) R_X86_64_32
2404 || ABI_64_P (output_bfd))
2405 howto = x86_64_elf_howto_table + r_type;
2406 else
2407 howto = (x86_64_elf_howto_table
2408 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
2409 r_symndx = htab->r_sym (rel->r_info);
2410 h = NULL;
2411 sym = NULL;
2412 sec = NULL;
2413 unresolved_reloc = FALSE;
2414 if (r_symndx < symtab_hdr->sh_info)
2415 {
2416 sym = local_syms + r_symndx;
2417 sec = local_sections[r_symndx];
2418
2419 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
2420 &sec, rel);
2421 st_size = sym->st_size;
2422
2423 /* Relocate against local STT_GNU_IFUNC symbol. */
2424 if (!bfd_link_relocatable (info)
2425 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2426 {
2427 h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd,
2428 rel, FALSE);
2429 if (h == NULL)
2430 abort ();
2431
2432 /* Set STT_GNU_IFUNC symbol value. */
2433 h->root.u.def.value = sym->st_value;
2434 h->root.u.def.section = sec;
2435 }
2436 }
2437 else
2438 {
2439 bfd_boolean warned ATTRIBUTE_UNUSED;
2440 bfd_boolean ignored ATTRIBUTE_UNUSED;
2441
2442 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2443 r_symndx, symtab_hdr, sym_hashes,
2444 h, sec, relocation,
2445 unresolved_reloc, warned, ignored);
2446 st_size = h->size;
2447 }
2448
2449 if (sec != NULL && discarded_section (sec))
2450 {
2451 _bfd_clear_contents (howto, input_bfd, input_section,
2452 contents + rel->r_offset);
2453 wrel->r_offset = rel->r_offset;
2454 wrel->r_info = 0;
2455 wrel->r_addend = 0;
2456
2457 /* For ld -r, remove relocations in debug sections against
2458 sections defined in discarded sections. Not done for
2459 eh_frame editing code expects to be present. */
2460 if (bfd_link_relocatable (info)
2461 && (input_section->flags & SEC_DEBUGGING))
2462 wrel--;
2463
2464 continue;
2465 }
2466
2467 if (bfd_link_relocatable (info))
2468 {
2469 if (wrel != rel)
2470 *wrel = *rel;
2471 continue;
2472 }
2473
2474 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
2475 {
2476 if (r_type == R_X86_64_64)
2477 {
2478 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
2479 zero-extend it to 64bit if addend is zero. */
2480 r_type = R_X86_64_32;
2481 memset (contents + rel->r_offset + 4, 0, 4);
2482 }
2483 else if (r_type == R_X86_64_SIZE64)
2484 {
2485 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
2486 zero-extend it to 64bit if addend is zero. */
2487 r_type = R_X86_64_SIZE32;
2488 memset (contents + rel->r_offset + 4, 0, 4);
2489 }
2490 }
2491
2492 eh = (struct elf_x86_link_hash_entry *) h;
2493
2494 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2495 it here if it is defined in a non-shared object. */
2496 if (h != NULL
2497 && h->type == STT_GNU_IFUNC
2498 && h->def_regular)
2499 {
2500 bfd_vma plt_index;
2501 const char *name;
2502
2503 if ((input_section->flags & SEC_ALLOC) == 0)
2504 {
2505 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2506 sections because such sections are not SEC_ALLOC and
2507 thus ld.so will not process them. */
2508 if ((input_section->flags & SEC_DEBUGGING) != 0)
2509 continue;
2510 abort ();
2511 }
2512
2513 switch (r_type)
2514 {
2515 default:
2516 break;
2517
2518 case R_X86_64_GOTPCREL:
2519 case R_X86_64_GOTPCRELX:
2520 case R_X86_64_REX_GOTPCRELX:
2521 case R_X86_64_GOTPCREL64:
2522 base_got = htab->elf.sgot;
2523 off = h->got.offset;
2524
2525 if (base_got == NULL)
2526 abort ();
2527
2528 if (off == (bfd_vma) -1)
2529 {
2530 /* We can't use h->got.offset here to save state, or
2531 even just remember the offset, as finish_dynamic_symbol
2532 would use that as offset into .got. */
2533
2534 if (h->plt.offset == (bfd_vma) -1)
2535 abort ();
2536
2537 if (htab->elf.splt != NULL)
2538 {
2539 plt_index = (h->plt.offset / plt_entry_size
2540 - htab->plt.has_plt0);
2541 off = (plt_index + 3) * GOT_ENTRY_SIZE;
2542 base_got = htab->elf.sgotplt;
2543 }
2544 else
2545 {
2546 plt_index = h->plt.offset / plt_entry_size;
2547 off = plt_index * GOT_ENTRY_SIZE;
2548 base_got = htab->elf.igotplt;
2549 }
2550
2551 if (h->dynindx == -1
2552 || h->forced_local
2553 || info->symbolic)
2554 {
2555 /* This references the local defitionion. We must
2556 initialize this entry in the global offset table.
2557 Since the offset must always be a multiple of 8,
2558 we use the least significant bit to record
2559 whether we have initialized it already.
2560
2561 When doing a dynamic link, we create a .rela.got
2562 relocation entry to initialize the value. This
2563 is done in the finish_dynamic_symbol routine. */
2564 if ((off & 1) != 0)
2565 off &= ~1;
2566 else
2567 {
2568 bfd_put_64 (output_bfd, relocation,
2569 base_got->contents + off);
2570 /* Note that this is harmless for the GOTPLT64
2571 case, as -1 | 1 still is -1. */
2572 h->got.offset |= 1;
2573 }
2574 }
2575 }
2576
2577 relocation = (base_got->output_section->vma
2578 + base_got->output_offset + off);
2579
2580 goto do_relocation;
2581 }
2582
2583 if (h->plt.offset == (bfd_vma) -1)
2584 {
2585 /* Handle static pointers of STT_GNU_IFUNC symbols. */
2586 if (r_type == htab->pointer_r_type
2587 && (input_section->flags & SEC_CODE) == 0)
2588 goto do_ifunc_pointer;
2589 goto bad_ifunc_reloc;
2590 }
2591
2592 /* STT_GNU_IFUNC symbol must go through PLT. */
2593 if (htab->elf.splt != NULL)
2594 {
2595 if (htab->plt_second != NULL)
2596 {
2597 resolved_plt = htab->plt_second;
2598 plt_offset = eh->plt_second.offset;
2599 }
2600 else
2601 {
2602 resolved_plt = htab->elf.splt;
2603 plt_offset = h->plt.offset;
2604 }
2605 }
2606 else
2607 {
2608 resolved_plt = htab->elf.iplt;
2609 plt_offset = h->plt.offset;
2610 }
2611
2612 relocation = (resolved_plt->output_section->vma
2613 + resolved_plt->output_offset + plt_offset);
2614
2615 switch (r_type)
2616 {
2617 default:
2618 bad_ifunc_reloc:
2619 if (h->root.root.string)
2620 name = h->root.root.string;
2621 else
2622 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2623 NULL);
2624 _bfd_error_handler
2625 /* xgettext:c-format */
2626 (_("%B: relocation %s against STT_GNU_IFUNC "
2627 "symbol `%s' isn't supported"), input_bfd,
2628 howto->name, name);
2629 bfd_set_error (bfd_error_bad_value);
2630 return FALSE;
2631
2632 case R_X86_64_32S:
2633 if (bfd_link_pic (info))
2634 abort ();
2635 goto do_relocation;
2636
2637 case R_X86_64_32:
2638 if (ABI_64_P (output_bfd))
2639 goto do_relocation;
2640 /* FALLTHROUGH */
2641 case R_X86_64_64:
2642 do_ifunc_pointer:
2643 if (rel->r_addend != 0)
2644 {
2645 if (h->root.root.string)
2646 name = h->root.root.string;
2647 else
2648 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
2649 sym, NULL);
2650 _bfd_error_handler
2651 /* xgettext:c-format */
2652 (_("%B: relocation %s against STT_GNU_IFUNC "
2653 "symbol `%s' has non-zero addend: %Ld"),
2654 input_bfd, howto->name, name, rel->r_addend);
2655 bfd_set_error (bfd_error_bad_value);
2656 return FALSE;
2657 }
2658
2659 /* Generate dynamic relcoation only when there is a
2660 non-GOT reference in a shared object or there is no
2661 PLT. */
2662 if ((bfd_link_pic (info) && h->non_got_ref)
2663 || h->plt.offset == (bfd_vma) -1)
2664 {
2665 Elf_Internal_Rela outrel;
2666 asection *sreloc;
2667
2668 /* Need a dynamic relocation to get the real function
2669 address. */
2670 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2671 info,
2672 input_section,
2673 rel->r_offset);
2674 if (outrel.r_offset == (bfd_vma) -1
2675 || outrel.r_offset == (bfd_vma) -2)
2676 abort ();
2677
2678 outrel.r_offset += (input_section->output_section->vma
2679 + input_section->output_offset);
2680
2681 if (POINTER_LOCAL_IFUNC_P (info, h))
2682 {
2683 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
2684 h->root.root.string,
2685 h->root.u.def.section->owner);
2686
2687 /* This symbol is resolved locally. */
2688 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
2689 outrel.r_addend = (h->root.u.def.value
2690 + h->root.u.def.section->output_section->vma
2691 + h->root.u.def.section->output_offset);
2692 }
2693 else
2694 {
2695 outrel.r_info = htab->r_info (h->dynindx, r_type);
2696 outrel.r_addend = 0;
2697 }
2698
2699 /* Dynamic relocations are stored in
2700 1. .rela.ifunc section in PIC object.
2701 2. .rela.got section in dynamic executable.
2702 3. .rela.iplt section in static executable. */
2703 if (bfd_link_pic (info))
2704 sreloc = htab->elf.irelifunc;
2705 else if (htab->elf.splt != NULL)
2706 sreloc = htab->elf.srelgot;
2707 else
2708 sreloc = htab->elf.irelplt;
2709 elf_append_rela (output_bfd, sreloc, &outrel);
2710
2711 /* If this reloc is against an external symbol, we
2712 do not want to fiddle with the addend. Otherwise,
2713 we need to include the symbol value so that it
2714 becomes an addend for the dynamic reloc. For an
2715 internal symbol, we have updated addend. */
2716 continue;
2717 }
2718 /* FALLTHROUGH */
2719 case R_X86_64_PC32:
2720 case R_X86_64_PC32_BND:
2721 case R_X86_64_PC64:
2722 case R_X86_64_PLT32:
2723 case R_X86_64_PLT32_BND:
2724 goto do_relocation;
2725 }
2726 }
2727
2728 resolved_to_zero = (eh != NULL
2729 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2730
2731 /* When generating a shared object, the relocations handled here are
2732 copied into the output file to be resolved at run time. */
2733 switch (r_type)
2734 {
2735 case R_X86_64_GOT32:
2736 case R_X86_64_GOT64:
2737 /* Relocation is to the entry for this symbol in the global
2738 offset table. */
2739 case R_X86_64_GOTPCREL:
2740 case R_X86_64_GOTPCRELX:
2741 case R_X86_64_REX_GOTPCRELX:
2742 case R_X86_64_GOTPCREL64:
2743 /* Use global offset table entry as symbol value. */
2744 case R_X86_64_GOTPLT64:
2745 /* This is obsolete and treated the same as GOT64. */
2746 base_got = htab->elf.sgot;
2747
2748 if (htab->elf.sgot == NULL)
2749 abort ();
2750
2751 relative_reloc = FALSE;
2752 if (h != NULL)
2753 {
2754 off = h->got.offset;
2755 if (h->needs_plt
2756 && h->plt.offset != (bfd_vma)-1
2757 && off == (bfd_vma)-1)
2758 {
2759 /* We can't use h->got.offset here to save
2760 state, or even just remember the offset, as
2761 finish_dynamic_symbol would use that as offset into
2762 .got. */
2763 bfd_vma plt_index = (h->plt.offset / plt_entry_size
2764 - htab->plt.has_plt0);
2765 off = (plt_index + 3) * GOT_ENTRY_SIZE;
2766 base_got = htab->elf.sgotplt;
2767 }
2768
2769 if (RESOLVED_LOCALLY_P (info, h, htab))
2770 {
2771 /* We must initialize this entry in the global offset
2772 table. Since the offset must always be a multiple
2773 of 8, we use the least significant bit to record
2774 whether we have initialized it already.
2775
2776 When doing a dynamic link, we create a .rela.got
2777 relocation entry to initialize the value. This is
2778 done in the finish_dynamic_symbol routine. */
2779 if ((off & 1) != 0)
2780 off &= ~1;
2781 else
2782 {
2783 bfd_put_64 (output_bfd, relocation,
2784 base_got->contents + off);
2785 /* Note that this is harmless for the GOTPLT64 case,
2786 as -1 | 1 still is -1. */
2787 h->got.offset |= 1;
2788
2789 if (GENERATE_RELATIVE_RELOC_P (info, h))
2790 {
2791 /* If this symbol isn't dynamic in PIC,
2792 generate R_X86_64_RELATIVE here. */
2793 eh->no_finish_dynamic_symbol = 1;
2794 relative_reloc = TRUE;
2795 }
2796 }
2797 }
2798 else
2799 unresolved_reloc = FALSE;
2800 }
2801 else
2802 {
2803 if (local_got_offsets == NULL)
2804 abort ();
2805
2806 off = local_got_offsets[r_symndx];
2807
2808 /* The offset must always be a multiple of 8. We use
2809 the least significant bit to record whether we have
2810 already generated the necessary reloc. */
2811 if ((off & 1) != 0)
2812 off &= ~1;
2813 else
2814 {
2815 bfd_put_64 (output_bfd, relocation,
2816 base_got->contents + off);
2817 local_got_offsets[r_symndx] |= 1;
2818
2819 if (bfd_link_pic (info))
2820 relative_reloc = TRUE;
2821 }
2822 }
2823
2824 if (relative_reloc)
2825 {
2826 asection *s;
2827 Elf_Internal_Rela outrel;
2828
2829 /* We need to generate a R_X86_64_RELATIVE reloc
2830 for the dynamic linker. */
2831 s = htab->elf.srelgot;
2832 if (s == NULL)
2833 abort ();
2834
2835 outrel.r_offset = (base_got->output_section->vma
2836 + base_got->output_offset
2837 + off);
2838 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
2839 outrel.r_addend = relocation;
2840 elf_append_rela (output_bfd, s, &outrel);
2841 }
2842
2843 if (off >= (bfd_vma) -2)
2844 abort ();
2845
2846 relocation = base_got->output_section->vma
2847 + base_got->output_offset + off;
2848 if (r_type != R_X86_64_GOTPCREL
2849 && r_type != R_X86_64_GOTPCRELX
2850 && r_type != R_X86_64_REX_GOTPCRELX
2851 && r_type != R_X86_64_GOTPCREL64)
2852 relocation -= htab->elf.sgotplt->output_section->vma
2853 - htab->elf.sgotplt->output_offset;
2854
2855 break;
2856
2857 case R_X86_64_GOTOFF64:
2858 /* Relocation is relative to the start of the global offset
2859 table. */
2860
2861 /* Check to make sure it isn't a protected function or data
2862 symbol for shared library since it may not be local when
2863 used as function address or with copy relocation. We also
2864 need to make sure that a symbol is referenced locally. */
2865 if (bfd_link_pic (info) && h)
2866 {
2867 if (!h->def_regular)
2868 {
2869 const char *v;
2870
2871 switch (ELF_ST_VISIBILITY (h->other))
2872 {
2873 case STV_HIDDEN:
2874 v = _("hidden symbol");
2875 break;
2876 case STV_INTERNAL:
2877 v = _("internal symbol");
2878 break;
2879 case STV_PROTECTED:
2880 v = _("protected symbol");
2881 break;
2882 default:
2883 v = _("symbol");
2884 break;
2885 }
2886
2887 _bfd_error_handler
2888 /* xgettext:c-format */
2889 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
2890 " `%s' can not be used when making a shared object"),
2891 input_bfd, v, h->root.root.string);
2892 bfd_set_error (bfd_error_bad_value);
2893 return FALSE;
2894 }
2895 else if (!bfd_link_executable (info)
2896 && !SYMBOL_REFERENCES_LOCAL_P (info, h)
2897 && (h->type == STT_FUNC
2898 || h->type == STT_OBJECT)
2899 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2900 {
2901 _bfd_error_handler
2902 /* xgettext:c-format */
2903 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
2904 " `%s' can not be used when making a shared object"),
2905 input_bfd,
2906 h->type == STT_FUNC ? "function" : "data",
2907 h->root.root.string);
2908 bfd_set_error (bfd_error_bad_value);
2909 return FALSE;
2910 }
2911 }
2912
2913 /* Note that sgot is not involved in this
2914 calculation. We always want the start of .got.plt. If we
2915 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2916 permitted by the ABI, we might have to change this
2917 calculation. */
2918 relocation -= htab->elf.sgotplt->output_section->vma
2919 + htab->elf.sgotplt->output_offset;
2920 break;
2921
2922 case R_X86_64_GOTPC32:
2923 case R_X86_64_GOTPC64:
2924 /* Use global offset table as symbol value. */
2925 relocation = htab->elf.sgotplt->output_section->vma
2926 + htab->elf.sgotplt->output_offset;
2927 unresolved_reloc = FALSE;
2928 break;
2929
2930 case R_X86_64_PLTOFF64:
2931 /* Relocation is PLT entry relative to GOT. For local
2932 symbols it's the symbol itself relative to GOT. */
2933 if (h != NULL
2934 /* See PLT32 handling. */
2935 && (h->plt.offset != (bfd_vma) -1
2936 || eh->plt_got.offset != (bfd_vma) -1)
2937 && htab->elf.splt != NULL)
2938 {
2939 if (eh->plt_got.offset != (bfd_vma) -1)
2940 {
2941 /* Use the GOT PLT. */
2942 resolved_plt = htab->plt_got;
2943 plt_offset = eh->plt_got.offset;
2944 }
2945 else if (htab->plt_second != NULL)
2946 {
2947 resolved_plt = htab->plt_second;
2948 plt_offset = eh->plt_second.offset;
2949 }
2950 else
2951 {
2952 resolved_plt = htab->elf.splt;
2953 plt_offset = h->plt.offset;
2954 }
2955
2956 relocation = (resolved_plt->output_section->vma
2957 + resolved_plt->output_offset
2958 + plt_offset);
2959 unresolved_reloc = FALSE;
2960 }
2961
2962 relocation -= htab->elf.sgotplt->output_section->vma
2963 + htab->elf.sgotplt->output_offset;
2964 break;
2965
2966 case R_X86_64_PLT32:
2967 case R_X86_64_PLT32_BND:
2968 /* Relocation is to the entry for this symbol in the
2969 procedure linkage table. */
2970
2971 /* Resolve a PLT32 reloc against a local symbol directly,
2972 without using the procedure linkage table. */
2973 if (h == NULL)
2974 break;
2975
2976 if ((h->plt.offset == (bfd_vma) -1
2977 && eh->plt_got.offset == (bfd_vma) -1)
2978 || htab->elf.splt == NULL)
2979 {
2980 /* We didn't make a PLT entry for this symbol. This
2981 happens when statically linking PIC code, or when
2982 using -Bsymbolic. */
2983 break;
2984 }
2985
2986 if (h->plt.offset != (bfd_vma) -1)
2987 {
2988 if (htab->plt_second != NULL)
2989 {
2990 resolved_plt = htab->plt_second;
2991 plt_offset = eh->plt_second.offset;
2992 }
2993 else
2994 {
2995 resolved_plt = htab->elf.splt;
2996 plt_offset = h->plt.offset;
2997 }
2998 }
2999 else
3000 {
3001 /* Use the GOT PLT. */
3002 resolved_plt = htab->plt_got;
3003 plt_offset = eh->plt_got.offset;
3004 }
3005
3006 relocation = (resolved_plt->output_section->vma
3007 + resolved_plt->output_offset
3008 + plt_offset);
3009 unresolved_reloc = FALSE;
3010 break;
3011
3012 case R_X86_64_SIZE32:
3013 case R_X86_64_SIZE64:
3014 /* Set to symbol size. */
3015 relocation = st_size;
3016 goto direct;
3017
3018 case R_X86_64_PC8:
3019 case R_X86_64_PC16:
3020 case R_X86_64_PC32:
3021 case R_X86_64_PC32_BND:
3022 /* Don't complain about -fPIC if the symbol is undefined when
3023 building executable unless it is unresolved weak symbol or
3024 -z nocopyreloc is used. */
3025 if ((input_section->flags & SEC_ALLOC) != 0
3026 && (input_section->flags & SEC_READONLY) != 0
3027 && h != NULL
3028 && ((bfd_link_executable (info)
3029 && ((h->root.type == bfd_link_hash_undefweak
3030 && !resolved_to_zero)
3031 || ((info->nocopyreloc
3032 || (eh->def_protected
3033 && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3034 && h->def_dynamic
3035 && !(h->root.u.def.section->flags & SEC_CODE))))
3036 || bfd_link_dll (info)))
3037 {
3038 bfd_boolean fail = FALSE;
3039 bfd_boolean branch
3040 = ((r_type == R_X86_64_PC32
3041 || r_type == R_X86_64_PC32_BND)
3042 && is_32bit_relative_branch (contents, rel->r_offset));
3043
3044 if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3045 {
3046 /* Symbol is referenced locally. Make sure it is
3047 defined locally or for a branch. */
3048 fail = (!(h->def_regular || ELF_COMMON_DEF_P (h))
3049 && !branch);
3050 }
3051 else if (!(bfd_link_pie (info)
3052 && (h->needs_copy || eh->needs_copy)))
3053 {
3054 /* Symbol doesn't need copy reloc and isn't referenced
3055 locally. We only allow branch to symbol with
3056 non-default visibility. */
3057 fail = (!branch
3058 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3059 }
3060
3061 if (fail)
3062 return elf_x86_64_need_pic (info, input_bfd, input_section,
3063 h, NULL, NULL, howto);
3064 }
3065 /* Fall through. */
3066
3067 case R_X86_64_8:
3068 case R_X86_64_16:
3069 case R_X86_64_32:
3070 case R_X86_64_PC64:
3071 case R_X86_64_64:
3072 /* FIXME: The ABI says the linker should make sure the value is
3073 the same when it's zeroextended to 64 bit. */
3074
3075 direct:
3076 if ((input_section->flags & SEC_ALLOC) == 0)
3077 break;
3078
3079 need_copy_reloc_in_pie = (bfd_link_pie (info)
3080 && h != NULL
3081 && (h->needs_copy
3082 || eh->needs_copy
3083 || (h->root.type
3084 == bfd_link_hash_undefined))
3085 && (X86_PCREL_TYPE_P (r_type)
3086 || X86_SIZE_TYPE_P (r_type)));
3087
3088 if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type,
3089 need_copy_reloc_in_pie,
3090 resolved_to_zero, FALSE))
3091 {
3092 Elf_Internal_Rela outrel;
3093 bfd_boolean skip, relocate;
3094 asection *sreloc;
3095
3096 /* When generating a shared object, these relocations
3097 are copied into the output file to be resolved at run
3098 time. */
3099 skip = FALSE;
3100 relocate = FALSE;
3101
3102 outrel.r_offset =
3103 _bfd_elf_section_offset (output_bfd, info, input_section,
3104 rel->r_offset);
3105 if (outrel.r_offset == (bfd_vma) -1)
3106 skip = TRUE;
3107 else if (outrel.r_offset == (bfd_vma) -2)
3108 skip = TRUE, relocate = TRUE;
3109
3110 outrel.r_offset += (input_section->output_section->vma
3111 + input_section->output_offset);
3112
3113 if (skip)
3114 memset (&outrel, 0, sizeof outrel);
3115
3116 else if (COPY_INPUT_RELOC_P (info, h, r_type))
3117 {
3118 outrel.r_info = htab->r_info (h->dynindx, r_type);
3119 outrel.r_addend = rel->r_addend;
3120 }
3121 else
3122 {
3123 /* This symbol is local, or marked to become local.
3124 When relocation overflow check is disabled, we
3125 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
3126 if (r_type == htab->pointer_r_type
3127 || (r_type == R_X86_64_32
3128 && info->no_reloc_overflow_check))
3129 {
3130 relocate = TRUE;
3131 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3132 outrel.r_addend = relocation + rel->r_addend;
3133 }
3134 else if (r_type == R_X86_64_64
3135 && !ABI_64_P (output_bfd))
3136 {
3137 relocate = TRUE;
3138 outrel.r_info = htab->r_info (0,
3139 R_X86_64_RELATIVE64);
3140 outrel.r_addend = relocation + rel->r_addend;
3141 /* Check addend overflow. */
3142 if ((outrel.r_addend & 0x80000000)
3143 != (rel->r_addend & 0x80000000))
3144 {
3145 const char *name;
3146 int addend = rel->r_addend;
3147 if (h && h->root.root.string)
3148 name = h->root.root.string;
3149 else
3150 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3151 sym, NULL);
3152 _bfd_error_handler
3153 /* xgettext:c-format */
3154 (_("%B: addend %s%#x in relocation %s against "
3155 "symbol `%s' at %#Lx in section `%A' is "
3156 "out of range"),
3157 input_bfd, addend < 0 ? "-" : "", addend,
3158 howto->name, name, rel->r_offset, input_section);
3159 bfd_set_error (bfd_error_bad_value);
3160 return FALSE;
3161 }
3162 }
3163 else
3164 {
3165 long sindx;
3166
3167 if (bfd_is_abs_section (sec))
3168 sindx = 0;
3169 else if (sec == NULL || sec->owner == NULL)
3170 {
3171 bfd_set_error (bfd_error_bad_value);
3172 return FALSE;
3173 }
3174 else
3175 {
3176 asection *osec;
3177
3178 /* We are turning this relocation into one
3179 against a section symbol. It would be
3180 proper to subtract the symbol's value,
3181 osec->vma, from the emitted reloc addend,
3182 but ld.so expects buggy relocs. */
3183 osec = sec->output_section;
3184 sindx = elf_section_data (osec)->dynindx;
3185 if (sindx == 0)
3186 {
3187 asection *oi = htab->elf.text_index_section;
3188 sindx = elf_section_data (oi)->dynindx;
3189 }
3190 BFD_ASSERT (sindx != 0);
3191 }
3192
3193 outrel.r_info = htab->r_info (sindx, r_type);
3194 outrel.r_addend = relocation + rel->r_addend;
3195 }
3196 }
3197
3198 sreloc = elf_section_data (input_section)->sreloc;
3199
3200 if (sreloc == NULL || sreloc->contents == NULL)
3201 {
3202 r = bfd_reloc_notsupported;
3203 goto check_relocation_error;
3204 }
3205
3206 elf_append_rela (output_bfd, sreloc, &outrel);
3207
3208 /* If this reloc is against an external symbol, we do
3209 not want to fiddle with the addend. Otherwise, we
3210 need to include the symbol value so that it becomes
3211 an addend for the dynamic reloc. */
3212 if (! relocate)
3213 continue;
3214 }
3215
3216 break;
3217
3218 case R_X86_64_TLSGD:
3219 case R_X86_64_GOTPC32_TLSDESC:
3220 case R_X86_64_TLSDESC_CALL:
3221 case R_X86_64_GOTTPOFF:
3222 tls_type = GOT_UNKNOWN;
3223 if (h == NULL && local_got_offsets)
3224 tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
3225 else if (h != NULL)
3226 tls_type = elf_x86_hash_entry (h)->tls_type;
3227
3228 r_type_tls = r_type;
3229 if (! elf_x86_64_tls_transition (info, input_bfd,
3230 input_section, contents,
3231 symtab_hdr, sym_hashes,
3232 &r_type_tls, tls_type, rel,
3233 relend, h, r_symndx, TRUE))
3234 return FALSE;
3235
3236 if (r_type_tls == R_X86_64_TPOFF32)
3237 {
3238 bfd_vma roff = rel->r_offset;
3239
3240 BFD_ASSERT (! unresolved_reloc);
3241
3242 if (r_type == R_X86_64_TLSGD)
3243 {
3244 /* GD->LE transition. For 64bit, change
3245 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3246 .word 0x6666; rex64; call __tls_get_addr@PLT
3247 or
3248 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3249 .byte 0x66; rex64
3250 call *__tls_get_addr@GOTPCREL(%rip)
3251 which may be converted to
3252 addr32 call __tls_get_addr
3253 into:
3254 movq %fs:0, %rax
3255 leaq foo@tpoff(%rax), %rax
3256 For 32bit, change
3257 leaq foo@tlsgd(%rip), %rdi
3258 .word 0x6666; rex64; call __tls_get_addr@PLT
3259 or
3260 leaq foo@tlsgd(%rip), %rdi
3261 .byte 0x66; rex64
3262 call *__tls_get_addr@GOTPCREL(%rip)
3263 which may be converted to
3264 addr32 call __tls_get_addr
3265 into:
3266 movl %fs:0, %eax
3267 leaq foo@tpoff(%rax), %rax
3268 For largepic, change:
3269 leaq foo@tlsgd(%rip), %rdi
3270 movabsq $__tls_get_addr@pltoff, %rax
3271 addq %r15, %rax
3272 call *%rax
3273 into:
3274 movq %fs:0, %rax
3275 leaq foo@tpoff(%rax), %rax
3276 nopw 0x0(%rax,%rax,1) */
3277 int largepic = 0;
3278 if (ABI_64_P (output_bfd))
3279 {
3280 if (contents[roff + 5] == 0xb8)
3281 {
3282 memcpy (contents + roff - 3,
3283 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
3284 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3285 largepic = 1;
3286 }
3287 else
3288 memcpy (contents + roff - 4,
3289 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3290 16);
3291 }
3292 else
3293 memcpy (contents + roff - 3,
3294 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3295 15);
3296 bfd_put_32 (output_bfd,
3297 elf_x86_64_tpoff (info, relocation),
3298 contents + roff + 8 + largepic);
3299 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
3300 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
3301 rel++;
3302 wrel++;
3303 continue;
3304 }
3305 else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3306 {
3307 /* GDesc -> LE transition.
3308 It's originally something like:
3309 leaq x@tlsdesc(%rip), %rax
3310
3311 Change it to:
3312 movl $x@tpoff, %rax. */
3313
3314 unsigned int val, type;
3315
3316 type = bfd_get_8 (input_bfd, contents + roff - 3);
3317 val = bfd_get_8 (input_bfd, contents + roff - 1);
3318 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3319 contents + roff - 3);
3320 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3321 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3322 contents + roff - 1);
3323 bfd_put_32 (output_bfd,
3324 elf_x86_64_tpoff (info, relocation),
3325 contents + roff);
3326 continue;
3327 }
3328 else if (r_type == R_X86_64_TLSDESC_CALL)
3329 {
3330 /* GDesc -> LE transition.
3331 It's originally:
3332 call *(%rax)
3333 Turn it into:
3334 xchg %ax,%ax. */
3335 bfd_put_8 (output_bfd, 0x66, contents + roff);
3336 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3337 continue;
3338 }
3339 else if (r_type == R_X86_64_GOTTPOFF)
3340 {
3341 /* IE->LE transition:
3342 For 64bit, originally it can be one of:
3343 movq foo@gottpoff(%rip), %reg
3344 addq foo@gottpoff(%rip), %reg
3345 We change it into:
3346 movq $foo, %reg
3347 leaq foo(%reg), %reg
3348 addq $foo, %reg.
3349 For 32bit, originally it can be one of:
3350 movq foo@gottpoff(%rip), %reg
3351 addl foo@gottpoff(%rip), %reg
3352 We change it into:
3353 movq $foo, %reg
3354 leal foo(%reg), %reg
3355 addl $foo, %reg. */
3356
3357 unsigned int val, type, reg;
3358
3359 if (roff >= 3)
3360 val = bfd_get_8 (input_bfd, contents + roff - 3);
3361 else
3362 val = 0;
3363 type = bfd_get_8 (input_bfd, contents + roff - 2);
3364 reg = bfd_get_8 (input_bfd, contents + roff - 1);
3365 reg >>= 3;
3366 if (type == 0x8b)
3367 {
3368 /* movq */
3369 if (val == 0x4c)
3370 bfd_put_8 (output_bfd, 0x49,
3371 contents + roff - 3);
3372 else if (!ABI_64_P (output_bfd) && val == 0x44)
3373 bfd_put_8 (output_bfd, 0x41,
3374 contents + roff - 3);
3375 bfd_put_8 (output_bfd, 0xc7,
3376 contents + roff - 2);
3377 bfd_put_8 (output_bfd, 0xc0 | reg,
3378 contents + roff - 1);
3379 }
3380 else if (reg == 4)
3381 {
3382 /* addq/addl -> addq/addl - addressing with %rsp/%r12
3383 is special */
3384 if (val == 0x4c)
3385 bfd_put_8 (output_bfd, 0x49,
3386 contents + roff - 3);
3387 else if (!ABI_64_P (output_bfd) && val == 0x44)
3388 bfd_put_8 (output_bfd, 0x41,
3389 contents + roff - 3);
3390 bfd_put_8 (output_bfd, 0x81,
3391 contents + roff - 2);
3392 bfd_put_8 (output_bfd, 0xc0 | reg,
3393 contents + roff - 1);
3394 }
3395 else
3396 {
3397 /* addq/addl -> leaq/leal */
3398 if (val == 0x4c)
3399 bfd_put_8 (output_bfd, 0x4d,
3400 contents + roff - 3);
3401 else if (!ABI_64_P (output_bfd) && val == 0x44)
3402 bfd_put_8 (output_bfd, 0x45,
3403 contents + roff - 3);
3404 bfd_put_8 (output_bfd, 0x8d,
3405 contents + roff - 2);
3406 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3407 contents + roff - 1);
3408 }
3409 bfd_put_32 (output_bfd,
3410 elf_x86_64_tpoff (info, relocation),
3411 contents + roff);
3412 continue;
3413 }
3414 else
3415 BFD_ASSERT (FALSE);
3416 }
3417
3418 if (htab->elf.sgot == NULL)
3419 abort ();
3420
3421 if (h != NULL)
3422 {
3423 off = h->got.offset;
3424 offplt = elf_x86_hash_entry (h)->tlsdesc_got;
3425 }
3426 else
3427 {
3428 if (local_got_offsets == NULL)
3429 abort ();
3430
3431 off = local_got_offsets[r_symndx];
3432 offplt = local_tlsdesc_gotents[r_symndx];
3433 }
3434
3435 if ((off & 1) != 0)
3436 off &= ~1;
3437 else
3438 {
3439 Elf_Internal_Rela outrel;
3440 int dr_type, indx;
3441 asection *sreloc;
3442
3443 if (htab->elf.srelgot == NULL)
3444 abort ();
3445
3446 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3447
3448 if (GOT_TLS_GDESC_P (tls_type))
3449 {
3450 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3451 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3452 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3453 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3454 + htab->elf.sgotplt->output_offset
3455 + offplt
3456 + htab->sgotplt_jump_table_size);
3457 sreloc = htab->elf.srelplt;
3458 if (indx == 0)
3459 outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3460 else
3461 outrel.r_addend = 0;
3462 elf_append_rela (output_bfd, sreloc, &outrel);
3463 }
3464
3465 sreloc = htab->elf.srelgot;
3466
3467 outrel.r_offset = (htab->elf.sgot->output_section->vma
3468 + htab->elf.sgot->output_offset + off);
3469
3470 if (GOT_TLS_GD_P (tls_type))
3471 dr_type = R_X86_64_DTPMOD64;
3472 else if (GOT_TLS_GDESC_P (tls_type))
3473 goto dr_done;
3474 else
3475 dr_type = R_X86_64_TPOFF64;
3476
3477 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3478 outrel.r_addend = 0;
3479 if ((dr_type == R_X86_64_TPOFF64
3480 || dr_type == R_X86_64_TLSDESC) && indx == 0)
3481 outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3482 outrel.r_info = htab->r_info (indx, dr_type);
3483
3484 elf_append_rela (output_bfd, sreloc, &outrel);
3485
3486 if (GOT_TLS_GD_P (tls_type))
3487 {
3488 if (indx == 0)
3489 {
3490 BFD_ASSERT (! unresolved_reloc);
3491 bfd_put_64 (output_bfd,
3492 relocation - _bfd_x86_elf_dtpoff_base (info),
3493 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3494 }
3495 else
3496 {
3497 bfd_put_64 (output_bfd, 0,
3498 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3499 outrel.r_info = htab->r_info (indx,
3500 R_X86_64_DTPOFF64);
3501 outrel.r_offset += GOT_ENTRY_SIZE;
3502 elf_append_rela (output_bfd, sreloc,
3503 &outrel);
3504 }
3505 }
3506
3507 dr_done:
3508 if (h != NULL)
3509 h->got.offset |= 1;
3510 else
3511 local_got_offsets[r_symndx] |= 1;
3512 }
3513
3514 if (off >= (bfd_vma) -2
3515 && ! GOT_TLS_GDESC_P (tls_type))
3516 abort ();
3517 if (r_type_tls == r_type)
3518 {
3519 if (r_type == R_X86_64_GOTPC32_TLSDESC
3520 || r_type == R_X86_64_TLSDESC_CALL)
3521 relocation = htab->elf.sgotplt->output_section->vma
3522 + htab->elf.sgotplt->output_offset
3523 + offplt + htab->sgotplt_jump_table_size;
3524 else
3525 relocation = htab->elf.sgot->output_section->vma
3526 + htab->elf.sgot->output_offset + off;
3527 unresolved_reloc = FALSE;
3528 }
3529 else
3530 {
3531 bfd_vma roff = rel->r_offset;
3532
3533 if (r_type == R_X86_64_TLSGD)
3534 {
3535 /* GD->IE transition. For 64bit, change
3536 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3537 .word 0x6666; rex64; call __tls_get_addr@PLT
3538 or
3539 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3540 .byte 0x66; rex64
3541 call *__tls_get_addr@GOTPCREL(%rip
3542 which may be converted to
3543 addr32 call __tls_get_addr
3544 into:
3545 movq %fs:0, %rax
3546 addq foo@gottpoff(%rip), %rax
3547 For 32bit, change
3548 leaq foo@tlsgd(%rip), %rdi
3549 .word 0x6666; rex64; call __tls_get_addr@PLT
3550 or
3551 leaq foo@tlsgd(%rip), %rdi
3552 .byte 0x66; rex64;
3553 call *__tls_get_addr@GOTPCREL(%rip)
3554 which may be converted to
3555 addr32 call __tls_get_addr
3556 into:
3557 movl %fs:0, %eax
3558 addq foo@gottpoff(%rip), %rax
3559 For largepic, change:
3560 leaq foo@tlsgd(%rip), %rdi
3561 movabsq $__tls_get_addr@pltoff, %rax
3562 addq %r15, %rax
3563 call *%rax
3564 into:
3565 movq %fs:0, %rax
3566 addq foo@gottpoff(%rax), %rax
3567 nopw 0x0(%rax,%rax,1) */
3568 int largepic = 0;
3569 if (ABI_64_P (output_bfd))
3570 {
3571 if (contents[roff + 5] == 0xb8)
3572 {
3573 memcpy (contents + roff - 3,
3574 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
3575 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3576 largepic = 1;
3577 }
3578 else
3579 memcpy (contents + roff - 4,
3580 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3581 16);
3582 }
3583 else
3584 memcpy (contents + roff - 3,
3585 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3586 15);
3587
3588 relocation = (htab->elf.sgot->output_section->vma
3589 + htab->elf.sgot->output_offset + off
3590 - roff
3591 - largepic
3592 - input_section->output_section->vma
3593 - input_section->output_offset
3594 - 12);
3595 bfd_put_32 (output_bfd, relocation,
3596 contents + roff + 8 + largepic);
3597 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
3598 rel++;
3599 wrel++;
3600 continue;
3601 }
3602 else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3603 {
3604 /* GDesc -> IE transition.
3605 It's originally something like:
3606 leaq x@tlsdesc(%rip), %rax
3607
3608 Change it to:
3609 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3610
3611 /* Now modify the instruction as appropriate. To
3612 turn a leaq into a movq in the form we use it, it
3613 suffices to change the second byte from 0x8d to
3614 0x8b. */
3615 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3616
3617 bfd_put_32 (output_bfd,
3618 htab->elf.sgot->output_section->vma
3619 + htab->elf.sgot->output_offset + off
3620 - rel->r_offset
3621 - input_section->output_section->vma
3622 - input_section->output_offset
3623 - 4,
3624 contents + roff);
3625 continue;
3626 }
3627 else if (r_type == R_X86_64_TLSDESC_CALL)
3628 {
3629 /* GDesc -> IE transition.
3630 It's originally:
3631 call *(%rax)
3632
3633 Change it to:
3634 xchg %ax, %ax. */
3635
3636 bfd_put_8 (output_bfd, 0x66, contents + roff);
3637 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3638 continue;
3639 }
3640 else
3641 BFD_ASSERT (FALSE);
3642 }
3643 break;
3644
3645 case R_X86_64_TLSLD:
3646 if (! elf_x86_64_tls_transition (info, input_bfd,
3647 input_section, contents,
3648 symtab_hdr, sym_hashes,
3649 &r_type, GOT_UNKNOWN, rel,
3650 relend, h, r_symndx, TRUE))
3651 return FALSE;
3652
3653 if (r_type != R_X86_64_TLSLD)
3654 {
3655 /* LD->LE transition:
3656 leaq foo@tlsld(%rip), %rdi
3657 call __tls_get_addr@PLT
3658 For 64bit, we change it into:
3659 .word 0x6666; .byte 0x66; movq %fs:0, %rax
3660 For 32bit, we change it into:
3661 nopl 0x0(%rax); movl %fs:0, %eax
3662 Or
3663 leaq foo@tlsld(%rip), %rdi;
3664 call *__tls_get_addr@GOTPCREL(%rip)
3665 which may be converted to
3666 addr32 call __tls_get_addr
3667 For 64bit, we change it into:
3668 .word 0x6666; .word 0x6666; movq %fs:0, %rax
3669 For 32bit, we change it into:
3670 nopw 0x0(%rax); movl %fs:0, %eax
3671 For largepic, change:
3672 leaq foo@tlsgd(%rip), %rdi
3673 movabsq $__tls_get_addr@pltoff, %rax
3674 addq %rbx, %rax
3675 call *%rax
3676 into
3677 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
3678 movq %fs:0, %eax */
3679
3680 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3681 if (ABI_64_P (output_bfd))
3682 {
3683 if (contents[rel->r_offset + 5] == 0xb8)
3684 memcpy (contents + rel->r_offset - 3,
3685 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
3686 "\x64\x48\x8b\x04\x25\0\0\0", 22);
3687 else if (contents[rel->r_offset + 4] == 0xff
3688 || contents[rel->r_offset + 4] == 0x67)
3689 memcpy (contents + rel->r_offset - 3,
3690 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
3691 13);
3692 else
3693 memcpy (contents + rel->r_offset - 3,
3694 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3695 }
3696 else
3697 {
3698 if (contents[rel->r_offset + 4] == 0xff)
3699 memcpy (contents + rel->r_offset - 3,
3700 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
3701 13);
3702 else
3703 memcpy (contents + rel->r_offset - 3,
3704 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
3705 }
3706 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
3707 and R_X86_64_PLTOFF64. */
3708 rel++;
3709 wrel++;
3710 continue;
3711 }
3712
3713 if (htab->elf.sgot == NULL)
3714 abort ();
3715
3716 off = htab->tls_ld_or_ldm_got.offset;
3717 if (off & 1)
3718 off &= ~1;
3719 else
3720 {
3721 Elf_Internal_Rela outrel;
3722
3723 if (htab->elf.srelgot == NULL)
3724 abort ();
3725
3726 outrel.r_offset = (htab->elf.sgot->output_section->vma
3727 + htab->elf.sgot->output_offset + off);
3728
3729 bfd_put_64 (output_bfd, 0,
3730 htab->elf.sgot->contents + off);
3731 bfd_put_64 (output_bfd, 0,
3732 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3733 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
3734 outrel.r_addend = 0;
3735 elf_append_rela (output_bfd, htab->elf.srelgot,
3736 &outrel);
3737 htab->tls_ld_or_ldm_got.offset |= 1;
3738 }
3739 relocation = htab->elf.sgot->output_section->vma
3740 + htab->elf.sgot->output_offset + off;
3741 unresolved_reloc = FALSE;
3742 break;
3743
3744 case R_X86_64_DTPOFF32:
3745 if (!bfd_link_executable (info)
3746 || (input_section->flags & SEC_CODE) == 0)
3747 relocation -= _bfd_x86_elf_dtpoff_base (info);
3748 else
3749 relocation = elf_x86_64_tpoff (info, relocation);
3750 break;
3751
3752 case R_X86_64_TPOFF32:
3753 case R_X86_64_TPOFF64:
3754 BFD_ASSERT (bfd_link_executable (info));
3755 relocation = elf_x86_64_tpoff (info, relocation);
3756 break;
3757
3758 case R_X86_64_DTPOFF64:
3759 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
3760 relocation -= _bfd_x86_elf_dtpoff_base (info);
3761 break;
3762
3763 default:
3764 break;
3765 }
3766
3767 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3768 because such sections are not SEC_ALLOC and thus ld.so will
3769 not process them. */
3770 if (unresolved_reloc
3771 && !((input_section->flags & SEC_DEBUGGING) != 0
3772 && h->def_dynamic)
3773 && _bfd_elf_section_offset (output_bfd, info, input_section,
3774 rel->r_offset) != (bfd_vma) -1)
3775 {
3776 switch (r_type)
3777 {
3778 case R_X86_64_32S:
3779 sec = h->root.u.def.section;
3780 if ((info->nocopyreloc
3781 || (eh->def_protected
3782 && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3783 && !(h->root.u.def.section->flags & SEC_CODE))
3784 return elf_x86_64_need_pic (info, input_bfd, input_section,
3785 h, NULL, NULL, howto);
3786 /* Fall through. */
3787
3788 default:
3789 _bfd_error_handler
3790 /* xgettext:c-format */
3791 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
3792 input_bfd,
3793 input_section,
3794 rel->r_offset,
3795 howto->name,
3796 h->root.root.string);
3797 return FALSE;
3798 }
3799 }
3800
3801 do_relocation:
3802 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3803 contents, rel->r_offset,
3804 relocation, rel->r_addend);
3805
3806 check_relocation_error:
3807 if (r != bfd_reloc_ok)
3808 {
3809 const char *name;
3810
3811 if (h != NULL)
3812 name = h->root.root.string;
3813 else
3814 {
3815 name = bfd_elf_string_from_elf_section (input_bfd,
3816 symtab_hdr->sh_link,
3817 sym->st_name);
3818 if (name == NULL)
3819 return FALSE;
3820 if (*name == '\0')
3821 name = bfd_section_name (input_bfd, sec);
3822 }
3823
3824 if (r == bfd_reloc_overflow)
3825 {
3826 if (converted_reloc)
3827 {
3828 info->callbacks->einfo
3829 (_("%F%P: failed to convert GOTPCREL relocation; relink with --no-relax\n"));
3830 return FALSE;
3831 }
3832 (*info->callbacks->reloc_overflow)
3833 (info, (h ? &h->root : NULL), name, howto->name,
3834 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3835 }
3836 else
3837 {
3838 _bfd_error_handler
3839 /* xgettext:c-format */
3840 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
3841 input_bfd, input_section,
3842 rel->r_offset, name, (int) r);
3843 return FALSE;
3844 }
3845 }
3846
3847 if (wrel != rel)
3848 *wrel = *rel;
3849 }
3850
3851 if (wrel != rel)
3852 {
3853 Elf_Internal_Shdr *rel_hdr;
3854 size_t deleted = rel - wrel;
3855
3856 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3857 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3858 if (rel_hdr->sh_size == 0)
3859 {
3860 /* It is too late to remove an empty reloc section. Leave
3861 one NONE reloc.
3862 ??? What is wrong with an empty section??? */
3863 rel_hdr->sh_size = rel_hdr->sh_entsize;
3864 deleted -= 1;
3865 }
3866 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3867 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3868 input_section->reloc_count -= deleted;
3869 }
3870
3871 return TRUE;
3872 }
3873
3874 /* Finish up dynamic symbol handling. We set the contents of various
3875 dynamic sections here. */
3876
3877 static bfd_boolean
3878 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3879 struct bfd_link_info *info,
3880 struct elf_link_hash_entry *h,
3881 Elf_Internal_Sym *sym)
3882 {
3883 struct elf_x86_link_hash_table *htab;
3884 bfd_boolean use_plt_second;
3885 struct elf_x86_link_hash_entry *eh;
3886 bfd_boolean local_undefweak;
3887
3888 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
3889 if (htab == NULL)
3890 return FALSE;
3891
3892 /* Use the second PLT section only if there is .plt section. */
3893 use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3894
3895 eh = (struct elf_x86_link_hash_entry *) h;
3896 if (eh->no_finish_dynamic_symbol)
3897 abort ();
3898
3899 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3900 resolved undefined weak symbols in executable so that their
3901 references have value 0 at run-time. */
3902 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3903
3904 if (h->plt.offset != (bfd_vma) -1)
3905 {
3906 bfd_vma plt_index;
3907 bfd_vma got_offset, plt_offset;
3908 Elf_Internal_Rela rela;
3909 bfd_byte *loc;
3910 asection *plt, *gotplt, *relplt, *resolved_plt;
3911 const struct elf_backend_data *bed;
3912 bfd_vma plt_got_pcrel_offset;
3913
3914 /* When building a static executable, use .iplt, .igot.plt and
3915 .rela.iplt sections for STT_GNU_IFUNC symbols. */
3916 if (htab->elf.splt != NULL)
3917 {
3918 plt = htab->elf.splt;
3919 gotplt = htab->elf.sgotplt;
3920 relplt = htab->elf.srelplt;
3921 }
3922 else
3923 {
3924 plt = htab->elf.iplt;
3925 gotplt = htab->elf.igotplt;
3926 relplt = htab->elf.irelplt;
3927 }
3928
3929 VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3930
3931 /* Get the index in the procedure linkage table which
3932 corresponds to this symbol. This is the index of this symbol
3933 in all the symbols for which we are making plt entries. The
3934 first entry in the procedure linkage table is reserved.
3935
3936 Get the offset into the .got table of the entry that
3937 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
3938 bytes. The first three are reserved for the dynamic linker.
3939
3940 For static executables, we don't reserve anything. */
3941
3942 if (plt == htab->elf.splt)
3943 {
3944 got_offset = (h->plt.offset / htab->plt.plt_entry_size
3945 - htab->plt.has_plt0);
3946 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
3947 }
3948 else
3949 {
3950 got_offset = h->plt.offset / htab->plt.plt_entry_size;
3951 got_offset = got_offset * GOT_ENTRY_SIZE;
3952 }
3953
3954 /* Fill in the entry in the procedure linkage table. */
3955 memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3956 htab->plt.plt_entry_size);
3957 if (use_plt_second)
3958 {
3959 memcpy (htab->plt_second->contents + eh->plt_second.offset,
3960 htab->non_lazy_plt->plt_entry,
3961 htab->non_lazy_plt->plt_entry_size);
3962
3963 resolved_plt = htab->plt_second;
3964 plt_offset = eh->plt_second.offset;
3965 }
3966 else
3967 {
3968 resolved_plt = plt;
3969 plt_offset = h->plt.offset;
3970 }
3971
3972 /* Insert the relocation positions of the plt section. */
3973
3974 /* Put offset the PC-relative instruction referring to the GOT entry,
3975 subtracting the size of that instruction. */
3976 plt_got_pcrel_offset = (gotplt->output_section->vma
3977 + gotplt->output_offset
3978 + got_offset
3979 - resolved_plt->output_section->vma
3980 - resolved_plt->output_offset
3981 - plt_offset
3982 - htab->plt.plt_got_insn_size);
3983
3984 /* Check PC-relative offset overflow in PLT entry. */
3985 if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
3986 /* xgettext:c-format */
3987 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
3988 output_bfd, h->root.root.string);
3989
3990 bfd_put_32 (output_bfd, plt_got_pcrel_offset,
3991 (resolved_plt->contents + plt_offset
3992 + htab->plt.plt_got_offset));
3993
3994 /* Fill in the entry in the global offset table, initially this
3995 points to the second part of the PLT entry. Leave the entry
3996 as zero for undefined weak symbol in PIE. No PLT relocation
3997 against undefined weak symbol in PIE. */
3998 if (!local_undefweak)
3999 {
4000 if (htab->plt.has_plt0)
4001 bfd_put_64 (output_bfd, (plt->output_section->vma
4002 + plt->output_offset
4003 + h->plt.offset
4004 + htab->lazy_plt->plt_lazy_offset),
4005 gotplt->contents + got_offset);
4006
4007 /* Fill in the entry in the .rela.plt section. */
4008 rela.r_offset = (gotplt->output_section->vma
4009 + gotplt->output_offset
4010 + got_offset);
4011 if (PLT_LOCAL_IFUNC_P (info, h))
4012 {
4013 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
4014 h->root.root.string,
4015 h->root.u.def.section->owner);
4016
4017 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4018 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4019 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4020 rela.r_addend = (h->root.u.def.value
4021 + h->root.u.def.section->output_section->vma
4022 + h->root.u.def.section->output_offset);
4023 /* R_X86_64_IRELATIVE comes last. */
4024 plt_index = htab->next_irelative_index--;
4025 }
4026 else
4027 {
4028 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4029 rela.r_addend = 0;
4030 plt_index = htab->next_jump_slot_index++;
4031 }
4032
4033 /* Don't fill the second and third slots in PLT entry for
4034 static executables nor without PLT0. */
4035 if (plt == htab->elf.splt && htab->plt.has_plt0)
4036 {
4037 bfd_vma plt0_offset
4038 = h->plt.offset + htab->lazy_plt->plt_plt_insn_end;
4039
4040 /* Put relocation index. */
4041 bfd_put_32 (output_bfd, plt_index,
4042 (plt->contents + h->plt.offset
4043 + htab->lazy_plt->plt_reloc_offset));
4044
4045 /* Put offset for jmp .PLT0 and check for overflow. We don't
4046 check relocation index for overflow since branch displacement
4047 will overflow first. */
4048 if (plt0_offset > 0x80000000)
4049 /* xgettext:c-format */
4050 info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
4051 output_bfd, h->root.root.string);
4052 bfd_put_32 (output_bfd, - plt0_offset,
4053 (plt->contents + h->plt.offset
4054 + htab->lazy_plt->plt_plt_offset));
4055 }
4056
4057 bed = get_elf_backend_data (output_bfd);
4058 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4059 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4060 }
4061 }
4062 else if (eh->plt_got.offset != (bfd_vma) -1)
4063 {
4064 bfd_vma got_offset, plt_offset;
4065 asection *plt, *got;
4066 bfd_boolean got_after_plt;
4067 int32_t got_pcrel_offset;
4068
4069 /* Set the entry in the GOT procedure linkage table. */
4070 plt = htab->plt_got;
4071 got = htab->elf.sgot;
4072 got_offset = h->got.offset;
4073
4074 if (got_offset == (bfd_vma) -1
4075 || (h->type == STT_GNU_IFUNC && h->def_regular)
4076 || plt == NULL
4077 || got == NULL)
4078 abort ();
4079
4080 /* Use the non-lazy PLT entry template for the GOT PLT since they
4081 are the identical. */
4082 /* Fill in the entry in the GOT procedure linkage table. */
4083 plt_offset = eh->plt_got.offset;
4084 memcpy (plt->contents + plt_offset,
4085 htab->non_lazy_plt->plt_entry,
4086 htab->non_lazy_plt->plt_entry_size);
4087
4088 /* Put offset the PC-relative instruction referring to the GOT
4089 entry, subtracting the size of that instruction. */
4090 got_pcrel_offset = (got->output_section->vma
4091 + got->output_offset
4092 + got_offset
4093 - plt->output_section->vma
4094 - plt->output_offset
4095 - plt_offset
4096 - htab->non_lazy_plt->plt_got_insn_size);
4097
4098 /* Check PC-relative offset overflow in GOT PLT entry. */
4099 got_after_plt = got->output_section->vma > plt->output_section->vma;
4100 if ((got_after_plt && got_pcrel_offset < 0)
4101 || (!got_after_plt && got_pcrel_offset > 0))
4102 /* xgettext:c-format */
4103 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
4104 output_bfd, h->root.root.string);
4105
4106 bfd_put_32 (output_bfd, got_pcrel_offset,
4107 (plt->contents + plt_offset
4108 + htab->non_lazy_plt->plt_got_offset));
4109 }
4110
4111 if (!local_undefweak
4112 && !h->def_regular
4113 && (h->plt.offset != (bfd_vma) -1
4114 || eh->plt_got.offset != (bfd_vma) -1))
4115 {
4116 /* Mark the symbol as undefined, rather than as defined in
4117 the .plt section. Leave the value if there were any
4118 relocations where pointer equality matters (this is a clue
4119 for the dynamic linker, to make function pointer
4120 comparisons work between an application and shared
4121 library), otherwise set it to zero. If a function is only
4122 called from a binary, there is no need to slow down
4123 shared libraries because of that. */
4124 sym->st_shndx = SHN_UNDEF;
4125 if (!h->pointer_equality_needed)
4126 sym->st_value = 0;
4127 }
4128
4129 /* Don't generate dynamic GOT relocation against undefined weak
4130 symbol in executable. */
4131 if (h->got.offset != (bfd_vma) -1
4132 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h)->tls_type)
4133 && elf_x86_hash_entry (h)->tls_type != GOT_TLS_IE
4134 && !local_undefweak)
4135 {
4136 Elf_Internal_Rela rela;
4137 asection *relgot = htab->elf.srelgot;
4138
4139 /* This symbol has an entry in the global offset table. Set it
4140 up. */
4141 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4142 abort ();
4143
4144 rela.r_offset = (htab->elf.sgot->output_section->vma
4145 + htab->elf.sgot->output_offset
4146 + (h->got.offset &~ (bfd_vma) 1));
4147
4148 /* If this is a static link, or it is a -Bsymbolic link and the
4149 symbol is defined locally or was forced to be local because
4150 of a version file, we just want to emit a RELATIVE reloc.
4151 The entry in the global offset table will already have been
4152 initialized in the relocate_section function. */
4153 if (h->def_regular
4154 && h->type == STT_GNU_IFUNC)
4155 {
4156 if (h->plt.offset == (bfd_vma) -1)
4157 {
4158 /* STT_GNU_IFUNC is referenced without PLT. */
4159 if (htab->elf.splt == NULL)
4160 {
4161 /* use .rel[a].iplt section to store .got relocations
4162 in static executable. */
4163 relgot = htab->elf.irelplt;
4164 }
4165 if (SYMBOL_REFERENCES_LOCAL_P (info, h))
4166 {
4167 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
4168 h->root.root.string,
4169 h->root.u.def.section->owner);
4170
4171 rela.r_info = htab->r_info (0,
4172 R_X86_64_IRELATIVE);
4173 rela.r_addend = (h->root.u.def.value
4174 + h->root.u.def.section->output_section->vma
4175 + h->root.u.def.section->output_offset);
4176 }
4177 else
4178 goto do_glob_dat;
4179 }
4180 else if (bfd_link_pic (info))
4181 {
4182 /* Generate R_X86_64_GLOB_DAT. */
4183 goto do_glob_dat;
4184 }
4185 else
4186 {
4187 asection *plt;
4188 bfd_vma plt_offset;
4189
4190 if (!h->pointer_equality_needed)
4191 abort ();
4192
4193 /* For non-shared object, we can't use .got.plt, which
4194 contains the real function addres if we need pointer
4195 equality. We load the GOT entry with the PLT entry. */
4196 if (htab->plt_second != NULL)
4197 {
4198 plt = htab->plt_second;
4199 plt_offset = eh->plt_second.offset;
4200 }
4201 else
4202 {
4203 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4204 plt_offset = h->plt.offset;
4205 }
4206 bfd_put_64 (output_bfd, (plt->output_section->vma
4207 + plt->output_offset
4208 + plt_offset),
4209 htab->elf.sgot->contents + h->got.offset);
4210 return TRUE;
4211 }
4212 }
4213 else if (bfd_link_pic (info)
4214 && SYMBOL_REFERENCES_LOCAL_P (info, h))
4215 {
4216 if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
4217 return FALSE;
4218 BFD_ASSERT((h->got.offset & 1) != 0);
4219 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4220 rela.r_addend = (h->root.u.def.value
4221 + h->root.u.def.section->output_section->vma
4222 + h->root.u.def.section->output_offset);
4223 }
4224 else
4225 {
4226 BFD_ASSERT((h->got.offset & 1) == 0);
4227 do_glob_dat:
4228 bfd_put_64 (output_bfd, (bfd_vma) 0,
4229 htab->elf.sgot->contents + h->got.offset);
4230 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4231 rela.r_addend = 0;
4232 }
4233
4234 elf_append_rela (output_bfd, relgot, &rela);
4235 }
4236
4237 if (h->needs_copy)
4238 {
4239 Elf_Internal_Rela rela;
4240 asection *s;
4241
4242 /* This symbol needs a copy reloc. Set it up. */
4243 VERIFY_COPY_RELOC (h, htab)
4244
4245 rela.r_offset = (h->root.u.def.value
4246 + h->root.u.def.section->output_section->vma
4247 + h->root.u.def.section->output_offset);
4248 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4249 rela.r_addend = 0;
4250 if (h->root.u.def.section == htab->elf.sdynrelro)
4251 s = htab->elf.sreldynrelro;
4252 else
4253 s = htab->elf.srelbss;
4254 elf_append_rela (output_bfd, s, &rela);
4255 }
4256
4257 return TRUE;
4258 }
4259
4260 /* Finish up local dynamic symbol handling. We set the contents of
4261 various dynamic sections here. */
4262
4263 static bfd_boolean
4264 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4265 {
4266 struct elf_link_hash_entry *h
4267 = (struct elf_link_hash_entry *) *slot;
4268 struct bfd_link_info *info
4269 = (struct bfd_link_info *) inf;
4270
4271 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4272 info, h, NULL);
4273 }
4274
4275 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
4276 here since undefined weak symbol may not be dynamic and may not be
4277 called for elf_x86_64_finish_dynamic_symbol. */
4278
4279 static bfd_boolean
4280 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
4281 void *inf)
4282 {
4283 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
4284 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4285
4286 if (h->root.type != bfd_link_hash_undefweak
4287 || h->dynindx != -1)
4288 return TRUE;
4289
4290 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4291 info, h, NULL);
4292 }
4293
4294 /* Used to decide how to sort relocs in an optimal manner for the
4295 dynamic linker, before writing them out. */
4296
4297 static enum elf_reloc_type_class
4298 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
4299 const asection *rel_sec ATTRIBUTE_UNUSED,
4300 const Elf_Internal_Rela *rela)
4301 {
4302 bfd *abfd = info->output_bfd;
4303 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4304 struct elf_x86_link_hash_table *htab
4305 = elf_x86_hash_table (info, X86_64_ELF_DATA);
4306
4307 if (htab->elf.dynsym != NULL
4308 && htab->elf.dynsym->contents != NULL)
4309 {
4310 /* Check relocation against STT_GNU_IFUNC symbol if there are
4311 dynamic symbols. */
4312 unsigned long r_symndx = htab->r_sym (rela->r_info);
4313 if (r_symndx != STN_UNDEF)
4314 {
4315 Elf_Internal_Sym sym;
4316 if (!bed->s->swap_symbol_in (abfd,
4317 (htab->elf.dynsym->contents
4318 + r_symndx * bed->s->sizeof_sym),
4319 0, &sym))
4320 abort ();
4321
4322 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
4323 return reloc_class_ifunc;
4324 }
4325 }
4326
4327 switch ((int) ELF32_R_TYPE (rela->r_info))
4328 {
4329 case R_X86_64_IRELATIVE:
4330 return reloc_class_ifunc;
4331 case R_X86_64_RELATIVE:
4332 case R_X86_64_RELATIVE64:
4333 return reloc_class_relative;
4334 case R_X86_64_JUMP_SLOT:
4335 return reloc_class_plt;
4336 case R_X86_64_COPY:
4337 return reloc_class_copy;
4338 default:
4339 return reloc_class_normal;
4340 }
4341 }
4342
4343 /* Finish up the dynamic sections. */
4344
4345 static bfd_boolean
4346 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4347 struct bfd_link_info *info)
4348 {
4349 struct elf_x86_link_hash_table *htab;
4350
4351 htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
4352 if (htab == NULL)
4353 return FALSE;
4354
4355 if (! htab->elf.dynamic_sections_created)
4356 return TRUE;
4357
4358 if (htab->elf.splt && htab->elf.splt->size > 0)
4359 {
4360 elf_section_data (htab->elf.splt->output_section)
4361 ->this_hdr.sh_entsize = htab->plt.plt_entry_size;
4362
4363 if (htab->plt.has_plt0)
4364 {
4365 /* Fill in the special first entry in the procedure linkage
4366 table. */
4367 memcpy (htab->elf.splt->contents,
4368 htab->lazy_plt->plt0_entry,
4369 htab->lazy_plt->plt0_entry_size);
4370 /* Add offset for pushq GOT+8(%rip), since the instruction
4371 uses 6 bytes subtract this value. */
4372 bfd_put_32 (output_bfd,
4373 (htab->elf.sgotplt->output_section->vma
4374 + htab->elf.sgotplt->output_offset
4375 + 8
4376 - htab->elf.splt->output_section->vma
4377 - htab->elf.splt->output_offset
4378 - 6),
4379 (htab->elf.splt->contents
4380 + htab->lazy_plt->plt0_got1_offset));
4381 /* Add offset for the PC-relative instruction accessing
4382 GOT+16, subtracting the offset to the end of that
4383 instruction. */
4384 bfd_put_32 (output_bfd,
4385 (htab->elf.sgotplt->output_section->vma
4386 + htab->elf.sgotplt->output_offset
4387 + 16
4388 - htab->elf.splt->output_section->vma
4389 - htab->elf.splt->output_offset
4390 - htab->lazy_plt->plt0_got2_insn_end),
4391 (htab->elf.splt->contents
4392 + htab->lazy_plt->plt0_got2_offset));
4393 }
4394
4395 if (htab->tlsdesc_plt)
4396 {
4397 bfd_put_64 (output_bfd, (bfd_vma) 0,
4398 htab->elf.sgot->contents + htab->tlsdesc_got);
4399
4400 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4401 htab->lazy_plt->plt0_entry,
4402 htab->lazy_plt->plt0_entry_size);
4403
4404 /* Add offset for pushq GOT+8(%rip), since the
4405 instruction uses 6 bytes subtract this value. */
4406 bfd_put_32 (output_bfd,
4407 (htab->elf.sgotplt->output_section->vma
4408 + htab->elf.sgotplt->output_offset
4409 + 8
4410 - htab->elf.splt->output_section->vma
4411 - htab->elf.splt->output_offset
4412 - htab->tlsdesc_plt
4413 - 6),
4414 (htab->elf.splt->contents
4415 + htab->tlsdesc_plt
4416 + htab->lazy_plt->plt0_got1_offset));
4417 /* Add offset for the PC-relative instruction accessing
4418 GOT+TDG, where TDG stands for htab->tlsdesc_got,
4419 subtracting the offset to the end of that
4420 instruction. */
4421 bfd_put_32 (output_bfd,
4422 (htab->elf.sgot->output_section->vma
4423 + htab->elf.sgot->output_offset
4424 + htab->tlsdesc_got
4425 - htab->elf.splt->output_section->vma
4426 - htab->elf.splt->output_offset
4427 - htab->tlsdesc_plt
4428 - htab->lazy_plt->plt0_got2_insn_end),
4429 (htab->elf.splt->contents
4430 + htab->tlsdesc_plt
4431 + htab->lazy_plt->plt0_got2_offset));
4432 }
4433 }
4434
4435 /* Fill PLT entries for undefined weak symbols in PIE. */
4436 if (bfd_link_pie (info))
4437 bfd_hash_traverse (&info->hash->table,
4438 elf_x86_64_pie_finish_undefweak_symbol,
4439 info);
4440
4441 return TRUE;
4442 }
4443
4444 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4445 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4446 It has to be done before elf_link_sort_relocs is called so that
4447 dynamic relocations are properly sorted. */
4448
4449 static bfd_boolean
4450 elf_x86_64_output_arch_local_syms
4451 (bfd *output_bfd ATTRIBUTE_UNUSED,
4452 struct bfd_link_info *info,
4453 void *flaginfo ATTRIBUTE_UNUSED,
4454 int (*func) (void *, const char *,
4455 Elf_Internal_Sym *,
4456 asection *,
4457 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4458 {
4459 struct elf_x86_link_hash_table *htab
4460 = elf_x86_hash_table (info, X86_64_ELF_DATA);
4461 if (htab == NULL)
4462 return FALSE;
4463
4464 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4465 htab_traverse (htab->loc_hash_table,
4466 elf_x86_64_finish_local_dynamic_symbol,
4467 info);
4468
4469 return TRUE;
4470 }
4471
4472 /* Forward declaration. */
4473 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt;
4474
4475 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
4476 dynamic relocations. */
4477
4478 static long
4479 elf_x86_64_get_synthetic_symtab (bfd *abfd,
4480 long symcount ATTRIBUTE_UNUSED,
4481 asymbol **syms ATTRIBUTE_UNUSED,
4482 long dynsymcount,
4483 asymbol **dynsyms,
4484 asymbol **ret)
4485 {
4486 long count, i, n;
4487 int j;
4488 bfd_byte *plt_contents;
4489 long relsize;
4490 const struct elf_x86_lazy_plt_layout *lazy_plt;
4491 const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4492 const struct elf_x86_lazy_plt_layout *lazy_bnd_plt;
4493 const struct elf_x86_non_lazy_plt_layout *non_lazy_bnd_plt;
4494 const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4495 const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4496 asection *plt;
4497 enum elf_x86_plt_type plt_type;
4498 struct elf_x86_plt plts[] =
4499 {
4500 { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4501 { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4502 { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4503 { ".plt.bnd", NULL, NULL, plt_second, 0, 0, 0, 0 },
4504 { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4505 };
4506
4507 *ret = NULL;
4508
4509 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4510 return 0;
4511
4512 if (dynsymcount <= 0)
4513 return 0;
4514
4515 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4516 if (relsize <= 0)
4517 return -1;
4518
4519 if (get_elf_x86_backend_data (abfd)->target_os == is_normal)
4520 {
4521 lazy_plt = &elf_x86_64_lazy_plt;
4522 non_lazy_plt = &elf_x86_64_non_lazy_plt;
4523 lazy_bnd_plt = &elf_x86_64_lazy_bnd_plt;
4524 non_lazy_bnd_plt = &elf_x86_64_non_lazy_bnd_plt;
4525 if (ABI_64_P (abfd))
4526 {
4527 lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4528 non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4529 }
4530 else
4531 {
4532 lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4533 non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4534 }
4535 }
4536 else
4537 {
4538 lazy_plt = &elf_x86_64_nacl_plt;
4539 non_lazy_plt = NULL;
4540 lazy_bnd_plt = NULL;
4541 non_lazy_bnd_plt = NULL;
4542 lazy_ibt_plt = NULL;
4543 non_lazy_ibt_plt = NULL;
4544 }
4545
4546 count = 0;
4547 for (j = 0; plts[j].name != NULL; j++)
4548 {
4549 plt = bfd_get_section_by_name (abfd, plts[j].name);
4550 if (plt == NULL || plt->size == 0)
4551 continue;
4552
4553 /* Get the PLT section contents. */
4554 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4555 if (plt_contents == NULL)
4556 break;
4557 if (!bfd_get_section_contents (abfd, (asection *) plt,
4558 plt_contents, 0, plt->size))
4559 {
4560 free (plt_contents);
4561 break;
4562 }
4563
4564 /* Check what kind of PLT it is. */
4565 plt_type = plt_unknown;
4566 if (plts[j].type == plt_unknown
4567 && (plt->size >= (lazy_plt->plt_entry_size
4568 + lazy_plt->plt_entry_size)))
4569 {
4570 /* Match lazy PLT first. Need to check the first two
4571 instructions. */
4572 if ((memcmp (plt_contents, lazy_plt->plt0_entry,
4573 lazy_plt->plt0_got1_offset) == 0)
4574 && (memcmp (plt_contents + 6, lazy_plt->plt0_entry + 6,
4575 2) == 0))
4576 plt_type = plt_lazy;
4577 else if (lazy_bnd_plt != NULL
4578 && (memcmp (plt_contents, lazy_bnd_plt->plt0_entry,
4579 lazy_bnd_plt->plt0_got1_offset) == 0)
4580 && (memcmp (plt_contents + 6,
4581 lazy_bnd_plt->plt0_entry + 6, 3) == 0))
4582 {
4583 plt_type = plt_lazy | plt_second;
4584 /* The fist entry in the lazy IBT PLT is the same as the
4585 lazy BND PLT. */
4586 if ((memcmp (plt_contents + lazy_ibt_plt->plt_entry_size,
4587 lazy_ibt_plt->plt_entry,
4588 lazy_ibt_plt->plt_got_offset) == 0))
4589 lazy_plt = lazy_ibt_plt;
4590 else
4591 lazy_plt = lazy_bnd_plt;
4592 }
4593 }
4594
4595 if (non_lazy_plt != NULL
4596 && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4597 && plt->size >= non_lazy_plt->plt_entry_size)
4598 {
4599 /* Match non-lazy PLT. */
4600 if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4601 non_lazy_plt->plt_got_offset) == 0)
4602 plt_type = plt_non_lazy;
4603 }
4604
4605 if (plt_type == plt_unknown || plt_type == plt_second)
4606 {
4607 if (non_lazy_bnd_plt != NULL
4608 && plt->size >= non_lazy_bnd_plt->plt_entry_size
4609 && (memcmp (plt_contents, non_lazy_bnd_plt->plt_entry,
4610 non_lazy_bnd_plt->plt_got_offset) == 0))
4611 {
4612 /* Match BND PLT. */
4613 plt_type = plt_second;
4614 non_lazy_plt = non_lazy_bnd_plt;
4615 }
4616 else if (non_lazy_ibt_plt != NULL
4617 && plt->size >= non_lazy_ibt_plt->plt_entry_size
4618 && (memcmp (plt_contents,
4619 non_lazy_ibt_plt->plt_entry,
4620 non_lazy_ibt_plt->plt_got_offset) == 0))
4621 {
4622 /* Match IBT PLT. */
4623 plt_type = plt_second;
4624 non_lazy_plt = non_lazy_ibt_plt;
4625 }
4626 }
4627
4628 if (plt_type == plt_unknown)
4629 {
4630 free (plt_contents);
4631 continue;
4632 }
4633
4634 plts[j].sec = plt;
4635 plts[j].type = plt_type;
4636
4637 if ((plt_type & plt_lazy))
4638 {
4639 plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4640 plts[j].plt_got_insn_size = lazy_plt->plt_got_insn_size;
4641 plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4642 /* Skip PLT0 in lazy PLT. */
4643 i = 1;
4644 }
4645 else
4646 {
4647 plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4648 plts[j].plt_got_insn_size = non_lazy_plt->plt_got_insn_size;
4649 plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4650 i = 0;
4651 }
4652
4653 /* Skip lazy PLT when the second PLT is used. */
4654 if (plt_type == (plt_lazy | plt_second))
4655 plts[j].count = 0;
4656 else
4657 {
4658 n = plt->size / plts[j].plt_entry_size;
4659 plts[j].count = n;
4660 count += n - i;
4661 }
4662
4663 plts[j].contents = plt_contents;
4664 }
4665
4666 return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4667 (bfd_vma) 0, plts, dynsyms,
4668 ret);
4669 }
4670
4671 /* Handle an x86-64 specific section when reading an object file. This
4672 is called when elfcode.h finds a section with an unknown type. */
4673
4674 static bfd_boolean
4675 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
4676 const char *name, int shindex)
4677 {
4678 if (hdr->sh_type != SHT_X86_64_UNWIND)
4679 return FALSE;
4680
4681 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4682 return FALSE;
4683
4684 return TRUE;
4685 }
4686
4687 /* Hook called by the linker routine which adds symbols from an object
4688 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4689 of .bss. */
4690
4691 static bfd_boolean
4692 elf_x86_64_add_symbol_hook (bfd *abfd,
4693 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4694 Elf_Internal_Sym *sym,
4695 const char **namep ATTRIBUTE_UNUSED,
4696 flagword *flagsp ATTRIBUTE_UNUSED,
4697 asection **secp,
4698 bfd_vma *valp)
4699 {
4700 asection *lcomm;
4701
4702 switch (sym->st_shndx)
4703 {
4704 case SHN_X86_64_LCOMMON:
4705 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4706 if (lcomm == NULL)
4707 {
4708 lcomm = bfd_make_section_with_flags (abfd,
4709 "LARGE_COMMON",
4710 (SEC_ALLOC
4711 | SEC_IS_COMMON
4712 | SEC_LINKER_CREATED));
4713 if (lcomm == NULL)
4714 return FALSE;
4715 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4716 }
4717 *secp = lcomm;
4718 *valp = sym->st_size;
4719 return TRUE;
4720 }
4721
4722 return TRUE;
4723 }
4724
4725
4726 /* Given a BFD section, try to locate the corresponding ELF section
4727 index. */
4728
4729 static bfd_boolean
4730 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4731 asection *sec, int *index_return)
4732 {
4733 if (sec == &_bfd_elf_large_com_section)
4734 {
4735 *index_return = SHN_X86_64_LCOMMON;
4736 return TRUE;
4737 }
4738 return FALSE;
4739 }
4740
4741 /* Process a symbol. */
4742
4743 static void
4744 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4745 asymbol *asym)
4746 {
4747 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4748
4749 switch (elfsym->internal_elf_sym.st_shndx)
4750 {
4751 case SHN_X86_64_LCOMMON:
4752 asym->section = &_bfd_elf_large_com_section;
4753 asym->value = elfsym->internal_elf_sym.st_size;
4754 /* Common symbol doesn't set BSF_GLOBAL. */
4755 asym->flags &= ~BSF_GLOBAL;
4756 break;
4757 }
4758 }
4759
4760 static bfd_boolean
4761 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4762 {
4763 return (sym->st_shndx == SHN_COMMON
4764 || sym->st_shndx == SHN_X86_64_LCOMMON);
4765 }
4766
4767 static unsigned int
4768 elf_x86_64_common_section_index (asection *sec)
4769 {
4770 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4771 return SHN_COMMON;
4772 else
4773 return SHN_X86_64_LCOMMON;
4774 }
4775
4776 static asection *
4777 elf_x86_64_common_section (asection *sec)
4778 {
4779 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4780 return bfd_com_section_ptr;
4781 else
4782 return &_bfd_elf_large_com_section;
4783 }
4784
4785 static bfd_boolean
4786 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
4787 const Elf_Internal_Sym *sym,
4788 asection **psec,
4789 bfd_boolean newdef,
4790 bfd_boolean olddef,
4791 bfd *oldbfd,
4792 const asection *oldsec)
4793 {
4794 /* A normal common symbol and a large common symbol result in a
4795 normal common symbol. We turn the large common symbol into a
4796 normal one. */
4797 if (!olddef
4798 && h->root.type == bfd_link_hash_common
4799 && !newdef
4800 && bfd_is_com_section (*psec)
4801 && oldsec != *psec)
4802 {
4803 if (sym->st_shndx == SHN_COMMON
4804 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
4805 {
4806 h->root.u.c.p->section
4807 = bfd_make_section_old_way (oldbfd, "COMMON");
4808 h->root.u.c.p->section->flags = SEC_ALLOC;
4809 }
4810 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4811 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
4812 *psec = bfd_com_section_ptr;
4813 }
4814
4815 return TRUE;
4816 }
4817
4818 static int
4819 elf_x86_64_additional_program_headers (bfd *abfd,
4820 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4821 {
4822 asection *s;
4823 int count = 0;
4824
4825 /* Check to see if we need a large readonly segment. */
4826 s = bfd_get_section_by_name (abfd, ".lrodata");
4827 if (s && (s->flags & SEC_LOAD))
4828 count++;
4829
4830 /* Check to see if we need a large data segment. Since .lbss sections
4831 is placed right after the .bss section, there should be no need for
4832 a large data segment just because of .lbss. */
4833 s = bfd_get_section_by_name (abfd, ".ldata");
4834 if (s && (s->flags & SEC_LOAD))
4835 count++;
4836
4837 return count;
4838 }
4839
4840 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4841
4842 static bfd_boolean
4843 elf_x86_64_relocs_compatible (const bfd_target *input,
4844 const bfd_target *output)
4845 {
4846 return ((xvec_get_elf_backend_data (input)->s->elfclass
4847 == xvec_get_elf_backend_data (output)->s->elfclass)
4848 && _bfd_elf_relocs_compatible (input, output));
4849 }
4850
4851 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
4852 with GNU properties if found. Otherwise, return NULL. */
4853
4854 static bfd *
4855 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
4856 {
4857 struct elf_x86_init_table init_table;
4858
4859 if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit
4860 || (int) R_X86_64_max <= (int) R_X86_64_converted_reloc_bit
4861 || ((int) (R_X86_64_GNU_VTINHERIT | R_X86_64_converted_reloc_bit)
4862 != (int) R_X86_64_GNU_VTINHERIT)
4863 || ((int) (R_X86_64_GNU_VTENTRY | R_X86_64_converted_reloc_bit)
4864 != (int) R_X86_64_GNU_VTENTRY))
4865 abort ();
4866
4867 /* This is unused for x86-64. */
4868 init_table.plt0_pad_byte = 0x90;
4869
4870 if (get_elf_x86_backend_data (info->output_bfd)->target_os
4871 == is_normal)
4872 {
4873 if (info->bndplt)
4874 {
4875 init_table.lazy_plt = &elf_x86_64_lazy_bnd_plt;
4876 init_table.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt;
4877 }
4878 else
4879 {
4880 init_table.lazy_plt = &elf_x86_64_lazy_plt;
4881 init_table.non_lazy_plt = &elf_x86_64_non_lazy_plt;
4882 }
4883
4884 if (ABI_64_P (info->output_bfd))
4885 {
4886 init_table.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4887 init_table.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4888 }
4889 else
4890 {
4891 init_table.lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4892 init_table.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4893 }
4894 }
4895 else
4896 {
4897 init_table.lazy_plt = &elf_x86_64_nacl_plt;
4898 init_table.non_lazy_plt = NULL;
4899 init_table.lazy_ibt_plt = NULL;
4900 init_table.non_lazy_ibt_plt = NULL;
4901 }
4902
4903 if (ABI_64_P (info->output_bfd))
4904 {
4905 init_table.r_info = elf64_r_info;
4906 init_table.r_sym = elf64_r_sym;
4907 }
4908 else
4909 {
4910 init_table.r_info = elf32_r_info;
4911 init_table.r_sym = elf32_r_sym;
4912 }
4913
4914 return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4915 }
4916
4917 static const struct bfd_elf_special_section
4918 elf_x86_64_special_sections[]=
4919 {
4920 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4921 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4922 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4923 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4924 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4925 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4926 { NULL, 0, 0, 0, 0 }
4927 };
4928
4929 #define TARGET_LITTLE_SYM x86_64_elf64_vec
4930 #define TARGET_LITTLE_NAME "elf64-x86-64"
4931 #define ELF_ARCH bfd_arch_i386
4932 #define ELF_TARGET_ID X86_64_ELF_DATA
4933 #define ELF_MACHINE_CODE EM_X86_64
4934 #define ELF_MAXPAGESIZE 0x200000
4935 #define ELF_MINPAGESIZE 0x1000
4936 #define ELF_COMMONPAGESIZE 0x1000
4937
4938 #define elf_backend_can_gc_sections 1
4939 #define elf_backend_can_refcount 1
4940 #define elf_backend_want_got_plt 1
4941 #define elf_backend_plt_readonly 1
4942 #define elf_backend_want_plt_sym 0
4943 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4944 #define elf_backend_rela_normal 1
4945 #define elf_backend_plt_alignment 4
4946 #define elf_backend_extern_protected_data 1
4947 #define elf_backend_caches_rawsize 1
4948 #define elf_backend_dtrel_excludes_plt 1
4949 #define elf_backend_want_dynrelro 1
4950
4951 #define elf_info_to_howto elf_x86_64_info_to_howto
4952
4953 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4954 #define bfd_elf64_bfd_reloc_name_lookup \
4955 elf_x86_64_reloc_name_lookup
4956
4957 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4958 #define elf_backend_check_relocs elf_x86_64_check_relocs
4959 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
4960 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4961 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4962 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
4963 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4964 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4965 #ifdef CORE_HEADER
4966 #define elf_backend_write_core_note elf_x86_64_write_core_note
4967 #endif
4968 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4969 #define elf_backend_relocate_section elf_x86_64_relocate_section
4970 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4971 #define elf_backend_object_p elf64_x86_64_elf_object_p
4972 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
4973
4974 #define elf_backend_section_from_shdr \
4975 elf_x86_64_section_from_shdr
4976
4977 #define elf_backend_section_from_bfd_section \
4978 elf_x86_64_elf_section_from_bfd_section
4979 #define elf_backend_add_symbol_hook \
4980 elf_x86_64_add_symbol_hook
4981 #define elf_backend_symbol_processing \
4982 elf_x86_64_symbol_processing
4983 #define elf_backend_common_section_index \
4984 elf_x86_64_common_section_index
4985 #define elf_backend_common_section \
4986 elf_x86_64_common_section
4987 #define elf_backend_common_definition \
4988 elf_x86_64_common_definition
4989 #define elf_backend_merge_symbol \
4990 elf_x86_64_merge_symbol
4991 #define elf_backend_special_sections \
4992 elf_x86_64_special_sections
4993 #define elf_backend_additional_program_headers \
4994 elf_x86_64_additional_program_headers
4995 #define elf_backend_setup_gnu_properties \
4996 elf_x86_64_link_setup_gnu_properties
4997 #define elf_backend_hide_symbol \
4998 _bfd_x86_elf_hide_symbol
4999
5000 #include "elf64-target.h"
5001
5002 /* CloudABI support. */
5003
5004 #undef TARGET_LITTLE_SYM
5005 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
5006 #undef TARGET_LITTLE_NAME
5007 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
5008
5009 #undef ELF_OSABI
5010 #define ELF_OSABI ELFOSABI_CLOUDABI
5011
5012 #undef elf64_bed
5013 #define elf64_bed elf64_x86_64_cloudabi_bed
5014
5015 #include "elf64-target.h"
5016
5017 /* FreeBSD support. */
5018
5019 #undef TARGET_LITTLE_SYM
5020 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5021 #undef TARGET_LITTLE_NAME
5022 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5023
5024 #undef ELF_OSABI
5025 #define ELF_OSABI ELFOSABI_FREEBSD
5026
5027 #undef elf64_bed
5028 #define elf64_bed elf64_x86_64_fbsd_bed
5029
5030 #include "elf64-target.h"
5031
5032 /* Solaris 2 support. */
5033
5034 #undef TARGET_LITTLE_SYM
5035 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5036 #undef TARGET_LITTLE_NAME
5037 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5038
5039 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5040 objects won't be recognized. */
5041 #undef ELF_OSABI
5042
5043 #undef elf64_bed
5044 #define elf64_bed elf64_x86_64_sol2_bed
5045
5046 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5047 boundary. */
5048 #undef elf_backend_static_tls_alignment
5049 #define elf_backend_static_tls_alignment 16
5050
5051 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5052
5053 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5054 File, p.63. */
5055 #undef elf_backend_want_plt_sym
5056 #define elf_backend_want_plt_sym 1
5057
5058 #undef elf_backend_strtab_flags
5059 #define elf_backend_strtab_flags SHF_STRINGS
5060
5061 static bfd_boolean
5062 elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5063 bfd *obfd ATTRIBUTE_UNUSED,
5064 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5065 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5066 {
5067 /* PR 19938: FIXME: Need to add code for setting the sh_info
5068 and sh_link fields of Solaris specific section types. */
5069 return FALSE;
5070 }
5071
5072 #undef elf_backend_copy_special_section_fields
5073 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
5074
5075 #include "elf64-target.h"
5076
5077 /* Native Client support. */
5078
5079 static bfd_boolean
5080 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5081 {
5082 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5083 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5084 return TRUE;
5085 }
5086
5087 #undef TARGET_LITTLE_SYM
5088 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5089 #undef TARGET_LITTLE_NAME
5090 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5091 #undef elf64_bed
5092 #define elf64_bed elf64_x86_64_nacl_bed
5093
5094 #undef ELF_MAXPAGESIZE
5095 #undef ELF_MINPAGESIZE
5096 #undef ELF_COMMONPAGESIZE
5097 #define ELF_MAXPAGESIZE 0x10000
5098 #define ELF_MINPAGESIZE 0x10000
5099 #define ELF_COMMONPAGESIZE 0x10000
5100
5101 /* Restore defaults. */
5102 #undef ELF_OSABI
5103 #undef elf_backend_static_tls_alignment
5104 #undef elf_backend_want_plt_sym
5105 #define elf_backend_want_plt_sym 0
5106 #undef elf_backend_strtab_flags
5107 #undef elf_backend_copy_special_section_fields
5108
5109 /* NaCl uses substantially different PLT entries for the same effects. */
5110
5111 #undef elf_backend_plt_alignment
5112 #define elf_backend_plt_alignment 5
5113 #define NACL_PLT_ENTRY_SIZE 64
5114 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5115
5116 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5117 {
5118 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5119 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5120 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5121 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5122 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5123
5124 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5125 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5126
5127 /* 32 bytes of nop to pad out to the standard size. */
5128 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5129 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5130 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5131 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5132 0x66, /* excess data16 prefix */
5133 0x90 /* nop */
5134 };
5135
5136 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5137 {
5138 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5139 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5140 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5141 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5142
5143 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5144 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5145 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5146
5147 /* Lazy GOT entries point here (32-byte aligned). */
5148 0x68, /* pushq immediate */
5149 0, 0, 0, 0, /* replaced with index into relocation table. */
5150 0xe9, /* jmp relative */
5151 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5152
5153 /* 22 bytes of nop to pad out to the standard size. */
5154 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5155 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5156 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5157 };
5158
5159 /* .eh_frame covering the .plt section. */
5160
5161 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5162 {
5163 #if (PLT_CIE_LENGTH != 20 \
5164 || PLT_FDE_LENGTH != 36 \
5165 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5166 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5167 # error "Need elf_x86_backend_data parameters for eh_frame_plt offsets!"
5168 #endif
5169 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5170 0, 0, 0, 0, /* CIE ID */
5171 1, /* CIE version */
5172 'z', 'R', 0, /* Augmentation string */
5173 1, /* Code alignment factor */
5174 0x78, /* Data alignment factor */
5175 16, /* Return address column */
5176 1, /* Augmentation size */
5177 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5178 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5179 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5180 DW_CFA_nop, DW_CFA_nop,
5181
5182 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5183 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5184 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5185 0, 0, 0, 0, /* .plt size goes here */
5186 0, /* Augmentation size */
5187 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5188 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5189 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5190 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5191 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5192 13, /* Block length */
5193 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5194 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5195 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5196 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5197 DW_CFA_nop, DW_CFA_nop
5198 };
5199
5200 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt =
5201 {
5202 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5203 NACL_PLT_ENTRY_SIZE, /* plt0_entry_size */
5204 elf_x86_64_nacl_plt_entry, /* plt_entry */
5205 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5206 2, /* plt0_got1_offset */
5207 9, /* plt0_got2_offset */
5208 13, /* plt0_got2_insn_end */
5209 3, /* plt_got_offset */
5210 33, /* plt_reloc_offset */
5211 38, /* plt_plt_offset */
5212 7, /* plt_got_insn_size */
5213 42, /* plt_plt_insn_end */
5214 32, /* plt_lazy_offset */
5215 elf_x86_64_nacl_plt0_entry, /* pic_plt0_entry */
5216 elf_x86_64_nacl_plt_entry, /* pic_plt_entry */
5217 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5218 sizeof (elf_x86_64_nacl_eh_frame_plt) /* eh_frame_plt_size */
5219 };
5220
5221 static const struct elf_x86_backend_data elf_x86_64_nacl_arch_bed =
5222 {
5223 is_nacl /* os */
5224 };
5225
5226 #undef elf_backend_arch_data
5227 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5228
5229 #undef elf_backend_object_p
5230 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5231 #undef elf_backend_modify_segment_map
5232 #define elf_backend_modify_segment_map nacl_modify_segment_map
5233 #undef elf_backend_modify_program_headers
5234 #define elf_backend_modify_program_headers nacl_modify_program_headers
5235 #undef elf_backend_final_write_processing
5236 #define elf_backend_final_write_processing nacl_final_write_processing
5237
5238 #include "elf64-target.h"
5239
5240 /* Native Client x32 support. */
5241
5242 static bfd_boolean
5243 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5244 {
5245 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5246 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5247 return TRUE;
5248 }
5249
5250 #undef TARGET_LITTLE_SYM
5251 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5252 #undef TARGET_LITTLE_NAME
5253 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5254 #undef elf32_bed
5255 #define elf32_bed elf32_x86_64_nacl_bed
5256
5257 #define bfd_elf32_bfd_reloc_type_lookup \
5258 elf_x86_64_reloc_type_lookup
5259 #define bfd_elf32_bfd_reloc_name_lookup \
5260 elf_x86_64_reloc_name_lookup
5261 #define bfd_elf32_get_synthetic_symtab \
5262 elf_x86_64_get_synthetic_symtab
5263
5264 #undef elf_backend_object_p
5265 #define elf_backend_object_p \
5266 elf32_x86_64_nacl_elf_object_p
5267
5268 #undef elf_backend_bfd_from_remote_memory
5269 #define elf_backend_bfd_from_remote_memory \
5270 _bfd_elf32_bfd_from_remote_memory
5271
5272 #undef elf_backend_size_info
5273 #define elf_backend_size_info \
5274 _bfd_elf32_size_info
5275
5276 #include "elf32-target.h"
5277
5278 /* Restore defaults. */
5279 #undef elf_backend_object_p
5280 #define elf_backend_object_p elf64_x86_64_elf_object_p
5281 #undef elf_backend_bfd_from_remote_memory
5282 #undef elf_backend_size_info
5283 #undef elf_backend_modify_segment_map
5284 #undef elf_backend_modify_program_headers
5285 #undef elf_backend_final_write_processing
5286
5287 /* Intel L1OM support. */
5288
5289 static bfd_boolean
5290 elf64_l1om_elf_object_p (bfd *abfd)
5291 {
5292 /* Set the right machine number for an L1OM elf64 file. */
5293 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5294 return TRUE;
5295 }
5296
5297 #undef TARGET_LITTLE_SYM
5298 #define TARGET_LITTLE_SYM l1om_elf64_vec
5299 #undef TARGET_LITTLE_NAME
5300 #define TARGET_LITTLE_NAME "elf64-l1om"
5301 #undef ELF_ARCH
5302 #define ELF_ARCH bfd_arch_l1om
5303
5304 #undef ELF_MACHINE_CODE
5305 #define ELF_MACHINE_CODE EM_L1OM
5306
5307 #undef ELF_OSABI
5308
5309 #undef elf64_bed
5310 #define elf64_bed elf64_l1om_bed
5311
5312 #undef elf_backend_object_p
5313 #define elf_backend_object_p elf64_l1om_elf_object_p
5314
5315 /* Restore defaults. */
5316 #undef ELF_MAXPAGESIZE
5317 #undef ELF_MINPAGESIZE
5318 #undef ELF_COMMONPAGESIZE
5319 #define ELF_MAXPAGESIZE 0x200000
5320 #define ELF_MINPAGESIZE 0x1000
5321 #define ELF_COMMONPAGESIZE 0x1000
5322 #undef elf_backend_plt_alignment
5323 #define elf_backend_plt_alignment 4
5324 #undef elf_backend_arch_data
5325 #define elf_backend_arch_data &elf_x86_64_arch_bed
5326
5327 #include "elf64-target.h"
5328
5329 /* FreeBSD L1OM support. */
5330
5331 #undef TARGET_LITTLE_SYM
5332 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
5333 #undef TARGET_LITTLE_NAME
5334 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5335
5336 #undef ELF_OSABI
5337 #define ELF_OSABI ELFOSABI_FREEBSD
5338
5339 #undef elf64_bed
5340 #define elf64_bed elf64_l1om_fbsd_bed
5341
5342 #include "elf64-target.h"
5343
5344 /* Intel K1OM support. */
5345
5346 static bfd_boolean
5347 elf64_k1om_elf_object_p (bfd *abfd)
5348 {
5349 /* Set the right machine number for an K1OM elf64 file. */
5350 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5351 return TRUE;
5352 }
5353
5354 #undef TARGET_LITTLE_SYM
5355 #define TARGET_LITTLE_SYM k1om_elf64_vec
5356 #undef TARGET_LITTLE_NAME
5357 #define TARGET_LITTLE_NAME "elf64-k1om"
5358 #undef ELF_ARCH
5359 #define ELF_ARCH bfd_arch_k1om
5360
5361 #undef ELF_MACHINE_CODE
5362 #define ELF_MACHINE_CODE EM_K1OM
5363
5364 #undef ELF_OSABI
5365
5366 #undef elf64_bed
5367 #define elf64_bed elf64_k1om_bed
5368
5369 #undef elf_backend_object_p
5370 #define elf_backend_object_p elf64_k1om_elf_object_p
5371
5372 #undef elf_backend_static_tls_alignment
5373
5374 #undef elf_backend_want_plt_sym
5375 #define elf_backend_want_plt_sym 0
5376
5377 #include "elf64-target.h"
5378
5379 /* FreeBSD K1OM support. */
5380
5381 #undef TARGET_LITTLE_SYM
5382 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
5383 #undef TARGET_LITTLE_NAME
5384 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5385
5386 #undef ELF_OSABI
5387 #define ELF_OSABI ELFOSABI_FREEBSD
5388
5389 #undef elf64_bed
5390 #define elf64_bed elf64_k1om_fbsd_bed
5391
5392 #include "elf64-target.h"
5393
5394 /* 32bit x86-64 support. */
5395
5396 #undef TARGET_LITTLE_SYM
5397 #define TARGET_LITTLE_SYM x86_64_elf32_vec
5398 #undef TARGET_LITTLE_NAME
5399 #define TARGET_LITTLE_NAME "elf32-x86-64"
5400 #undef elf32_bed
5401
5402 #undef ELF_ARCH
5403 #define ELF_ARCH bfd_arch_i386
5404
5405 #undef ELF_MACHINE_CODE
5406 #define ELF_MACHINE_CODE EM_X86_64
5407
5408 #undef ELF_OSABI
5409
5410 #undef elf_backend_object_p
5411 #define elf_backend_object_p \
5412 elf32_x86_64_elf_object_p
5413
5414 #undef elf_backend_bfd_from_remote_memory
5415 #define elf_backend_bfd_from_remote_memory \
5416 _bfd_elf32_bfd_from_remote_memory
5417
5418 #undef elf_backend_size_info
5419 #define elf_backend_size_info \
5420 _bfd_elf32_size_info
5421
5422 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.225928 seconds and 5 git commands to generate.