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