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