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