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