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