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