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