]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - bfd/elf64-x86-64.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
2009-06-03 Tristan Gingold <gingold@adacore.com>
[thirdparty/binutils-gdb.git] / bfd / elf64-x86-64.c
... / ...
CommitLineData
1/* X86-64 specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka <jh@suse.cz>.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
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
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
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.
17
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
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "bfdlink.h"
26#include "libbfd.h"
27#include "elf-bfd.h"
28#include "bfd_stdint.h"
29
30#include "elf/x86-64.h"
31
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:
36 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
37 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
38static reloc_howto_type x86_64_elf_howto_table[] =
39{
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),
78 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
80 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
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),
99 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
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),
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),
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),
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),
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),
149
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. */
154#define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
155#define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
156
157/* GNU extension to record C++ vtable hierarchy. */
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),
160
161/* GNU extension to record C++ vtable member usage. */
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)
165};
166
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
173/* Map BFD relocs to the x86_64 elf relocs. */
174struct elf_reloc_map
175{
176 bfd_reloc_code_real_type bfd_reloc_val;
177 unsigned char elf_reloc_val;
178};
179
180static const struct elf_reloc_map x86_64_reloc_map[] =
181{
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, },
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, },
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, },
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, },
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, },
217 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
218 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
219 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
220};
221
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}
243
244/* Given a BFD reloc type, return a HOWTO structure. */
245static reloc_howto_type *
246elf64_x86_64_reloc_type_lookup (bfd *abfd,
247 bfd_reloc_code_real_type code)
248{
249 unsigned int i;
250
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)
255 return elf64_x86_64_rtype_to_howto (abfd,
256 x86_64_reloc_map[i].elf_reloc_val);
257 }
258 return 0;
259}
260
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
278/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
279
280static void
281elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
282 Elf_Internal_Rela *dst)
283{
284 unsigned r_type;
285
286 r_type = ELF64_R_TYPE (dst->r_info);
287 cache_ptr->howto = elf64_x86_64_rtype_to_howto (abfd, r_type);
288 BFD_ASSERT (r_type == cache_ptr->howto->type);
289}
290\f
291/* Support for core dump NOTE sections. */
292static bfd_boolean
293elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
294{
295 int offset;
296 size_t size;
297
298 switch (note->descsz)
299 {
300 default:
301 return FALSE;
302
303 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
304 /* pr_cursig */
305 elf_tdata (abfd)->core_signal
306 = bfd_get_16 (abfd, note->descdata + 12);
307
308 /* pr_pid */
309 elf_tdata (abfd)->core_pid
310 = bfd_get_32 (abfd, note->descdata + 32);
311
312 /* pr_reg */
313 offset = 112;
314 size = 216;
315
316 break;
317 }
318
319 /* Make a ".reg/999" section. */
320 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
321 size, note->descpos + offset);
322}
323
324static bfd_boolean
325elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
326{
327 switch (note->descsz)
328 {
329 default:
330 return FALSE;
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
351 return TRUE;
352}
353\f
354/* Functions for the x86-64 ELF linker. */
355
356/* The name of the dynamic interpreter. This is put in the .interp
357 section. */
358
359#define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
360
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
367/* The size in bytes of an entry in the global offset table. */
368
369#define GOT_ENTRY_SIZE 8
370
371/* The size in bytes of an entry in the procedure linkage table. */
372
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{
380 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
381 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
382 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
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{
389 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
390 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
391 0x68, /* pushq immediate */
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
398 it decides to copy as dynamic relocs in check_relocs for each symbol.
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. */
402
403struct elf64_x86_64_dyn_relocs
404{
405 /* Next section. */
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. */
412 bfd_size_type count;
413
414 /* Number of pc-relative relocs copied for the input section. */
415 bfd_size_type pc_count;
416};
417
418/* x86-64 ELF linker hash entry. */
419
420struct elf64_x86_64_link_hash_entry
421{
422 struct elf_link_hash_entry elf;
423
424 /* Track dynamic relocs copied for this symbol. */
425 struct elf64_x86_64_dyn_relocs *dyn_relocs;
426
427#define GOT_UNKNOWN 0
428#define GOT_NORMAL 1
429#define GOT_TLS_GD 2
430#define GOT_TLS_IE 3
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))
440 unsigned char tls_type;
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;
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;
456
457 /* GOTPLT entries for TLS descriptors. */
458 bfd_vma *local_tlsdesc_gotent;
459};
460
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
467#define elf64_x86_64_local_tlsdesc_gotent(abfd) \
468 (elf64_x86_64_tdata (abfd)->local_tlsdesc_gotent)
469
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
482/* x86-64 ELF linker hash table. */
483
484struct elf64_x86_64_link_hash_table
485{
486 struct elf_link_hash_table elf;
487
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;
496 asection *igotplt;
497 asection *iplt;
498 asection *irelplt;
499
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
509 union {
510 bfd_signed_vma refcount;
511 bfd_vma offset;
512 } tls_ld_got;
513
514 /* The amount of space used by the jump slots in the GOT. */
515 bfd_vma sgotplt_jump_table_size;
516
517 /* Small local sym to section mapping cache. */
518 struct sym_sec_cache sym_sec;
519
520 /* _TLS_MODULE_BASE_ symbol. */
521 struct bfd_link_hash_entry *tls_module_base;
522};
523
524/* Get the x86-64 ELF linker hash table from a link_info structure. */
525
526#define elf64_x86_64_hash_table(p) \
527 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
528
529#define elf64_x86_64_compute_jump_table_size(htab) \
530 ((htab)->srelplt->reloc_count * GOT_ENTRY_SIZE)
531
532/* Create an entry in an x86-64 ELF linker hash table. */
533
534static struct bfd_hash_entry *
535elf64_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
536 struct bfd_hash_table *table,
537 const char *string)
538{
539 /* Allocate the structure if it has not already been allocated by a
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 }
548
549 /* Call the allocation method of the superclass. */
550 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
551 if (entry != NULL)
552 {
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;
557 eh->tls_type = GOT_UNKNOWN;
558 eh->tlsdesc_got = (bfd_vma) -1;
559 }
560
561 return entry;
562}
563
564/* Create an X86-64 ELF linker hash table. */
565
566static struct bfd_link_hash_table *
567elf64_x86_64_link_hash_table_create (bfd *abfd)
568{
569 struct elf64_x86_64_link_hash_table *ret;
570 bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
571
572 ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
573 if (ret == NULL)
574 return NULL;
575
576 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
577 elf64_x86_64_link_hash_newfunc,
578 sizeof (struct elf64_x86_64_link_hash_entry)))
579 {
580 free (ret);
581 return NULL;
582 }
583
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;
591 ret->igotplt= NULL;
592 ret->iplt = NULL;
593 ret->irelplt= NULL;
594 ret->sym_sec.abfd = NULL;
595 ret->tlsdesc_plt = 0;
596 ret->tlsdesc_got = 0;
597 ret->tls_ld_got.refcount = 0;
598 ret->sgotplt_jump_table_size = 0;
599 ret->tls_module_base = NULL;
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
607static bfd_boolean
608elf64_x86_64_create_got_section (bfd *dynobj, struct bfd_link_info *info)
609{
610 struct elf64_x86_64_link_hash_table *htab;
611
612 if (! _bfd_elf_create_got_section (dynobj, info))
613 return FALSE;
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
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));
627 if (htab->srelgot == NULL
628 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
629 return FALSE;
630 return TRUE;
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
637static bfd_boolean
638elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
639{
640 struct elf64_x86_64_link_hash_table *htab;
641
642 htab = elf64_x86_64_hash_table (info);
643 if (!htab->sgot && !elf64_x86_64_create_got_section (dynobj, info))
644 return FALSE;
645
646 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
647 return FALSE;
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
659 return TRUE;
660}
661
662/* Copy the extra info we tack onto an elf_link_hash_entry. */
663
664static void
665elf64_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
666 struct elf_link_hash_entry *dir,
667 struct elf_link_hash_entry *ind)
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
681 /* Add reloc counts against the indirect sym to the direct sym
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
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
712 if (ELIMINATE_COPY_RELOCS
713 && ind->root.type != bfd_link_hash_indirect
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 }
725 else
726 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
727}
728
729static bfd_boolean
730elf64_x86_64_elf_object_p (bfd *abfd)
731{
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);
734 return TRUE;
735}
736
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)
762{
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;
778
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;
785 switch (r_type)
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];
831 /* Use strncmp to check __tls_get_addr since __tls_get_addr
832 may be versioned. */
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)
837 && (strncmp (h->root.root.string,
838 "__tls_get_addr", 14) == 0));
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)
917 {
918 case R_X86_64_TLSGD:
919 case R_X86_64_GOTPC32_TLSDESC:
920 case R_X86_64_TLSDESC_CALL:
921 case R_X86_64_GOTTPOFF:
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
960 case R_X86_64_TLSLD:
961 if (!info->shared)
962 to_type = R_X86_64_TPOFF32;
963 break;
964
965 default:
966 return TRUE;
967 }
968
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 {
979 reloc_howto_type *from, *to;
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;
996}
997
998/* Look through the relocs for a section during the first phase, and
999 calculate needed space in the global offset table, procedure
1000 linkage table, and dynamic reloc sections. */
1001
1002static bfd_boolean
1003elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1004 asection *sec,
1005 const Elf_Internal_Rela *relocs)
1006{
1007 struct elf64_x86_64_link_hash_table *htab;
1008 Elf_Internal_Shdr *symtab_hdr;
1009 struct elf_link_hash_entry **sym_hashes;
1010 const Elf_Internal_Rela *rel;
1011 const Elf_Internal_Rela *rel_end;
1012 asection *sreloc;
1013
1014 if (info->relocatable)
1015 return TRUE;
1016
1017 BFD_ASSERT (is_x86_64_elf (abfd));
1018
1019 htab = elf64_x86_64_hash_table (info);
1020 symtab_hdr = &elf_symtab_hdr (abfd);
1021 sym_hashes = elf_sym_hashes (abfd);
1022
1023 sreloc = NULL;
1024
1025 rel_end = relocs + sec->reloc_count;
1026 for (rel = relocs; rel < rel_end; rel++)
1027 {
1028 unsigned int r_type;
1029 unsigned long r_symndx;
1030 struct elf_link_hash_entry *h;
1031
1032 r_symndx = ELF64_R_SYM (rel->r_info);
1033 r_type = ELF64_R_TYPE (rel->r_info);
1034
1035 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1036 {
1037 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1038 abfd, r_symndx);
1039 return FALSE;
1040 }
1041
1042 if (r_symndx < symtab_hdr->sh_info)
1043 h = NULL;
1044 else
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;
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:
1129 h->got.refcount += 1;
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 }
1139 }
1140
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
1147 switch (r_type)
1148 {
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)
1155 {
1156 (*_bfd_error_handler)
1157 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1158 abfd,
1159 x86_64_elf_howto_table[r_type].name,
1160 (h) ? h->root.root.string : "a local symbol");
1161 bfd_set_error (bfd_error_bad_value);
1162 return FALSE;
1163 }
1164 break;
1165
1166 case R_X86_64_GOTTPOFF:
1167 if (info->shared)
1168 info->flags |= DF_STATIC_TLS;
1169 /* Fall through */
1170
1171 case R_X86_64_GOT32:
1172 case R_X86_64_GOTPCREL:
1173 case R_X86_64_TLSGD:
1174 case R_X86_64_GOT64:
1175 case R_X86_64_GOTPCREL64:
1176 case R_X86_64_GOTPLT64:
1177 case R_X86_64_GOTPC32_TLSDESC:
1178 case R_X86_64_TLSDESC_CALL:
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;
1188 case R_X86_64_GOTPC32_TLSDESC:
1189 case R_X86_64_TLSDESC_CALL:
1190 tls_type = GOT_TLS_GDESC; break;
1191 }
1192
1193 if (h != NULL)
1194 {
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 }
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;
1217 size *= sizeof (bfd_signed_vma)
1218 + sizeof (bfd_vma) + sizeof (char);
1219 local_got_refcounts = ((bfd_signed_vma *)
1220 bfd_zalloc (abfd, size));
1221 if (local_got_refcounts == NULL)
1222 return FALSE;
1223 elf_local_got_refcounts (abfd) = local_got_refcounts;
1224 elf64_x86_64_local_tlsdesc_gotent (abfd)
1225 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1226 elf64_x86_64_local_got_tls_type (abfd)
1227 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
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
1237 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1238 || tls_type != GOT_TLS_IE))
1239 {
1240 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1241 tls_type = old_tls_type;
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;
1245 else
1246 {
1247 (*_bfd_error_handler)
1248 (_("%B: '%s' accessed both as normal and thread local symbol"),
1249 abfd, h ? h->root.root.string : "<local>");
1250 return FALSE;
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 }
1262 /* Fall through */
1263
1264 case R_X86_64_GOTOFF64:
1265 case R_X86_64_GOTPC32:
1266 case R_X86_64_GOTPC64:
1267 create_got:
1268 if (htab->sgot == NULL)
1269 {
1270 if (htab->elf.dynobj == NULL)
1271 htab->elf.dynobj = abfd;
1272 if (!elf64_x86_64_create_got_section (htab->elf.dynobj,
1273 info))
1274 return FALSE;
1275 }
1276 break;
1277
1278 case R_X86_64_PLT32:
1279 /* This symbol requires a procedure linkage table entry. We
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. */
1285
1286 /* If this is a local symbol, we resolve it directly without
1287 creating a procedure linkage table entry. */
1288 if (h == NULL)
1289 continue;
1290
1291 h->needs_plt = 1;
1292 h->plt.refcount += 1;
1293 break;
1294
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
1305 case R_X86_64_8:
1306 case R_X86_64_16:
1307 case R_X86_64_32:
1308 case R_X86_64_32S:
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)
1318 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1319 abfd,
1320 x86_64_elf_howto_table[r_type].name,
1321 (h) ? h->root.root.string : "a local symbol");
1322 bfd_set_error (bfd_error_bad_value);
1323 return FALSE;
1324 }
1325 /* Fall through. */
1326
1327 case R_X86_64_PC8:
1328 case R_X86_64_PC16:
1329 case R_X86_64_PC32:
1330 case R_X86_64_PC64:
1331 case R_X86_64_64:
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. */
1340 h->non_got_ref = 1;
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;
1345 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1346 h->pointer_equality_needed = 1;
1347 }
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
1355 including in the link (i.e., DEF_REGULAR is set). At
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
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
1369 symbol. */
1370 if ((info->shared
1371 && (sec->flags & SEC_ALLOC) != 0
1372 && (! IS_X86_64_PCREL_TYPE (r_type)
1373 || (h != NULL
1374 && (! SYMBOLIC_BIND (info, h)
1375 || h->root.type == bfd_link_hash_defweak
1376 || !h->def_regular))))
1377 || (ELIMINATE_COPY_RELOCS
1378 && !info->shared
1379 && (sec->flags & SEC_ALLOC) != 0
1380 && h != NULL
1381 && (h->root.type == bfd_link_hash_defweak
1382 || !h->def_regular)))
1383 {
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. */
1390 if (sreloc == NULL)
1391 {
1392 if (htab->elf.dynobj == NULL)
1393 htab->elf.dynobj = abfd;
1394
1395 sreloc = _bfd_elf_make_dynamic_reloc_section
1396 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1397
1398 if (sreloc == NULL)
1399 return FALSE;
1400 }
1401
1402 /* If this is a global symbol, we count the number of
1403 relocations we need for this symbol. */
1404 if (h != NULL)
1405 {
1406 head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
1407 }
1408 else
1409 {
1410 void **vpp;
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)
1419 return FALSE;
1420
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;
1425 }
1426
1427 p = *head;
1428 if (p == NULL || p->sec != sec)
1429 {
1430 bfd_size_type amt = sizeof *p;
1431
1432 p = ((struct elf64_x86_64_dyn_relocs *)
1433 bfd_alloc (htab->elf.dynobj, amt));
1434 if (p == NULL)
1435 return FALSE;
1436 p->next = *head;
1437 *head = p;
1438 p->sec = sec;
1439 p->count = 0;
1440 p->pc_count = 0;
1441 }
1442
1443 p->count += 1;
1444 if (IS_X86_64_PCREL_TYPE (r_type))
1445 p->pc_count += 1;
1446 }
1447 break;
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:
1452 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1453 return FALSE;
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:
1459 BFD_ASSERT (h != NULL);
1460 if (h != NULL
1461 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1462 return FALSE;
1463 break;
1464
1465 default:
1466 break;
1467 }
1468 }
1469
1470 return TRUE;
1471}
1472
1473/* Return the section that should be marked against GC for a given
1474 relocation. */
1475
1476static asection *
1477elf64_x86_64_gc_mark_hook (asection *sec,
1478 struct bfd_link_info *info,
1479 Elf_Internal_Rela *rel,
1480 struct elf_link_hash_entry *h,
1481 Elf_Internal_Sym *sym)
1482{
1483 if (h != NULL)
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);
1492}
1493
1494/* Update the got entry reference counts for the section being removed. */
1495
1496static bfd_boolean
1497elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1498 asection *sec,
1499 const Elf_Internal_Rela *relocs)
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;
1505
1506 if (info->relocatable)
1507 return TRUE;
1508
1509 elf_section_data (sec)->local_dynrel = NULL;
1510
1511 symtab_hdr = &elf_symtab_hdr (abfd);
1512 sym_hashes = elf_sym_hashes (abfd);
1513 local_got_refcounts = elf_local_got_refcounts (abfd);
1514
1515 relend = relocs + sec->reloc_count;
1516 for (rel = relocs; rel < relend; rel++)
1517 {
1518 unsigned long r_symndx;
1519 unsigned int r_type;
1520 struct elf_link_hash_entry *h = NULL;
1521
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;
1528
1529 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
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;
1533 eh = (struct elf64_x86_64_link_hash_entry *) h;
1534
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 }
1543
1544 r_type = ELF64_R_TYPE (rel->r_info);
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
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;
1557
1558 case R_X86_64_TLSGD:
1559 case R_X86_64_GOTPC32_TLSDESC:
1560 case R_X86_64_TLSDESC_CALL:
1561 case R_X86_64_GOTTPOFF:
1562 case R_X86_64_GOT32:
1563 case R_X86_64_GOTPCREL:
1564 case R_X86_64_GOT64:
1565 case R_X86_64_GOTPCREL64:
1566 case R_X86_64_GOTPLT64:
1567 if (h != NULL)
1568 {
1569 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
1570 h->plt.refcount -= 1;
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;
1580
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:
1589 case R_X86_64_PC64:
1590 if (info->shared)
1591 break;
1592 /* Fall thru */
1593
1594 case R_X86_64_PLT32:
1595 case R_X86_64_PLTOFF64:
1596 if (h != NULL)
1597 {
1598 if (h->plt.refcount > 0)
1599 h->plt.refcount -= 1;
1600 }
1601 break;
1602
1603 default:
1604 break;
1605 }
1606 }
1607
1608 return TRUE;
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
1615 understand. */
1616
1617static bfd_boolean
1618elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
1619 struct elf_link_hash_entry *h)
1620{
1621 struct elf64_x86_64_link_hash_table *htab;
1622 asection *s;
1623
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
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
1639 || h->needs_plt)
1640 {
1641 if (h->plt.refcount <= 0
1642 || SYMBOL_CALLS_LOCAL (info, h)
1643 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1644 && h->root.type == bfd_link_hash_undefweak))
1645 {
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. */
1651 h->plt.offset = (bfd_vma) -1;
1652 h->needs_plt = 0;
1653 }
1654
1655 return TRUE;
1656 }
1657 else
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. */
1663 h->plt.offset = (bfd_vma) -1;
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
1667 real definition first, and we can just use the same value. */
1668 if (h->u.weakdef != NULL)
1669 {
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;
1674 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1675 h->non_got_ref = h->u.weakdef->non_got_ref;
1676 return TRUE;
1677 }
1678
1679 /* This is a reference to a symbol defined by a dynamic object which
1680 is not a function. */
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
1685 be handled correctly by relocate_section. */
1686 if (info->shared)
1687 return TRUE;
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. */
1691 if (!h->non_got_ref)
1692 return TRUE;
1693
1694 /* If -z nocopyreloc was given, we won't generate them either. */
1695 if (info->nocopyreloc)
1696 {
1697 h->non_got_ref = 0;
1698 return TRUE;
1699 }
1700
1701 if (ELIMINATE_COPY_RELOCS)
1702 {
1703 struct elf64_x86_64_link_hash_entry * eh;
1704 struct elf64_x86_64_dyn_relocs *p;
1705
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 {
1718 h->non_got_ref = 0;
1719 return TRUE;
1720 }
1721 }
1722
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
1730 /* We must allocate the symbol in our .dynbss section, which will
1731 become part of the .bss section of the executable. There will be
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
1740 htab = elf64_x86_64_hash_table (info);
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
1744 runtime process image. */
1745 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1746 {
1747 htab->srelbss->size += sizeof (Elf64_External_Rela);
1748 h->needs_copy = 1;
1749 }
1750
1751 s = htab->sdynbss;
1752
1753 return _bfd_elf_adjust_dynamic_copy (h, s);
1754}
1755
1756/* Allocate space in .plt, .got and associated reloc sections for
1757 dynamic relocs. */
1758
1759static bfd_boolean
1760elf64_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
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
1767 if (h->root.type == bfd_link_hash_indirect)
1768 return TRUE;
1769
1770 if (h->root.type == bfd_link_hash_warning)
1771 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1772 eh = (struct elf64_x86_64_link_hash_entry *) h;
1773
1774 info = (struct bfd_link_info *) inf;
1775 htab = elf64_x86_64_hash_table (info);
1776
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
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;
1848 }
1849 else if (htab->elf.dynamic_sections_created
1850 && h->plt.refcount > 0)
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
1855 && !h->forced_local)
1856 {
1857 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1858 return FALSE;
1859 }
1860
1861 if (info->shared
1862 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1863 {
1864 asection *s = htab->splt;
1865
1866 /* If this is the first .plt entry, make room for the special
1867 first entry. */
1868 if (s->size == 0)
1869 s->size += PLT_ENTRY_SIZE;
1870
1871 h->plt.offset = s->size;
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
1879 && !h->def_regular)
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. */
1886 s->size += PLT_ENTRY_SIZE;
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. */
1890 htab->sgotplt->size += GOT_ENTRY_SIZE;
1891
1892 /* We also need to make an entry in the .rela.plt section. */
1893 htab->srelplt->size += sizeof (Elf64_External_Rela);
1894 htab->srelplt->reloc_count++;
1895 }
1896 else
1897 {
1898 h->plt.offset = (bfd_vma) -1;
1899 h->needs_plt = 0;
1900 }
1901 }
1902 else
1903 {
1904 h->plt.offset = (bfd_vma) -1;
1905 h->needs_plt = 0;
1906 }
1907
1908 eh->tlsdesc_got = (bfd_vma) -1;
1909
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)
1916 {
1917 h->got.offset = (bfd_vma) -1;
1918 }
1919 else if (h->got.refcount > 0)
1920 {
1921 asection *s;
1922 bfd_boolean dyn;
1923 int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
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
1928 && !h->forced_local)
1929 {
1930 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1931 return FALSE;
1932 }
1933
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 }
1950 dyn = htab->elf.dynamic_sections_created;
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. */
1954 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1955 || tls_type == GOT_TLS_IE)
1956 htab->srelgot->size += sizeof (Elf64_External_Rela);
1957 else if (GOT_TLS_GD_P (tls_type))
1958 htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
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)
1962 && (info->shared
1963 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1964 htab->srelgot->size += sizeof (Elf64_External_Rela);
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 }
1970 }
1971 else
1972 h->got.offset = (bfd_vma) -1;
1973
1974 if (eh->dyn_relocs == NULL)
1975 return TRUE;
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 {
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))
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 }
2005
2006 /* Also discard relocs on undefined weak syms with non-default
2007 visibility. */
2008 if (eh->dyn_relocs != NULL
2009 && h->root.type == bfd_link_hash_undefweak)
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
2017 && ! h->forced_local
2018 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2019 return FALSE;
2020 }
2021
2022 }
2023 else if (ELIMINATE_COPY_RELOCS)
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
2029 if (!h->non_got_ref
2030 && ((h->def_dynamic
2031 && !h->def_regular)
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
2039 && ! h->forced_local
2040 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2041 return FALSE;
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 {
2057 asection * sreloc;
2058
2059 sreloc = elf_section_data (p->sec)->sreloc;
2060
2061 BFD_ASSERT (sreloc != NULL);
2062
2063 sreloc->size += p->count * sizeof (Elf64_External_Rela);
2064 }
2065
2066 return TRUE;
2067}
2068
2069/* Find any dynamic relocs that apply to read-only sections. */
2070
2071static bfd_boolean
2072elf64_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2073{
2074 struct elf64_x86_64_link_hash_entry *eh;
2075 struct elf64_x86_64_dyn_relocs *p;
2076
2077 if (h->root.type == bfd_link_hash_warning)
2078 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2079
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. */
2092 return FALSE;
2093 }
2094 }
2095 return TRUE;
2096}
2097
2098/* Set the sizes of the dynamic sections. */
2099
2100static bfd_boolean
2101elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2102 struct bfd_link_info *info)
2103{
2104 struct elf64_x86_64_link_hash_table *htab;
2105 bfd *dynobj;
2106 asection *s;
2107 bfd_boolean relocs;
2108 bfd *ibfd;
2109
2110 htab = elf64_x86_64_hash_table (info);
2111 dynobj = htab->elf.dynobj;
2112 if (dynobj == NULL)
2113 abort ();
2114
2115 if (htab->elf.dynamic_sections_created)
2116 {
2117 /* Set the contents of the .interp section to the interpreter. */
2118 if (info->executable)
2119 {
2120 s = bfd_get_section_by_name (dynobj, ".interp");
2121 if (s == NULL)
2122 abort ();
2123 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2124 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2125 }
2126 }
2127
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)
2131 {
2132 bfd_signed_vma *local_got;
2133 bfd_signed_vma *end_local_got;
2134 char *local_tls_type;
2135 bfd_vma *local_tlsdesc_gotent;
2136 bfd_size_type locsymcount;
2137 Elf_Internal_Shdr *symtab_hdr;
2138 asection *srel;
2139
2140 if (! is_x86_64_elf (ibfd))
2141 continue;
2142
2143 for (s = ibfd->sections; s != NULL; s = s->next)
2144 {
2145 struct elf64_x86_64_dyn_relocs *p;
2146
2147 for (p = (struct elf64_x86_64_dyn_relocs *)
2148 (elf_section_data (s)->local_dynrel);
2149 p != NULL;
2150 p = p->next)
2151 {
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;
2163 srel->size += p->count * sizeof (Elf64_External_Rela);
2164 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2165 info->flags |= DF_TEXTREL;
2166 }
2167 }
2168 }
2169
2170 local_got = elf_local_got_refcounts (ibfd);
2171 if (!local_got)
2172 continue;
2173
2174 symtab_hdr = &elf_symtab_hdr (ibfd);
2175 locsymcount = symtab_hdr->sh_info;
2176 end_local_got = local_got + locsymcount;
2177 local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
2178 local_tlsdesc_gotent = elf64_x86_64_local_tlsdesc_gotent (ibfd);
2179 s = htab->sgot;
2180 srel = htab->srelgot;
2181 for (; local_got < end_local_got;
2182 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2183 {
2184 *local_tlsdesc_gotent = (bfd_vma) -1;
2185 if (*local_got > 0)
2186 {
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 }
2202 if (info->shared
2203 || GOT_TLS_GD_ANY_P (*local_tls_type)
2204 || *local_tls_type == GOT_TLS_IE)
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 }
2215 }
2216 else
2217 *local_got = (bfd_vma) -1;
2218 }
2219 }
2220
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. */
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);
2228 }
2229 else
2230 htab->tls_ld_got.offset = -1;
2231
2232 /* Allocate global sym .plt and .got entries, and space for global
2233 sym dynamic relocs. */
2234 elf_link_hash_traverse (&htab->elf, elf64_x86_64_allocate_dynrelocs,
2235 info);
2236
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
2265 /* We now have determined the sizes of the various dynamic sections.
2266 Allocate memory for them. */
2267 relocs = FALSE;
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
2275 || s == htab->sgotplt
2276 || s == htab->iplt
2277 || s == htab->igotplt
2278 || s == htab->sdynbss)
2279 {
2280 /* Strip this section if we don't need it; see the
2281 comment below. */
2282 }
2283 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2284 {
2285 if (s->size != 0 && s != htab->srelplt)
2286 relocs = TRUE;
2287
2288 /* We use the reloc_count field as a counter if we need
2289 to copy relocs into the output file. */
2290 if (s != htab->srelplt)
2291 s->reloc_count = 0;
2292 }
2293 else
2294 {
2295 /* It's not one of our sections, so don't allocate space. */
2296 continue;
2297 }
2298
2299 if (s->size == 0)
2300 {
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
2311 s->flags |= SEC_EXCLUDE;
2312 continue;
2313 }
2314
2315 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2316 continue;
2317
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. */
2323 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2324 if (s->contents == NULL)
2325 return FALSE;
2326 }
2327
2328 if (htab->elf.dynamic_sections_created)
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
2333 the .dynamic section. The DT_DEBUG entry is filled in by the
2334 dynamic linker and used by the debugger. */
2335#define add_dynamic_entry(TAG, VAL) \
2336 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2337
2338 if (info->executable)
2339 {
2340 if (!add_dynamic_entry (DT_DEBUG, 0))
2341 return FALSE;
2342 }
2343
2344 if (htab->splt->size != 0)
2345 {
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))
2350 return FALSE;
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;
2356 }
2357
2358 if (relocs)
2359 {
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)))
2363 return FALSE;
2364
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)
2368 elf_link_hash_traverse (&htab->elf,
2369 elf64_x86_64_readonly_dynrelocs,
2370 info);
2371
2372 if ((info->flags & DF_TEXTREL) != 0)
2373 {
2374 if (!add_dynamic_entry (DT_TEXTREL, 0))
2375 return FALSE;
2376 }
2377 }
2378 }
2379#undef add_dynamic_entry
2380
2381 return TRUE;
2382}
2383
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;
2409
2410 elf64_x86_64_hash_table (info)->tls_module_base = bh;
2411
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
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
2428elf64_x86_64_set_tls_module_base (struct bfd_link_info *info)
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
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
2448elf64_x86_64_dtpoff_base (struct bfd_link_info *info)
2449{
2450 /* If tls_sec is NULL, we should have signalled an error already. */
2451 if (elf_hash_table (info)->tls_sec == NULL)
2452 return 0;
2453 return elf_hash_table (info)->tls_sec->vma;
2454}
2455
2456/* Return the relocation value for @tpoff relocation
2457 if STT_TLS virtual address is ADDRESS. */
2458
2459static bfd_vma
2460elf64_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2461{
2462 struct elf_link_hash_table *htab = elf_hash_table (info);
2463
2464 /* If tls_segment is NULL, we should have signalled an error already. */
2465 if (htab->tls_sec == NULL)
2466 return 0;
2467 return address - htab->tls_size - htab->tls_sec->vma;
2468}
2469
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
2488/* Relocate an x86_64 ELF section. */
2489
2490static bfd_boolean
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)
2496{
2497 struct elf64_x86_64_link_hash_table *htab;
2498 Elf_Internal_Shdr *symtab_hdr;
2499 struct elf_link_hash_entry **sym_hashes;
2500 bfd_vma *local_got_offsets;
2501 bfd_vma *local_tlsdesc_gotents;
2502 Elf_Internal_Rela *rel;
2503 Elf_Internal_Rela *relend;
2504
2505 BFD_ASSERT (is_x86_64_elf (input_bfd));
2506
2507 htab = elf64_x86_64_hash_table (info);
2508 symtab_hdr = &elf_symtab_hdr (input_bfd);
2509 sym_hashes = elf_sym_hashes (input_bfd);
2510 local_got_offsets = elf_local_got_offsets (input_bfd);
2511 local_tlsdesc_gotents = elf64_x86_64_local_tlsdesc_gotent (input_bfd);
2512
2513 elf64_x86_64_set_tls_module_base (info);
2514
2515 rel = relocs;
2516 relend = relocs + input_section->reloc_count;
2517 for (; rel < relend; rel++)
2518 {
2519 unsigned int r_type;
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;
2525 bfd_vma off, offplt;
2526 bfd_vma relocation;
2527 bfd_boolean unresolved_reloc;
2528 bfd_reloc_status_type r;
2529 int tls_type;
2530 asection *base_got;
2531
2532 r_type = ELF64_R_TYPE (rel->r_info);
2533 if (r_type == (int) R_X86_64_GNU_VTINHERIT
2534 || r_type == (int) R_X86_64_GNU_VTENTRY)
2535 continue;
2536
2537 if (r_type >= R_X86_64_max)
2538 {
2539 bfd_set_error (bfd_error_bad_value);
2540 return FALSE;
2541 }
2542
2543 howto = x86_64_elf_howto_table + r_type;
2544 r_symndx = ELF64_R_SYM (rel->r_info);
2545 h = NULL;
2546 sym = NULL;
2547 sec = NULL;
2548 unresolved_reloc = FALSE;
2549 if (r_symndx < symtab_hdr->sh_info)
2550 {
2551 sym = local_syms + r_symndx;
2552 sec = local_sections[r_symndx];
2553
2554 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2555 }
2556 else
2557 {
2558 bfd_boolean warned;
2559
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);
2564 }
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
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
2625 if (base_got == NULL)
2626 abort ();
2627
2628 if (off == (bfd_vma) -1)
2629 {
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. */
2633
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 }
2640 else
2641 {
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 }
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
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:
2697 case R_X86_64_GOT64:
2698 /* Relocation is to the entry for this symbol in the global
2699 offset table. */
2700 case R_X86_64_GOTPCREL:
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
2712 if (htab->sgot == NULL)
2713 abort ();
2714
2715 if (h != NULL)
2716 {
2717 bfd_boolean dyn;
2718
2719 off = h->got.offset;
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
2733 dyn = htab->elf.dynamic_sections_created;
2734
2735 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2736 || (info->shared
2737 && SYMBOL_REFERENCES_LOCAL (info, h))
2738 || (ELF_ST_VISIBILITY (h->other)
2739 && h->root.type == bfd_link_hash_undefweak))
2740 {
2741 /* This is actually a static link, or it is a -Bsymbolic
2742 link and the symbol is defined locally, or the symbol
2743 was forced to be local because of a version file. We
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
2750 relocation entry to initialize the value. This is
2751 done in the finish_dynamic_symbol routine. */
2752 if ((off & 1) != 0)
2753 off &= ~1;
2754 else
2755 {
2756 bfd_put_64 (output_bfd, relocation,
2757 base_got->contents + off);
2758 /* Note that this is harmless for the GOTPLT64 case,
2759 as -1 | 1 still is -1. */
2760 h->got.offset |= 1;
2761 }
2762 }
2763 else
2764 unresolved_reloc = FALSE;
2765 }
2766 else
2767 {
2768 if (local_got_offsets == NULL)
2769 abort ();
2770
2771 off = local_got_offsets[r_symndx];
2772
2773 /* The offset must always be a multiple of 8. We use
2774 the least significant bit to record whether we have
2775 already generated the necessary reloc. */
2776 if ((off & 1) != 0)
2777 off &= ~1;
2778 else
2779 {
2780 bfd_put_64 (output_bfd, relocation,
2781 base_got->contents + off);
2782
2783 if (info->shared)
2784 {
2785 asection *s;
2786 Elf_Internal_Rela outrel;
2787 bfd_byte *loc;
2788
2789 /* We need to generate a R_X86_64_RELATIVE reloc
2790 for the dynamic linker. */
2791 s = htab->srelgot;
2792 if (s == NULL)
2793 abort ();
2794
2795 outrel.r_offset = (base_got->output_section->vma
2796 + base_got->output_offset
2797 + off);
2798 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2799 outrel.r_addend = relocation;
2800 loc = s->contents;
2801 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2802 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2803 }
2804
2805 local_got_offsets[r_symndx] |= 1;
2806 }
2807 }
2808
2809 if (off >= (bfd_vma) -2)
2810 abort ();
2811
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)
2815 relocation -= htab->sgotplt->output_section->vma
2816 - htab->sgotplt->output_offset;
2817
2818 break;
2819
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:
2850 case R_X86_64_GOTPC64:
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;
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;
2874
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,
2880 without using the procedure linkage table. */
2881 if (h == NULL)
2882 break;
2883
2884 if (h->plt.offset == (bfd_vma) -1
2885 || htab->splt == NULL)
2886 {
2887 /* We didn't make a PLT entry for this symbol. This
2888 happens when statically linking PIC code, or when
2889 using -Bsymbolic. */
2890 break;
2891 }
2892
2893 relocation = (htab->splt->output_section->vma
2894 + htab->splt->output_offset
2895 + h->plt.offset);
2896 unresolved_reloc = FALSE;
2897 break;
2898
2899 case R_X86_64_PC8:
2900 case R_X86_64_PC16:
2901 case R_X86_64_PC32:
2902 if (info->shared
2903 && (input_section->flags & SEC_ALLOC) != 0
2904 && (input_section->flags & SEC_READONLY) != 0
2905 && h != NULL)
2906 {
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 }
2918 else
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 }
2960 }
2961 /* Fall through. */
2962
2963 case R_X86_64_8:
2964 case R_X86_64_16:
2965 case R_X86_64_32:
2966 case R_X86_64_PC64:
2967 case R_X86_64_64:
2968 /* FIXME: The ABI says the linker should make sure the value is
2969 the same when it's zeroextended to 64 bit. */
2970
2971 if ((input_section->flags & SEC_ALLOC) == 0)
2972 break;
2973
2974 if ((info->shared
2975 && (h == NULL
2976 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2977 || h->root.type != bfd_link_hash_undefweak)
2978 && (! IS_X86_64_PCREL_TYPE (r_type)
2979 || ! SYMBOL_CALLS_LOCAL (info, h)))
2980 || (ELIMINATE_COPY_RELOCS
2981 && !info->shared
2982 && h != NULL
2983 && h->dynindx != -1
2984 && !h->non_got_ref
2985 && ((h->def_dynamic
2986 && !h->def_regular)
2987 || h->root.type == bfd_link_hash_undefweak
2988 || h->root.type == bfd_link_hash_undefined)))
2989 {
2990 Elf_Internal_Rela outrel;
2991 bfd_byte *loc;
2992 bfd_boolean skip, relocate;
2993 asection *sreloc;
2994
2995 /* When generating a shared object, these relocations
2996 are copied into the output file to be resolved at run
2997 time. */
2998 skip = FALSE;
2999 relocate = FALSE;
3000
3001 outrel.r_offset =
3002 _bfd_elf_section_offset (output_bfd, info, input_section,
3003 rel->r_offset);
3004 if (outrel.r_offset == (bfd_vma) -1)
3005 skip = TRUE;
3006 else if (outrel.r_offset == (bfd_vma) -2)
3007 skip = TRUE, relocate = TRUE;
3008
3009 outrel.r_offset += (input_section->output_section->vma
3010 + input_section->output_offset);
3011
3012 if (skip)
3013 memset (&outrel, 0, sizeof outrel);
3014
3015 /* h->dynindx may be -1 if this symbol was marked to
3016 become local. */
3017 else if (h != NULL
3018 && h->dynindx != -1
3019 && (IS_X86_64_PCREL_TYPE (r_type)
3020 || ! info->shared
3021 || ! SYMBOLIC_BIND (info, h)
3022 || ! h->def_regular))
3023 {
3024 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
3025 outrel.r_addend = rel->r_addend;
3026 }
3027 else
3028 {
3029 /* This symbol is local, or marked to become local. */
3030 if (r_type == R_X86_64_64)
3031 {
3032 relocate = TRUE;
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
3040 if (bfd_is_abs_section (sec))
3041 sindx = 0;
3042 else if (sec == NULL || sec->owner == NULL)
3043 {
3044 bfd_set_error (bfd_error_bad_value);
3045 return FALSE;
3046 }
3047 else
3048 {
3049 asection *osec;
3050
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. */
3056 osec = sec->output_section;
3057 sindx = elf_section_data (osec)->dynindx;
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);
3064 }
3065
3066 outrel.r_info = ELF64_R_INFO (sindx, r_type);
3067 outrel.r_addend = relocation + rel->r_addend;
3068 }
3069 }
3070
3071 sreloc = elf_section_data (input_section)->sreloc;
3072
3073 BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
3074
3075 loc = sreloc->contents;
3076 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3077 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
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. */
3083 if (! relocate)
3084 continue;
3085 }
3086
3087 break;
3088
3089 case R_X86_64_TLSGD:
3090 case R_X86_64_GOTPC32_TLSDESC:
3091 case R_X86_64_TLSDESC_CALL:
3092 case R_X86_64_GOTTPOFF:
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)
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))
3104 return FALSE;
3105
3106 if (r_type == R_X86_64_TPOFF32)
3107 {
3108 bfd_vma roff = rel->r_offset;
3109
3110 BFD_ASSERT (! unresolved_reloc);
3111
3112 if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3113 {
3114 /* GD->LE transition.
3115 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3116 .word 0x6666; rex64; call __tls_get_addr
3117 Change it into:
3118 movq %fs:0, %rax
3119 leaq foo@tpoff(%rax), %rax */
3120 memcpy (contents + roff - 4,
3121 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3122 16);
3123 bfd_put_32 (output_bfd,
3124 elf64_x86_64_tpoff (info, relocation),
3125 contents + roff + 8);
3126 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3127 rel++;
3128 continue;
3129 }
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
3138 */
3139
3140 unsigned int val, type, type2;
3141
3142 type = bfd_get_8 (input_bfd, contents + roff - 3);
3143 type2 = bfd_get_8 (input_bfd, contents + roff - 2);
3144 val = bfd_get_8 (input_bfd, contents + roff - 1);
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);
3150 bfd_put_32 (output_bfd,
3151 elf64_x86_64_tpoff (info, relocation),
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:
3161 xchg %ax,%ax. */
3162 bfd_put_8 (output_bfd, 0x66, contents + roff);
3163 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3164 continue;
3165 }
3166 else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3167 {
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. */
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);
3182 reg >>= 3;
3183 if (type == 0x8b)
3184 {
3185 /* movq */
3186 if (val == 0x4c)
3187 bfd_put_8 (output_bfd, 0x49,
3188 contents + roff - 3);
3189 bfd_put_8 (output_bfd, 0xc7,
3190 contents + roff - 2);
3191 bfd_put_8 (output_bfd, 0xc0 | reg,
3192 contents + roff - 1);
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,
3200 contents + roff - 3);
3201 bfd_put_8 (output_bfd, 0x81,
3202 contents + roff - 2);
3203 bfd_put_8 (output_bfd, 0xc0 | reg,
3204 contents + roff - 1);
3205 }
3206 else
3207 {
3208 /* addq -> leaq */
3209 if (val == 0x4c)
3210 bfd_put_8 (output_bfd, 0x4d,
3211 contents + roff - 3);
3212 bfd_put_8 (output_bfd, 0x8d,
3213 contents + roff - 2);
3214 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3215 contents + roff - 1);
3216 }
3217 bfd_put_32 (output_bfd,
3218 elf64_x86_64_tpoff (info, relocation),
3219 contents + roff);
3220 continue;
3221 }
3222 else
3223 BFD_ASSERT (FALSE);
3224 }
3225
3226 if (htab->sgot == NULL)
3227 abort ();
3228
3229 if (h != NULL)
3230 {
3231 off = h->got.offset;
3232 offplt = elf64_x86_64_hash_entry (h)->tlsdesc_got;
3233 }
3234 else
3235 {
3236 if (local_got_offsets == NULL)
3237 abort ();
3238
3239 off = local_got_offsets[r_symndx];
3240 offplt = local_tlsdesc_gotents[r_symndx];
3241 }
3242
3243 if ((off & 1) != 0)
3244 off &= ~1;
3245 else
3246 {
3247 Elf_Internal_Rela outrel;
3248 bfd_byte *loc;
3249 int dr_type, indx;
3250 asection *sreloc;
3251
3252 if (htab->srelgot == NULL)
3253 abort ();
3254
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)
3273 outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3274 else
3275 outrel.r_addend = 0;
3276 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3277 }
3278
3279 sreloc = htab->srelgot;
3280
3281 outrel.r_offset = (htab->sgot->output_section->vma
3282 + htab->sgot->output_offset + off);
3283
3284 if (GOT_TLS_GD_P (tls_type))
3285 dr_type = R_X86_64_DTPMOD64;
3286 else if (GOT_TLS_GDESC_P (tls_type))
3287 goto dr_done;
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;
3293 if ((dr_type == R_X86_64_TPOFF64
3294 || dr_type == R_X86_64_TLSDESC) && indx == 0)
3295 outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3296 outrel.r_info = ELF64_R_INFO (indx, dr_type);
3297
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);
3302 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3303
3304 if (GOT_TLS_GD_P (tls_type))
3305 {
3306 if (indx == 0)
3307 {
3308 BFD_ASSERT (! unresolved_reloc);
3309 bfd_put_64 (output_bfd,
3310 relocation - elf64_x86_64_dtpoff_base (info),
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;
3320 sreloc->reloc_count++;
3321 loc += sizeof (Elf64_External_Rela);
3322 BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
3323 <= sreloc->contents + sreloc->size);
3324 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3325 }
3326 }
3327
3328 dr_done:
3329 if (h != NULL)
3330 h->got.offset |= 1;
3331 else
3332 local_got_offsets[r_symndx] |= 1;
3333 }
3334
3335 if (off >= (bfd_vma) -2
3336 && ! GOT_TLS_GDESC_P (tls_type))
3337 abort ();
3338 if (r_type == ELF64_R_TYPE (rel->r_info))
3339 {
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;
3348 unresolved_reloc = FALSE;
3349 }
3350 else
3351 {
3352 bfd_vma roff = rel->r_offset;
3353
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
3383
3384 Change it to:
3385 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax
3386 */
3387
3388 unsigned int val, type, type2;
3389
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);
3393
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);
3429 }
3430 break;
3431
3432 case R_X86_64_TLSLD:
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;
3439
3440 if (r_type != R_X86_64_TLSLD)
3441 {
3442 /* LD->LE transition:
3443 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
3444 We change it into:
3445 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */
3446
3447 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3448 memcpy (contents + rel->r_offset - 3,
3449 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3450 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
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;
3464 bfd_byte *loc;
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;
3478 loc = htab->srelgot->contents;
3479 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
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;
3485 unresolved_reloc = FALSE;
3486 break;
3487
3488 case R_X86_64_DTPOFF32:
3489 if (info->shared || (input_section->flags & SEC_CODE) == 0)
3490 relocation -= elf64_x86_64_dtpoff_base (info);
3491 else
3492 relocation = elf64_x86_64_tpoff (info, relocation);
3493 break;
3494
3495 case R_X86_64_TPOFF32:
3496 BFD_ASSERT (! info->shared);
3497 relocation = elf64_x86_64_tpoff (info, relocation);
3498 break;
3499
3500 default:
3501 break;
3502 }
3503
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. */
3507 if (unresolved_reloc
3508 && !((input_section->flags & SEC_DEBUGGING) != 0
3509 && h->def_dynamic))
3510 (*_bfd_error_handler)
3511 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3512 input_bfd,
3513 input_section,
3514 (long) rel->r_offset,
3515 howto->name,
3516 h->root.root.string);
3517
3518do_relocation:
3519 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3520 contents, rel->r_offset,
3521 relocation, rel->r_addend);
3522
3523 if (r != bfd_reloc_ok)
3524 {
3525 const char *name;
3526
3527 if (h != NULL)
3528 name = h->root.root.string;
3529 else
3530 {
3531 name = bfd_elf_string_from_elf_section (input_bfd,
3532 symtab_hdr->sh_link,
3533 sym->st_name);
3534 if (name == NULL)
3535 return FALSE;
3536 if (*name == '\0')
3537 name = bfd_section_name (input_bfd, sec);
3538 }
3539
3540 if (r == bfd_reloc_overflow)
3541 {
3542 if (! ((*info->callbacks->reloc_overflow)
3543 (info, (h ? &h->root : NULL), name, howto->name,
3544 (bfd_vma) 0, input_bfd, input_section,
3545 rel->r_offset)))
3546 return FALSE;
3547 }
3548 else
3549 {
3550 (*_bfd_error_handler)
3551 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3552 input_bfd, input_section,
3553 (long) rel->r_offset, name, (int) r);
3554 return FALSE;
3555 }
3556 }
3557 }
3558
3559 return TRUE;
3560}
3561
3562/* Finish up dynamic symbol handling. We set the contents of various
3563 dynamic sections here. */
3564
3565static bfd_boolean
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)
3570{
3571 struct elf64_x86_64_link_hash_table *htab;
3572
3573 htab = elf64_x86_64_hash_table (info);
3574
3575 if (h->plt.offset != (bfd_vma) -1)
3576 {
3577 bfd_vma plt_index;
3578 bfd_vma got_offset;
3579 Elf_Internal_Rela rela;
3580 bfd_byte *loc;
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 }
3597
3598 /* This symbol has an entry in the procedure linkage table. Set
3599 it up. */
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)
3607 abort ();
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
3612 first entry in the procedure linkage table is reserved.
3613
3614 Get the offset into the .got table of the entry that
3615 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
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 }
3630
3631 /* Fill in the entry in the procedure linkage table. */
3632 memcpy (plt->contents + h->plt.offset, elf64_x86_64_plt_entry,
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. */
3638 /* Put offset for jmp *name@GOTPCREL(%rip), since the
3639 instruction uses 6 bytes, subtract this value. */
3640 bfd_put_32 (output_bfd,
3641 (gotplt->output_section->vma
3642 + gotplt->output_offset
3643 + got_offset
3644 - plt->output_section->vma
3645 - plt->output_offset
3646 - h->plt.offset
3647 - 6),
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 }
3660
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. */
3663 bfd_put_64 (output_bfd, (plt->output_section->vma
3664 + plt->output_offset
3665 + h->plt.offset + 6),
3666 gotplt->contents + got_offset);
3667
3668 /* Fill in the entry in the .rela.plt section. */
3669 rela.r_offset = (gotplt->output_section->vma
3670 + gotplt->output_offset
3671 + got_offset);
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);
3691 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3692
3693 if (!h->def_regular)
3694 {
3695 /* Mark the symbol as undefined, rather than as defined in
3696 the .plt section. Leave the value if there were any
3697 relocations where pointer equality matters (this is a clue
3698 for the dynamic linker, to make function pointer
3699 comparisons work between an application and shared
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. */
3703 sym->st_shndx = SHN_UNDEF;
3704 if (!h->pointer_equality_needed)
3705 sym->st_value = 0;
3706 }
3707 }
3708
3709 if (h->got.offset != (bfd_vma) -1
3710 && ! GOT_TLS_GD_ANY_P (elf64_x86_64_hash_entry (h)->tls_type)
3711 && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
3712 {
3713 Elf_Internal_Rela rela;
3714 bfd_byte *loc;
3715
3716 /* This symbol has an entry in the global offset table. Set it
3717 up. */
3718 if (htab->sgot == NULL || htab->srelgot == NULL)
3719 abort ();
3720
3721 rela.r_offset = (htab->sgot->output_section->vma
3722 + htab->sgot->output_offset
3723 + (h->got.offset &~ (bfd_vma) 1));
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. */
3730 if (info->shared
3731 && SYMBOL_REFERENCES_LOCAL (info, h))
3732 {
3733 if (!h->def_regular)
3734 return FALSE;
3735 BFD_ASSERT((h->got.offset & 1) != 0);
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);
3744 bfd_put_64 (output_bfd, (bfd_vma) 0,
3745 htab->sgot->contents + h->got.offset);
3746 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
3747 rela.r_addend = 0;
3748 }
3749
3750 loc = htab->srelgot->contents;
3751 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3752 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3753 }
3754
3755 if (h->needs_copy)
3756 {
3757 Elf_Internal_Rela rela;
3758 bfd_byte *loc;
3759
3760 /* This symbol needs a copy reloc. Set it up. */
3761
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 ();
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;
3773 loc = htab->srelbss->contents;
3774 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3775 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3776 }
3777
3778 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3779 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3780 || h == htab->elf.hgot)
3781 sym->st_shndx = SHN_ABS;
3782
3783 return TRUE;
3784}
3785
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
3790elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
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
3805/* Finish up the dynamic sections. */
3806
3807static bfd_boolean
3808elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3809{
3810 struct elf64_x86_64_link_hash_table *htab;
3811 bfd *dynobj;
3812 asection *sdyn;
3813
3814 htab = elf64_x86_64_hash_table (info);
3815 dynobj = htab->elf.dynobj;
3816 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3817
3818 if (htab->elf.dynamic_sections_created)
3819 {
3820 Elf64_External_Dyn *dyncon, *dynconend;
3821
3822 if (sdyn == NULL || htab->sgot == NULL)
3823 abort ();
3824
3825 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3826 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3827 for (; dyncon < dynconend; dyncon++)
3828 {
3829 Elf_Internal_Dyn dyn;
3830 asection *s;
3831
3832 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3833
3834 switch (dyn.d_tag)
3835 {
3836 default:
3837 continue;
3838
3839 case DT_PLTGOT:
3840 s = htab->sgotplt;
3841 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3842 break;
3843
3844 case DT_JMPREL:
3845 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3846 break;
3847
3848 case DT_PLTRELSZ:
3849 s = htab->srelplt->output_section;
3850 dyn.d_un.d_val = s->size;
3851 break;
3852
3853 case DT_RELASZ:
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)
3862 {
3863 s = htab->srelplt->output_section;
3864 dyn.d_un.d_val -= s->size;
3865 }
3866 break;
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;
3879 }
3880
3881 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3882 }
3883
3884 /* Fill in the special first entry in the procedure linkage table. */
3885 if (htab->splt && htab->splt->size > 0)
3886 {
3887 /* Fill in the first entry in the procedure linkage table. */
3888 memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
3889 PLT_ENTRY_SIZE);
3890 /* Add offset for pushq GOT+8(%rip), since the instruction
3891 uses 6 bytes subtract this value. */
3892 bfd_put_32 (output_bfd,
3893 (htab->sgotplt->output_section->vma
3894 + htab->sgotplt->output_offset
3895 + 8
3896 - htab->splt->output_section->vma
3897 - htab->splt->output_offset
3898 - 6),
3899 htab->splt->contents + 2);
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,
3903 (htab->sgotplt->output_section->vma
3904 + htab->sgotplt->output_offset
3905 + 16
3906 - htab->splt->output_section->vma
3907 - htab->splt->output_offset
3908 - 12),
3909 htab->splt->contents + 8);
3910
3911 elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
3912 PLT_ENTRY_SIZE;
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 }
3947 }
3948 }
3949
3950 if (htab->sgotplt)
3951 {
3952 /* Fill in the first three entries in the global offset table. */
3953 if (htab->sgotplt->size > 0)
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 }
3967
3968 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
3969 GOT_ENTRY_SIZE;
3970 }
3971
3972 if (htab->sgot && htab->sgot->size > 0)
3973 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
3974 = GOT_ENTRY_SIZE;
3975
3976 return TRUE;
3977}
3978
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}
3988
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
3993elf64_x86_64_section_from_shdr (bfd *abfd,
3994 Elf_Internal_Shdr *hdr,
3995 const char *name,
3996 int shindex)
3997{
3998 if (hdr->sh_type != SHT_X86_64_UNWIND)
3999 return FALSE;
4000
4001 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4002 return FALSE;
4003
4004 return TRUE;
4005}
4006
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,
4013 struct bfd_link_info *info,
4014 Elf_Internal_Sym *sym,
4015 const char **namep ATTRIBUTE_UNUSED,
4016 flagword *flagsp ATTRIBUTE_UNUSED,
4017 asection **secp,
4018 bfd_vma *valp)
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 }
4041
4042 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4043 elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4044
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,
4113 asection **psec,
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,
4130 bfd *oldbfd,
4131 asection **oldsec)
4132{
4133 /* A normal common symbol and a large common symbol result in a
4134 normal common symbol. We turn the large common symbol into a
4135 normal one. */
4136 if (!*olddyn
4137 && h->root.type == bfd_link_hash_common
4138 && !*newdyn
4139 && bfd_is_com_section (*sec)
4140 && *oldsec != *sec)
4141 {
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)
4151 *psec = *sec = bfd_com_section_ptr;
4152 }
4153
4154 return TRUE;
4155}
4156
4157static int
4158elf64_x86_64_additional_program_headers (bfd *abfd,
4159 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4160{
4161 asection *s;
4162 int count = 0;
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
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
4192static const struct bfd_elf_special_section
4193 elf64_x86_64_special_sections[]=
4194{
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 }
4202};
4203
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
4208#define ELF_MAXPAGESIZE 0x200000
4209#define ELF_MINPAGESIZE 0x1000
4210#define ELF_COMMONPAGESIZE 0x1000
4211
4212#define elf_backend_can_gc_sections 1
4213#define elf_backend_can_refcount 1
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)
4218#define elf_backend_rela_normal 1
4219
4220#define elf_info_to_howto elf64_x86_64_info_to_howto
4221
4222#define bfd_elf64_bfd_link_hash_table_create \
4223 elf64_x86_64_link_hash_table_create
4224#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
4225#define bfd_elf64_bfd_reloc_name_lookup \
4226 elf64_x86_64_reloc_name_lookup
4227
4228#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
4229#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4230#define elf_backend_check_relocs elf64_x86_64_check_relocs
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
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
4237#define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus
4238#define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo
4239#define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
4240#define elf_backend_relocate_section elf64_x86_64_relocate_section
4241#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
4242#define elf_backend_always_size_sections elf64_x86_64_always_size_sections
4243#define elf_backend_init_index_section _bfd_elf_init_1_index_section
4244#define elf_backend_plt_sym_val elf64_x86_64_plt_sym_val
4245#define elf_backend_object_p elf64_x86_64_elf_object_p
4246#define bfd_elf64_mkobject elf64_x86_64_mkobject
4247
4248#define elf_backend_section_from_shdr \
4249 elf64_x86_64_section_from_shdr
4250
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
4269#define elf_backend_hash_symbol \
4270 elf64_x86_64_hash_symbol
4271
4272#undef elf_backend_post_process_headers
4273#define elf_backend_post_process_headers _bfd_elf_set_osabi
4274
4275#include "elf64-target.h"
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
4284#undef ELF_OSABI
4285#define ELF_OSABI ELFOSABI_FREEBSD
4286
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