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