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