projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR ld/13909
[deliverable/binutils-gdb.git] / bfd / elf64-x86-64.c
CommitLineData
351f65ca 1/* X86-64 specific support for ELF
4dfe6ac6 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3ce231f8 3 2010, 2011, 2012
9f973f28 4 Free Software Foundation, Inc.
8d88c4ca
NC		 5 Contributed by Jan Hubicka <jh@suse.cz>.
6
ae9a127f 7 This file is part of BFD, the Binary File Descriptor library.
8d88c4ca 8
ae9a127f
NC		 9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
ae9a127f 12 (at your option) any later version.
8d88c4ca 13
ae9a127f
NC		 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
8d88c4ca 18
ae9a127f
NC		 19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
cd123cb7
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
8d88c4ca 23
8d88c4ca 24#include "sysdep.h"
3db64b00 25#include "bfd.h"
c434dee6 26#include "bfdlink.h"
8d88c4ca
NC		 27#include "libbfd.h"
28#include "elf-bfd.h"
5a68afcf 29#include "elf-nacl.h"
142411ca 30#include "bfd_stdint.h"
c25bc9fc
L		 31#include "objalloc.h"
32#include "hashtab.h"
e41b3a13 33#include "dwarf2.h"
d7921315 34#include "libiberty.h"
8d88c4ca
NC		 35
36#include "elf/x86-64.h"
37
8fd79e71
L		 38#ifdef CORE_HEADER
39#include <stdarg.h>
40#include CORE_HEADER
41#endif
42
8d88c4ca
NC		 43/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
44#define MINUS_ONE (~ (bfd_vma) 0)
45
351f65ca
L		 46/* Since both 32-bit and 64-bit x86-64 encode relocation type in the
47 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
48 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
49 since they are the same. */
50
51#define ABI_64_P(abfd) \
52 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53
8d88c4ca 54/* The relocation "howto" table. Order of fields:
7b81dfbb
AJ		 55 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
56 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
70256ad8
AJ		 57static reloc_howto_type x86_64_elf_howto_table[] =
58{
b34976b6
AM		 59 HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
60 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
61 FALSE),
62 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
64 FALSE),
65 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
66 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
67 TRUE),
68 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
69 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
70 FALSE),
71 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
72 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
73 TRUE),
74 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
75 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
76 FALSE),
77 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
79 MINUS_ONE, FALSE),
80 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
81 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
82 MINUS_ONE, FALSE),
83 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
85 MINUS_ONE, FALSE),
86 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
87 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
88 0xffffffff, TRUE),
89 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
90 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
91 FALSE),
92 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
93 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
94 FALSE),
95 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
b0360d8c 97 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
b34976b6 98 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
ac2aa337 99 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
b34976b6
AM		 100 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
101 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
102 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
103 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
105 MINUS_ONE, FALSE),
106 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
108 MINUS_ONE, FALSE),
109 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
110 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
111 MINUS_ONE, FALSE),
112 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
113 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
114 0xffffffff, TRUE),
115 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
116 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
117 0xffffffff, TRUE),
ac2aa337 118 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
b34976b6
AM		 119 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
120 0xffffffff, FALSE),
121 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
122 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
123 0xffffffff, TRUE),
124 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
125 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
126 0xffffffff, FALSE),
d6ab8113
JB		 127 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
129 TRUE),
130 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
131 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
132 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
133 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
134 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
135 FALSE, 0xffffffff, 0xffffffff, TRUE),
7b81dfbb
AJ		 136 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
137 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
138 FALSE),
139 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
140 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
141 MINUS_ONE, TRUE),
142 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
143 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
144 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
145 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
146 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
147 MINUS_ONE, FALSE),
148 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
149 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
150 MINUS_ONE, FALSE),
67a4f2b7
AO		 151 EMPTY_HOWTO (32),
152 EMPTY_HOWTO (33),
153 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
154 complain_overflow_bitfield, bfd_elf_generic_reloc,
155 "R_X86_64_GOTPC32_TLSDESC",
156 FALSE, 0xffffffff, 0xffffffff, TRUE),
157 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
158 complain_overflow_dont, bfd_elf_generic_reloc,
159 "R_X86_64_TLSDESC_CALL",
160 FALSE, 0, 0, FALSE),
161 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
162 complain_overflow_bitfield, bfd_elf_generic_reloc,
163 "R_X86_64_TLSDESC",
164 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
cbe950e9
L		 165 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
166 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
167 MINUS_ONE, FALSE),
64d25c44
L		 168 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
169 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
170 MINUS_ONE, FALSE),
fe4770f4 171
a33d77bc
JB		 172 /* We have a gap in the reloc numbers here.
173 R_X86_64_standard counts the number up to this point, and
174 R_X86_64_vt_offset is the value to subtract from a reloc type of
175 R_X86_64_GNU_VT* to form an index into this table. */
cbe950e9 176#define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
a33d77bc
JB		 177#define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
178
fe4770f4 179/* GNU extension to record C++ vtable hierarchy. */
b34976b6
AM		 180 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
181 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
fe4770f4
AJ		 182
183/* GNU extension to record C++ vtable member usage. */
b34976b6
AM		 184 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
185 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
d7921315
L		 186 FALSE),
187
188/* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
189 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
190 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
191 FALSE)
8d88c4ca
NC		 192};
193
d8045f23
NC		 194#define IS_X86_64_PCREL_TYPE(TYPE) \
195 ( ((TYPE) == R_X86_64_PC8) \
196 || ((TYPE) == R_X86_64_PC16) \
197 || ((TYPE) == R_X86_64_PC32) \
198 || ((TYPE) == R_X86_64_PC64))
199
8d88c4ca 200/* Map BFD relocs to the x86_64 elf relocs. */
70256ad8
AJ		 201struct elf_reloc_map
202{
8d88c4ca
NC		 203 bfd_reloc_code_real_type bfd_reloc_val;
204 unsigned char elf_reloc_val;
205};
206
dc810e39 207static const struct elf_reloc_map x86_64_reloc_map[] =
8d88c4ca 208{
70256ad8
AJ		 209 { BFD_RELOC_NONE, R_X86_64_NONE, },
210 { BFD_RELOC_64, R_X86_64_64, },
211 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
212 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
213 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
214 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
215 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
216 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
217 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
218 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
219 { BFD_RELOC_32, R_X86_64_32, },
220 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
221 { BFD_RELOC_16, R_X86_64_16, },
222 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
223 { BFD_RELOC_8, R_X86_64_8, },
224 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
bffbf940
JJ		 225 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
226 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
227 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
228 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
229 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
230 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
231 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
232 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
d6ab8113
JB		 233 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
234 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
235 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
7b81dfbb
AJ		 236 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
237 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
238 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
239 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
240 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
67a4f2b7
AO		 241 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
242 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
243 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
cbe950e9 244 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
fe4770f4
AJ		 245 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
246 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
8d88c4ca
NC		 247};
248
67a4f2b7 249static reloc_howto_type *
351f65ca 250elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
67a4f2b7
AO		 251{
252 unsigned i;
253
d7921315
L		 254 if (r_type == (unsigned int) R_X86_64_32)
255 {
256 if (ABI_64_P (abfd))
257 i = r_type;
258 else
259 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
260 }
261 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
262 || r_type >= (unsigned int) R_X86_64_max)
67a4f2b7
AO		 263 {
264 if (r_type >= (unsigned int) R_X86_64_standard)
265 {
266 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
267 abfd, (int) r_type);
268 r_type = R_X86_64_NONE;
269 }
270 i = r_type;
271 }
272 else
273 i = r_type - (unsigned int) R_X86_64_vt_offset;
274 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
275 return &x86_64_elf_howto_table[i];
276}
8d88c4ca
NC		 277
278/* Given a BFD reloc type, return a HOWTO structure. */
279static reloc_howto_type *
351f65ca
L		 280elf_x86_64_reloc_type_lookup (bfd *abfd,
281 bfd_reloc_code_real_type code)
8d88c4ca
NC		 282{
283 unsigned int i;
27482721 284
8d88c4ca
NC		 285 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
286 i++)
287 {
288 if (x86_64_reloc_map[i].bfd_reloc_val == code)
351f65ca
L		 289 return elf_x86_64_rtype_to_howto (abfd,
290 x86_64_reloc_map[i].elf_reloc_val);
8d88c4ca
NC		 291 }
292 return 0;
293}
294
157090f7 295static reloc_howto_type *
d7921315 296elf_x86_64_reloc_name_lookup (bfd *abfd,
351f65ca 297 const char *r_name)
157090f7
AM		 298{
299 unsigned int i;
300
d7921315
L		 301 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
302 {
303 /* Get x32 R_X86_64_32. */
304 reloc_howto_type *reloc
305 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
306 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
307 return reloc;
308 }
309
310 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
157090f7
AM		 311 if (x86_64_elf_howto_table[i].name != NULL
312 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
313 return &x86_64_elf_howto_table[i];
314
315 return NULL;
316}
317
8d88c4ca 318/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
8da6118f 319
8d88c4ca 320static void
351f65ca
L		 321elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
322 Elf_Internal_Rela *dst)
8d88c4ca 323{
67a4f2b7 324 unsigned r_type;
8d88c4ca 325
351f65ca
L		 326 r_type = ELF32_R_TYPE (dst->r_info);
327 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
8d88c4ca
NC		 328 BFD_ASSERT (r_type == cache_ptr->howto->type);
329}
70256ad8 330\f
3bab7989 331/* Support for core dump NOTE sections. */
b34976b6 332static bfd_boolean
351f65ca 333elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 334{
335 int offset;
eea6121a 336 size_t size;
3bab7989
ML		 337
338 switch (note->descsz)
339 {
340 default:
b34976b6 341 return FALSE;
3bab7989 342
bcd823f1
L		 343 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
344 /* pr_cursig */
345 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
346
347 /* pr_pid */
348 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
349
350 /* pr_reg */
351 offset = 72;
352 size = 216;
353
354 break;
355
3bab7989
ML		 356 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
357 /* pr_cursig */
cedb70c5 358 elf_tdata (abfd)->core_signal
3bab7989
ML		 359 = bfd_get_16 (abfd, note->descdata + 12);
360
361 /* pr_pid */
261b8d08 362 elf_tdata (abfd)->core_lwpid
3bab7989
ML		 363 = bfd_get_32 (abfd, note->descdata + 32);
364
365 /* pr_reg */
366 offset = 112;
eea6121a 367 size = 216;
3bab7989
ML		 368
369 break;
370 }
371
372 /* Make a ".reg/999" section. */
373 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 374 size, note->descpos + offset);
3bab7989
ML		 375}
376
b34976b6 377static bfd_boolean
351f65ca 378elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 379{
380 switch (note->descsz)
381 {
382 default:
b34976b6 383 return FALSE;
3bab7989 384
bcd823f1
L		 385 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
386 elf_tdata (abfd)->core_pid
387 = bfd_get_32 (abfd, note->descdata + 12);
388 elf_tdata (abfd)->core_program
389 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
390 elf_tdata (abfd)->core_command
391 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
392 break;
393
3bab7989 394 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
261b8d08
PA		 395 elf_tdata (abfd)->core_pid
396 = bfd_get_32 (abfd, note->descdata + 24);
3bab7989
ML		 397 elf_tdata (abfd)->core_program
398 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
399 elf_tdata (abfd)->core_command
400 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
401 }
402
403 /* Note that for some reason, a spurious space is tacked
404 onto the end of the args in some (at least one anyway)
405 implementations, so strip it off if it exists. */
406
407 {
408 char *command = elf_tdata (abfd)->core_command;
409 int n = strlen (command);
410
411 if (0 < n && command[n - 1] == ' ')
412 command[n - 1] = '\0';
413 }
414
b34976b6 415 return TRUE;
3bab7989 416}
8fd79e71
L		 417
418#ifdef CORE_HEADER
419static char *
420elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
421 int note_type, ...)
422{
423 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8fd79e71
L		 424 va_list ap;
425 const char *fname, *psargs;
426 long pid;
427 int cursig;
428 const void *gregs;
429
430 switch (note_type)
431 {
432 default:
433 return NULL;
434
435 case NT_PRPSINFO:
436 va_start (ap, note_type);
437 fname = va_arg (ap, const char *);
438 psargs = va_arg (ap, const char *);
439 va_end (ap);
440
441 if (bed->s->elfclass == ELFCLASS32)
442 {
443 prpsinfo32_t data;
444 memset (&data, 0, sizeof (data));
445 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
446 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
e85c6a70
JK		 447 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
448 &data, sizeof (data));
8fd79e71
L		 449 }
450 else
451 {
452 prpsinfo_t data;
453 memset (&data, 0, sizeof (data));
454 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
455 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
e85c6a70
JK		 456 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
457 &data, sizeof (data));
8fd79e71 458 }
e85c6a70 459 /* NOTREACHED */
8fd79e71
L		 460
461 case NT_PRSTATUS:
462 va_start (ap, note_type);
463 pid = va_arg (ap, long);
464 cursig = va_arg (ap, int);
465 gregs = va_arg (ap, const void *);
466 va_end (ap);
467
468 if (bed->s->elfclass == ELFCLASS32)
469 {
470 if (bed->elf_machine_code == EM_X86_64)
471 {
472 prstatusx32_t prstat;
473 memset (&prstat, 0, sizeof (prstat));
474 prstat.pr_pid = pid;
475 prstat.pr_cursig = cursig;
476 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 477 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
478 &prstat, sizeof (prstat));
8fd79e71
L		 479 }
480 else
481 {
482 prstatus32_t prstat;
483 memset (&prstat, 0, sizeof (prstat));
484 prstat.pr_pid = pid;
485 prstat.pr_cursig = cursig;
486 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 487 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
488 &prstat, sizeof (prstat));
8fd79e71
L		 489 }
490 }
491 else
492 {
493 prstatus_t prstat;
494 memset (&prstat, 0, sizeof (prstat));
495 prstat.pr_pid = pid;
496 prstat.pr_cursig = cursig;
497 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 498 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
499 &prstat, sizeof (prstat));
8fd79e71 500 }
8fd79e71 501 }
e85c6a70 502 /* NOTREACHED */
8fd79e71
L		 503}
504#endif
3bab7989 505\f
407443a3 506/* Functions for the x86-64 ELF linker. */
70256ad8 507
407443a3 508/* The name of the dynamic interpreter. This is put in the .interp
70256ad8
AJ		 509 section. */
510
351f65ca 511#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
eec9dd95 512#define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
70256ad8 513
d40d037c
AJ		 514/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
515 copying dynamic variables from a shared lib into an app's dynbss
516 section, and instead use a dynamic relocation to point into the
517 shared lib. */
518#define ELIMINATE_COPY_RELOCS 1
519
70256ad8
AJ		 520/* The size in bytes of an entry in the global offset table. */
521
522#define GOT_ENTRY_SIZE 8
8d88c4ca 523
70256ad8 524/* The size in bytes of an entry in the procedure linkage table. */
8d88c4ca 525
70256ad8
AJ		 526#define PLT_ENTRY_SIZE 16
527
528/* The first entry in a procedure linkage table looks like this. See the
529 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
530
351f65ca 531static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
70256ad8 532{
653165cc
AJ		 533 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
534 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
10efb593 535 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
70256ad8
AJ		 536};
537
538/* Subsequent entries in a procedure linkage table look like this. */
539
351f65ca 540static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
70256ad8 541{
653165cc 542 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
407443a3 543 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653165cc 544 0x68, /* pushq immediate */
70256ad8
AJ		 545 0, 0, 0, 0, /* replaced with index into relocation table. */
546 0xe9, /* jmp relative */
547 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
548};
549
e41b3a13
JJ		 550/* .eh_frame covering the .plt section. */
551
552static const bfd_byte elf_x86_64_eh_frame_plt[] =
553{
554#define PLT_CIE_LENGTH 20
555#define PLT_FDE_LENGTH 36
556#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
557#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
558 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
559 0, 0, 0, 0, /* CIE ID */
560 1, /* CIE version */
561 'z', 'R', 0, /* Augmentation string */
562 1, /* Code alignment factor */
563 0x78, /* Data alignment factor */
564 16, /* Return address column */
565 1, /* Augmentation size */
566 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
567 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
568 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
569 DW_CFA_nop, DW_CFA_nop,
570
571 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
572 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
573 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
574 0, 0, 0, 0, /* .plt size goes here */
575 0, /* Augmentation size */
576 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
577 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
578 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
579 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
580 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
581 11, /* Block length */
582 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
583 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
584 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
585 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
586 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
587};
588
eed180f8
RM		 589/* Architecture-specific backend data for x86-64. */
590
591struct elf_x86_64_backend_data
592{
593 /* Templates for the initial PLT entry and for subsequent entries. */
594 const bfd_byte *plt0_entry;
595 const bfd_byte *plt_entry;
596 unsigned int plt_entry_size; /* Size of each PLT entry. */
597
598 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
599 unsigned int plt0_got1_offset;
600 unsigned int plt0_got2_offset;
601
602 /* Offset of the end of the PC-relative instruction containing
603 plt0_got2_offset. */
604 unsigned int plt0_got2_insn_end;
605
606 /* Offsets into plt_entry that are to be replaced with... */
607 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
608 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
609 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
610
611 /* Length of the PC-relative instruction containing plt_got_offset. */
612 unsigned int plt_got_insn_size;
613
614 /* Offset of the end of the PC-relative jump to plt0_entry. */
615 unsigned int plt_plt_insn_end;
616
617 /* Offset into plt_entry where the initial value of the GOT entry points. */
618 unsigned int plt_lazy_offset;
619
620 /* .eh_frame covering the .plt section. */
621 const bfd_byte *eh_frame_plt;
622 unsigned int eh_frame_plt_size;
623};
624
625#define get_elf_x86_64_backend_data(abfd) \
626 ((const struct elf_x86_64_backend_data *) \
627 get_elf_backend_data (abfd)->arch_data)
628
629#define GET_PLT_ENTRY_SIZE(abfd) \
630 get_elf_x86_64_backend_data (abfd)->plt_entry_size
631
632/* These are the standard parameters. */
633static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
634 {
635 elf_x86_64_plt0_entry, /* plt0_entry */
636 elf_x86_64_plt_entry, /* plt_entry */
637 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
638 2, /* plt0_got1_offset */
639 8, /* plt0_got2_offset */
640 12, /* plt0_got2_insn_end */
641 2, /* plt_got_offset */
642 7, /* plt_reloc_offset */
643 12, /* plt_plt_offset */
644 6, /* plt_got_insn_size */
645 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
646 6, /* plt_lazy_offset */
647 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
648 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
649 };
650
651#define elf_backend_arch_data &elf_x86_64_arch_bed
652
70256ad8
AJ		 653/* x86-64 ELF linker hash entry. */
654
351f65ca 655struct elf_x86_64_link_hash_entry
70256ad8 656{
c434dee6 657 struct elf_link_hash_entry elf;
70256ad8 658
c434dee6 659 /* Track dynamic relocs copied for this symbol. */
e03a8ed8 660 struct elf_dyn_relocs *dyn_relocs;
bffbf940
JJ		 661
662#define GOT_UNKNOWN 0
663#define GOT_NORMAL 1
664#define GOT_TLS_GD 2
665#define GOT_TLS_IE 3
67a4f2b7
AO		 666#define GOT_TLS_GDESC 4
667#define GOT_TLS_GD_BOTH_P(type) \
668 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
669#define GOT_TLS_GD_P(type) \
670 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
671#define GOT_TLS_GDESC_P(type) \
672 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
673#define GOT_TLS_GD_ANY_P(type) \
674 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
bffbf940 675 unsigned char tls_type;
67a4f2b7
AO		 676
677 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
678 starting at the end of the jump table. */
679 bfd_vma tlsdesc_got;
bffbf940
JJ		 680};
681
351f65ca
L		 682#define elf_x86_64_hash_entry(ent) \
683 ((struct elf_x86_64_link_hash_entry *)(ent))
bffbf940 684
351f65ca 685struct elf_x86_64_obj_tdata
bffbf940
JJ		 686{
687 struct elf_obj_tdata root;
688
689 /* tls_type for each local got entry. */
690 char *local_got_tls_type;
67a4f2b7
AO		 691
692 /* GOTPLT entries for TLS descriptors. */
693 bfd_vma *local_tlsdesc_gotent;
70256ad8
AJ		 694};
695
351f65ca
L		 696#define elf_x86_64_tdata(abfd) \
697 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
bffbf940 698
351f65ca
L		 699#define elf_x86_64_local_got_tls_type(abfd) \
700 (elf_x86_64_tdata (abfd)->local_got_tls_type)
bffbf940 701
351f65ca
L		 702#define elf_x86_64_local_tlsdesc_gotent(abfd) \
703 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
bffbf940 704
0ffa91dd
NC		 705#define is_x86_64_elf(bfd) \
706 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
707 && elf_tdata (bfd) != NULL \
4dfe6ac6 708 && elf_object_id (bfd) == X86_64_ELF_DATA)
0ffa91dd
NC		 709
710static bfd_boolean
351f65ca 711elf_x86_64_mkobject (bfd *abfd)
0ffa91dd 712{
351f65ca 713 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
4dfe6ac6 714 X86_64_ELF_DATA);
0ffa91dd
NC		 715}
716
c434dee6 717/* x86-64 ELF linker hash table. */
8d88c4ca 718
351f65ca 719struct elf_x86_64_link_hash_table
407443a3 720{
c434dee6 721 struct elf_link_hash_table elf;
70256ad8 722
c434dee6 723 /* Short-cuts to get to dynamic linker sections. */
c434dee6
AJ		 724 asection *sdynbss;
725 asection *srelbss;
e41b3a13 726 asection *plt_eh_frame;
70256ad8 727
4dfe6ac6
NC		 728 union
729 {
bffbf940
JJ		 730 bfd_signed_vma refcount;
731 bfd_vma offset;
732 } tls_ld_got;
733
67a4f2b7
AO		 734 /* The amount of space used by the jump slots in the GOT. */
735 bfd_vma sgotplt_jump_table_size;
736
87d72d41
AM		 737 /* Small local sym cache. */
738 struct sym_cache sym_cache;
9f03412a 739
351f65ca
L		 740 bfd_vma (*r_info) (bfd_vma, bfd_vma);
741 bfd_vma (*r_sym) (bfd_vma);
248775ba 742 unsigned int pointer_r_type;
351f65ca
L		 743 const char *dynamic_interpreter;
744 int dynamic_interpreter_size;
745
9f03412a
AO		 746 /* _TLS_MODULE_BASE_ symbol. */
747 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 748
749 /* Used by local STT_GNU_IFUNC symbols. */
750 htab_t loc_hash_table;
4dfe6ac6
NC		 751 void * loc_hash_memory;
752
753 /* The offset into splt of the PLT entry for the TLS descriptor
754 resolver. Special values are 0, if not necessary (or not found
755 to be necessary yet), and -1 if needed but not determined
756 yet. */
757 bfd_vma tlsdesc_plt;
758 /* The offset into sgot of the GOT entry used by the PLT entry
759 above. */
760 bfd_vma tlsdesc_got;
e1f98742
L		 761
762 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
763 bfd_vma next_jump_slot_index;
764 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
765 bfd_vma next_irelative_index;
c434dee6 766};
70256ad8
AJ		 767
768/* Get the x86-64 ELF linker hash table from a link_info structure. */
8d88c4ca 769
351f65ca 770#define elf_x86_64_hash_table(p) \
4dfe6ac6 771 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
351f65ca 772 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
8d88c4ca 773
351f65ca 774#define elf_x86_64_compute_jump_table_size(htab) \
6de2ae4a 775 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
67a4f2b7 776
407443a3 777/* Create an entry in an x86-64 ELF linker hash table. */
70256ad8
AJ		 778
779static struct bfd_hash_entry *
351f65ca
L		 780elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
781 struct bfd_hash_table *table,
782 const char *string)
70256ad8 783{
70256ad8 784 /* Allocate the structure if it has not already been allocated by a
c434dee6
AJ		 785 subclass. */
786 if (entry == NULL)
787 {
a50b1753 788 entry = (struct bfd_hash_entry *)
eed180f8
RM		 789 bfd_hash_allocate (table,
790 sizeof (struct elf_x86_64_link_hash_entry));
c434dee6
AJ		 791 if (entry == NULL)
792 return entry;
793 }
70256ad8
AJ		 794
795 /* Call the allocation method of the superclass. */
c434dee6
AJ		 796 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
797 if (entry != NULL)
70256ad8 798 {
351f65ca 799 struct elf_x86_64_link_hash_entry *eh;
c434dee6 800
351f65ca 801 eh = (struct elf_x86_64_link_hash_entry *) entry;
c434dee6 802 eh->dyn_relocs = NULL;
bffbf940 803 eh->tls_type = GOT_UNKNOWN;
67a4f2b7 804 eh->tlsdesc_got = (bfd_vma) -1;
70256ad8
AJ		 805 }
806
c434dee6 807 return entry;
70256ad8
AJ		 808}
809
c25bc9fc
L		 810/* Compute a hash of a local hash entry. We use elf_link_hash_entry
811 for local symbol so that we can handle local STT_GNU_IFUNC symbols
812 as global symbol. We reuse indx and dynstr_index for local symbol
813 hash since they aren't used by global symbols in this backend. */
814
815static hashval_t
351f65ca 816elf_x86_64_local_htab_hash (const void *ptr)
c25bc9fc
L		 817{
818 struct elf_link_hash_entry *h
819 = (struct elf_link_hash_entry *) ptr;
d2149d72 820 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
c25bc9fc
L		 821}
822
823/* Compare local hash entries. */
824
825static int
351f65ca 826elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
c25bc9fc
L		 827{
828 struct elf_link_hash_entry *h1
829 = (struct elf_link_hash_entry *) ptr1;
830 struct elf_link_hash_entry *h2
831 = (struct elf_link_hash_entry *) ptr2;
832
833 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
834}
835
836/* Find and/or create a hash entry for local symbol. */
837
838static struct elf_link_hash_entry *
351f65ca
L		 839elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
840 bfd *abfd, const Elf_Internal_Rela *rel,
841 bfd_boolean create)
c25bc9fc 842{
351f65ca 843 struct elf_x86_64_link_hash_entry e, *ret;
c25bc9fc 844 asection *sec = abfd->sections;
d2149d72 845 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
351f65ca 846 htab->r_sym (rel->r_info));
c25bc9fc
L		 847 void **slot;
848
849 e.elf.indx = sec->id;
351f65ca 850 e.elf.dynstr_index = htab->r_sym (rel->r_info);
c25bc9fc
L		 851 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
852 create ? INSERT : NO_INSERT);
853
854 if (!slot)
855 return NULL;
856
857 if (*slot)
858 {
351f65ca 859 ret = (struct elf_x86_64_link_hash_entry *) *slot;
c25bc9fc
L		 860 return &ret->elf;
861 }
862
351f65ca 863 ret = (struct elf_x86_64_link_hash_entry *)
c25bc9fc 864 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
351f65ca 865 sizeof (struct elf_x86_64_link_hash_entry));
c25bc9fc
L		 866 if (ret)
867 {
868 memset (ret, 0, sizeof (*ret));
869 ret->elf.indx = sec->id;
351f65ca 870 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
c25bc9fc 871 ret->elf.dynindx = -1;
c25bc9fc
L		 872 *slot = ret;
873 }
874 return &ret->elf;
875}
876
8d88c4ca
NC		 877/* Create an X86-64 ELF linker hash table. */
878
879static struct bfd_link_hash_table *
351f65ca 880elf_x86_64_link_hash_table_create (bfd *abfd)
8d88c4ca 881{
351f65ca
L		 882 struct elf_x86_64_link_hash_table *ret;
883 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
8d88c4ca 884
351f65ca 885 ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
c434dee6 886 if (ret == NULL)
8d88c4ca
NC		 887 return NULL;
888
eb4ff4d6 889 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
351f65ca
L		 890 elf_x86_64_link_hash_newfunc,
891 sizeof (struct elf_x86_64_link_hash_entry),
4dfe6ac6 892 X86_64_ELF_DATA))
8d88c4ca 893 {
e2d34d7d 894 free (ret);
8d88c4ca
NC		 895 return NULL;
896 }
897
c434dee6
AJ		 898 ret->sdynbss = NULL;
899 ret->srelbss = NULL;
332ce62b 900 ret->plt_eh_frame = NULL;
87d72d41 901 ret->sym_cache.abfd = NULL;
67a4f2b7
AO		 902 ret->tlsdesc_plt = 0;
903 ret->tlsdesc_got = 0;
bffbf940 904 ret->tls_ld_got.refcount = 0;
67a4f2b7 905 ret->sgotplt_jump_table_size = 0;
9f03412a 906 ret->tls_module_base = NULL;
eed180f8 907 ret->next_jump_slot_index = 0;
e1f98742 908 ret->next_irelative_index = 0;
6bbec505 909
351f65ca
L		 910 if (ABI_64_P (abfd))
911 {
912 ret->r_info = elf64_r_info;
913 ret->r_sym = elf64_r_sym;
248775ba 914 ret->pointer_r_type = R_X86_64_64;
351f65ca
L		 915 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
916 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
917 }
918 else
919 {
920 ret->r_info = elf32_r_info;
921 ret->r_sym = elf32_r_sym;
248775ba 922 ret->pointer_r_type = R_X86_64_32;
351f65ca
L		 923 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
924 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
925 }
926
c25bc9fc 927 ret->loc_hash_table = htab_try_create (1024,
351f65ca
L		 928 elf_x86_64_local_htab_hash,
929 elf_x86_64_local_htab_eq,
c25bc9fc
L		 930 NULL);
931 ret->loc_hash_memory = objalloc_create ();
932 if (!ret->loc_hash_table || !ret->loc_hash_memory)
933 {
934 free (ret);
935 return NULL;
936 }
937
c434dee6
AJ		 938 return &ret->elf.root;
939}
940
c25bc9fc
L		 941/* Destroy an X86-64 ELF linker hash table. */
942
943static void
351f65ca 944elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
c25bc9fc 945{
351f65ca
L		 946 struct elf_x86_64_link_hash_table *htab
947 = (struct elf_x86_64_link_hash_table *) hash;
c25bc9fc
L		 948
949 if (htab->loc_hash_table)
950 htab_delete (htab->loc_hash_table);
951 if (htab->loc_hash_memory)
952 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
953 _bfd_generic_link_hash_table_free (hash);
954}
955
c434dee6
AJ		 956/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
957 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
958 hash table. */
959
b34976b6 960static bfd_boolean
351f65ca
L		 961elf_x86_64_create_dynamic_sections (bfd *dynobj,
962 struct bfd_link_info *info)
c434dee6 963{
351f65ca 964 struct elf_x86_64_link_hash_table *htab;
c434dee6 965
c434dee6 966 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 967 return FALSE;
c434dee6 968
351f65ca 969 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 970 if (htab == NULL)
971 return FALSE;
972
c434dee6
AJ		 973 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
974 if (!info->shared)
975 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
976
6de2ae4a 977 if (!htab->sdynbss
c434dee6
AJ		 978 || (!info->shared && !htab->srelbss))
979 abort ();
980
e41b3a13 981 if (!info->no_ld_generated_unwind_info
2fe0fd06 982 && htab->plt_eh_frame == NULL
e4de50d4 983 && htab->elf.splt != NULL)
e41b3a13
JJ		 984 {
985 flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
986 htab->plt_eh_frame
2fe0fd06
L		 987 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame",
988 (flags
989 | SEC_LINKER_CREATED
990 | SEC_READONLY));
e41b3a13
JJ		 991 if (htab->plt_eh_frame == NULL
992 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
993 return FALSE;
e41b3a13 994 }
b34976b6 995 return TRUE;
c434dee6
AJ		 996}
997
998/* Copy the extra info we tack onto an elf_link_hash_entry. */
999
1000static void
351f65ca
L		 1001elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1002 struct elf_link_hash_entry *dir,
1003 struct elf_link_hash_entry *ind)
c434dee6 1004{
351f65ca 1005 struct elf_x86_64_link_hash_entry *edir, *eind;
c434dee6 1006
351f65ca
L		 1007 edir = (struct elf_x86_64_link_hash_entry *) dir;
1008 eind = (struct elf_x86_64_link_hash_entry *) ind;
c434dee6
AJ		 1009
1010 if (eind->dyn_relocs != NULL)
1011 {
1012 if (edir->dyn_relocs != NULL)
1013 {
e03a8ed8
L		 1014 struct elf_dyn_relocs **pp;
1015 struct elf_dyn_relocs *p;
c434dee6 1016
fcfa13d2 1017 /* Add reloc counts against the indirect sym to the direct sym
c434dee6
AJ		 1018 list. Merge any entries against the same section. */
1019 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1020 {
e03a8ed8 1021 struct elf_dyn_relocs *q;
c434dee6
AJ		 1022
1023 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1024 if (q->sec == p->sec)
1025 {
1026 q->pc_count += p->pc_count;
1027 q->count += p->count;
1028 *pp = p->next;
1029 break;
1030 }
1031 if (q == NULL)
1032 pp = &p->next;
1033 }
1034 *pp = edir->dyn_relocs;
1035 }
1036
1037 edir->dyn_relocs = eind->dyn_relocs;
1038 eind->dyn_relocs = NULL;
1039 }
1040
bffbf940
JJ		 1041 if (ind->root.type == bfd_link_hash_indirect
1042 && dir->got.refcount <= 0)
1043 {
1044 edir->tls_type = eind->tls_type;
1045 eind->tls_type = GOT_UNKNOWN;
1046 }
1047
d40d037c
AJ		 1048 if (ELIMINATE_COPY_RELOCS
1049 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 1050 && dir->dynamic_adjusted)
1051 {
1052 /* If called to transfer flags for a weakdef during processing
1053 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1054 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1055 dir->ref_dynamic |= ind->ref_dynamic;
1056 dir->ref_regular |= ind->ref_regular;
1057 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1058 dir->needs_plt |= ind->needs_plt;
1059 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1060 }
d40d037c 1061 else
fcfa13d2 1062 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
8d88c4ca
NC		 1063}
1064
b34976b6 1065static bfd_boolean
27482721 1066elf64_x86_64_elf_object_p (bfd *abfd)
bffbf940 1067{
8d88c4ca
NC		 1068 /* Set the right machine number for an x86-64 elf64 file. */
1069 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
b34976b6 1070 return TRUE;
8d88c4ca
NC		 1071}
1072
8059fb19
RM		 1073static bfd_boolean
1074elf32_x86_64_elf_object_p (bfd *abfd)
1075{
1076 /* Set the right machine number for an x86-64 elf32 file. */
1077 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1078 return TRUE;
1079}
1080
142411ca
L		 1081/* Return TRUE if the TLS access code sequence support transition
1082 from R_TYPE. */
1083
1084static bfd_boolean
351f65ca
L		 1085elf_x86_64_check_tls_transition (bfd *abfd,
1086 struct bfd_link_info *info,
1087 asection *sec,
1088 bfd_byte *contents,
1089 Elf_Internal_Shdr *symtab_hdr,
1090 struct elf_link_hash_entry **sym_hashes,
1091 unsigned int r_type,
1092 const Elf_Internal_Rela *rel,
1093 const Elf_Internal_Rela *relend)
bffbf940 1094{
142411ca
L		 1095 unsigned int val;
1096 unsigned long r_symndx;
1097 struct elf_link_hash_entry *h;
1098 bfd_vma offset;
351f65ca 1099 struct elf_x86_64_link_hash_table *htab;
142411ca
L		 1100
1101 /* Get the section contents. */
1102 if (contents == NULL)
1103 {
1104 if (elf_section_data (sec)->this_hdr.contents != NULL)
1105 contents = elf_section_data (sec)->this_hdr.contents;
1106 else
1107 {
1108 /* FIXME: How to better handle error condition? */
1109 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1110 return FALSE;
bffbf940 1111
142411ca
L		 1112 /* Cache the section contents for elf_link_input_bfd. */
1113 elf_section_data (sec)->this_hdr.contents = contents;
1114 }
1115 }
1116
351f65ca 1117 htab = elf_x86_64_hash_table (info);
142411ca 1118 offset = rel->r_offset;
bffbf940 1119 switch (r_type)
142411ca
L		 1120 {
1121 case R_X86_64_TLSGD:
1122 case R_X86_64_TLSLD:
1123 if ((rel + 1) >= relend)
1124 return FALSE;
1125
1126 if (r_type == R_X86_64_TLSGD)
1127 {
52bc799a 1128 /* Check transition from GD access model. For 64bit, only
142411ca
L		 1129 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1130 .word 0x6666; rex64; call __tls_get_addr
52bc799a
L		 1131 can transit to different access model. For 32bit, only
1132 leaq foo@tlsgd(%rip), %rdi
1133 .word 0x6666; rex64; call __tls_get_addr
142411ca
L		 1134 can transit to different access model. */
1135
fa289a5f
AM		 1136 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1137 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1138
52bc799a 1139 if ((offset + 12) > sec->size
fa289a5f 1140 || memcmp (contents + offset + 4, call, 4) != 0)
142411ca 1141 return FALSE;
52bc799a
L		 1142
1143 if (ABI_64_P (abfd))
1144 {
52bc799a 1145 if (offset < 4
fa289a5f 1146 || memcmp (contents + offset - 4, leaq, 4) != 0)
52bc799a
L		 1147 return FALSE;
1148 }
1149 else
1150 {
52bc799a 1151 if (offset < 3
fa289a5f 1152 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
52bc799a
L		 1153 return FALSE;
1154 }
142411ca
L		 1155 }
1156 else
1157 {
1158 /* Check transition from LD access model. Only
1159 leaq foo@tlsld(%rip), %rdi;
1160 call __tls_get_addr
1161 can transit to different access model. */
1162
fa289a5f 1163 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
142411ca
L		 1164
1165 if (offset < 3 || (offset + 9) > sec->size)
1166 return FALSE;
1167
fa289a5f
AM		 1168 if (memcmp (contents + offset - 3, lea, 3) != 0
1169 || 0xe8 != *(contents + offset + 4))
142411ca
L		 1170 return FALSE;
1171 }
1172
351f65ca 1173 r_symndx = htab->r_sym (rel[1].r_info);
142411ca
L		 1174 if (r_symndx < symtab_hdr->sh_info)
1175 return FALSE;
1176
1177 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
c4fb387b 1178 /* Use strncmp to check __tls_get_addr since __tls_get_addr
eed180f8 1179 may be versioned. */
142411ca
L		 1180 return (h != NULL
1181 && h->root.root.string != NULL
351f65ca
L		 1182 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1183 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
c4fb387b
L		 1184 && (strncmp (h->root.root.string,
1185 "__tls_get_addr", 14) == 0));
142411ca
L		 1186
1187 case R_X86_64_GOTTPOFF:
1188 /* Check transition from IE access model:
4a4c5f25
L		 1189 mov foo@gottpoff(%rip), %reg
1190 add foo@gottpoff(%rip), %reg
142411ca
L		 1191 */
1192
4a4c5f25
L		 1193 /* Check REX prefix first. */
1194 if (offset >= 3 && (offset + 4) <= sec->size)
1195 {
1196 val = bfd_get_8 (abfd, contents + offset - 3);
1197 if (val != 0x48 && val != 0x4c)
1198 {
1199 /* X32 may have 0x44 REX prefix or no REX prefix. */
1200 if (ABI_64_P (abfd))
1201 return FALSE;
1202 }
1203 }
1204 else
1205 {
1206 /* X32 may not have any REX prefix. */
1207 if (ABI_64_P (abfd))
1208 return FALSE;
1209 if (offset < 2 || (offset + 3) > sec->size)
1210 return FALSE;
1211 }
142411ca
L		 1212
1213 val = bfd_get_8 (abfd, contents + offset - 2);
1214 if (val != 0x8b && val != 0x03)
1215 return FALSE;
1216
1217 val = bfd_get_8 (abfd, contents + offset - 1);
1218 return (val & 0xc7) == 5;
1219
1220 case R_X86_64_GOTPC32_TLSDESC:
1221 /* Check transition from GDesc access model:
1222 leaq x@tlsdesc(%rip), %rax
1223
1224 Make sure it's a leaq adding rip to a 32-bit offset
1225 into any register, although it's probably almost always
1226 going to be rax. */
1227
1228 if (offset < 3 || (offset + 4) > sec->size)
1229 return FALSE;
1230
1231 val = bfd_get_8 (abfd, contents + offset - 3);
1232 if ((val & 0xfb) != 0x48)
1233 return FALSE;
1234
1235 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1236 return FALSE;
1237
1238 val = bfd_get_8 (abfd, contents + offset - 1);
1239 return (val & 0xc7) == 0x05;
1240
1241 case R_X86_64_TLSDESC_CALL:
1242 /* Check transition from GDesc access model:
1243 call *x@tlsdesc(%rax)
1244 */
1245 if (offset + 2 <= sec->size)
1246 {
1247 /* Make sure that it's a call *x@tlsdesc(%rax). */
fa289a5f
AM		 1248 static const unsigned char call[] = { 0xff, 0x10 };
1249 return memcmp (contents + offset, call, 2) == 0;
142411ca
L		 1250 }
1251
1252 return FALSE;
1253
1254 default:
1255 abort ();
1256 }
1257}
1258
1259/* Return TRUE if the TLS access transition is OK or no transition
1260 will be performed. Update R_TYPE if there is a transition. */
1261
1262static bfd_boolean
351f65ca
L		 1263elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1264 asection *sec, bfd_byte *contents,
1265 Elf_Internal_Shdr *symtab_hdr,
1266 struct elf_link_hash_entry **sym_hashes,
1267 unsigned int *r_type, int tls_type,
1268 const Elf_Internal_Rela *rel,
1269 const Elf_Internal_Rela *relend,
1270 struct elf_link_hash_entry *h,
1271 unsigned long r_symndx)
142411ca
L		 1272{
1273 unsigned int from_type = *r_type;
1274 unsigned int to_type = from_type;
1275 bfd_boolean check = TRUE;
1276
bb1cb422
L		 1277 /* Skip TLS transition for functions. */
1278 if (h != NULL
1279 && (h->type == STT_FUNC
1280 || h->type == STT_GNU_IFUNC))
1281 return TRUE;
1282
142411ca 1283 switch (from_type)
bffbf940
JJ		 1284 {
1285 case R_X86_64_TLSGD:
67a4f2b7
AO		 1286 case R_X86_64_GOTPC32_TLSDESC:
1287 case R_X86_64_TLSDESC_CALL:
bffbf940 1288 case R_X86_64_GOTTPOFF:
1d85728f 1289 if (info->executable)
142411ca
L		 1290 {
1291 if (h == NULL)
1292 to_type = R_X86_64_TPOFF32;
1293 else
1294 to_type = R_X86_64_GOTTPOFF;
1295 }
1296
351f65ca 1297 /* When we are called from elf_x86_64_relocate_section,
142411ca
L		 1298 CONTENTS isn't NULL and there may be additional transitions
1299 based on TLS_TYPE. */
1300 if (contents != NULL)
1301 {
1302 unsigned int new_to_type = to_type;
1303
1d85728f 1304 if (info->executable
142411ca
L		 1305 && h != NULL
1306 && h->dynindx == -1
1307 && tls_type == GOT_TLS_IE)
1308 new_to_type = R_X86_64_TPOFF32;
1309
1310 if (to_type == R_X86_64_TLSGD
1311 || to_type == R_X86_64_GOTPC32_TLSDESC
1312 || to_type == R_X86_64_TLSDESC_CALL)
1313 {
1314 if (tls_type == GOT_TLS_IE)
1315 new_to_type = R_X86_64_GOTTPOFF;
1316 }
1317
1318 /* We checked the transition before when we were called from
351f65ca 1319 elf_x86_64_check_relocs. We only want to check the new
142411ca
L		 1320 transition which hasn't been checked before. */
1321 check = new_to_type != to_type && from_type == to_type;
1322 to_type = new_to_type;
1323 }
1324
1325 break;
1326
bffbf940 1327 case R_X86_64_TLSLD:
1d85728f 1328 if (info->executable)
142411ca
L		 1329 to_type = R_X86_64_TPOFF32;
1330 break;
1331
1332 default:
1333 return TRUE;
bffbf940
JJ		 1334 }
1335
142411ca
L		 1336 /* Return TRUE if there is no transition. */
1337 if (from_type == to_type)
1338 return TRUE;
1339
1340 /* Check if the transition can be performed. */
1341 if (check
351f65ca
L		 1342 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1343 symtab_hdr, sym_hashes,
1344 from_type, rel, relend))
142411ca 1345 {
2f629d23 1346 reloc_howto_type *from, *to;
4c544807 1347 const char *name;
142411ca 1348
351f65ca
L		 1349 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1350 to = elf_x86_64_rtype_to_howto (abfd, to_type);
142411ca 1351
4c544807
L		 1352 if (h)
1353 name = h->root.root.string;
1354 else
1355 {
351f65ca 1356 struct elf_x86_64_link_hash_table *htab;
4dfe6ac6 1357
351f65ca 1358 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1359 if (htab == NULL)
1360 name = "*unknown*";
1361 else
1362 {
1363 Elf_Internal_Sym *isym;
1364
1365 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1366 abfd, r_symndx);
1367 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1368 }
4c544807
L		 1369 }
1370
142411ca
L		 1371 (*_bfd_error_handler)
1372 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1373 "in section `%A' failed"),
4c544807 1374 abfd, sec, from->name, to->name, name,
142411ca
L		 1375 (unsigned long) rel->r_offset);
1376 bfd_set_error (bfd_error_bad_value);
1377 return FALSE;
1378 }
1379
1380 *r_type = to_type;
1381 return TRUE;
bffbf940
JJ		 1382}
1383
70256ad8 1384/* Look through the relocs for a section during the first phase, and
c434dee6
AJ		 1385 calculate needed space in the global offset table, procedure
1386 linkage table, and dynamic reloc sections. */
70256ad8 1387
b34976b6 1388static bfd_boolean
351f65ca
L		 1389elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1390 asection *sec,
1391 const Elf_Internal_Rela *relocs)
70256ad8 1392{
351f65ca 1393 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 1394 Elf_Internal_Shdr *symtab_hdr;
1395 struct elf_link_hash_entry **sym_hashes;
70256ad8
AJ		 1396 const Elf_Internal_Rela *rel;
1397 const Elf_Internal_Rela *rel_end;
70256ad8
AJ		 1398 asection *sreloc;
1399
1049f94e 1400 if (info->relocatable)
b34976b6 1401 return TRUE;
70256ad8 1402
0ffa91dd
NC		 1403 BFD_ASSERT (is_x86_64_elf (abfd));
1404
351f65ca 1405 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1406 if (htab == NULL)
1407 return FALSE;
1408
0ffa91dd 1409 symtab_hdr = &elf_symtab_hdr (abfd);
70256ad8 1410 sym_hashes = elf_sym_hashes (abfd);
70256ad8 1411
c434dee6 1412 sreloc = NULL;
cbe950e9 1413
70256ad8
AJ		 1414 rel_end = relocs + sec->reloc_count;
1415 for (rel = relocs; rel < rel_end; rel++)
1416 {
bffbf940 1417 unsigned int r_type;
70256ad8
AJ		 1418 unsigned long r_symndx;
1419 struct elf_link_hash_entry *h;
4c544807
L		 1420 Elf_Internal_Sym *isym;
1421 const char *name;
70256ad8 1422
351f65ca
L		 1423 r_symndx = htab->r_sym (rel->r_info);
1424 r_type = ELF32_R_TYPE (rel->r_info);
c434dee6
AJ		 1425
1426 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1427 {
d003868e
AM		 1428 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1429 abfd, r_symndx);
b34976b6 1430 return FALSE;
c434dee6
AJ		 1431 }
1432
70256ad8 1433 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1434 {
1435 /* A local symbol. */
c2e61a4e
L		 1436 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1437 abfd, r_symndx);
1438 if (isym == NULL)
1439 return FALSE;
c25bc9fc
L		 1440
1441 /* Check relocation against local STT_GNU_IFUNC symbol. */
351f65ca 1442 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
c25bc9fc 1443 {
351f65ca
L		 1444 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1445 TRUE);
c25bc9fc 1446 if (h == NULL)
c2e61a4e 1447 return FALSE;
6bbec505 1448
c25bc9fc
L		 1449 /* Fake a STT_GNU_IFUNC symbol. */
1450 h->type = STT_GNU_IFUNC;
1451 h->def_regular = 1;
1452 h->ref_regular = 1;
1453 h->forced_local = 1;
1454 h->root.type = bfd_link_hash_defined;
1455 }
1456 else
1457 h = NULL;
1458 }
70256ad8 1459 else
71cb9464 1460 {
4c544807 1461 isym = NULL;
71cb9464
L		 1462 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1463 while (h->root.type == bfd_link_hash_indirect
1464 || h->root.type == bfd_link_hash_warning)
1465 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1466 }
cbe950e9 1467
d1534d16
L		 1468 /* Check invalid x32 relocations. */
1469 if (!ABI_64_P (abfd))
1470 switch (r_type)
1471 {
1472 default:
1473 break;
1474
d1534d16
L		 1475 case R_X86_64_DTPOFF64:
1476 case R_X86_64_TPOFF64:
1477 case R_X86_64_PC64:
1478 case R_X86_64_GOTOFF64:
1479 case R_X86_64_GOT64:
1480 case R_X86_64_GOTPCREL64:
1481 case R_X86_64_GOTPC64:
1482 case R_X86_64_GOTPLT64:
1483 case R_X86_64_PLTOFF64:
1484 {
1485 if (h)
1486 name = h->root.root.string;
1487 else
1488 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1489 NULL);
1490 (*_bfd_error_handler)
1491 (_("%B: relocation %s against symbol `%s' isn't "
1492 "supported in x32 mode"), abfd,
1493 x86_64_elf_howto_table[r_type].name, name);
1494 bfd_set_error (bfd_error_bad_value);
1495 return FALSE;
1496 }
1497 break;
1498 }
1499
c25bc9fc
L		 1500 if (h != NULL)
1501 {
cbe950e9
L		 1502 /* Create the ifunc sections for static executables. If we
1503 never see an indirect function symbol nor we are building
1504 a static executable, those sections will be empty and
1505 won't appear in output. */
1506 switch (r_type)
1507 {
1508 default:
1509 break;
1510
1511 case R_X86_64_32S:
1512 case R_X86_64_32:
1513 case R_X86_64_64:
1514 case R_X86_64_PC32:
1515 case R_X86_64_PC64:
1516 case R_X86_64_PLT32:
1517 case R_X86_64_GOTPCREL:
1518 case R_X86_64_GOTPCREL64:
9d4057ee
AM		 1519 if (htab->elf.dynobj == NULL)
1520 htab->elf.dynobj = abfd;
1521 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
c2e61a4e 1522 return FALSE;
cbe950e9
L		 1523 break;
1524 }
1525
1526 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1527 it here if it is defined in a non-shared object. */
1528 if (h->type == STT_GNU_IFUNC
1529 && h->def_regular)
1530 {
1531 /* It is referenced by a non-shared object. */
1532 h->ref_regular = 1;
7ae26bc1 1533 h->needs_plt = 1;
6bbec505 1534
cbe950e9
L		 1535 /* STT_GNU_IFUNC symbol must go through PLT. */
1536 h->plt.refcount += 1;
1537
1538 /* STT_GNU_IFUNC needs dynamic sections. */
1539 if (htab->elf.dynobj == NULL)
1540 htab->elf.dynobj = abfd;
1541
1542 switch (r_type)
1543 {
048cbda4 1544 default:
4c544807
L		 1545 if (h->root.root.string)
1546 name = h->root.root.string;
1547 else
1548 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1549 NULL);
048cbda4
L		 1550 (*_bfd_error_handler)
1551 (_("%B: relocation %s against STT_GNU_IFUNC "
1552 "symbol `%s' isn't handled by %s"), abfd,
1553 x86_64_elf_howto_table[r_type].name,
4c544807 1554 name, __FUNCTION__);
048cbda4 1555 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1556 return FALSE;
cbe950e9 1557
248775ba
L		 1558 case R_X86_64_32:
1559 if (ABI_64_P (abfd))
1560 goto not_pointer;
710ab287
L		 1561 case R_X86_64_64:
1562 h->non_got_ref = 1;
1563 h->pointer_equality_needed = 1;
1564 if (info->shared)
1565 {
710ab287
L		 1566 /* We must copy these reloc types into the output
1567 file. Create a reloc section in dynobj and
1568 make room for this reloc. */
e03a8ed8
L		 1569 sreloc = _bfd_elf_create_ifunc_dyn_reloc
1570 (abfd, info, sec, sreloc,
351f65ca 1571 &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs);
710ab287 1572 if (sreloc == NULL)
c2e61a4e 1573 return FALSE;
710ab287
L		 1574 }
1575 break;
1576
cbe950e9 1577 case R_X86_64_32S:
cbe950e9
L		 1578 case R_X86_64_PC32:
1579 case R_X86_64_PC64:
248775ba 1580not_pointer:
cbe950e9
L		 1581 h->non_got_ref = 1;
1582 if (r_type != R_X86_64_PC32
1583 && r_type != R_X86_64_PC64)
1584 h->pointer_equality_needed = 1;
1585 break;
1586
1587 case R_X86_64_PLT32:
1588 break;
1589
1590 case R_X86_64_GOTPCREL:
1591 case R_X86_64_GOTPCREL64:
7afd84dc 1592 h->got.refcount += 1;
6de2ae4a
L		 1593 if (htab->elf.sgot == NULL
1594 && !_bfd_elf_create_got_section (htab->elf.dynobj,
1595 info))
c2e61a4e 1596 return FALSE;
cbe950e9
L		 1597 break;
1598 }
1599
1600 continue;
1601 }
71cb9464 1602 }
70256ad8 1603
351f65ca
L		 1604 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1605 symtab_hdr, sym_hashes,
1606 &r_type, GOT_UNKNOWN,
1607 rel, rel_end, h, r_symndx))
c2e61a4e 1608 return FALSE;
142411ca 1609
bffbf940 1610 switch (r_type)
70256ad8 1611 {
bffbf940
JJ		 1612 case R_X86_64_TLSLD:
1613 htab->tls_ld_got.refcount += 1;
1614 goto create_got;
1615
1616 case R_X86_64_TPOFF32:
351f65ca 1617 if (!info->executable && ABI_64_P (abfd))
70256ad8 1618 {
09a24cbf 1619 if (h)
4c544807
L		 1620 name = h->root.root.string;
1621 else
1622 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1623 NULL);
bffbf940 1624 (*_bfd_error_handler)
d003868e
AM		 1625 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1626 abfd,
4c544807 1627 x86_64_elf_howto_table[r_type].name, name);
bffbf940 1628 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1629 return FALSE;
70256ad8 1630 }
bffbf940 1631 break;
c434dee6 1632
bffbf940 1633 case R_X86_64_GOTTPOFF:
1d85728f 1634 if (!info->executable)
bffbf940
JJ		 1635 info->flags |= DF_STATIC_TLS;
1636 /* Fall through */
70256ad8 1637
bffbf940
JJ		 1638 case R_X86_64_GOT32:
1639 case R_X86_64_GOTPCREL:
1640 case R_X86_64_TLSGD:
7b81dfbb
AJ		 1641 case R_X86_64_GOT64:
1642 case R_X86_64_GOTPCREL64:
1643 case R_X86_64_GOTPLT64:
67a4f2b7
AO		 1644 case R_X86_64_GOTPC32_TLSDESC:
1645 case R_X86_64_TLSDESC_CALL:
bffbf940
JJ		 1646 /* This symbol requires a global offset table entry. */
1647 {
1648 int tls_type, old_tls_type;
1649
1650 switch (r_type)
1651 {
1652 default: tls_type = GOT_NORMAL; break;
1653 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1654 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
67a4f2b7
AO		 1655 case R_X86_64_GOTPC32_TLSDESC:
1656 case R_X86_64_TLSDESC_CALL:
1657 tls_type = GOT_TLS_GDESC; break;
bffbf940
JJ		 1658 }
1659
1660 if (h != NULL)
1661 {
7b81dfbb
AJ		 1662 if (r_type == R_X86_64_GOTPLT64)
1663 {
1664 /* This relocation indicates that we also need
1665 a PLT entry, as this is a function. We don't need
1666 a PLT entry for local symbols. */
1667 h->needs_plt = 1;
1668 h->plt.refcount += 1;
1669 }
bffbf940 1670 h->got.refcount += 1;
351f65ca 1671 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
bffbf940
JJ		 1672 }
1673 else
1674 {
1675 bfd_signed_vma *local_got_refcounts;
1676
1677 /* This is a global offset table entry for a local symbol. */
1678 local_got_refcounts = elf_local_got_refcounts (abfd);
1679 if (local_got_refcounts == NULL)
1680 {
1681 bfd_size_type size;
1682
1683 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1684 size *= sizeof (bfd_signed_vma)
1685 + sizeof (bfd_vma) + sizeof (char);
bffbf940
JJ		 1686 local_got_refcounts = ((bfd_signed_vma *)
1687 bfd_zalloc (abfd, size));
1688 if (local_got_refcounts == NULL)
c2e61a4e 1689 return FALSE;
bffbf940 1690 elf_local_got_refcounts (abfd) = local_got_refcounts;
351f65ca 1691 elf_x86_64_local_tlsdesc_gotent (abfd)
67a4f2b7 1692 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
351f65ca 1693 elf_x86_64_local_got_tls_type (abfd)
67a4f2b7 1694 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
bffbf940
JJ		 1695 }
1696 local_got_refcounts[r_symndx] += 1;
1697 old_tls_type
351f65ca 1698 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
bffbf940
JJ		 1699 }
1700
1701 /* If a TLS symbol is accessed using IE at least once,
1702 there is no point to use dynamic model for it. */
1703 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7
AO		 1704 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1705 || tls_type != GOT_TLS_IE))
bffbf940 1706 {
67a4f2b7 1707 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
bffbf940 1708 tls_type = old_tls_type;
67a4f2b7
AO		 1709 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1710 && GOT_TLS_GD_ANY_P (tls_type))
1711 tls_type |= old_tls_type;
bffbf940
JJ		 1712 else
1713 {
09a24cbf 1714 if (h)
4c544807
L		 1715 name = h->root.root.string;
1716 else
1717 name = bfd_elf_sym_name (abfd, symtab_hdr,
1718 isym, NULL);
bffbf940 1719 (*_bfd_error_handler)
1f7a4e42 1720 (_("%B: '%s' accessed both as normal and thread local symbol"),
4c544807 1721 abfd, name);
c2e61a4e 1722 return FALSE;
bffbf940
JJ		 1723 }
1724 }
1725
1726 if (old_tls_type != tls_type)
1727 {
1728 if (h != NULL)
351f65ca 1729 elf_x86_64_hash_entry (h)->tls_type = tls_type;
bffbf940 1730 else
351f65ca 1731 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
bffbf940
JJ		 1732 }
1733 }
c434dee6
AJ		 1734 /* Fall through */
1735
d6ab8113
JB		 1736 case R_X86_64_GOTOFF64:
1737 case R_X86_64_GOTPC32:
7b81dfbb 1738 case R_X86_64_GOTPC64:
bffbf940 1739 create_got:
6de2ae4a 1740 if (htab->elf.sgot == NULL)
c434dee6
AJ		 1741 {
1742 if (htab->elf.dynobj == NULL)
1743 htab->elf.dynobj = abfd;
6de2ae4a
L		 1744 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1745 info))
c2e61a4e 1746 return FALSE;
c434dee6 1747 }
70256ad8
AJ		 1748 break;
1749
1750 case R_X86_64_PLT32:
1751 /* This symbol requires a procedure linkage table entry. We
407443a3
AJ		 1752 actually build the entry in adjust_dynamic_symbol,
1753 because this might be a case of linking PIC code which is
1754 never referenced by a dynamic object, in which case we
1755 don't need to generate a procedure linkage table entry
1756 after all. */
70256ad8
AJ		 1757
1758 /* If this is a local symbol, we resolve it directly without
407443a3 1759 creating a procedure linkage table entry. */
70256ad8
AJ		 1760 if (h == NULL)
1761 continue;
1762
f5385ebf 1763 h->needs_plt = 1;
51b64d56 1764 h->plt.refcount += 1;
70256ad8
AJ		 1765 break;
1766
7b81dfbb
AJ		 1767 case R_X86_64_PLTOFF64:
1768 /* This tries to form the 'address' of a function relative
1769 to GOT. For global symbols we need a PLT entry. */
1770 if (h != NULL)
1771 {
1772 h->needs_plt = 1;
1773 h->plt.refcount += 1;
1774 }
1775 goto create_got;
1776
248775ba
L		 1777 case R_X86_64_32:
1778 if (!ABI_64_P (abfd))
1779 goto pointer;
cc78d0af
AJ		 1780 case R_X86_64_8:
1781 case R_X86_64_16:
70256ad8 1782 case R_X86_64_32S:
1b71fb54
AJ		 1783 /* Let's help debug shared library creation. These relocs
1784 cannot be used in shared libs. Don't error out for
1785 sections we don't care about, such as debug sections or
1786 non-constant sections. */
1787 if (info->shared
1788 && (sec->flags & SEC_ALLOC) != 0
1789 && (sec->flags & SEC_READONLY) != 0)
1790 {
09a24cbf 1791 if (h)
4c544807
L		 1792 name = h->root.root.string;
1793 else
1794 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1b71fb54 1795 (*_bfd_error_handler)
d003868e 1796 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
4c544807 1797 abfd, x86_64_elf_howto_table[r_type].name, name);
1b71fb54 1798 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1799 return FALSE;
1b71fb54
AJ		 1800 }
1801 /* Fall through. */
1802
c434dee6
AJ		 1803 case R_X86_64_PC8:
1804 case R_X86_64_PC16:
70256ad8 1805 case R_X86_64_PC32:
d6ab8113 1806 case R_X86_64_PC64:
1b71fb54 1807 case R_X86_64_64:
248775ba 1808pointer:
710ab287 1809 if (h != NULL && info->executable)
c434dee6
AJ		 1810 {
1811 /* If this reloc is in a read-only section, we might
1812 need a copy reloc. We can't check reliably at this
1813 stage whether the section is read-only, as input
1814 sections have not yet been mapped to output sections.
1815 Tentatively set the flag for now, and correct in
1816 adjust_dynamic_symbol. */
f5385ebf 1817 h->non_got_ref = 1;
c434dee6
AJ		 1818
1819 /* We may need a .plt entry if the function this reloc
1820 refers to is in a shared lib. */
1821 h->plt.refcount += 1;
d6ab8113 1822 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
f5385ebf 1823 h->pointer_equality_needed = 1;
c434dee6 1824 }
70256ad8
AJ		 1825
1826 /* If we are creating a shared library, and this is a reloc
1827 against a global symbol, or a non PC relative reloc
1828 against a local symbol, then we need to copy the reloc
1829 into the shared library. However, if we are linking with
1830 -Bsymbolic, we do not need to copy a reloc against a
1831 global symbol which is defined in an object we are
407443a3 1832 including in the link (i.e., DEF_REGULAR is set). At
70256ad8
AJ		 1833 this point we have not seen all the input files, so it is
1834 possible that DEF_REGULAR is not set now but will be set
c434dee6
AJ		 1835 later (it is never cleared). In case of a weak definition,
1836 DEF_REGULAR may be cleared later by a strong definition in
1837 a shared library. We account for that possibility below by
1838 storing information in the relocs_copied field of the hash
1839 table entry. A similar situation occurs when creating
1840 shared libraries and symbol visibility changes render the
1841 symbol local.
1842
1843 If on the other hand, we are creating an executable, we
1844 may need to keep relocations for symbols satisfied by a
1845 dynamic library if we manage to avoid copy relocs for the
0f88be7a 1846 symbol. */
c434dee6
AJ		 1847 if ((info->shared
1848 && (sec->flags & SEC_ALLOC) != 0
d8045f23 1849 && (! IS_X86_64_PCREL_TYPE (r_type)
c434dee6 1850 || (h != NULL
55255dae 1851 && (! SYMBOLIC_BIND (info, h)
c434dee6 1852 || h->root.type == bfd_link_hash_defweak
f5385ebf 1853 || !h->def_regular))))
d40d037c
AJ		 1854 || (ELIMINATE_COPY_RELOCS
1855 && !info->shared
c434dee6
AJ		 1856 && (sec->flags & SEC_ALLOC) != 0
1857 && h != NULL
1858 && (h->root.type == bfd_link_hash_defweak
0f88be7a 1859 || !h->def_regular)))
70256ad8 1860 {
e03a8ed8
L		 1861 struct elf_dyn_relocs *p;
1862 struct elf_dyn_relocs **head;
c434dee6
AJ		 1863
1864 /* We must copy these reloc types into the output file.
1865 Create a reloc section in dynobj and make room for
1866 this reloc. */
70256ad8
AJ		 1867 if (sreloc == NULL)
1868 {
c434dee6
AJ		 1869 if (htab->elf.dynobj == NULL)
1870 htab->elf.dynobj = abfd;
1871
83bac4b0 1872 sreloc = _bfd_elf_make_dynamic_reloc_section
82e96e07
L		 1873 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1874 abfd, /*rela?*/ TRUE);
70256ad8 1875
70256ad8 1876 if (sreloc == NULL)
c2e61a4e 1877 return FALSE;
70256ad8
AJ		 1878 }
1879
c434dee6
AJ		 1880 /* If this is a global symbol, we count the number of
1881 relocations we need for this symbol. */
1882 if (h != NULL)
70256ad8 1883 {
351f65ca 1884 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
c434dee6
AJ		 1885 }
1886 else
1887 {
1888 /* Track dynamic relocs needed for local syms too.
1889 We really need local syms available to do this
1890 easily. Oh well. */
c434dee6 1891 asection *s;
87d72d41 1892 void **vpp;
87d72d41
AM		 1893
1894 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1895 abfd, r_symndx);
1896 if (isym == NULL)
1897 return FALSE;
1898
1899 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
c434dee6 1900 if (s == NULL)
87d72d41 1901 s = sec;
70256ad8 1902
e81d3500
DD		 1903 /* Beware of type punned pointers vs strict aliasing
1904 rules. */
1905 vpp = &(elf_section_data (s)->local_dynrel);
e03a8ed8 1906 head = (struct elf_dyn_relocs **)vpp;
c434dee6 1907 }
70256ad8 1908
c434dee6
AJ		 1909 p = *head;
1910 if (p == NULL || p->sec != sec)
1911 {
1912 bfd_size_type amt = sizeof *p;
d8045f23 1913
e03a8ed8 1914 p = ((struct elf_dyn_relocs *)
c434dee6 1915 bfd_alloc (htab->elf.dynobj, amt));
70256ad8 1916 if (p == NULL)
c2e61a4e 1917 return FALSE;
c434dee6
AJ		 1918 p->next = *head;
1919 *head = p;
1920 p->sec = sec;
1921 p->count = 0;
1922 p->pc_count = 0;
70256ad8 1923 }
c434dee6
AJ		 1924
1925 p->count += 1;
d8045f23 1926 if (IS_X86_64_PCREL_TYPE (r_type))
c434dee6 1927 p->pc_count += 1;
70256ad8
AJ		 1928 }
1929 break;
fe4770f4
AJ		 1930
1931 /* This relocation describes the C++ object vtable hierarchy.
1932 Reconstruct it for later use during GC. */
1933 case R_X86_64_GNU_VTINHERIT:
c152c796 1934 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c2e61a4e 1935 return FALSE;
fe4770f4
AJ		 1936 break;
1937
1938 /* This relocation describes which C++ vtable entries are actually
1939 used. Record for later use during GC. */
1940 case R_X86_64_GNU_VTENTRY:
d17e0c6e
JB		 1941 BFD_ASSERT (h != NULL);
1942 if (h != NULL
1943 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
c2e61a4e 1944 return FALSE;
fe4770f4 1945 break;
c434dee6
AJ		 1946
1947 default:
1948 break;
70256ad8
AJ		 1949 }
1950 }
1951
b34976b6 1952 return TRUE;
70256ad8
AJ		 1953}
1954
1955/* Return the section that should be marked against GC for a given
407443a3 1956 relocation. */
70256ad8
AJ		 1957
1958static asection *
351f65ca
L		 1959elf_x86_64_gc_mark_hook (asection *sec,
1960 struct bfd_link_info *info,
1961 Elf_Internal_Rela *rel,
1962 struct elf_link_hash_entry *h,
1963 Elf_Internal_Sym *sym)
70256ad8
AJ		 1964{
1965 if (h != NULL)
351f65ca 1966 switch (ELF32_R_TYPE (rel->r_info))
07adf181
AM		 1967 {
1968 case R_X86_64_GNU_VTINHERIT:
1969 case R_X86_64_GNU_VTENTRY:
1970 return NULL;
1971 }
1972
1973 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
70256ad8
AJ		 1974}
1975
407443a3 1976/* Update the got entry reference counts for the section being removed. */
70256ad8 1977
b34976b6 1978static bfd_boolean
351f65ca
L		 1979elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1980 asection *sec,
1981 const Elf_Internal_Rela *relocs)
70256ad8 1982{
351f65ca 1983 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 1984 Elf_Internal_Shdr *symtab_hdr;
1985 struct elf_link_hash_entry **sym_hashes;
1986 bfd_signed_vma *local_got_refcounts;
1987 const Elf_Internal_Rela *rel, *relend;
c434dee6 1988
7dda2462
TG		 1989 if (info->relocatable)
1990 return TRUE;
1991
351f65ca 1992 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1993 if (htab == NULL)
1994 return FALSE;
1995
c434dee6 1996 elf_section_data (sec)->local_dynrel = NULL;
70256ad8 1997
0ffa91dd 1998 symtab_hdr = &elf_symtab_hdr (abfd);
70256ad8
AJ		 1999 sym_hashes = elf_sym_hashes (abfd);
2000 local_got_refcounts = elf_local_got_refcounts (abfd);
2001
351f65ca 2002 htab = elf_x86_64_hash_table (info);
70256ad8
AJ		 2003 relend = relocs + sec->reloc_count;
2004 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 2005 {
2006 unsigned long r_symndx;
2007 unsigned int r_type;
2008 struct elf_link_hash_entry *h = NULL;
70256ad8 2009
351f65ca 2010 r_symndx = htab->r_sym (rel->r_info);
26e41594
AM		 2011 if (r_symndx >= symtab_hdr->sh_info)
2012 {
26e41594 2013 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 2014 while (h->root.type == bfd_link_hash_indirect
2015 || h->root.type == bfd_link_hash_warning)
2016 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 2017 }
bb1cb422
L		 2018 else
2019 {
2020 /* A local symbol. */
2021 Elf_Internal_Sym *isym;
2022
2023 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2024 abfd, r_symndx);
2025
2026 /* Check relocation against local STT_GNU_IFUNC symbol. */
2027 if (isym != NULL
82e96e07 2028 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
bb1cb422 2029 {
351f65ca 2030 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
bb1cb422
L		 2031 if (h == NULL)
2032 abort ();
2033 }
2034 }
c434dee6 2035
3db2e7dd
L		 2036 if (h)
2037 {
2038 struct elf_x86_64_link_hash_entry *eh;
2039 struct elf_dyn_relocs **pp;
2040 struct elf_dyn_relocs *p;
2041
2042 eh = (struct elf_x86_64_link_hash_entry *) h;
2043
2044 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2045 if (p->sec == sec)
2046 {
2047 /* Everything must go for SEC. */
2048 *pp = p->next;
2049 break;
2050 }
2051 }
2052
351f65ca
L		 2053 r_type = ELF32_R_TYPE (rel->r_info);
2054 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2055 symtab_hdr, sym_hashes,
2056 &r_type, GOT_UNKNOWN,
2057 rel, relend, h, r_symndx))
142411ca
L		 2058 return FALSE;
2059
26e41594
AM		 2060 switch (r_type)
2061 {
2062 case R_X86_64_TLSLD:
4dfe6ac6
NC		 2063 if (htab->tls_ld_got.refcount > 0)
2064 htab->tls_ld_got.refcount -= 1;
26e41594 2065 break;
c434dee6 2066
26e41594 2067 case R_X86_64_TLSGD:
67a4f2b7
AO		 2068 case R_X86_64_GOTPC32_TLSDESC:
2069 case R_X86_64_TLSDESC_CALL:
26e41594
AM		 2070 case R_X86_64_GOTTPOFF:
2071 case R_X86_64_GOT32:
2072 case R_X86_64_GOTPCREL:
7b81dfbb
AJ		 2073 case R_X86_64_GOT64:
2074 case R_X86_64_GOTPCREL64:
2075 case R_X86_64_GOTPLT64:
26e41594
AM		 2076 if (h != NULL)
2077 {
7b81dfbb 2078 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
eed180f8 2079 h->plt.refcount -= 1;
26e41594
AM		 2080 if (h->got.refcount > 0)
2081 h->got.refcount -= 1;
bb1cb422
L		 2082 if (h->type == STT_GNU_IFUNC)
2083 {
2084 if (h->plt.refcount > 0)
2085 h->plt.refcount -= 1;
2086 }
26e41594
AM		 2087 }
2088 else if (local_got_refcounts != NULL)
2089 {
2090 if (local_got_refcounts[r_symndx] > 0)
2091 local_got_refcounts[r_symndx] -= 1;
2092 }
2093 break;
c434dee6 2094
26e41594
AM		 2095 case R_X86_64_8:
2096 case R_X86_64_16:
2097 case R_X86_64_32:
2098 case R_X86_64_64:
2099 case R_X86_64_32S:
2100 case R_X86_64_PC8:
2101 case R_X86_64_PC16:
2102 case R_X86_64_PC32:
d6ab8113 2103 case R_X86_64_PC64:
3db2e7dd
L		 2104 if (info->shared
2105 && (h == NULL || h->type != STT_GNU_IFUNC))
26e41594
AM		 2106 break;
2107 /* Fall thru */
c434dee6 2108
26e41594 2109 case R_X86_64_PLT32:
7b81dfbb 2110 case R_X86_64_PLTOFF64:
26e41594
AM		 2111 if (h != NULL)
2112 {
2113 if (h->plt.refcount > 0)
2114 h->plt.refcount -= 1;
2115 }
2116 break;
70256ad8 2117
26e41594
AM		 2118 default:
2119 break;
2120 }
2121 }
70256ad8 2122
b34976b6 2123 return TRUE;
70256ad8
AJ		 2124}
2125
2126/* Adjust a symbol defined by a dynamic object and referenced by a
2127 regular object. The current definition is in some section of the
2128 dynamic object, but we're not including those sections. We have to
2129 change the definition to something the rest of the link can
407443a3 2130 understand. */
70256ad8 2131
b34976b6 2132static bfd_boolean
351f65ca
L		 2133elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2134 struct elf_link_hash_entry *h)
70256ad8 2135{
351f65ca 2136 struct elf_x86_64_link_hash_table *htab;
70256ad8 2137 asection *s;
70256ad8 2138
cbe950e9
L		 2139 /* STT_GNU_IFUNC symbol must go through PLT. */
2140 if (h->type == STT_GNU_IFUNC)
2141 {
2142 if (h->plt.refcount <= 0)
2143 {
2144 h->plt.offset = (bfd_vma) -1;
2145 h->needs_plt = 0;
2146 }
2147 return TRUE;
2148 }
2149
70256ad8
AJ		 2150 /* If this is a function, put it in the procedure linkage table. We
2151 will fill in the contents of the procedure linkage table later,
2152 when we know the address of the .got section. */
2153 if (h->type == STT_FUNC
f5385ebf 2154 || h->needs_plt)
70256ad8 2155 {
c434dee6 2156 if (h->plt.refcount <= 0
27482721
AJ		 2157 || SYMBOL_CALLS_LOCAL (info, h)
2158 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2159 && h->root.type == bfd_link_hash_undefweak))
70256ad8 2160 {
70256ad8
AJ		 2161 /* This case can occur if we saw a PLT32 reloc in an input
2162 file, but the symbol was never referred to by a dynamic
2163 object, or if all references were garbage collected. In
2164 such a case, we don't actually need to build a procedure
2165 linkage table, and we can just do a PC32 reloc instead. */
70256ad8 2166 h->plt.offset = (bfd_vma) -1;
f5385ebf 2167 h->needs_plt = 0;
70256ad8
AJ		 2168 }
2169
b34976b6 2170 return TRUE;
70256ad8 2171 }
bbd7ec4a 2172 else
c434dee6
AJ		 2173 /* It's possible that we incorrectly decided a .plt reloc was
2174 needed for an R_X86_64_PC32 reloc to a non-function sym in
2175 check_relocs. We can't decide accurately between function and
2176 non-function syms in check-relocs; Objects loaded later in
2177 the link may change h->type. So fix it now. */
bbd7ec4a 2178 h->plt.offset = (bfd_vma) -1;
70256ad8
AJ		 2179
2180 /* If this is a weak symbol, and there is a real definition, the
2181 processor independent code will have arranged for us to see the
407443a3 2182 real definition first, and we can just use the same value. */
f6e332e6 2183 if (h->u.weakdef != NULL)
70256ad8 2184 {
f6e332e6
AM		 2185 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2186 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2187 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2188 h->root.u.def.value = h->u.weakdef->root.u.def.value;
d40d037c 2189 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2190 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2191 return TRUE;
70256ad8
AJ		 2192 }
2193
2194 /* This is a reference to a symbol defined by a dynamic object which
407443a3 2195 is not a function. */
70256ad8
AJ		 2196
2197 /* If we are creating a shared library, we must presume that the
2198 only references to the symbol are via the global offset table.
2199 For such cases we need not do anything here; the relocations will
407443a3 2200 be handled correctly by relocate_section. */
70256ad8 2201 if (info->shared)
b34976b6 2202 return TRUE;
70256ad8
AJ		 2203
2204 /* If there are no references to this symbol that do not use the
2205 GOT, we don't need to generate a copy reloc. */
f5385ebf 2206 if (!h->non_got_ref)
b34976b6 2207 return TRUE;
70256ad8 2208
c434dee6
AJ		 2209 /* If -z nocopyreloc was given, we won't generate them either. */
2210 if (info->nocopyreloc)
2211 {
f5385ebf 2212 h->non_got_ref = 0;
b34976b6 2213 return TRUE;
c434dee6
AJ		 2214 }
2215
d40d037c 2216 if (ELIMINATE_COPY_RELOCS)
c434dee6 2217 {
351f65ca 2218 struct elf_x86_64_link_hash_entry * eh;
e03a8ed8 2219 struct elf_dyn_relocs *p;
c434dee6 2220
351f65ca 2221 eh = (struct elf_x86_64_link_hash_entry *) h;
d40d037c
AJ		 2222 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2223 {
2224 s = p->sec->output_section;
2225 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2226 break;
2227 }
2228
2229 /* If we didn't find any dynamic relocs in read-only sections, then
2230 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2231 if (p == NULL)
2232 {
f5385ebf 2233 h->non_got_ref = 0;
d40d037c
AJ		 2234 return TRUE;
2235 }
c434dee6
AJ		 2236 }
2237
70256ad8 2238 /* We must allocate the symbol in our .dynbss section, which will
407443a3 2239 become part of the .bss section of the executable. There will be
70256ad8
AJ		 2240 an entry for this symbol in the .dynsym section. The dynamic
2241 object will contain position independent code, so all references
2242 from the dynamic object to this symbol will go through the global
2243 offset table. The dynamic linker will use the .dynsym entry to
2244 determine the address it must put in the global offset table, so
2245 both the dynamic object and the regular object will refer to the
2246 same memory location for the variable. */
2247
351f65ca 2248 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2249 if (htab == NULL)
2250 return FALSE;
70256ad8
AJ		 2251
2252 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2253 to copy the initial value out of the dynamic object and into the
cedb70c5 2254 runtime process image. */
1d7e9d18 2255 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
70256ad8 2256 {
351f65ca
L		 2257 const struct elf_backend_data *bed;
2258 bed = get_elf_backend_data (info->output_bfd);
2259 htab->srelbss->size += bed->s->sizeof_rela;
f5385ebf 2260 h->needs_copy = 1;
70256ad8
AJ		 2261 }
2262
c434dee6 2263 s = htab->sdynbss;
70256ad8 2264
027297b7 2265 return _bfd_elf_adjust_dynamic_copy (h, s);
70256ad8
AJ		 2266}
2267
c434dee6
AJ		 2268/* Allocate space in .plt, .got and associated reloc sections for
2269 dynamic relocs. */
2270
b34976b6 2271static bfd_boolean
351f65ca 2272elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
c434dee6
AJ		 2273{
2274 struct bfd_link_info *info;
351f65ca
L		 2275 struct elf_x86_64_link_hash_table *htab;
2276 struct elf_x86_64_link_hash_entry *eh;
e03a8ed8 2277 struct elf_dyn_relocs *p;
351f65ca 2278 const struct elf_backend_data *bed;
eed180f8 2279 unsigned int plt_entry_size;
c434dee6 2280
e92d460e 2281 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2282 return TRUE;
c434dee6 2283
351f65ca 2284 eh = (struct elf_x86_64_link_hash_entry *) h;
e92d460e 2285
c434dee6 2286 info = (struct bfd_link_info *) inf;
351f65ca 2287 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2288 if (htab == NULL)
2289 return FALSE;
351f65ca 2290 bed = get_elf_backend_data (info->output_bfd);
eed180f8 2291 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
c434dee6 2292
cbe950e9
L		 2293 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2294 here if it is defined and referenced in a non-shared object. */
2295 if (h->type == STT_GNU_IFUNC
2296 && h->def_regular)
e03a8ed8
L		 2297 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2298 &eh->dyn_relocs,
eed180f8 2299 plt_entry_size,
e03a8ed8 2300 GOT_ENTRY_SIZE);
cbe950e9
L		 2301 else if (htab->elf.dynamic_sections_created
2302 && h->plt.refcount > 0)
c434dee6
AJ		 2303 {
2304 /* Make sure this symbol is output as a dynamic symbol.
2305 Undefined weak syms won't yet be marked as dynamic. */
2306 if (h->dynindx == -1
f5385ebf 2307 && !h->forced_local)
c434dee6 2308 {
c152c796 2309 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2310 return FALSE;
c434dee6
AJ		 2311 }
2312
27482721
AJ		 2313 if (info->shared
2314 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
c434dee6 2315 {
6de2ae4a 2316 asection *s = htab->elf.splt;
c434dee6
AJ		 2317
2318 /* If this is the first .plt entry, make room for the special
2319 first entry. */
eea6121a 2320 if (s->size == 0)
eed180f8 2321 s->size += plt_entry_size;
c434dee6 2322
eea6121a 2323 h->plt.offset = s->size;
c434dee6
AJ		 2324
2325 /* If this symbol is not defined in a regular file, and we are
2326 not generating a shared library, then set the symbol to this
2327 location in the .plt. This is required to make function
2328 pointers compare as equal between the normal executable and
2329 the shared library. */
2330 if (! info->shared
f5385ebf 2331 && !h->def_regular)
c434dee6
AJ		 2332 {
2333 h->root.u.def.section = s;
2334 h->root.u.def.value = h->plt.offset;
2335 }
2336
2337 /* Make room for this entry. */
eed180f8 2338 s->size += plt_entry_size;
c434dee6
AJ		 2339
2340 /* We also need to make an entry in the .got.plt section, which
2341 will be placed in the .got section by the linker script. */
6de2ae4a 2342 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
c434dee6
AJ		 2343
2344 /* We also need to make an entry in the .rela.plt section. */
351f65ca 2345 htab->elf.srelplt->size += bed->s->sizeof_rela;
6de2ae4a 2346 htab->elf.srelplt->reloc_count++;
c434dee6
AJ		 2347 }
2348 else
2349 {
2350 h->plt.offset = (bfd_vma) -1;
f5385ebf 2351 h->needs_plt = 0;
c434dee6
AJ		 2352 }
2353 }
2354 else
2355 {
2356 h->plt.offset = (bfd_vma) -1;
f5385ebf 2357 h->needs_plt = 0;
c434dee6
AJ		 2358 }
2359
67a4f2b7
AO		 2360 eh->tlsdesc_got = (bfd_vma) -1;
2361
bffbf940
JJ		 2362 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2363 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2364 if (h->got.refcount > 0
1d85728f 2365 && info->executable
bffbf940 2366 && h->dynindx == -1
351f65ca 2367 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
d8045f23
NC		 2368 {
2369 h->got.offset = (bfd_vma) -1;
2370 }
bffbf940 2371 else if (h->got.refcount > 0)
c434dee6
AJ		 2372 {
2373 asection *s;
b34976b6 2374 bfd_boolean dyn;
351f65ca 2375 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
c434dee6
AJ		 2376
2377 /* Make sure this symbol is output as a dynamic symbol.
2378 Undefined weak syms won't yet be marked as dynamic. */
2379 if (h->dynindx == -1
f5385ebf 2380 && !h->forced_local)
c434dee6 2381 {
c152c796 2382 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2383 return FALSE;
c434dee6
AJ		 2384 }
2385
67a4f2b7
AO		 2386 if (GOT_TLS_GDESC_P (tls_type))
2387 {
6de2ae4a 2388 eh->tlsdesc_got = htab->elf.sgotplt->size
351f65ca 2389 - elf_x86_64_compute_jump_table_size (htab);
6de2ae4a 2390 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
67a4f2b7
AO		 2391 h->got.offset = (bfd_vma) -2;
2392 }
2393 if (! GOT_TLS_GDESC_P (tls_type)
2394 || GOT_TLS_GD_P (tls_type))
2395 {
6de2ae4a 2396 s = htab->elf.sgot;
67a4f2b7
AO		 2397 h->got.offset = s->size;
2398 s->size += GOT_ENTRY_SIZE;
2399 if (GOT_TLS_GD_P (tls_type))
2400 s->size += GOT_ENTRY_SIZE;
2401 }
c434dee6 2402 dyn = htab->elf.dynamic_sections_created;
bffbf940
JJ		 2403 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2404 and two if global.
2405 R_X86_64_GOTTPOFF needs one dynamic relocation. */
67a4f2b7 2406 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
bffbf940 2407 || tls_type == GOT_TLS_IE)
351f65ca 2408 htab->elf.srelgot->size += bed->s->sizeof_rela;
67a4f2b7 2409 else if (GOT_TLS_GD_P (tls_type))
351f65ca 2410 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
67a4f2b7
AO		 2411 else if (! GOT_TLS_GDESC_P (tls_type)
2412 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2413 || h->root.type != bfd_link_hash_undefweak)
27482721
AJ		 2414 && (info->shared
2415 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
351f65ca 2416 htab->elf.srelgot->size += bed->s->sizeof_rela;
67a4f2b7
AO		 2417 if (GOT_TLS_GDESC_P (tls_type))
2418 {
351f65ca 2419 htab->elf.srelplt->size += bed->s->sizeof_rela;
67a4f2b7
AO		 2420 htab->tlsdesc_plt = (bfd_vma) -1;
2421 }
c434dee6
AJ		 2422 }
2423 else
2424 h->got.offset = (bfd_vma) -1;
2425
c434dee6 2426 if (eh->dyn_relocs == NULL)
b34976b6 2427 return TRUE;
c434dee6
AJ		 2428
2429 /* In the shared -Bsymbolic case, discard space allocated for
2430 dynamic pc-relative relocs against symbols which turn out to be
2431 defined in regular objects. For the normal shared case, discard
2432 space for pc-relative relocs that have become local due to symbol
2433 visibility changes. */
2434
2435 if (info->shared)
2436 {
27482721
AJ		 2437 /* Relocs that use pc_count are those that appear on a call
2438 insn, or certain REL relocs that can generated via assembly.
2439 We want calls to protected symbols to resolve directly to the
2440 function rather than going via the plt. If people want
2441 function pointer comparisons to work as expected then they
2442 should avoid writing weird assembly. */
2443 if (SYMBOL_CALLS_LOCAL (info, h))
c434dee6 2444 {
e03a8ed8 2445 struct elf_dyn_relocs **pp;
c434dee6
AJ		 2446
2447 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2448 {
2449 p->count -= p->pc_count;
2450 p->pc_count = 0;
2451 if (p->count == 0)
2452 *pp = p->next;
2453 else
2454 pp = &p->next;
2455 }
2456 }
4e795f50
AM		 2457
2458 /* Also discard relocs on undefined weak syms with non-default
2459 visibility. */
22d606e9 2460 if (eh->dyn_relocs != NULL
4e795f50 2461 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 2462 {
2463 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2464 eh->dyn_relocs = NULL;
2465
2466 /* Make sure undefined weak symbols are output as a dynamic
2467 symbol in PIEs. */
2468 else if (h->dynindx == -1
d8045f23
NC		 2469 && ! h->forced_local
2470 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2471 return FALSE;
22d606e9 2472 }
cbe950e9 2473
d8045f23 2474 }
d40d037c 2475 else if (ELIMINATE_COPY_RELOCS)
c434dee6
AJ		 2476 {
2477 /* For the non-shared case, discard space for relocs against
2478 symbols which turn out to need copy relocs or are not
2479 dynamic. */
2480
f5385ebf
AM		 2481 if (!h->non_got_ref
2482 && ((h->def_dynamic
2483 && !h->def_regular)
c434dee6
AJ		 2484 || (htab->elf.dynamic_sections_created
2485 && (h->root.type == bfd_link_hash_undefweak
2486 || h->root.type == bfd_link_hash_undefined))))
2487 {
2488 /* Make sure this symbol is output as a dynamic symbol.
2489 Undefined weak syms won't yet be marked as dynamic. */
2490 if (h->dynindx == -1
d8045f23
NC		 2491 && ! h->forced_local
2492 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2493 return FALSE;
c434dee6
AJ		 2494
2495 /* If that succeeded, we know we'll be keeping all the
2496 relocs. */
2497 if (h->dynindx != -1)
2498 goto keep;
2499 }
2500
2501 eh->dyn_relocs = NULL;
2502
2503 keep: ;
2504 }
2505
2506 /* Finally, allocate space. */
2507 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2508 {
e7c33416
NC		 2509 asection * sreloc;
2510
cbe950e9 2511 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2512
2513 BFD_ASSERT (sreloc != NULL);
2514
351f65ca 2515 sreloc->size += p->count * bed->s->sizeof_rela;
c434dee6
AJ		 2516 }
2517
b34976b6 2518 return TRUE;
c434dee6
AJ		 2519}
2520
c25bc9fc
L		 2521/* Allocate space in .plt, .got and associated reloc sections for
2522 local dynamic relocs. */
2523
2524static bfd_boolean
351f65ca 2525elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
c25bc9fc
L		 2526{
2527 struct elf_link_hash_entry *h
2528 = (struct elf_link_hash_entry *) *slot;
2529
2530 if (h->type != STT_GNU_IFUNC
2531 || !h->def_regular
2532 || !h->ref_regular
2533 || !h->forced_local
2534 || h->root.type != bfd_link_hash_defined)
2535 abort ();
2536
351f65ca 2537 return elf_x86_64_allocate_dynrelocs (h, inf);
c25bc9fc
L		 2538}
2539
c434dee6
AJ		 2540/* Find any dynamic relocs that apply to read-only sections. */
2541
b34976b6 2542static bfd_boolean
351f65ca
L		 2543elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2544 void * inf)
c434dee6 2545{
351f65ca 2546 struct elf_x86_64_link_hash_entry *eh;
e03a8ed8 2547 struct elf_dyn_relocs *p;
c434dee6 2548
aa715242
L		 2549 /* Skip local IFUNC symbols. */
2550 if (h->forced_local && h->type == STT_GNU_IFUNC)
2551 return TRUE;
2552
351f65ca 2553 eh = (struct elf_x86_64_link_hash_entry *) h;
c434dee6
AJ		 2554 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2555 {
2556 asection *s = p->sec->output_section;
2557
2558 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2559 {
2560 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2561
2562 info->flags |= DF_TEXTREL;
2563
b70321a2
L		 2564 if (info->warn_shared_textrel && info->shared)
2565 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2566 p->sec->owner, h->root.root.string,
2567 p->sec);
2568
c434dee6 2569 /* Not an error, just cut short the traversal. */
b34976b6 2570 return FALSE;
c434dee6
AJ		 2571 }
2572 }
b34976b6 2573 return TRUE;
c434dee6
AJ		 2574}
2575
70256ad8
AJ		 2576/* Set the sizes of the dynamic sections. */
2577
b34976b6 2578static bfd_boolean
351f65ca
L		 2579elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2580 struct bfd_link_info *info)
70256ad8 2581{
351f65ca 2582 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 2583 bfd *dynobj;
2584 asection *s;
b34976b6 2585 bfd_boolean relocs;
c434dee6 2586 bfd *ibfd;
351f65ca 2587 const struct elf_backend_data *bed;
70256ad8 2588
351f65ca 2589 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2590 if (htab == NULL)
2591 return FALSE;
351f65ca 2592 bed = get_elf_backend_data (output_bfd);
4dfe6ac6 2593
c434dee6
AJ		 2594 dynobj = htab->elf.dynobj;
2595 if (dynobj == NULL)
2596 abort ();
70256ad8 2597
c434dee6 2598 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 2599 {
2600 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 2601 if (info->executable)
70256ad8
AJ		 2602 {
2603 s = bfd_get_section_by_name (dynobj, ".interp");
c434dee6
AJ		 2604 if (s == NULL)
2605 abort ();
351f65ca
L		 2606 s->size = htab->dynamic_interpreter_size;
2607 s->contents = (unsigned char *) htab->dynamic_interpreter;
70256ad8
AJ		 2608 }
2609 }
70256ad8 2610
c434dee6
AJ		 2611 /* Set up .got offsets for local syms, and space for local dynamic
2612 relocs. */
2613 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
70256ad8 2614 {
c434dee6
AJ		 2615 bfd_signed_vma *local_got;
2616 bfd_signed_vma *end_local_got;
bffbf940 2617 char *local_tls_type;
67a4f2b7 2618 bfd_vma *local_tlsdesc_gotent;
c434dee6
AJ		 2619 bfd_size_type locsymcount;
2620 Elf_Internal_Shdr *symtab_hdr;
2621 asection *srel;
70256ad8 2622
0ffa91dd 2623 if (! is_x86_64_elf (ibfd))
70256ad8
AJ		 2624 continue;
2625
c434dee6 2626 for (s = ibfd->sections; s != NULL; s = s->next)
70256ad8 2627 {
e03a8ed8 2628 struct elf_dyn_relocs *p;
c434dee6 2629
e03a8ed8 2630 for (p = (struct elf_dyn_relocs *)
e81d3500 2631 (elf_section_data (s)->local_dynrel);
c434dee6
AJ		 2632 p != NULL;
2633 p = p->next)
70256ad8 2634 {
c434dee6
AJ		 2635 if (!bfd_is_abs_section (p->sec)
2636 && bfd_is_abs_section (p->sec->output_section))
2637 {
2638 /* Input section has been discarded, either because
2639 it is a copy of a linkonce section or due to
2640 linker script /DISCARD/, so we'll be discarding
2641 the relocs too. */
2642 }
2643 else if (p->count != 0)
2644 {
2645 srel = elf_section_data (p->sec)->sreloc;
351f65ca 2646 srel->size += p->count * bed->s->sizeof_rela;
4b819e1f
L		 2647 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2648 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 2649 {
2650 info->flags |= DF_TEXTREL;
2651 if (info->warn_shared_textrel && info->shared)
2652 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2653 p->sec->owner, p->sec);
b70321a2 2654 }
c434dee6 2655 }
70256ad8
AJ		 2656 }
2657 }
c434dee6
AJ		 2658
2659 local_got = elf_local_got_refcounts (ibfd);
2660 if (!local_got)
2661 continue;
2662
0ffa91dd 2663 symtab_hdr = &elf_symtab_hdr (ibfd);
c434dee6
AJ		 2664 locsymcount = symtab_hdr->sh_info;
2665 end_local_got = local_got + locsymcount;
351f65ca
L		 2666 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2667 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 2668 s = htab->elf.sgot;
2669 srel = htab->elf.srelgot;
67a4f2b7
AO		 2670 for (; local_got < end_local_got;
2671 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
70256ad8 2672 {
67a4f2b7 2673 *local_tlsdesc_gotent = (bfd_vma) -1;
c434dee6 2674 if (*local_got > 0)
70256ad8 2675 {
67a4f2b7
AO		 2676 if (GOT_TLS_GDESC_P (*local_tls_type))
2677 {
6de2ae4a 2678 *local_tlsdesc_gotent = htab->elf.sgotplt->size
351f65ca 2679 - elf_x86_64_compute_jump_table_size (htab);
6de2ae4a 2680 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
67a4f2b7
AO		 2681 *local_got = (bfd_vma) -2;
2682 }
2683 if (! GOT_TLS_GDESC_P (*local_tls_type)
2684 || GOT_TLS_GD_P (*local_tls_type))
2685 {
2686 *local_got = s->size;
2687 s->size += GOT_ENTRY_SIZE;
2688 if (GOT_TLS_GD_P (*local_tls_type))
2689 s->size += GOT_ENTRY_SIZE;
2690 }
bffbf940 2691 if (info->shared
67a4f2b7 2692 || GOT_TLS_GD_ANY_P (*local_tls_type)
bffbf940 2693 || *local_tls_type == GOT_TLS_IE)
67a4f2b7
AO		 2694 {
2695 if (GOT_TLS_GDESC_P (*local_tls_type))
2696 {
6de2ae4a 2697 htab->elf.srelplt->size
351f65ca 2698 += bed->s->sizeof_rela;
67a4f2b7
AO		 2699 htab->tlsdesc_plt = (bfd_vma) -1;
2700 }
2701 if (! GOT_TLS_GDESC_P (*local_tls_type)
2702 || GOT_TLS_GD_P (*local_tls_type))
351f65ca 2703 srel->size += bed->s->sizeof_rela;
67a4f2b7 2704 }
70256ad8
AJ		 2705 }
2706 else
c434dee6
AJ		 2707 *local_got = (bfd_vma) -1;
2708 }
2709 }
70256ad8 2710
bffbf940
JJ		 2711 if (htab->tls_ld_got.refcount > 0)
2712 {
2713 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2714 relocs. */
6de2ae4a
L		 2715 htab->tls_ld_got.offset = htab->elf.sgot->size;
2716 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
351f65ca 2717 htab->elf.srelgot->size += bed->s->sizeof_rela;
bffbf940
JJ		 2718 }
2719 else
2720 htab->tls_ld_got.offset = -1;
2721
c434dee6
AJ		 2722 /* Allocate global sym .plt and .got entries, and space for global
2723 sym dynamic relocs. */
351f65ca 2724 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
eb4ff4d6 2725 info);
c434dee6 2726
c25bc9fc
L		 2727 /* Allocate .plt and .got entries, and space for local symbols. */
2728 htab_traverse (htab->loc_hash_table,
351f65ca 2729 elf_x86_64_allocate_local_dynrelocs,
c25bc9fc
L		 2730 info);
2731
67a4f2b7
AO		 2732 /* For every jump slot reserved in the sgotplt, reloc_count is
2733 incremented. However, when we reserve space for TLS descriptors,
2734 it's not incremented, so in order to compute the space reserved
2735 for them, it suffices to multiply the reloc count by the jump
e1f98742
L		 2736 slot size.
2737
2738 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2739 so that R_X86_64_IRELATIVE entries come last. */
6de2ae4a 2740 if (htab->elf.srelplt)
e1f98742
L		 2741 {
2742 htab->sgotplt_jump_table_size
2743 = elf_x86_64_compute_jump_table_size (htab);
2744 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2745 }
2746 else if (htab->elf.irelplt)
2747 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
67a4f2b7
AO		 2748
2749 if (htab->tlsdesc_plt)
2750 {
2751 /* If we're not using lazy TLS relocations, don't generate the
2752 PLT and GOT entries they require. */
2753 if ((info->flags & DF_BIND_NOW))
2754 htab->tlsdesc_plt = 0;
2755 else
2756 {
6de2ae4a
L		 2757 htab->tlsdesc_got = htab->elf.sgot->size;
2758 htab->elf.sgot->size += GOT_ENTRY_SIZE;
67a4f2b7
AO		 2759 /* Reserve room for the initial entry.
2760 FIXME: we could probably do away with it in this case. */
6de2ae4a 2761 if (htab->elf.splt->size == 0)
eed180f8 2762 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
6de2ae4a 2763 htab->tlsdesc_plt = htab->elf.splt->size;
eed180f8 2764 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
67a4f2b7
AO		 2765 }
2766 }
2767
a7b16ceb
L		 2768 if (htab->elf.sgotplt)
2769 {
e28df02b
L		 2770 struct elf_link_hash_entry *got;
2771 got = elf_link_hash_lookup (elf_hash_table (info),
2772 "_GLOBAL_OFFSET_TABLE_",
2773 FALSE, FALSE, FALSE);
2774
a7b16ceb 2775 /* Don't allocate .got.plt section if there are no GOT nor PLT
eed180f8 2776 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
e28df02b
L		 2777 if ((got == NULL
2778 || !got->ref_regular_nonweak)
2779 && (htab->elf.sgotplt->size
2780 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 2781 && (htab->elf.splt == NULL
2782 || htab->elf.splt->size == 0)
2783 && (htab->elf.sgot == NULL
2784 || htab->elf.sgot->size == 0)
2785 && (htab->elf.iplt == NULL
2786 || htab->elf.iplt->size == 0)
2787 && (htab->elf.igotplt == NULL
2788 || htab->elf.igotplt->size == 0))
2789 htab->elf.sgotplt->size = 0;
2790 }
2791
9a2a56cc
AM		 2792 if (htab->plt_eh_frame != NULL
2793 && htab->elf.splt != NULL
2794 && htab->elf.splt->size != 0
2795 && !bfd_is_abs_section (htab->elf.splt->output_section)
2796 && _bfd_elf_eh_frame_present (info))
2797 {
2798 const struct elf_x86_64_backend_data *arch_data
2799 = (const struct elf_x86_64_backend_data *) bed->arch_data;
2800 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2801 }
2802
c434dee6
AJ		 2803 /* We now have determined the sizes of the various dynamic sections.
2804 Allocate memory for them. */
b34976b6 2805 relocs = FALSE;
c434dee6
AJ		 2806 for (s = dynobj->sections; s != NULL; s = s->next)
2807 {
2808 if ((s->flags & SEC_LINKER_CREATED) == 0)
2809 continue;
2810
6de2ae4a
L		 2811 if (s == htab->elf.splt
2812 || s == htab->elf.sgot
2813 || s == htab->elf.sgotplt
2814 || s == htab->elf.iplt
2815 || s == htab->elf.igotplt
9a2a56cc 2816 || s == htab->plt_eh_frame
75ff4589 2817 || s == htab->sdynbss)
c434dee6
AJ		 2818 {
2819 /* Strip this section if we don't need it; see the
2820 comment below. */
2821 }
0112cd26 2822 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
c434dee6 2823 {
6de2ae4a 2824 if (s->size != 0 && s != htab->elf.srelplt)
b34976b6 2825 relocs = TRUE;
c434dee6
AJ		 2826
2827 /* We use the reloc_count field as a counter if we need
2828 to copy relocs into the output file. */
6de2ae4a 2829 if (s != htab->elf.srelplt)
67a4f2b7 2830 s->reloc_count = 0;
70256ad8 2831 }
c434dee6 2832 else
70256ad8
AJ		 2833 {
2834 /* It's not one of our sections, so don't allocate space. */
2835 continue;
2836 }
2837
eea6121a 2838 if (s->size == 0)
70256ad8 2839 {
c434dee6
AJ		 2840 /* If we don't need this section, strip it from the
2841 output file. This is mostly to handle .rela.bss and
2842 .rela.plt. We must create both sections in
2843 create_dynamic_sections, because they must be created
2844 before the linker maps input sections to output
2845 sections. The linker does that before
2846 adjust_dynamic_symbol is called, and it is that
2847 function which decides whether anything needs to go
2848 into these sections. */
2849
8423293d 2850 s->flags |= SEC_EXCLUDE;
70256ad8
AJ		 2851 continue;
2852 }
2853
c456f082
AM		 2854 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2855 continue;
2856
70256ad8
AJ		 2857 /* Allocate memory for the section contents. We use bfd_zalloc
2858 here in case unused entries are not reclaimed before the
2859 section's contents are written out. This should not happen,
2860 but this way if it does, we get a R_X86_64_NONE reloc instead
2861 of garbage. */
eea6121a 2862 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c434dee6 2863 if (s->contents == NULL)
b34976b6 2864 return FALSE;
70256ad8
AJ		 2865 }
2866
e41b3a13 2867 if (htab->plt_eh_frame != NULL
9a2a56cc
AM		 2868 && htab->plt_eh_frame->contents != NULL)
2869 {
2870 const struct elf_x86_64_backend_data *arch_data
2871 = (const struct elf_x86_64_backend_data *) bed->arch_data;
2872
2873 memcpy (htab->plt_eh_frame->contents,
2874 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
2875 bfd_put_32 (dynobj, htab->elf.splt->size,
2876 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2877 }
e41b3a13 2878
c434dee6 2879 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 2880 {
2881 /* Add some entries to the .dynamic section. We fill in the
351f65ca 2882 values later, in elf_x86_64_finish_dynamic_sections, but we
70256ad8 2883 must add the entries now so that we get the correct size for
407443a3 2884 the .dynamic section. The DT_DEBUG entry is filled in by the
70256ad8 2885 dynamic linker and used by the debugger. */
dc810e39 2886#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2887 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2888
36af4a4e 2889 if (info->executable)
70256ad8 2890 {
dc810e39 2891 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2892 return FALSE;
70256ad8
AJ		 2893 }
2894
6de2ae4a 2895 if (htab->elf.splt->size != 0)
70256ad8 2896 {
dc810e39
AM		 2897 if (!add_dynamic_entry (DT_PLTGOT, 0)
2898 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2899 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2900 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2901 return FALSE;
67a4f2b7
AO		 2902
2903 if (htab->tlsdesc_plt
2904 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2905 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2906 return FALSE;
70256ad8
AJ		 2907 }
2908
2909 if (relocs)
2910 {
dc810e39
AM		 2911 if (!add_dynamic_entry (DT_RELA, 0)
2912 || !add_dynamic_entry (DT_RELASZ, 0)
351f65ca 2913 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
b34976b6 2914 return FALSE;
70256ad8 2915
c434dee6
AJ		 2916 /* If any dynamic relocs apply to a read-only section,
2917 then we need a DT_TEXTREL entry. */
2918 if ((info->flags & DF_TEXTREL) == 0)
eed180f8 2919 elf_link_hash_traverse (&htab->elf,
351f65ca 2920 elf_x86_64_readonly_dynrelocs,
eb4ff4d6 2921 info);
c434dee6
AJ		 2922
2923 if ((info->flags & DF_TEXTREL) != 0)
2924 {
2925 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2926 return FALSE;
c434dee6 2927 }
70256ad8
AJ		 2928 }
2929 }
dc810e39 2930#undef add_dynamic_entry
70256ad8 2931
b34976b6 2932 return TRUE;
70256ad8
AJ		 2933}
2934
67a4f2b7 2935static bfd_boolean
351f65ca
L		 2936elf_x86_64_always_size_sections (bfd *output_bfd,
2937 struct bfd_link_info *info)
67a4f2b7
AO		 2938{
2939 asection *tls_sec = elf_hash_table (info)->tls_sec;
2940
2941 if (tls_sec)
2942 {
2943 struct elf_link_hash_entry *tlsbase;
2944
2945 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2946 "_TLS_MODULE_BASE_",
2947 FALSE, FALSE, FALSE);
2948
2949 if (tlsbase && tlsbase->type == STT_TLS)
2950 {
351f65ca 2951 struct elf_x86_64_link_hash_table *htab;
67a4f2b7
AO		 2952 struct bfd_link_hash_entry *bh = NULL;
2953 const struct elf_backend_data *bed
2954 = get_elf_backend_data (output_bfd);
2955
351f65ca 2956 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2957 if (htab == NULL)
2958 return FALSE;
2959
67a4f2b7
AO		 2960 if (!(_bfd_generic_link_add_one_symbol
2961 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2962 tls_sec, 0, NULL, FALSE,
2963 bed->collect, &bh)))
2964 return FALSE;
9f03412a 2965
4dfe6ac6 2966 htab->tls_module_base = bh;
9f03412a 2967
67a4f2b7
AO		 2968 tlsbase = (struct elf_link_hash_entry *)bh;
2969 tlsbase->def_regular = 1;
2970 tlsbase->other = STV_HIDDEN;
2971 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2972 }
2973 }
2974
2975 return TRUE;
2976}
2977
9f03412a
AO		 2978/* _TLS_MODULE_BASE_ needs to be treated especially when linking
2979 executables. Rather than setting it to the beginning of the TLS
2980 section, we have to set it to the end. This function may be called
2981 multiple times, it is idempotent. */
2982
2983static void
351f65ca 2984elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
9f03412a 2985{
351f65ca 2986 struct elf_x86_64_link_hash_table *htab;
9f03412a
AO		 2987 struct bfd_link_hash_entry *base;
2988
2989 if (!info->executable)
2990 return;
2991
351f65ca 2992 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2993 if (htab == NULL)
2994 return;
9f03412a 2995
4dfe6ac6
NC		 2996 base = htab->tls_module_base;
2997 if (base == NULL)
9f03412a
AO		 2998 return;
2999
4dfe6ac6 3000 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 3001}
3002
bffbf940
JJ		 3003/* Return the base VMA address which should be subtracted from real addresses
3004 when resolving @dtpoff relocation.
3005 This is PT_TLS segment p_vaddr. */
3006
3007static bfd_vma
351f65ca 3008elf_x86_64_dtpoff_base (struct bfd_link_info *info)
bffbf940 3009{
e1918d23
AM		 3010 /* If tls_sec is NULL, we should have signalled an error already. */
3011 if (elf_hash_table (info)->tls_sec == NULL)
bffbf940 3012 return 0;
e1918d23 3013 return elf_hash_table (info)->tls_sec->vma;
bffbf940
JJ		 3014}
3015
3016/* Return the relocation value for @tpoff relocation
3017 if STT_TLS virtual address is ADDRESS. */
3018
3019static bfd_vma
351f65ca 3020elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
bffbf940 3021{
e1918d23 3022 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 3023 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3024 bfd_vma static_tls_size;
bffbf940
JJ		 3025
3026 /* If tls_segment is NULL, we should have signalled an error already. */
e1918d23 3027 if (htab->tls_sec == NULL)
bffbf940 3028 return 0;
7dc98aea
RO		 3029
3030 /* Consider special static TLS alignment requirements. */
3031 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3032 return address - static_tls_size - htab->tls_sec->vma;
bffbf940
JJ		 3033}
3034
90f487df
L		 3035/* Is the instruction before OFFSET in CONTENTS a 32bit relative
3036 branch? */
3037
3038static bfd_boolean
3039is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3040{
3041 /* Opcode Instruction
3042 0xe8 call
3043 0xe9 jump
3044 0x0f 0x8x conditional jump */
3045 return ((offset > 0
3046 && (contents [offset - 1] == 0xe8
3047 || contents [offset - 1] == 0xe9))
3048 || (offset > 1
3049 && contents [offset - 2] == 0x0f
3050 && (contents [offset - 1] & 0xf0) == 0x80));
3051}
3052
8d88c4ca
NC		 3053/* Relocate an x86_64 ELF section. */
3054
b34976b6 3055static bfd_boolean
351f65ca
L		 3056elf_x86_64_relocate_section (bfd *output_bfd,
3057 struct bfd_link_info *info,
3058 bfd *input_bfd,
3059 asection *input_section,
3060 bfd_byte *contents,
3061 Elf_Internal_Rela *relocs,
3062 Elf_Internal_Sym *local_syms,
3063 asection **local_sections)
8d88c4ca 3064{
351f65ca 3065 struct elf_x86_64_link_hash_table *htab;
8d88c4ca
NC		 3066 Elf_Internal_Shdr *symtab_hdr;
3067 struct elf_link_hash_entry **sym_hashes;
3068 bfd_vma *local_got_offsets;
67a4f2b7 3069 bfd_vma *local_tlsdesc_gotents;
c434dee6 3070 Elf_Internal_Rela *rel;
8d88c4ca 3071 Elf_Internal_Rela *relend;
eed180f8 3072 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
8d88c4ca 3073
0ffa91dd
NC		 3074 BFD_ASSERT (is_x86_64_elf (input_bfd));
3075
351f65ca 3076 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 3077 if (htab == NULL)
3078 return FALSE;
0ffa91dd 3079 symtab_hdr = &elf_symtab_hdr (input_bfd);
8d88c4ca
NC		 3080 sym_hashes = elf_sym_hashes (input_bfd);
3081 local_got_offsets = elf_local_got_offsets (input_bfd);
351f65ca 3082 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
8d88c4ca 3083
351f65ca 3084 elf_x86_64_set_tls_module_base (info);
9f03412a 3085
c434dee6 3086 rel = relocs;
8d88c4ca 3087 relend = relocs + input_section->reloc_count;
c434dee6 3088 for (; rel < relend; rel++)
8d88c4ca 3089 {
bffbf940 3090 unsigned int r_type;
8d88c4ca
NC		 3091 reloc_howto_type *howto;
3092 unsigned long r_symndx;
3093 struct elf_link_hash_entry *h;
3094 Elf_Internal_Sym *sym;
3095 asection *sec;
67a4f2b7 3096 bfd_vma off, offplt;
8d88c4ca 3097 bfd_vma relocation;
b34976b6 3098 bfd_boolean unresolved_reloc;
8d88c4ca 3099 bfd_reloc_status_type r;
bffbf940 3100 int tls_type;
cbe950e9 3101 asection *base_got;
8d88c4ca 3102
351f65ca 3103 r_type = ELF32_R_TYPE (rel->r_info);
fe4770f4
AJ		 3104 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3105 || r_type == (int) R_X86_64_GNU_VTENTRY)
3106 continue;
8d88c4ca 3107
bffbf940 3108 if (r_type >= R_X86_64_max)
8da6118f
KH		 3109 {
3110 bfd_set_error (bfd_error_bad_value);
b34976b6 3111 return FALSE;
8da6118f 3112 }
8d88c4ca 3113
d7921315 3114 if (r_type != (int) R_X86_64_32
eed180f8 3115 || ABI_64_P (output_bfd))
d7921315
L		 3116 howto = x86_64_elf_howto_table + r_type;
3117 else
3118 howto = (x86_64_elf_howto_table
3119 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
351f65ca 3120 r_symndx = htab->r_sym (rel->r_info);
8d88c4ca
NC		 3121 h = NULL;
3122 sym = NULL;
3123 sec = NULL;
b34976b6 3124 unresolved_reloc = FALSE;
8d88c4ca 3125 if (r_symndx < symtab_hdr->sh_info)
8da6118f
KH		 3126 {
3127 sym = local_syms + r_symndx;
3128 sec = local_sections[r_symndx];
c434dee6 3129
c25bc9fc
L		 3130 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3131 &sec, rel);
3132
3133 /* Relocate against local STT_GNU_IFUNC symbol. */
1f85278f 3134 if (!info->relocatable
351f65ca 3135 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc 3136 {
351f65ca
L		 3137 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3138 rel, FALSE);
c25bc9fc
L		 3139 if (h == NULL)
3140 abort ();
3141
eed180f8 3142 /* Set STT_GNU_IFUNC symbol value. */
c25bc9fc
L		 3143 h->root.u.def.value = sym->st_value;
3144 h->root.u.def.section = sec;
3145 }
8da6118f 3146 }
8d88c4ca 3147 else
8da6118f 3148 {
c9736ba0 3149 bfd_boolean warned ATTRIBUTE_UNUSED;
c434dee6 3150
b2a8e766
AM		 3151 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3152 r_symndx, symtab_hdr, sym_hashes,
3153 h, sec, relocation,
3154 unresolved_reloc, warned);
8da6118f 3155 }
ab96bf03 3156
dbaa2011 3157 if (sec != NULL && discarded_section (sec))
0672748a 3158 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 3159 rel, 1, relend, howto, 0, contents);
ab96bf03
AM		 3160
3161 if (info->relocatable)
3162 continue;
3163
64d25c44
L		 3164 if (rel->r_addend == 0
3165 && r_type == R_X86_64_64
3166 && !ABI_64_P (output_bfd))
3167 {
3168 /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3169 it to 64bit if addend is zero. */
3170 r_type = R_X86_64_32;
3171 memset (contents + rel->r_offset + 4, 0, 4);
3172 }
3173
cbe950e9
L		 3174 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3175 it here if it is defined in a non-shared object. */
3176 if (h != NULL
3177 && h->type == STT_GNU_IFUNC
3178 && h->def_regular)
3179 {
3180 asection *plt;
3181 bfd_vma plt_index;
4c544807 3182 const char *name;
cbe950e9
L		 3183
3184 if ((input_section->flags & SEC_ALLOC) == 0
3185 || h->plt.offset == (bfd_vma) -1)
3186 abort ();
3187
3188 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3189 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
cbe950e9
L		 3190 relocation = (plt->output_section->vma
3191 + plt->output_offset + h->plt.offset);
3192
3193 switch (r_type)
3194 {
3195 default:
4c544807
L		 3196 if (h->root.root.string)
3197 name = h->root.root.string;
3198 else
3199 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3200 NULL);
cbe950e9
L		 3201 (*_bfd_error_handler)
3202 (_("%B: relocation %s against STT_GNU_IFUNC "
3203 "symbol `%s' isn't handled by %s"), input_bfd,
3204 x86_64_elf_howto_table[r_type].name,
4c544807 3205 name, __FUNCTION__);
cbe950e9
L		 3206 bfd_set_error (bfd_error_bad_value);
3207 return FALSE;
3208
3209 case R_X86_64_32S:
710ab287 3210 if (info->shared)
cbe950e9 3211 abort ();
710ab287
L		 3212 goto do_relocation;
3213
248775ba
L		 3214 case R_X86_64_32:
3215 if (ABI_64_P (output_bfd))
3216 goto do_relocation;
17672001 3217 /* FALLTHROUGH */
eed180f8 3218 case R_X86_64_64:
710ab287
L		 3219 if (rel->r_addend != 0)
3220 {
4c544807
L		 3221 if (h->root.root.string)
3222 name = h->root.root.string;
3223 else
3224 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3225 sym, NULL);
710ab287
L		 3226 (*_bfd_error_handler)
3227 (_("%B: relocation %s against STT_GNU_IFUNC "
3228 "symbol `%s' has non-zero addend: %d"),
3229 input_bfd, x86_64_elf_howto_table[r_type].name,
4c544807 3230 name, rel->r_addend);
710ab287
L		 3231 bfd_set_error (bfd_error_bad_value);
3232 return FALSE;
3233 }
3234
3235 /* Generate dynamic relcoation only when there is a
c293fa49 3236 non-GOT reference in a shared object. */
710ab287
L		 3237 if (info->shared && h->non_got_ref)
3238 {
3239 Elf_Internal_Rela outrel;
710ab287
L		 3240 asection *sreloc;
3241
c25bc9fc
L		 3242 /* Need a dynamic relocation to get the real function
3243 address. */
710ab287
L		 3244 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3245 info,
3246 input_section,
3247 rel->r_offset);
3248 if (outrel.r_offset == (bfd_vma) -1
3249 || outrel.r_offset == (bfd_vma) -2)
3250 abort ();
3251
3252 outrel.r_offset += (input_section->output_section->vma
3253 + input_section->output_offset);
3254
3255 if (h->dynindx == -1
44c4ea11
L		 3256 || h->forced_local
3257 || info->executable)
710ab287
L		 3258 {
3259 /* This symbol is resolved locally. */
56b8aada
L		 3260 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3261 outrel.r_addend = (h->root.u.def.value
3262 + h->root.u.def.section->output_section->vma
3263 + h->root.u.def.section->output_offset);
710ab287
L		 3264 }
3265 else
3266 {
351f65ca 3267 outrel.r_info = htab->r_info (h->dynindx, r_type);
710ab287
L		 3268 outrel.r_addend = 0;
3269 }
3270
6de2ae4a 3271 sreloc = htab->elf.irelifunc;
351f65ca 3272 elf_append_rela (output_bfd, sreloc, &outrel);
710ab287
L		 3273
3274 /* If this reloc is against an external symbol, we
3275 do not want to fiddle with the addend. Otherwise,
3276 we need to include the symbol value so that it
3277 becomes an addend for the dynamic reloc. For an
3278 internal symbol, we have updated addend. */
56b8aada 3279 continue;
710ab287 3280 }
17672001 3281 /* FALLTHROUGH */
cbe950e9
L		 3282 case R_X86_64_PC32:
3283 case R_X86_64_PC64:
3284 case R_X86_64_PLT32:
3285 goto do_relocation;
3286
3287 case R_X86_64_GOTPCREL:
3288 case R_X86_64_GOTPCREL64:
6de2ae4a 3289 base_got = htab->elf.sgot;
cbe950e9
L		 3290 off = h->got.offset;
3291
7afd84dc 3292 if (base_got == NULL)
cbe950e9
L		 3293 abort ();
3294
7afd84dc 3295 if (off == (bfd_vma) -1)
cbe950e9 3296 {
7afd84dc
L		 3297 /* We can't use h->got.offset here to save state, or
3298 even just remember the offset, as finish_dynamic_symbol
3299 would use that as offset into .got. */
cbe950e9 3300
6de2ae4a 3301 if (htab->elf.splt != NULL)
7afd84dc 3302 {
eed180f8 3303 plt_index = h->plt.offset / plt_entry_size - 1;
7afd84dc 3304 off = (plt_index + 3) * GOT_ENTRY_SIZE;
6de2ae4a 3305 base_got = htab->elf.sgotplt;
7afd84dc 3306 }
cbe950e9
L		 3307 else
3308 {
eed180f8 3309 plt_index = h->plt.offset / plt_entry_size;
7afd84dc 3310 off = plt_index * GOT_ENTRY_SIZE;
6de2ae4a 3311 base_got = htab->elf.igotplt;
7afd84dc
L		 3312 }
3313
3314 if (h->dynindx == -1
3315 || h->forced_local
3316 || info->symbolic)
3317 {
eed180f8 3318 /* This references the local defitionion. We must
7afd84dc 3319 initialize this entry in the global offset table.
eed180f8 3320 Since the offset must always be a multiple of 8,
7afd84dc
L		 3321 we use the least significant bit to record
3322 whether we have initialized it already.
3323
3324 When doing a dynamic link, we create a .rela.got
3325 relocation entry to initialize the value. This
3326 is done in the finish_dynamic_symbol routine. */
3327 if ((off & 1) != 0)
3328 off &= ~1;
3329 else
3330 {
3331 bfd_put_64 (output_bfd, relocation,
3332 base_got->contents + off);
3333 /* Note that this is harmless for the GOTPLT64
3334 case, as -1 | 1 still is -1. */
3335 h->got.offset |= 1;
3336 }
cbe950e9
L		 3337 }
3338 }
3339
3340 relocation = (base_got->output_section->vma
3341 + base_got->output_offset + off);
3342
cbe950e9
L		 3343 goto do_relocation;
3344 }
3345 }
3346
70256ad8
AJ		 3347 /* When generating a shared object, the relocations handled here are
3348 copied into the output file to be resolved at run time. */
3349 switch (r_type)
3350 {
3351 case R_X86_64_GOT32:
7b81dfbb 3352 case R_X86_64_GOT64:
70256ad8
AJ		 3353 /* Relocation is to the entry for this symbol in the global
3354 offset table. */
70256ad8 3355 case R_X86_64_GOTPCREL:
7b81dfbb
AJ		 3356 case R_X86_64_GOTPCREL64:
3357 /* Use global offset table entry as symbol value. */
3358 case R_X86_64_GOTPLT64:
3359 /* This is the same as GOT64 for relocation purposes, but
3360 indicates the existence of a PLT entry. The difficulty is,
3361 that we must calculate the GOT slot offset from the PLT
3362 offset, if this symbol got a PLT entry (it was global).
3363 Additionally if it's computed from the PLT entry, then that
3364 GOT offset is relative to .got.plt, not to .got. */
6de2ae4a 3365 base_got = htab->elf.sgot;
7b81dfbb 3366
6de2ae4a 3367 if (htab->elf.sgot == NULL)
c434dee6 3368 abort ();
053579d7 3369
51e0a107 3370 if (h != NULL)
70256ad8 3371 {
b34976b6 3372 bfd_boolean dyn;
c434dee6
AJ		 3373
3374 off = h->got.offset;
7b81dfbb 3375 if (h->needs_plt
eed180f8 3376 && h->plt.offset != (bfd_vma)-1
7b81dfbb
AJ		 3377 && off == (bfd_vma)-1)
3378 {
3379 /* We can't use h->got.offset here to save
3380 state, or even just remember the offset, as
3381 finish_dynamic_symbol would use that as offset into
3382 .got. */
eed180f8 3383 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
7b81dfbb 3384 off = (plt_index + 3) * GOT_ENTRY_SIZE;
6de2ae4a 3385 base_got = htab->elf.sgotplt;
7b81dfbb
AJ		 3386 }
3387
c434dee6 3388 dyn = htab->elf.dynamic_sections_created;
51e0a107 3389
27482721 3390 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
51e0a107 3391 || (info->shared
27482721 3392 && SYMBOL_REFERENCES_LOCAL (info, h))
4bc6e03a
AJ		 3393 || (ELF_ST_VISIBILITY (h->other)
3394 && h->root.type == bfd_link_hash_undefweak))
51e0a107
JH		 3395 {
3396 /* This is actually a static link, or it is a -Bsymbolic
3397 link and the symbol is defined locally, or the symbol
407443a3 3398 was forced to be local because of a version file. We
51e0a107
JH		 3399 must initialize this entry in the global offset table.
3400 Since the offset must always be a multiple of 8, we
3401 use the least significant bit to record whether we
3402 have initialized it already.
3403
3404 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 3405 relocation entry to initialize the value. This is
3406 done in the finish_dynamic_symbol routine. */
51e0a107
JH		 3407 if ((off & 1) != 0)
3408 off &= ~1;
3409 else
3410 {
3411 bfd_put_64 (output_bfd, relocation,
7b81dfbb
AJ		 3412 base_got->contents + off);
3413 /* Note that this is harmless for the GOTPLT64 case,
eed180f8 3414 as -1 | 1 still is -1. */
51e0a107
JH		 3415 h->got.offset |= 1;
3416 }
3417 }
053579d7 3418 else
b34976b6 3419 unresolved_reloc = FALSE;
70256ad8 3420 }
51e0a107
JH		 3421 else
3422 {
c434dee6
AJ		 3423 if (local_got_offsets == NULL)
3424 abort ();
51e0a107
JH		 3425
3426 off = local_got_offsets[r_symndx];
3427
3428 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 3429 the least significant bit to record whether we have
3430 already generated the necessary reloc. */
51e0a107
JH		 3431 if ((off & 1) != 0)
3432 off &= ~1;
3433 else
3434 {
c434dee6 3435 bfd_put_64 (output_bfd, relocation,
7b81dfbb 3436 base_got->contents + off);
51e0a107
JH		 3437
3438 if (info->shared)
3439 {
947216bf 3440 asection *s;
51e0a107 3441 Elf_Internal_Rela outrel;
70256ad8 3442
51e0a107
JH		 3443 /* We need to generate a R_X86_64_RELATIVE reloc
3444 for the dynamic linker. */
6de2ae4a 3445 s = htab->elf.srelgot;
947216bf 3446 if (s == NULL)
c434dee6 3447 abort ();
51e0a107 3448
7b81dfbb
AJ		 3449 outrel.r_offset = (base_got->output_section->vma
3450 + base_got->output_offset
51e0a107 3451 + off);
351f65ca 3452 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
51e0a107 3453 outrel.r_addend = relocation;
351f65ca 3454 elf_append_rela (output_bfd, s, &outrel);
51e0a107
JH		 3455 }
3456
3457 local_got_offsets[r_symndx] |= 1;
3458 }
51e0a107 3459 }
6a2bda3f 3460
c434dee6
AJ		 3461 if (off >= (bfd_vma) -2)
3462 abort ();
3463
7b81dfbb
AJ		 3464 relocation = base_got->output_section->vma
3465 + base_got->output_offset + off;
3466 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
6de2ae4a
L		 3467 relocation -= htab->elf.sgotplt->output_section->vma
3468 - htab->elf.sgotplt->output_offset;
c434dee6 3469
70256ad8
AJ		 3470 break;
3471
d6ab8113
JB		 3472 case R_X86_64_GOTOFF64:
3473 /* Relocation is relative to the start of the global offset
3474 table. */
3475
3476 /* Check to make sure it isn't a protected function symbol
3477 for shared library since it may not be local when used
3478 as function address. */
bdb892b9 3479 if (!info->executable
d6ab8113 3480 && h
bdb892b9 3481 && !SYMBOLIC_BIND (info, h)
d6ab8113
JB		 3482 && h->def_regular
3483 && h->type == STT_FUNC
3484 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3485 {
3486 (*_bfd_error_handler)
3487 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3488 input_bfd, h->root.root.string);
3489 bfd_set_error (bfd_error_bad_value);
3490 return FALSE;
3491 }
3492
3493 /* Note that sgot is not involved in this
3494 calculation. We always want the start of .got.plt. If we
3495 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3496 permitted by the ABI, we might have to change this
3497 calculation. */
6de2ae4a
L		 3498 relocation -= htab->elf.sgotplt->output_section->vma
3499 + htab->elf.sgotplt->output_offset;
d6ab8113
JB		 3500 break;
3501
3502 case R_X86_64_GOTPC32:
7b81dfbb 3503 case R_X86_64_GOTPC64:
d6ab8113 3504 /* Use global offset table as symbol value. */
6de2ae4a
L		 3505 relocation = htab->elf.sgotplt->output_section->vma
3506 + htab->elf.sgotplt->output_offset;
d6ab8113
JB		 3507 unresolved_reloc = FALSE;
3508 break;
7b81dfbb
AJ		 3509
3510 case R_X86_64_PLTOFF64:
3511 /* Relocation is PLT entry relative to GOT. For local
3512 symbols it's the symbol itself relative to GOT. */
eed180f8 3513 if (h != NULL
7b81dfbb
AJ		 3514 /* See PLT32 handling. */
3515 && h->plt.offset != (bfd_vma) -1
6de2ae4a 3516 && htab->elf.splt != NULL)
7b81dfbb 3517 {
6de2ae4a
L		 3518 relocation = (htab->elf.splt->output_section->vma
3519 + htab->elf.splt->output_offset
7b81dfbb
AJ		 3520 + h->plt.offset);
3521 unresolved_reloc = FALSE;
3522 }
3523
6de2ae4a
L		 3524 relocation -= htab->elf.sgotplt->output_section->vma
3525 + htab->elf.sgotplt->output_offset;
7b81dfbb 3526 break;
d6ab8113 3527
70256ad8
AJ		 3528 case R_X86_64_PLT32:
3529 /* Relocation is to the entry for this symbol in the
3530 procedure linkage table. */
3531
3532 /* Resolve a PLT32 reloc against a local symbol directly,
407443a3 3533 without using the procedure linkage table. */
70256ad8
AJ		 3534 if (h == NULL)
3535 break;
3536
c434dee6 3537 if (h->plt.offset == (bfd_vma) -1
6de2ae4a 3538 || htab->elf.splt == NULL)
70256ad8
AJ		 3539 {
3540 /* We didn't make a PLT entry for this symbol. This
407443a3
AJ		 3541 happens when statically linking PIC code, or when
3542 using -Bsymbolic. */
70256ad8
AJ		 3543 break;
3544 }
3545
6de2ae4a
L		 3546 relocation = (htab->elf.splt->output_section->vma
3547 + htab->elf.splt->output_offset
70256ad8 3548 + h->plt.offset);
b34976b6 3549 unresolved_reloc = FALSE;
70256ad8
AJ		 3550 break;
3551
fd8ab9e5
AJ		 3552 case R_X86_64_PC8:
3553 case R_X86_64_PC16:
3554 case R_X86_64_PC32:
6610a52d 3555 if (info->shared
ba3bee0b 3556 && (input_section->flags & SEC_ALLOC) != 0
90f487df 3557 && (input_section->flags & SEC_READONLY) != 0
41bed6dd 3558 && h != NULL)
6610a52d 3559 {
41bed6dd
L		 3560 bfd_boolean fail = FALSE;
3561 bfd_boolean branch
3562 = (r_type == R_X86_64_PC32
3563 && is_32bit_relative_branch (contents, rel->r_offset));
3564
3565 if (SYMBOL_REFERENCES_LOCAL (info, h))
3566 {
3567 /* Symbol is referenced locally. Make sure it is
3568 defined locally or for a branch. */
3569 fail = !h->def_regular && !branch;
3570 }
90f487df 3571 else
41bed6dd
L		 3572 {
3573 /* Symbol isn't referenced locally. We only allow
3574 branch to symbol with non-default visibility. */
3575 fail = (!branch
3576 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3577 }
3578
3579 if (fail)
3580 {
3581 const char *fmt;
3582 const char *v;
3583 const char *pic = "";
3584
3585 switch (ELF_ST_VISIBILITY (h->other))
3586 {
3587 case STV_HIDDEN:
3588 v = _("hidden symbol");
3589 break;
3590 case STV_INTERNAL:
3591 v = _("internal symbol");
3592 break;
3593 case STV_PROTECTED:
3594 v = _("protected symbol");
3595 break;
3596 default:
3597 v = _("symbol");
3598 pic = _("; recompile with -fPIC");
3599 break;
3600 }
3601
3602 if (h->def_regular)
3603 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3604 else
3605 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3606
3607 (*_bfd_error_handler) (fmt, input_bfd,
3608 x86_64_elf_howto_table[r_type].name,
3609 v, h->root.root.string, pic);
3610 bfd_set_error (bfd_error_bad_value);
3611 return FALSE;
3612 }
6610a52d
L		 3613 }
3614 /* Fall through. */
3615
70256ad8
AJ		 3616 case R_X86_64_8:
3617 case R_X86_64_16:
3618 case R_X86_64_32:
d6ab8113 3619 case R_X86_64_PC64:
6b3db546 3620 case R_X86_64_64:
80643fbc 3621 /* FIXME: The ABI says the linker should make sure the value is
407443a3 3622 the same when it's zeroextended to 64 bit. */
c434dee6 3623
b1e24c02 3624 if ((input_section->flags & SEC_ALLOC) == 0)
c434dee6
AJ		 3625 break;
3626
3627 if ((info->shared
4bc6e03a
AJ		 3628 && (h == NULL
3629 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3630 || h->root.type != bfd_link_hash_undefweak)
d8045f23
NC		 3631 && (! IS_X86_64_PCREL_TYPE (r_type)
3632 || ! SYMBOL_CALLS_LOCAL (info, h)))
d40d037c
AJ		 3633 || (ELIMINATE_COPY_RELOCS
3634 && !info->shared
c434dee6
AJ		 3635 && h != NULL
3636 && h->dynindx != -1
f5385ebf
AM		 3637 && !h->non_got_ref
3638 && ((h->def_dynamic
3639 && !h->def_regular)
c434dee6 3640 || h->root.type == bfd_link_hash_undefweak
0f88be7a 3641 || h->root.type == bfd_link_hash_undefined)))
70256ad8
AJ		 3642 {
3643 Elf_Internal_Rela outrel;
b34976b6 3644 bfd_boolean skip, relocate;
c434dee6 3645 asection *sreloc;
70256ad8
AJ		 3646
3647 /* When generating a shared object, these relocations
3648 are copied into the output file to be resolved at run
407443a3 3649 time. */
b34976b6
AM		 3650 skip = FALSE;
3651 relocate = FALSE;
70256ad8 3652
c629eae0
JJ		 3653 outrel.r_offset =
3654 _bfd_elf_section_offset (output_bfd, info, input_section,
c434dee6 3655 rel->r_offset);
c629eae0 3656 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 3657 skip = TRUE;
0fb19cbc 3658 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 3659 skip = TRUE, relocate = TRUE;
70256ad8
AJ		 3660
3661 outrel.r_offset += (input_section->output_section->vma
3662 + input_section->output_offset);
3663
3664 if (skip)
0bb2d96a 3665 memset (&outrel, 0, sizeof outrel);
c434dee6 3666
fd8ab9e5
AJ		 3667 /* h->dynindx may be -1 if this symbol was marked to
3668 become local. */
3669 else if (h != NULL
c434dee6 3670 && h->dynindx != -1
d8045f23
NC		 3671 && (IS_X86_64_PCREL_TYPE (r_type)
3672 || ! info->shared
3673 || ! SYMBOLIC_BIND (info, h)
3674 || ! h->def_regular))
70256ad8 3675 {
351f65ca 3676 outrel.r_info = htab->r_info (h->dynindx, r_type);
c434dee6 3677 outrel.r_addend = rel->r_addend;
70256ad8
AJ		 3678 }
3679 else
3680 {
c434dee6 3681 /* This symbol is local, or marked to become local. */
248775ba 3682 if (r_type == htab->pointer_r_type)
607c0e09 3683 {
b34976b6 3684 relocate = TRUE;
351f65ca 3685 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
607c0e09
AS		 3686 outrel.r_addend = relocation + rel->r_addend;
3687 }
64d25c44
L		 3688 else if (r_type == R_X86_64_64
3689 && !ABI_64_P (output_bfd))
3690 {
3691 relocate = TRUE;
3692 outrel.r_info = htab->r_info (0,
3693 R_X86_64_RELATIVE64);
3694 outrel.r_addend = relocation + rel->r_addend;
8cf0d2dd
L		 3695 /* Check addend overflow. */
3696 if ((outrel.r_addend & 0x80000000)
3697 != (rel->r_addend & 0x80000000))
3698 {
3699 const char *name;
268a8d3a 3700 int addend = rel->r_addend;
8cf0d2dd
L		 3701 if (h && h->root.root.string)
3702 name = h->root.root.string;
3703 else
3704 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3705 sym, NULL);
6f2c9068
L		 3706 if (addend < 0)
3707 (*_bfd_error_handler)
268a8d3a 3708 (_("%B: addend -0x%x in relocation %s against "
6f2c9068
L		 3709 "symbol `%s' at 0x%lx in section `%A' is "
3710 "out of range"),
3711 input_bfd, input_section, addend,
3712 x86_64_elf_howto_table[r_type].name,
3713 name, (unsigned long) rel->r_offset);
3714 else
3715 (*_bfd_error_handler)
268a8d3a 3716 (_("%B: addend 0x%x in relocation %s against "
6f2c9068
L		 3717 "symbol `%s' at 0x%lx in section `%A' is "
3718 "out of range"),
3719 input_bfd, input_section, addend,
3720 x86_64_elf_howto_table[r_type].name,
3721 name, (unsigned long) rel->r_offset);
8cf0d2dd
L		 3722 bfd_set_error (bfd_error_bad_value);
3723 return FALSE;
3724 }
64d25c44 3725 }
607c0e09
AS		 3726 else
3727 {
3728 long sindx;
3729
8517fae7 3730 if (bfd_is_abs_section (sec))
607c0e09
AS		 3731 sindx = 0;
3732 else if (sec == NULL || sec->owner == NULL)
3733 {
3734 bfd_set_error (bfd_error_bad_value);
b34976b6 3735 return FALSE;
607c0e09
AS		 3736 }
3737 else
3738 {
3739 asection *osec;
3740
74541ad4
AM		 3741 /* We are turning this relocation into one
3742 against a section symbol. It would be
3743 proper to subtract the symbol's value,
3744 osec->vma, from the emitted reloc addend,
3745 but ld.so expects buggy relocs. */
607c0e09
AS		 3746 osec = sec->output_section;
3747 sindx = elf_section_data (osec)->dynindx;
74541ad4
AM		 3748 if (sindx == 0)
3749 {
3750 asection *oi = htab->elf.text_index_section;
3751 sindx = elf_section_data (oi)->dynindx;
3752 }
3753 BFD_ASSERT (sindx != 0);
607c0e09
AS		 3754 }
3755
351f65ca 3756 outrel.r_info = htab->r_info (sindx, r_type);
607c0e09
AS		 3757 outrel.r_addend = relocation + rel->r_addend;
3758 }
70256ad8
AJ		 3759 }
3760
cbe950e9 3761 sreloc = elf_section_data (input_section)->sreloc;
d8045f23 3762
62d78908
L		 3763 if (sreloc == NULL || sreloc->contents == NULL)
3764 {
3765 r = bfd_reloc_notsupported;
3766 goto check_relocation_error;
3767 }
c434dee6 3768
351f65ca 3769 elf_append_rela (output_bfd, sreloc, &outrel);
70256ad8
AJ		 3770
3771 /* If this reloc is against an external symbol, we do
3772 not want to fiddle with the addend. Otherwise, we
3773 need to include the symbol value so that it becomes
3774 an addend for the dynamic reloc. */
0f88be7a 3775 if (! relocate)
70256ad8
AJ		 3776 continue;
3777 }
3778
3779 break;
3780
bffbf940 3781 case R_X86_64_TLSGD:
67a4f2b7
AO		 3782 case R_X86_64_GOTPC32_TLSDESC:
3783 case R_X86_64_TLSDESC_CALL:
bffbf940 3784 case R_X86_64_GOTTPOFF:
bffbf940
JJ		 3785 tls_type = GOT_UNKNOWN;
3786 if (h == NULL && local_got_offsets)
351f65ca 3787 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
bffbf940 3788 else if (h != NULL)
351f65ca 3789 tls_type = elf_x86_64_hash_entry (h)->tls_type;
142411ca 3790
351f65ca
L		 3791 if (! elf_x86_64_tls_transition (info, input_bfd,
3792 input_section, contents,
3793 symtab_hdr, sym_hashes,
3794 &r_type, tls_type, rel,
3795 relend, h, r_symndx))
534a31f6 3796 return FALSE;
bffbf940
JJ		 3797
3798 if (r_type == R_X86_64_TPOFF32)
3799 {
142411ca
L		 3800 bfd_vma roff = rel->r_offset;
3801
bffbf940 3802 BFD_ASSERT (! unresolved_reloc);
142411ca 3803
351f65ca 3804 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
bffbf940 3805 {
52bc799a 3806 /* GD->LE transition. For 64bit, change
abcf1d52 3807 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
a3fadc9a 3808 .word 0x6666; rex64; call __tls_get_addr
52bc799a 3809 into:
bffbf940 3810 movq %fs:0, %rax
52bc799a
L		 3811 leaq foo@tpoff(%rax), %rax
3812 For 32bit, change
3813 leaq foo@tlsgd(%rip), %rdi
3814 .word 0x6666; rex64; call __tls_get_addr
3815 into:
3816 movl %fs:0, %eax
bffbf940 3817 leaq foo@tpoff(%rax), %rax */
52bc799a
L		 3818 if (ABI_64_P (output_bfd))
3819 memcpy (contents + roff - 4,
3820 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3821 16);
3822 else
3823 memcpy (contents + roff - 3,
3824 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3825 15);
eb4ff4d6 3826 bfd_put_32 (output_bfd,
351f65ca 3827 elf_x86_64_tpoff (info, relocation),
142411ca 3828 contents + roff + 8);
a3fadc9a 3829 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
bffbf940
JJ		 3830 rel++;
3831 continue;
3832 }
351f65ca 3833 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
67a4f2b7
AO		 3834 {
3835 /* GDesc -> LE transition.
3836 It's originally something like:
3837 leaq x@tlsdesc(%rip), %rax
3838
3839 Change it to:
c9736ba0 3840 movl $x@tpoff, %rax. */
67a4f2b7 3841
c9736ba0 3842 unsigned int val, type;
67a4f2b7 3843
67a4f2b7 3844 type = bfd_get_8 (input_bfd, contents + roff - 3);
67a4f2b7 3845 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 3846 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3847 contents + roff - 3);
3848 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3849 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3850 contents + roff - 1);
eb4ff4d6 3851 bfd_put_32 (output_bfd,
351f65ca 3852 elf_x86_64_tpoff (info, relocation),
67a4f2b7
AO		 3853 contents + roff);
3854 continue;
3855 }
351f65ca 3856 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
67a4f2b7
AO		 3857 {
3858 /* GDesc -> LE transition.
3859 It's originally:
3860 call *(%rax)
3861 Turn it into:
142411ca 3862 xchg %ax,%ax. */
10efb593 3863 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3864 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3865 continue;
3866 }
351f65ca 3867 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
bffbf940 3868 {
bffbf940
JJ		 3869 /* IE->LE transition:
3870 Originally it can be one of:
3871 movq foo@gottpoff(%rip), %reg
3872 addq foo@gottpoff(%rip), %reg
3873 We change it into:
3874 movq $foo, %reg
3875 leaq foo(%reg), %reg
3876 addq $foo, %reg. */
142411ca
L		 3877
3878 unsigned int val, type, reg;
3879
3880 val = bfd_get_8 (input_bfd, contents + roff - 3);
3881 type = bfd_get_8 (input_bfd, contents + roff - 2);
3882 reg = bfd_get_8 (input_bfd, contents + roff - 1);
bffbf940 3883 reg >>= 3;
bffbf940
JJ		 3884 if (type == 0x8b)
3885 {
3886 /* movq */
3887 if (val == 0x4c)
3888 bfd_put_8 (output_bfd, 0x49,
142411ca 3889 contents + roff - 3);
4a4c5f25
L		 3890 else if (!ABI_64_P (output_bfd) && val == 0x44)
3891 bfd_put_8 (output_bfd, 0x41,
3892 contents + roff - 3);
bffbf940 3893 bfd_put_8 (output_bfd, 0xc7,
142411ca 3894 contents + roff - 2);
bffbf940 3895 bfd_put_8 (output_bfd, 0xc0 | reg,
142411ca 3896 contents + roff - 1);
bffbf940
JJ		 3897 }
3898 else if (reg == 4)
3899 {
3900 /* addq -> addq - addressing with %rsp/%r12 is
3901 special */
3902 if (val == 0x4c)
3903 bfd_put_8 (output_bfd, 0x49,
142411ca 3904 contents + roff - 3);
4a4c5f25
L		 3905 else if (!ABI_64_P (output_bfd) && val == 0x44)
3906 bfd_put_8 (output_bfd, 0x41,
3907 contents + roff - 3);
bffbf940 3908 bfd_put_8 (output_bfd, 0x81,
142411ca 3909 contents + roff - 2);
bffbf940 3910 bfd_put_8 (output_bfd, 0xc0 | reg,
142411ca 3911 contents + roff - 1);
bffbf940
JJ		 3912 }
3913 else
3914 {
3915 /* addq -> leaq */
3916 if (val == 0x4c)
3917 bfd_put_8 (output_bfd, 0x4d,
142411ca 3918 contents + roff - 3);
4a4c5f25
L		 3919 else if (!ABI_64_P (output_bfd) && val == 0x44)
3920 bfd_put_8 (output_bfd, 0x45,
3921 contents + roff - 3);
bffbf940 3922 bfd_put_8 (output_bfd, 0x8d,
142411ca 3923 contents + roff - 2);
bffbf940 3924 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
142411ca 3925 contents + roff - 1);
bffbf940 3926 }
eb4ff4d6 3927 bfd_put_32 (output_bfd,
351f65ca 3928 elf_x86_64_tpoff (info, relocation),
142411ca 3929 contents + roff);
bffbf940
JJ		 3930 continue;
3931 }
142411ca
L		 3932 else
3933 BFD_ASSERT (FALSE);
bffbf940
JJ		 3934 }
3935
6de2ae4a 3936 if (htab->elf.sgot == NULL)
bffbf940
JJ		 3937 abort ();
3938
3939 if (h != NULL)
67a4f2b7
AO		 3940 {
3941 off = h->got.offset;
351f65ca 3942 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
67a4f2b7 3943 }
bffbf940
JJ		 3944 else
3945 {
3946 if (local_got_offsets == NULL)
3947 abort ();
3948
3949 off = local_got_offsets[r_symndx];
67a4f2b7 3950 offplt = local_tlsdesc_gotents[r_symndx];
bffbf940
JJ		 3951 }
3952
3953 if ((off & 1) != 0)
3954 off &= ~1;
26e41594 3955 else
bffbf940
JJ		 3956 {
3957 Elf_Internal_Rela outrel;
bffbf940 3958 int dr_type, indx;
67a4f2b7 3959 asection *sreloc;
bffbf940 3960
6de2ae4a 3961 if (htab->elf.srelgot == NULL)
bffbf940
JJ		 3962 abort ();
3963
67a4f2b7
AO		 3964 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3965
3966 if (GOT_TLS_GDESC_P (tls_type))
3967 {
351f65ca 3968 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
67a4f2b7 3969 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
6de2ae4a
L		 3970 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3971 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3972 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 3973 + offplt
3974 + htab->sgotplt_jump_table_size);
6de2ae4a 3975 sreloc = htab->elf.srelplt;
67a4f2b7 3976 if (indx == 0)
351f65ca 3977 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
67a4f2b7
AO		 3978 else
3979 outrel.r_addend = 0;
351f65ca 3980 elf_append_rela (output_bfd, sreloc, &outrel);
67a4f2b7
AO		 3981 }
3982
6de2ae4a 3983 sreloc = htab->elf.srelgot;
67a4f2b7 3984
6de2ae4a
L		 3985 outrel.r_offset = (htab->elf.sgot->output_section->vma
3986 + htab->elf.sgot->output_offset + off);
bffbf940 3987
67a4f2b7 3988 if (GOT_TLS_GD_P (tls_type))
bffbf940 3989 dr_type = R_X86_64_DTPMOD64;
67a4f2b7
AO		 3990 else if (GOT_TLS_GDESC_P (tls_type))
3991 goto dr_done;
bffbf940
JJ		 3992 else
3993 dr_type = R_X86_64_TPOFF64;
3994
6de2ae4a 3995 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
bffbf940 3996 outrel.r_addend = 0;
67a4f2b7
AO		 3997 if ((dr_type == R_X86_64_TPOFF64
3998 || dr_type == R_X86_64_TLSDESC) && indx == 0)
351f65ca
L		 3999 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4000 outrel.r_info = htab->r_info (indx, dr_type);
bffbf940 4001
351f65ca 4002 elf_append_rela (output_bfd, sreloc, &outrel);
bffbf940 4003
67a4f2b7 4004 if (GOT_TLS_GD_P (tls_type))
bffbf940
JJ		 4005 {
4006 if (indx == 0)
4007 {
d40d037c 4008 BFD_ASSERT (! unresolved_reloc);
bffbf940 4009 bfd_put_64 (output_bfd,
351f65ca 4010 relocation - elf_x86_64_dtpoff_base (info),
6de2ae4a 4011 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
bffbf940
JJ		 4012 }
4013 else
4014 {
4015 bfd_put_64 (output_bfd, 0,
6de2ae4a 4016 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
351f65ca 4017 outrel.r_info = htab->r_info (indx,
bffbf940
JJ		 4018 R_X86_64_DTPOFF64);
4019 outrel.r_offset += GOT_ENTRY_SIZE;
351f65ca 4020 elf_append_rela (output_bfd, sreloc,
464d3bd4 4021 &outrel);
bffbf940
JJ		 4022 }
4023 }
4024
67a4f2b7 4025 dr_done:
bffbf940
JJ		 4026 if (h != NULL)
4027 h->got.offset |= 1;
4028 else
4029 local_got_offsets[r_symndx] |= 1;
4030 }
4031
67a4f2b7
AO		 4032 if (off >= (bfd_vma) -2
4033 && ! GOT_TLS_GDESC_P (tls_type))
bffbf940 4034 abort ();
351f65ca 4035 if (r_type == ELF32_R_TYPE (rel->r_info))
bffbf940 4036 {
67a4f2b7
AO		 4037 if (r_type == R_X86_64_GOTPC32_TLSDESC
4038 || r_type == R_X86_64_TLSDESC_CALL)
6de2ae4a
L		 4039 relocation = htab->elf.sgotplt->output_section->vma
4040 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 4041 + offplt + htab->sgotplt_jump_table_size;
4042 else
6de2ae4a
L		 4043 relocation = htab->elf.sgot->output_section->vma
4044 + htab->elf.sgot->output_offset + off;
b34976b6 4045 unresolved_reloc = FALSE;
bffbf940 4046 }
142411ca 4047 else
67a4f2b7 4048 {
142411ca 4049 bfd_vma roff = rel->r_offset;
67a4f2b7 4050
351f65ca 4051 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
142411ca 4052 {
52bc799a 4053 /* GD->IE transition. For 64bit, change
142411ca
L		 4054 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4055 .word 0x6666; rex64; call __tls_get_addr@plt
52bc799a 4056 into:
142411ca 4057 movq %fs:0, %rax
52bc799a
L		 4058 addq foo@gottpoff(%rip), %rax
4059 For 32bit, change
4060 leaq foo@tlsgd(%rip), %rdi
4061 .word 0x6666; rex64; call __tls_get_addr@plt
4062 into:
4063 movl %fs:0, %eax
142411ca 4064 addq foo@gottpoff(%rip), %rax */
52bc799a
L		 4065 if (ABI_64_P (output_bfd))
4066 memcpy (contents + roff - 4,
4067 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4068 16);
4069 else
4070 memcpy (contents + roff - 3,
4071 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4072 15);
142411ca 4073
6de2ae4a
L		 4074 relocation = (htab->elf.sgot->output_section->vma
4075 + htab->elf.sgot->output_offset + off
142411ca
L		 4076 - roff
4077 - input_section->output_section->vma
4078 - input_section->output_offset
4079 - 12);
4080 bfd_put_32 (output_bfd, relocation,
4081 contents + roff + 8);
4082 /* Skip R_X86_64_PLT32. */
4083 rel++;
4084 continue;
4085 }
351f65ca 4086 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
142411ca
L		 4087 {
4088 /* GDesc -> IE transition.
4089 It's originally something like:
4090 leaq x@tlsdesc(%rip), %rax
67a4f2b7 4091
142411ca 4092 Change it to:
c9736ba0 4093 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
67a4f2b7 4094
142411ca
L		 4095 /* Now modify the instruction as appropriate. To
4096 turn a leaq into a movq in the form we use it, it
4097 suffices to change the second byte from 0x8d to
4098 0x8b. */
4099 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4100
4101 bfd_put_32 (output_bfd,
6de2ae4a
L		 4102 htab->elf.sgot->output_section->vma
4103 + htab->elf.sgot->output_offset + off
142411ca
L		 4104 - rel->r_offset
4105 - input_section->output_section->vma
4106 - input_section->output_offset
4107 - 4,
4108 contents + roff);
4109 continue;
4110 }
351f65ca 4111 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
142411ca
L		 4112 {
4113 /* GDesc -> IE transition.
4114 It's originally:
4115 call *(%rax)
4116
4117 Change it to:
c9736ba0 4118 xchg %ax, %ax. */
142411ca 4119
142411ca
L		 4120 bfd_put_8 (output_bfd, 0x66, contents + roff);
4121 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4122 continue;
4123 }
4124 else
4125 BFD_ASSERT (FALSE);
67a4f2b7 4126 }
bffbf940
JJ		 4127 break;
4128
4129 case R_X86_64_TLSLD:
351f65ca
L		 4130 if (! elf_x86_64_tls_transition (info, input_bfd,
4131 input_section, contents,
4132 symtab_hdr, sym_hashes,
4133 &r_type, GOT_UNKNOWN,
4134 rel, relend, h, r_symndx))
142411ca 4135 return FALSE;
a3fadc9a 4136
142411ca
L		 4137 if (r_type != R_X86_64_TLSLD)
4138 {
bffbf940 4139 /* LD->LE transition:
a3fadc9a 4140 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
52bc799a
L		 4141 For 64bit, we change it into:
4142 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4143 For 32bit, we change it into:
4144 nopl 0x0(%rax); movl %fs:0, %eax. */
142411ca
L		 4145
4146 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
52bc799a
L		 4147 if (ABI_64_P (output_bfd))
4148 memcpy (contents + rel->r_offset - 3,
4149 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4150 else
4151 memcpy (contents + rel->r_offset - 3,
4152 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
a3fadc9a 4153 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
bffbf940
JJ		 4154 rel++;
4155 continue;
4156 }
4157
6de2ae4a 4158 if (htab->elf.sgot == NULL)
bffbf940
JJ		 4159 abort ();
4160
4161 off = htab->tls_ld_got.offset;
4162 if (off & 1)
4163 off &= ~1;
4164 else
4165 {
4166 Elf_Internal_Rela outrel;
bffbf940 4167
6de2ae4a 4168 if (htab->elf.srelgot == NULL)
bffbf940
JJ		 4169 abort ();
4170
6de2ae4a
L		 4171 outrel.r_offset = (htab->elf.sgot->output_section->vma
4172 + htab->elf.sgot->output_offset + off);
bffbf940
JJ		 4173
4174 bfd_put_64 (output_bfd, 0,
6de2ae4a 4175 htab->elf.sgot->contents + off);
bffbf940 4176 bfd_put_64 (output_bfd, 0,
6de2ae4a 4177 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
351f65ca 4178 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
bffbf940 4179 outrel.r_addend = 0;
351f65ca 4180 elf_append_rela (output_bfd, htab->elf.srelgot,
464d3bd4 4181 &outrel);
bffbf940
JJ		 4182 htab->tls_ld_got.offset |= 1;
4183 }
6de2ae4a
L		 4184 relocation = htab->elf.sgot->output_section->vma
4185 + htab->elf.sgot->output_offset + off;
b34976b6 4186 unresolved_reloc = FALSE;
bffbf940
JJ		 4187 break;
4188
4189 case R_X86_64_DTPOFF32:
1d85728f 4190 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
351f65ca 4191 relocation -= elf_x86_64_dtpoff_base (info);
bffbf940 4192 else
351f65ca 4193 relocation = elf_x86_64_tpoff (info, relocation);
bffbf940
JJ		 4194 break;
4195
4196 case R_X86_64_TPOFF32:
6769d501 4197 case R_X86_64_TPOFF64:
9b769489 4198 BFD_ASSERT (info->executable);
351f65ca 4199 relocation = elf_x86_64_tpoff (info, relocation);
bffbf940
JJ		 4200 break;
4201
70256ad8
AJ		 4202 default:
4203 break;
4204 }
8d88c4ca 4205
239e1f3a
AM		 4206 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4207 because such sections are not SEC_ALLOC and thus ld.so will
4208 not process them. */
c434dee6 4209 if (unresolved_reloc
239e1f3a 4210 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 4211 && h->def_dynamic)
4212 && _bfd_elf_section_offset (output_bfd, info, input_section,
4213 rel->r_offset) != (bfd_vma) -1)
c434dee6 4214 (*_bfd_error_handler)
843fe662 4215 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4216 input_bfd,
4217 input_section,
c434dee6 4218 (long) rel->r_offset,
843fe662 4219 howto->name,
c434dee6
AJ		 4220 h->root.root.string);
4221
cbe950e9 4222do_relocation:
8d88c4ca 4223 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
c434dee6
AJ		 4224 contents, rel->r_offset,
4225 relocation, rel->r_addend);
8d88c4ca 4226
62d78908 4227check_relocation_error:
8d88c4ca 4228 if (r != bfd_reloc_ok)
8da6118f 4229 {
c434dee6
AJ		 4230 const char *name;
4231
4232 if (h != NULL)
4233 name = h->root.root.string;
4234 else
8da6118f 4235 {
c434dee6
AJ		 4236 name = bfd_elf_string_from_elf_section (input_bfd,
4237 symtab_hdr->sh_link,
4238 sym->st_name);
4239 if (name == NULL)
b34976b6 4240 return FALSE;
c434dee6
AJ		 4241 if (*name == '\0')
4242 name = bfd_section_name (input_bfd, sec);
4243 }
4244
4245 if (r == bfd_reloc_overflow)
4246 {
c434dee6 4247 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 4248 (info, (h ? &h->root : NULL), name, howto->name,
4249 (bfd_vma) 0, input_bfd, input_section,
4250 rel->r_offset)))
b34976b6 4251 return FALSE;
c434dee6
AJ		 4252 }
4253 else
4254 {
4255 (*_bfd_error_handler)
bb95161d 4256 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
d003868e 4257 input_bfd, input_section,
c434dee6 4258 (long) rel->r_offset, name, (int) r);
b34976b6 4259 return FALSE;
8da6118f
KH		 4260 }
4261 }
8d88c4ca 4262 }
70256ad8 4263
b34976b6 4264 return TRUE;
70256ad8
AJ		 4265}
4266
4267/* Finish up dynamic symbol handling. We set the contents of various
4268 dynamic sections here. */
4269
b34976b6 4270static bfd_boolean
351f65ca
L		 4271elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4272 struct bfd_link_info *info,
4273 struct elf_link_hash_entry *h,
220cf809 4274 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
70256ad8 4275{
351f65ca 4276 struct elf_x86_64_link_hash_table *htab;
eed180f8
RM		 4277 const struct elf_x86_64_backend_data *const abed
4278 = get_elf_x86_64_backend_data (output_bfd);
70256ad8 4279
351f65ca 4280 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 4281 if (htab == NULL)
4282 return FALSE;
70256ad8
AJ		 4283
4284 if (h->plt.offset != (bfd_vma) -1)
4285 {
70256ad8
AJ		 4286 bfd_vma plt_index;
4287 bfd_vma got_offset;
4288 Elf_Internal_Rela rela;
947216bf 4289 bfd_byte *loc;
cbe950e9 4290 asection *plt, *gotplt, *relplt;
351f65ca 4291 const struct elf_backend_data *bed;
cbe950e9
L		 4292
4293 /* When building a static executable, use .iplt, .igot.plt and
4294 .rela.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 4295 if (htab->elf.splt != NULL)
cbe950e9 4296 {
6de2ae4a
L		 4297 plt = htab->elf.splt;
4298 gotplt = htab->elf.sgotplt;
4299 relplt = htab->elf.srelplt;
cbe950e9
L		 4300 }
4301 else
4302 {
6de2ae4a
L		 4303 plt = htab->elf.iplt;
4304 gotplt = htab->elf.igotplt;
4305 relplt = htab->elf.irelplt;
cbe950e9 4306 }
70256ad8
AJ		 4307
4308 /* This symbol has an entry in the procedure linkage table. Set
407443a3 4309 it up. */
cbe950e9
L		 4310 if ((h->dynindx == -1
4311 && !((h->forced_local || info->executable)
4312 && h->def_regular
4313 && h->type == STT_GNU_IFUNC))
4314 || plt == NULL
4315 || gotplt == NULL
4316 || relplt == NULL)
f6df62c8 4317 return FALSE;
70256ad8
AJ		 4318
4319 /* Get the index in the procedure linkage table which
4320 corresponds to this symbol. This is the index of this symbol
4321 in all the symbols for which we are making plt entries. The
cbe950e9 4322 first entry in the procedure linkage table is reserved.
6bbec505 4323
cbe950e9 4324 Get the offset into the .got table of the entry that
407443a3 4325 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
cbe950e9
L		 4326 bytes. The first three are reserved for the dynamic linker.
4327
4328 For static executables, we don't reserve anything. */
4329
6de2ae4a 4330 if (plt == htab->elf.splt)
cbe950e9 4331 {
eed180f8 4332 got_offset = h->plt.offset / abed->plt_entry_size - 1;
e1f98742 4333 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
cbe950e9
L		 4334 }
4335 else
4336 {
eed180f8 4337 got_offset = h->plt.offset / abed->plt_entry_size;
e1f98742 4338 got_offset = got_offset * GOT_ENTRY_SIZE;
cbe950e9 4339 }
70256ad8
AJ		 4340
4341 /* Fill in the entry in the procedure linkage table. */
eed180f8
RM		 4342 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4343 abed->plt_entry_size);
4344
4345 /* Insert the relocation positions of the plt section. */
4346
4347 /* Put offset the PC-relative instruction referring to the GOT entry,
4348 subtracting the size of that instruction. */
653165cc 4349 bfd_put_32 (output_bfd,
eed180f8
RM		 4350 (gotplt->output_section->vma
4351 + gotplt->output_offset
4352 + got_offset
4353 - plt->output_section->vma
4354 - plt->output_offset
4355 - h->plt.offset
4356 - abed->plt_got_insn_size),
4357 plt->contents + h->plt.offset + abed->plt_got_offset);
cbe950e9 4358
653165cc 4359 /* Fill in the entry in the global offset table, initially this
eed180f8 4360 points to the second part of the PLT entry. */
cbe950e9
L		 4361 bfd_put_64 (output_bfd, (plt->output_section->vma
4362 + plt->output_offset
eed180f8 4363 + h->plt.offset + abed->plt_lazy_offset),
cbe950e9 4364 gotplt->contents + got_offset);
70256ad8
AJ		 4365
4366 /* Fill in the entry in the .rela.plt section. */
cbe950e9
L		 4367 rela.r_offset = (gotplt->output_section->vma
4368 + gotplt->output_offset
70256ad8 4369 + got_offset);
cbe950e9
L		 4370 if (h->dynindx == -1
4371 || ((info->executable
4372 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4373 && h->def_regular
4374 && h->type == STT_GNU_IFUNC))
4375 {
4376 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4377 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
351f65ca 4378 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
cbe950e9
L		 4379 rela.r_addend = (h->root.u.def.value
4380 + h->root.u.def.section->output_section->vma
4381 + h->root.u.def.section->output_offset);
e1f98742
L		 4382 /* R_X86_64_IRELATIVE comes last. */
4383 plt_index = htab->next_irelative_index--;
cbe950e9
L		 4384 }
4385 else
4386 {
351f65ca 4387 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
cbe950e9 4388 rela.r_addend = 0;
e1f98742
L		 4389 plt_index = htab->next_jump_slot_index++;
4390 }
4391
4392 /* Don't fill PLT entry for static executables. */
4393 if (plt == htab->elf.splt)
4394 {
4395 /* Put relocation index. */
4396 bfd_put_32 (output_bfd, plt_index,
eed180f8 4397 plt->contents + h->plt.offset + abed->plt_reloc_offset);
e1f98742 4398 /* Put offset for jmp .PLT0. */
eed180f8
RM		 4399 bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4400 plt->contents + h->plt.offset + abed->plt_plt_offset);
cbe950e9 4401 }
351f65ca
L		 4402
4403 bed = get_elf_backend_data (output_bfd);
4404 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
82e96e07 4405 bed->s->swap_reloca_out (output_bfd, &rela, loc);
70256ad8 4406
f5385ebf 4407 if (!h->def_regular)
70256ad8
AJ		 4408 {
4409 /* Mark the symbol as undefined, rather than as defined in
47a9f7b3
JJ		 4410 the .plt section. Leave the value if there were any
4411 relocations where pointer equality matters (this is a clue
c434dee6
AJ		 4412 for the dynamic linker, to make function pointer
4413 comparisons work between an application and shared
47a9f7b3
JJ		 4414 library), otherwise set it to zero. If a function is only
4415 called from a binary, there is no need to slow down
4416 shared libraries because of that. */
70256ad8 4417 sym->st_shndx = SHN_UNDEF;
f5385ebf 4418 if (!h->pointer_equality_needed)
47a9f7b3 4419 sym->st_value = 0;
70256ad8
AJ		 4420 }
4421 }
4422
bffbf940 4423 if (h->got.offset != (bfd_vma) -1
351f65ca
L		 4424 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4425 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
053579d7 4426 {
053579d7
AJ		 4427 Elf_Internal_Rela rela;
4428
4429 /* This symbol has an entry in the global offset table. Set it
bffbf940 4430 up. */
6de2ae4a 4431 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
c434dee6 4432 abort ();
053579d7 4433
6de2ae4a
L		 4434 rela.r_offset = (htab->elf.sgot->output_section->vma
4435 + htab->elf.sgot->output_offset
dc810e39 4436 + (h->got.offset &~ (bfd_vma) 1));
053579d7
AJ		 4437
4438 /* If this is a static link, or it is a -Bsymbolic link and the
4439 symbol is defined locally or was forced to be local because
4440 of a version file, we just want to emit a RELATIVE reloc.
4441 The entry in the global offset table will already have been
4442 initialized in the relocate_section function. */
710ab287 4443 if (h->def_regular
0018b0a3
L		 4444 && h->type == STT_GNU_IFUNC)
4445 {
710ab287
L		 4446 if (info->shared)
4447 {
4448 /* Generate R_X86_64_GLOB_DAT. */
4449 goto do_glob_dat;
4450 }
4451 else
4452 {
90d60710
L		 4453 asection *plt;
4454
710ab287
L		 4455 if (!h->pointer_equality_needed)
4456 abort ();
4457
4458 /* For non-shared object, we can't use .got.plt, which
4459 contains the real function addres if we need pointer
4460 equality. We load the GOT entry with the PLT entry. */
90d60710 4461 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 4462 bfd_put_64 (output_bfd, (plt->output_section->vma
4463 + plt->output_offset
4464 + h->plt.offset),
6de2ae4a 4465 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 4466 return TRUE;
4467 }
0018b0a3
L		 4468 }
4469 else if (info->shared
4470 && SYMBOL_REFERENCES_LOCAL (info, h))
053579d7 4471 {
41bed6dd
L		 4472 if (!h->def_regular)
4473 return FALSE;
cc78d0af 4474 BFD_ASSERT((h->got.offset & 1) != 0);
351f65ca 4475 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
053579d7
AJ		 4476 rela.r_addend = (h->root.u.def.value
4477 + h->root.u.def.section->output_section->vma
4478 + h->root.u.def.section->output_offset);
4479 }
4480 else
4481 {
4482 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 4483do_glob_dat:
c434dee6 4484 bfd_put_64 (output_bfd, (bfd_vma) 0,
6de2ae4a 4485 htab->elf.sgot->contents + h->got.offset);
351f65ca 4486 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
053579d7
AJ		 4487 rela.r_addend = 0;
4488 }
4489
351f65ca 4490 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
053579d7
AJ		 4491 }
4492
f5385ebf 4493 if (h->needs_copy)
70256ad8 4494 {
70256ad8
AJ		 4495 Elf_Internal_Rela rela;
4496
4497 /* This symbol needs a copy reloc. Set it up. */
4498
c434dee6
AJ		 4499 if (h->dynindx == -1
4500 || (h->root.type != bfd_link_hash_defined
4501 && h->root.type != bfd_link_hash_defweak)
4502 || htab->srelbss == NULL)
4503 abort ();
70256ad8
AJ		 4504
4505 rela.r_offset = (h->root.u.def.value
4506 + h->root.u.def.section->output_section->vma
4507 + h->root.u.def.section->output_offset);
351f65ca 4508 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
70256ad8 4509 rela.r_addend = 0;
351f65ca 4510 elf_append_rela (output_bfd, htab->srelbss, &rela);
70256ad8
AJ		 4511 }
4512
b34976b6 4513 return TRUE;
70256ad8
AJ		 4514}
4515
c25bc9fc
L		 4516/* Finish up local dynamic symbol handling. We set the contents of
4517 various dynamic sections here. */
4518
4519static bfd_boolean
351f65ca 4520elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
c25bc9fc
L		 4521{
4522 struct elf_link_hash_entry *h
4523 = (struct elf_link_hash_entry *) *slot;
4524 struct bfd_link_info *info
eed180f8 4525 = (struct bfd_link_info *) inf;
c25bc9fc 4526
351f65ca 4527 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
c25bc9fc
L		 4528 info, h, NULL);
4529}
4530
c434dee6
AJ		 4531/* Used to decide how to sort relocs in an optimal manner for the
4532 dynamic linker, before writing them out. */
4533
4534static enum elf_reloc_type_class
351f65ca 4535elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
c434dee6 4536{
351f65ca 4537 switch ((int) ELF32_R_TYPE (rela->r_info))
c434dee6
AJ		 4538 {
4539 case R_X86_64_RELATIVE:
1da80baa 4540 case R_X86_64_RELATIVE64:
c434dee6
AJ		 4541 return reloc_class_relative;
4542 case R_X86_64_JUMP_SLOT:
4543 return reloc_class_plt;
4544 case R_X86_64_COPY:
4545 return reloc_class_copy;
4546 default:
4547 return reloc_class_normal;
4548 }
4549}
4550
70256ad8
AJ		 4551/* Finish up the dynamic sections. */
4552
b34976b6 4553static bfd_boolean
351f65ca
L		 4554elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4555 struct bfd_link_info *info)
70256ad8 4556{
351f65ca 4557 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 4558 bfd *dynobj;
4559 asection *sdyn;
eed180f8
RM		 4560 const struct elf_x86_64_backend_data *const abed
4561 = get_elf_x86_64_backend_data (output_bfd);
70256ad8 4562
351f65ca 4563 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 4564 if (htab == NULL)
4565 return FALSE;
4566
c434dee6 4567 dynobj = htab->elf.dynobj;
70256ad8
AJ		 4568 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4569
c434dee6 4570 if (htab->elf.dynamic_sections_created)
70256ad8 4571 {
82e96e07
L		 4572 bfd_byte *dyncon, *dynconend;
4573 const struct elf_backend_data *bed;
4574 bfd_size_type sizeof_dyn;
70256ad8 4575
6de2ae4a 4576 if (sdyn == NULL || htab->elf.sgot == NULL)
c434dee6 4577 abort ();
70256ad8 4578
82e96e07
L		 4579 bed = get_elf_backend_data (dynobj);
4580 sizeof_dyn = bed->s->sizeof_dyn;
4581 dyncon = sdyn->contents;
4582 dynconend = sdyn->contents + sdyn->size;
4583 for (; dyncon < dynconend; dyncon += sizeof_dyn)
70256ad8
AJ		 4584 {
4585 Elf_Internal_Dyn dyn;
70256ad8
AJ		 4586 asection *s;
4587
82e96e07 4588 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
70256ad8
AJ		 4589
4590 switch (dyn.d_tag)
4591 {
4592 default:
053579d7 4593 continue;
70256ad8
AJ		 4594
4595 case DT_PLTGOT:
6de2ae4a 4596 s = htab->elf.sgotplt;
8c37241b 4597 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
c434dee6 4598 break;
70256ad8
AJ		 4599
4600 case DT_JMPREL:
6de2ae4a 4601 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
c434dee6 4602 break;
70256ad8 4603
c434dee6 4604 case DT_PLTRELSZ:
6de2ae4a 4605 s = htab->elf.srelplt->output_section;
eea6121a 4606 dyn.d_un.d_val = s->size;
70256ad8
AJ		 4607 break;
4608
4609 case DT_RELASZ:
c434dee6
AJ		 4610 /* The procedure linkage table relocs (DT_JMPREL) should
4611 not be included in the overall relocs (DT_RELA).
4612 Therefore, we override the DT_RELASZ entry here to
4613 make it not include the JMPREL relocs. Since the
4614 linker script arranges for .rela.plt to follow all
4615 other relocation sections, we don't have to worry
4616 about changing the DT_RELA entry. */
6de2ae4a 4617 if (htab->elf.srelplt != NULL)
70256ad8 4618 {
6de2ae4a 4619 s = htab->elf.srelplt->output_section;
eea6121a 4620 dyn.d_un.d_val -= s->size;
70256ad8
AJ		 4621 }
4622 break;
67a4f2b7
AO		 4623
4624 case DT_TLSDESC_PLT:
6de2ae4a 4625 s = htab->elf.splt;
67a4f2b7
AO		 4626 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4627 + htab->tlsdesc_plt;
4628 break;
4629
4630 case DT_TLSDESC_GOT:
6de2ae4a 4631 s = htab->elf.sgot;
67a4f2b7
AO		 4632 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4633 + htab->tlsdesc_got;
4634 break;
70256ad8 4635 }
c434dee6 4636
82e96e07 4637 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
70256ad8
AJ		 4638 }
4639
c434dee6 4640 /* Fill in the special first entry in the procedure linkage table. */
6de2ae4a 4641 if (htab->elf.splt && htab->elf.splt->size > 0)
70256ad8 4642 {
653165cc 4643 /* Fill in the first entry in the procedure linkage table. */
eed180f8
RM		 4644 memcpy (htab->elf.splt->contents,
4645 abed->plt0_entry, abed->plt_entry_size);
653165cc
AJ		 4646 /* Add offset for pushq GOT+8(%rip), since the instruction
4647 uses 6 bytes subtract this value. */
4648 bfd_put_32 (output_bfd,
6de2ae4a
L		 4649 (htab->elf.sgotplt->output_section->vma
4650 + htab->elf.sgotplt->output_offset
653165cc 4651 + 8
6de2ae4a
L		 4652 - htab->elf.splt->output_section->vma
4653 - htab->elf.splt->output_offset
653165cc 4654 - 6),
eed180f8
RM		 4655 htab->elf.splt->contents + abed->plt0_got1_offset);
4656 /* Add offset for the PC-relative instruction accessing GOT+16,
4657 subtracting the offset to the end of that instruction. */
653165cc 4658 bfd_put_32 (output_bfd,
6de2ae4a
L		 4659 (htab->elf.sgotplt->output_section->vma
4660 + htab->elf.sgotplt->output_offset
653165cc 4661 + 16
6de2ae4a
L		 4662 - htab->elf.splt->output_section->vma
4663 - htab->elf.splt->output_offset
eed180f8
RM		 4664 - abed->plt0_got2_insn_end),
4665 htab->elf.splt->contents + abed->plt0_got2_offset);
653165cc 4666
eed180f8
RM		 4667 elf_section_data (htab->elf.splt->output_section)
4668 ->this_hdr.sh_entsize = abed->plt_entry_size;
67a4f2b7
AO		 4669
4670 if (htab->tlsdesc_plt)
4671 {
4672 bfd_put_64 (output_bfd, (bfd_vma) 0,
6de2ae4a 4673 htab->elf.sgot->contents + htab->tlsdesc_got);
67a4f2b7 4674
6de2ae4a 4675 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
eed180f8 4676 abed->plt0_entry, abed->plt_entry_size);
67a4f2b7
AO		 4677
4678 /* Add offset for pushq GOT+8(%rip), since the
4679 instruction uses 6 bytes subtract this value. */
4680 bfd_put_32 (output_bfd,
6de2ae4a
L		 4681 (htab->elf.sgotplt->output_section->vma
4682 + htab->elf.sgotplt->output_offset
67a4f2b7 4683 + 8
6de2ae4a
L		 4684 - htab->elf.splt->output_section->vma
4685 - htab->elf.splt->output_offset
67a4f2b7
AO		 4686 - htab->tlsdesc_plt
4687 - 6),
eed180f8
RM		 4688 htab->elf.splt->contents
4689 + htab->tlsdesc_plt + abed->plt0_got1_offset);
4690 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4691 where TGD stands for htab->tlsdesc_got, subtracting the offset
4692 to the end of that instruction. */
67a4f2b7 4693 bfd_put_32 (output_bfd,
6de2ae4a
L		 4694 (htab->elf.sgot->output_section->vma
4695 + htab->elf.sgot->output_offset
67a4f2b7 4696 + htab->tlsdesc_got
6de2ae4a
L		 4697 - htab->elf.splt->output_section->vma
4698 - htab->elf.splt->output_offset
67a4f2b7 4699 - htab->tlsdesc_plt
eed180f8
RM		 4700 - abed->plt0_got2_insn_end),
4701 htab->elf.splt->contents
4702 + htab->tlsdesc_plt + abed->plt0_got2_offset);
67a4f2b7 4703 }
70256ad8 4704 }
70256ad8
AJ		 4705 }
4706
6de2ae4a 4707 if (htab->elf.sgotplt)
70256ad8 4708 {
56d4289c
L		 4709 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4710 {
4711 (*_bfd_error_handler)
4712 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4713 return FALSE;
4714 }
4715
c434dee6 4716 /* Fill in the first three entries in the global offset table. */
6de2ae4a 4717 if (htab->elf.sgotplt->size > 0)
c434dee6
AJ		 4718 {
4719 /* Set the first entry in the global offset table to the address of
4720 the dynamic section. */
4721 if (sdyn == NULL)
6de2ae4a 4722 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
c434dee6
AJ		 4723 else
4724 bfd_put_64 (output_bfd,
4725 sdyn->output_section->vma + sdyn->output_offset,
6de2ae4a 4726 htab->elf.sgotplt->contents);
c434dee6 4727 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6de2ae4a
L		 4728 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4729 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
c434dee6 4730 }
70256ad8 4731
6de2ae4a 4732 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
c434dee6
AJ		 4733 GOT_ENTRY_SIZE;
4734 }
70256ad8 4735
e41b3a13 4736 /* Adjust .eh_frame for .plt section. */
9a2a56cc
AM		 4737 if (htab->plt_eh_frame != NULL
4738 && htab->plt_eh_frame->contents != NULL)
e41b3a13
JJ		 4739 {
4740 if (htab->elf.splt != NULL
4741 && htab->elf.splt->size != 0
4742 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4743 && htab->elf.splt->output_section != NULL
4744 && htab->plt_eh_frame->output_section != NULL)
4745 {
4746 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4747 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4748 + htab->plt_eh_frame->output_offset
4749 + PLT_FDE_START_OFFSET;
4750 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4751 htab->plt_eh_frame->contents
4752 + PLT_FDE_START_OFFSET);
4753 }
dbaa2011 4754 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
e41b3a13
JJ		 4755 {
4756 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4757 htab->plt_eh_frame,
4758 htab->plt_eh_frame->contents))
4759 return FALSE;
4760 }
4761 }
4762
6de2ae4a
L		 4763 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4764 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
8c37241b
JJ		 4765 = GOT_ENTRY_SIZE;
4766
c25bc9fc
L		 4767 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4768 htab_traverse (htab->loc_hash_table,
351f65ca 4769 elf_x86_64_finish_local_dynamic_symbol,
c25bc9fc
L		 4770 info);
4771
b34976b6 4772 return TRUE;
8d88c4ca
NC		 4773}
4774
4c45e5c9
JJ		 4775/* Return address for Ith PLT stub in section PLT, for relocation REL
4776 or (bfd_vma) -1 if it should not be included. */
4777
4778static bfd_vma
351f65ca
L		 4779elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4780 const arelent *rel ATTRIBUTE_UNUSED)
4c45e5c9 4781{
eed180f8 4782 return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4c45e5c9 4783}
8df9fc9d 4784
d2b2c203
DJ		 4785/* Handle an x86-64 specific section when reading an object file. This
4786 is called when elfcode.h finds a section with an unknown type. */
4787
4788static bfd_boolean
351f65ca 4789elf_x86_64_section_from_shdr (bfd *abfd,
6dc132d9
L		 4790 Elf_Internal_Shdr *hdr,
4791 const char *name,
4792 int shindex)
d2b2c203
DJ		 4793{
4794 if (hdr->sh_type != SHT_X86_64_UNWIND)
4795 return FALSE;
4796
6dc132d9 4797 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
d2b2c203
DJ		 4798 return FALSE;
4799
4800 return TRUE;
4801}
4802
3b22753a
L		 4803/* Hook called by the linker routine which adds symbols from an object
4804 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4805 of .bss. */
4806
4807static bfd_boolean
351f65ca
L		 4808elf_x86_64_add_symbol_hook (bfd *abfd,
4809 struct bfd_link_info *info,
4810 Elf_Internal_Sym *sym,
4811 const char **namep ATTRIBUTE_UNUSED,
4812 flagword *flagsp ATTRIBUTE_UNUSED,
4813 asection **secp,
4814 bfd_vma *valp)
3b22753a
L		 4815{
4816 asection *lcomm;
4817
4818 switch (sym->st_shndx)
4819 {
4820 case SHN_X86_64_LCOMMON:
4821 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4822 if (lcomm == NULL)
4823 {
4824 lcomm = bfd_make_section_with_flags (abfd,
4825 "LARGE_COMMON",
4826 (SEC_ALLOC
4827 | SEC_IS_COMMON
4828 | SEC_LINKER_CREATED));
4829 if (lcomm == NULL)
4830 return FALSE;
4831 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4832 }
4833 *secp = lcomm;
4834 *valp = sym->st_size;
c35bdf6e 4835 return TRUE;
3b22753a 4836 }
d8045f23 4837
c16153ae 4838 if ((abfd->flags & DYNAMIC) == 0
f64b2e8d
NC		 4839 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4840 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4841 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
d8045f23 4842
3b22753a
L		 4843 return TRUE;
4844}
4845
4846
4847/* Given a BFD section, try to locate the corresponding ELF section
4848 index. */
4849
4850static bfd_boolean
351f65ca
L		 4851elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4852 asection *sec, int *index_return)
3b22753a
L		 4853{
4854 if (sec == &_bfd_elf_large_com_section)
4855 {
91d6fa6a 4856 *index_return = SHN_X86_64_LCOMMON;
3b22753a
L		 4857 return TRUE;
4858 }
4859 return FALSE;
4860}
4861
4862/* Process a symbol. */
4863
4864static void
351f65ca
L		 4865elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4866 asymbol *asym)
3b22753a
L		 4867{
4868 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4869
4870 switch (elfsym->internal_elf_sym.st_shndx)
4871 {
4872 case SHN_X86_64_LCOMMON:
4873 asym->section = &_bfd_elf_large_com_section;
4874 asym->value = elfsym->internal_elf_sym.st_size;
4875 /* Common symbol doesn't set BSF_GLOBAL. */
4876 asym->flags &= ~BSF_GLOBAL;
4877 break;
4878 }
4879}
4880
4881static bfd_boolean
351f65ca 4882elf_x86_64_common_definition (Elf_Internal_Sym *sym)
3b22753a
L		 4883{
4884 return (sym->st_shndx == SHN_COMMON
4885 || sym->st_shndx == SHN_X86_64_LCOMMON);
4886}
4887
4888static unsigned int
351f65ca 4889elf_x86_64_common_section_index (asection *sec)
3b22753a
L		 4890{
4891 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4892 return SHN_COMMON;
4893 else
4894 return SHN_X86_64_LCOMMON;
4895}
4896
4897static asection *
351f65ca 4898elf_x86_64_common_section (asection *sec)
3b22753a
L		 4899{
4900 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4901 return bfd_com_section_ptr;
4902 else
4903 return &_bfd_elf_large_com_section;
4904}
4905
4906static bfd_boolean
351f65ca
L		 4907elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4908 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4909 struct elf_link_hash_entry *h,
4910 Elf_Internal_Sym *sym,
4911 asection **psec,
4912 bfd_vma *pvalue ATTRIBUTE_UNUSED,
4913 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4914 bfd_boolean *skip ATTRIBUTE_UNUSED,
4915 bfd_boolean *override ATTRIBUTE_UNUSED,
4916 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4917 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
71e7aa7d
L		 4918 bfd_boolean *newdyn ATTRIBUTE_UNUSED,
4919 bfd_boolean *newdef,
351f65ca
L		 4920 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4921 bfd_boolean *newweak ATTRIBUTE_UNUSED,
4922 bfd *abfd ATTRIBUTE_UNUSED,
4923 asection **sec,
71e7aa7d
L		 4924 bfd_boolean *olddyn ATTRIBUTE_UNUSED,
4925 bfd_boolean *olddef,
351f65ca
L		 4926 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4927 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4928 bfd *oldbfd,
4929 asection **oldsec)
3b22753a
L		 4930{
4931 /* A normal common symbol and a large common symbol result in a
00492999
L		 4932 normal common symbol. We turn the large common symbol into a
4933 normal one. */
71e7aa7d 4934 if (!*olddef
3b22753a 4935 && h->root.type == bfd_link_hash_common
71e7aa7d 4936 && !*newdef
3b22753a 4937 && bfd_is_com_section (*sec)
00492999 4938 && *oldsec != *sec)
3b22753a 4939 {
00492999
L		 4940 if (sym->st_shndx == SHN_COMMON
4941 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4942 {
4943 h->root.u.c.p->section
4944 = bfd_make_section_old_way (oldbfd, "COMMON");
4945 h->root.u.c.p->section->flags = SEC_ALLOC;
4946 }
4947 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4948 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
9a2e389a 4949 *psec = *sec = bfd_com_section_ptr;
3b22753a
L		 4950 }
4951
4952 return TRUE;
4953}
4954
4955static int
351f65ca
L		 4956elf_x86_64_additional_program_headers (bfd *abfd,
4957 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3b22753a
L		 4958{
4959 asection *s;
9a2e389a 4960 int count = 0;
3b22753a
L		 4961
4962 /* Check to see if we need a large readonly segment. */
4963 s = bfd_get_section_by_name (abfd, ".lrodata");
4964 if (s && (s->flags & SEC_LOAD))
4965 count++;
4966
4967 /* Check to see if we need a large data segment. Since .lbss sections
4968 is placed right after the .bss section, there should be no need for
4969 a large data segment just because of .lbss. */
4970 s = bfd_get_section_by_name (abfd, ".ldata");
4971 if (s && (s->flags & SEC_LOAD))
4972 count++;
4973
4974 return count;
4975}
4976
fdc90cb4
JJ		 4977/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4978
4979static bfd_boolean
351f65ca 4980elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
fdc90cb4
JJ		 4981{
4982 if (h->plt.offset != (bfd_vma) -1
4983 && !h->def_regular
4984 && !h->pointer_equality_needed)
4985 return FALSE;
4986
4987 return _bfd_elf_hash_symbol (h);
4988}
4989
c543bf9a
L		 4990/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4991
4992static bfd_boolean
4993elf_x86_64_relocs_compatible (const bfd_target *input,
4994 const bfd_target *output)
4995{
4996 return ((xvec_get_elf_backend_data (input)->s->elfclass
4997 == xvec_get_elf_backend_data (output)->s->elfclass)
4998 && _bfd_elf_relocs_compatible (input, output));
4999}
5000
9a2e389a 5001static const struct bfd_elf_special_section
351f65ca 5002 elf_x86_64_special_sections[]=
3b22753a 5003{
0112cd26
NC		 5004 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5005 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5006 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5007 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5008 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5009 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5010 { NULL, 0, 0, 0, 0 }
3b22753a
L		 5011};
5012
70256ad8
AJ		 5013#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5014#define TARGET_LITTLE_NAME "elf64-x86-64"
5015#define ELF_ARCH bfd_arch_i386
ae95ffa6 5016#define ELF_TARGET_ID X86_64_ELF_DATA
70256ad8 5017#define ELF_MACHINE_CODE EM_X86_64
f7661549 5018#define ELF_MAXPAGESIZE 0x200000
2043964e 5019#define ELF_MINPAGESIZE 0x1000
24718e3b 5020#define ELF_COMMONPAGESIZE 0x1000
70256ad8
AJ		 5021
5022#define elf_backend_can_gc_sections 1
51b64d56 5023#define elf_backend_can_refcount 1
70256ad8
AJ		 5024#define elf_backend_want_got_plt 1
5025#define elf_backend_plt_readonly 1
5026#define elf_backend_want_plt_sym 0
5027#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
b491616a 5028#define elf_backend_rela_normal 1
e41b3a13 5029#define elf_backend_plt_alignment 4
70256ad8 5030
351f65ca 5031#define elf_info_to_howto elf_x86_64_info_to_howto
70256ad8 5032
70256ad8 5033#define bfd_elf64_bfd_link_hash_table_create \
351f65ca 5034 elf_x86_64_link_hash_table_create
c25bc9fc 5035#define bfd_elf64_bfd_link_hash_table_free \
351f65ca
L		 5036 elf_x86_64_link_hash_table_free
5037#define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
157090f7 5038#define bfd_elf64_bfd_reloc_name_lookup \
351f65ca 5039 elf_x86_64_reloc_name_lookup
70256ad8 5040
351f65ca 5041#define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
c543bf9a 5042#define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
351f65ca
L		 5043#define elf_backend_check_relocs elf_x86_64_check_relocs
5044#define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5045#define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5046#define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5047#define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5048#define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5049#define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5050#define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5051#define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
8fd79e71
L		 5052#ifdef CORE_HEADER
5053#define elf_backend_write_core_note elf_x86_64_write_core_note
5054#endif
351f65ca
L		 5055#define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5056#define elf_backend_relocate_section elf_x86_64_relocate_section
5057#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5058#define elf_backend_always_size_sections elf_x86_64_always_size_sections
74541ad4 5059#define elf_backend_init_index_section _bfd_elf_init_1_index_section
351f65ca 5060#define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
407443a3 5061#define elf_backend_object_p elf64_x86_64_elf_object_p
351f65ca 5062#define bfd_elf64_mkobject elf_x86_64_mkobject
8d88c4ca 5063
d2b2c203 5064#define elf_backend_section_from_shdr \
351f65ca 5065 elf_x86_64_section_from_shdr
d2b2c203 5066
3b22753a 5067#define elf_backend_section_from_bfd_section \
351f65ca 5068 elf_x86_64_elf_section_from_bfd_section
3b22753a 5069#define elf_backend_add_symbol_hook \
351f65ca 5070 elf_x86_64_add_symbol_hook
3b22753a 5071#define elf_backend_symbol_processing \
351f65ca 5072 elf_x86_64_symbol_processing
3b22753a 5073#define elf_backend_common_section_index \
351f65ca 5074 elf_x86_64_common_section_index
3b22753a 5075#define elf_backend_common_section \
351f65ca 5076 elf_x86_64_common_section
3b22753a 5077#define elf_backend_common_definition \
351f65ca 5078 elf_x86_64_common_definition
3b22753a 5079#define elf_backend_merge_symbol \
351f65ca 5080 elf_x86_64_merge_symbol
3b22753a 5081#define elf_backend_special_sections \
351f65ca 5082 elf_x86_64_special_sections
3b22753a 5083#define elf_backend_additional_program_headers \
351f65ca 5084 elf_x86_64_additional_program_headers
fdc90cb4 5085#define elf_backend_hash_symbol \
351f65ca 5086 elf_x86_64_hash_symbol
3b22753a 5087
d8045f23
NC		 5088#define elf_backend_post_process_headers _bfd_elf_set_osabi
5089
8d88c4ca 5090#include "elf64-target.h"
9d7cbccd
NC		 5091
5092/* FreeBSD support. */
5093
5094#undef TARGET_LITTLE_SYM
5095#define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5096#undef TARGET_LITTLE_NAME
5097#define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5098
d1036acb
L		 5099#undef ELF_OSABI
5100#define ELF_OSABI ELFOSABI_FREEBSD
9d7cbccd 5101
9d7cbccd
NC		 5102#undef elf64_bed
5103#define elf64_bed elf64_x86_64_fbsd_bed
5104
5105#include "elf64-target.h"
8a9036a4 5106
a6cc6b3b
RO		 5107/* Solaris 2 support. */
5108
5109#undef TARGET_LITTLE_SYM
5110#define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5111#undef TARGET_LITTLE_NAME
5112#define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5113
5114/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5115 objects won't be recognized. */
5116#undef ELF_OSABI
5117
5118#undef elf64_bed
5119#define elf64_bed elf64_x86_64_sol2_bed
5120
7dc98aea
RO		 5121/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5122 boundary. */
5123#undef elf_backend_static_tls_alignment
5124#define elf_backend_static_tls_alignment 16
5125
a6cc6b3b
RO		 5126/* The Solaris 2 ABI requires a plt symbol on all platforms.
5127
5128 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5129 File, p.63. */
5130#undef elf_backend_want_plt_sym
5131#define elf_backend_want_plt_sym 1
5132
5133#include "elf64-target.h"
5134
8059fb19
RM		 5135/* Native Client support. */
5136
5137#undef TARGET_LITTLE_SYM
5138#define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5139#undef TARGET_LITTLE_NAME
5140#define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5141#undef elf64_bed
5142#define elf64_bed elf64_x86_64_nacl_bed
5143
5144#undef ELF_MAXPAGESIZE
5145#undef ELF_MINPAGESIZE
5146#undef ELF_COMMONPAGESIZE
5147#define ELF_MAXPAGESIZE 0x10000
5148#define ELF_MINPAGESIZE 0x10000
5149#define ELF_COMMONPAGESIZE 0x10000
5150
5151/* Restore defaults. */
5152#undef ELF_OSABI
5153#undef elf_backend_static_tls_alignment
5154#undef elf_backend_want_plt_sym
5155#define elf_backend_want_plt_sym 0
5156
5157/* NaCl uses substantially different PLT entries for the same effects. */
5158
5159#undef elf_backend_plt_alignment
5160#define elf_backend_plt_alignment 5
5161#define NACL_PLT_ENTRY_SIZE 64
5162#define NACLMASK 0xe0 /* 32-byte alignment mask. */
5163
5164static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5165 {
5166 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5167 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5168 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5169 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5170 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5171
ea2d813e
RM		 5172 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5173 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5174
5175 /* 32 bytes of nop to pad out to the standard size. */
8059fb19
RM		 5176 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5177 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5178 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5179 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
ea2d813e
RM		 5180 0x66, /* excess data32 prefix */
5181 0x90 /* nop */
8059fb19
RM		 5182 };
5183
5184static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5185 {
5186 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5187 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5188 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5189 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5190
5191 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5192 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5193 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5194
5195 /* Lazy GOT entries point here (32-byte aligned). */
5196 0x68, /* pushq immediate */
5197 0, 0, 0, 0, /* replaced with index into relocation table. */
5198 0xe9, /* jmp relative */
5199 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5200
5201 /* 22 bytes of nop to pad out to the standard size. */
5202 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5203 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5204 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5205 };
5206
5207/* .eh_frame covering the .plt section. */
5208
5209static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5210 {
5211#if (PLT_CIE_LENGTH != 20 \
5212 || PLT_FDE_LENGTH != 36 \
5213 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5214 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5215# error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5216#endif
5217 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5218 0, 0, 0, 0, /* CIE ID */
5219 1, /* CIE version */
5220 'z', 'R', 0, /* Augmentation string */
5221 1, /* Code alignment factor */
5222 0x78, /* Data alignment factor */
5223 16, /* Return address column */
5224 1, /* Augmentation size */
5225 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5226 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5227 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5228 DW_CFA_nop, DW_CFA_nop,
5229
5230 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5231 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5232 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5233 0, 0, 0, 0, /* .plt size goes here */
5234 0, /* Augmentation size */
5235 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5236 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5237 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5238 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5239 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5240 13, /* Block length */
5241 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5242 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5243 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5244 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5245 DW_CFA_nop, DW_CFA_nop
5246 };
5247
5248static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5249 {
5250 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5251 elf_x86_64_nacl_plt_entry, /* plt_entry */
5252 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5253 2, /* plt0_got1_offset */
5254 9, /* plt0_got2_offset */
5255 13, /* plt0_got2_insn_end */
5256 3, /* plt_got_offset */
5257 33, /* plt_reloc_offset */
5258 38, /* plt_plt_offset */
5259 7, /* plt_got_insn_size */
5260 42, /* plt_plt_insn_end */
5261 32, /* plt_lazy_offset */
5262 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5263 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5264 };
5265
5266#undef elf_backend_arch_data
5267#define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5268
5a68afcf
RM		 5269#undef elf_backend_modify_segment_map
5270#define elf_backend_modify_segment_map nacl_modify_segment_map
5271#undef elf_backend_modify_program_headers
5272#define elf_backend_modify_program_headers nacl_modify_program_headers
5273
8059fb19
RM		 5274#include "elf64-target.h"
5275
5276/* Native Client x32 support. */
5277
5278#undef TARGET_LITTLE_SYM
5279#define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5280#undef TARGET_LITTLE_NAME
5281#define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5282#undef elf32_bed
5283#define elf32_bed elf32_x86_64_nacl_bed
5284
5285#define bfd_elf32_bfd_link_hash_table_create \
5286 elf_x86_64_link_hash_table_create
5287#define bfd_elf32_bfd_link_hash_table_free \
5288 elf_x86_64_link_hash_table_free
5289#define bfd_elf32_bfd_reloc_type_lookup \
5290 elf_x86_64_reloc_type_lookup
5291#define bfd_elf32_bfd_reloc_name_lookup \
5292 elf_x86_64_reloc_name_lookup
5293#define bfd_elf32_mkobject \
5294 elf_x86_64_mkobject
5295
5296#undef elf_backend_object_p
5297#define elf_backend_object_p \
5298 elf32_x86_64_elf_object_p
5299
5300#undef elf_backend_bfd_from_remote_memory
5301#define elf_backend_bfd_from_remote_memory \
5302 _bfd_elf32_bfd_from_remote_memory
5303
5304#undef elf_backend_size_info
5305#define elf_backend_size_info \
5306 _bfd_elf32_size_info
5307
5308#include "elf32-target.h"
5309
5310/* Restore defaults. */
5a68afcf 5311#undef elf_backend_object_p
8059fb19 5312#define elf_backend_object_p elf64_x86_64_elf_object_p
5a68afcf
RM		 5313#undef elf_backend_bfd_from_remote_memory
5314#undef elf_backend_size_info
5315#undef elf_backend_modify_segment_map
5316#undef elf_backend_modify_program_headers
8059fb19 5317
8a9036a4
L		 5318/* Intel L1OM support. */
5319
5320static bfd_boolean
5321elf64_l1om_elf_object_p (bfd *abfd)
5322{
5323 /* Set the right machine number for an L1OM elf64 file. */
5324 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5325 return TRUE;
5326}
5327
5328#undef TARGET_LITTLE_SYM
5329#define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5330#undef TARGET_LITTLE_NAME
5331#define TARGET_LITTLE_NAME "elf64-l1om"
5332#undef ELF_ARCH
5333#define ELF_ARCH bfd_arch_l1om
5334
5335#undef ELF_MACHINE_CODE
5336#define ELF_MACHINE_CODE EM_L1OM
5337
5338#undef ELF_OSABI
5339
5340#undef elf64_bed
5341#define elf64_bed elf64_l1om_bed
5342
5343#undef elf_backend_object_p
5344#define elf_backend_object_p elf64_l1om_elf_object_p
5345
8059fb19
RM		 5346/* Restore defaults. */
5347#undef ELF_MAXPAGESIZE
5348#undef ELF_MINPAGESIZE
5349#undef ELF_COMMONPAGESIZE
5350#define ELF_MAXPAGESIZE 0x200000
5351#define ELF_MINPAGESIZE 0x1000
5352#define ELF_COMMONPAGESIZE 0x1000
5353#undef elf_backend_plt_alignment
5354#define elf_backend_plt_alignment 4
5355#undef elf_backend_arch_data
5356#define elf_backend_arch_data &elf_x86_64_arch_bed
1a0c107f 5357
8a9036a4
L		 5358#include "elf64-target.h"
5359
5360/* FreeBSD L1OM support. */
5361
5362#undef TARGET_LITTLE_SYM
5363#define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5364#undef TARGET_LITTLE_NAME
5365#define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5366
5367#undef ELF_OSABI
5368#define ELF_OSABI ELFOSABI_FREEBSD
5369
5370#undef elf64_bed
5371#define elf64_bed elf64_l1om_fbsd_bed
5372
8a9036a4 5373#include "elf64-target.h"
351f65ca 5374
7a9068fe
L		 5375/* Intel K1OM support. */
5376
5377static bfd_boolean
5378elf64_k1om_elf_object_p (bfd *abfd)
5379{
5380 /* Set the right machine number for an K1OM elf64 file. */
5381 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5382 return TRUE;
5383}
5384
5385#undef TARGET_LITTLE_SYM
5386#define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5387#undef TARGET_LITTLE_NAME
5388#define TARGET_LITTLE_NAME "elf64-k1om"
5389#undef ELF_ARCH
5390#define ELF_ARCH bfd_arch_k1om
5391
5392#undef ELF_MACHINE_CODE
5393#define ELF_MACHINE_CODE EM_K1OM
5394
5395#undef ELF_OSABI
5396
5397#undef elf64_bed
5398#define elf64_bed elf64_k1om_bed
5399
5400#undef elf_backend_object_p
5401#define elf_backend_object_p elf64_k1om_elf_object_p
5402
5403#undef elf_backend_static_tls_alignment
5404
5405#undef elf_backend_want_plt_sym
5406#define elf_backend_want_plt_sym 0
5407
5408#include "elf64-target.h"
5409
5410/* FreeBSD K1OM support. */
5411
5412#undef TARGET_LITTLE_SYM
5413#define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5414#undef TARGET_LITTLE_NAME
5415#define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5416
5417#undef ELF_OSABI
5418#define ELF_OSABI ELFOSABI_FREEBSD
5419
5420#undef elf64_bed
5421#define elf64_bed elf64_k1om_fbsd_bed
5422
5423#include "elf64-target.h"
5424
351f65ca
L		 5425/* 32bit x86-64 support. */
5426
351f65ca
L		 5427#undef TARGET_LITTLE_SYM
5428#define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5429#undef TARGET_LITTLE_NAME
5430#define TARGET_LITTLE_NAME "elf32-x86-64"
8059fb19 5431#undef elf32_bed
351f65ca
L		 5432
5433#undef ELF_ARCH
5434#define ELF_ARCH bfd_arch_i386
5435
5436#undef ELF_MACHINE_CODE
5437#define ELF_MACHINE_CODE EM_X86_64
5438
351f65ca
L		 5439#undef ELF_OSABI
5440
351f65ca
L		 5441#undef elf_backend_object_p
5442#define elf_backend_object_p \
5443 elf32_x86_64_elf_object_p
5444
5445#undef elf_backend_bfd_from_remote_memory
5446#define elf_backend_bfd_from_remote_memory \
5447 _bfd_elf32_bfd_from_remote_memory
5448
5449#undef elf_backend_size_info
5450#define elf_backend_size_info \
5451 _bfd_elf32_size_info
5452
5453#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.034811 seconds and 4 git commands to generate.