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