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