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