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