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