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