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