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