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