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