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