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