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