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