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