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