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