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