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