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