projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Give emulation a chance to process unrecognized file before fatal error is
[deliverable/binutils-gdb.git] / bfd / elf64-x86-64.c
CommitLineData
8d88c4ca 1/* X86-64 specific support for 64-bit ELF
70256ad8 2 Copyright 2000, 2001 Free Software Foundation, Inc.
8d88c4ca
NC		 3 Contributed by Jan Hubicka <jh@suse.cz>.
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21#include "bfd.h"
22#include "sysdep.h"
23#include "libbfd.h"
24#include "elf-bfd.h"
25
26#include "elf/x86-64.h"
27
28/* We use only the RELA entries. */
29#define USE_RELA
30
31/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
32#define MINUS_ONE (~ (bfd_vma) 0)
33
34/* The relocation "howto" table. Order of fields:
407443a3
AJ		 35 type, size, bitsize, pc_relative, complain_on_overflow,
36 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
70256ad8
AJ		 37static reloc_howto_type x86_64_elf_howto_table[] =
38{
407443a3 39 HOWTO(R_X86_64_NONE, 0, 0, 0, false, 0, complain_overflow_dont,
fe4770f4
AJ		 40 bfd_elf_generic_reloc, "R_X86_64_NONE", false, 0x00000000, 0x00000000,
41 false),
407443a3 42 HOWTO(R_X86_64_64, 0, 4, 64, false, 0, complain_overflow_bitfield,
fe4770f4
AJ		 43 bfd_elf_generic_reloc, "R_X86_64_64", false, MINUS_ONE, MINUS_ONE,
44 false),
407443a3 45 HOWTO(R_X86_64_PC32, 0, 4, 32, true, 0, complain_overflow_signed,
fe4770f4
AJ		 46 bfd_elf_generic_reloc, "R_X86_64_PC32", false, 0xffffffff, 0xffffffff,
47 true),
407443a3 48 HOWTO(R_X86_64_GOT32, 0, 4, 32, false, 0, complain_overflow_signed,
fe4770f4
AJ		 49 bfd_elf_generic_reloc, "R_X86_64_GOT32", false, 0xffffffff, 0xffffffff,
50 false),
407443a3 51 HOWTO(R_X86_64_PLT32, 0, 4, 32, true, 0, complain_overflow_signed,
fe4770f4
AJ		 52 bfd_elf_generic_reloc, "R_X86_64_PLT32", false, 0xffffffff, 0xffffffff,
53 true),
407443a3 54 HOWTO(R_X86_64_COPY, 0, 4, 32, false, 0, complain_overflow_bitfield,
fe4770f4
AJ		 55 bfd_elf_generic_reloc, "R_X86_64_COPY", false, 0xffffffff, 0xffffffff,
56 false),
407443a3 57 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, false, 0, complain_overflow_bitfield,
fe4770f4
AJ		 58 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", false, MINUS_ONE,
59 MINUS_ONE, false),
407443a3 60 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, false, 0, complain_overflow_bitfield,
fe4770f4
AJ		 61 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", false, MINUS_ONE,
62 MINUS_ONE, false),
4a73f21b 63 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, false, 0, complain_overflow_bitfield,
fe4770f4
AJ		 64 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", false, MINUS_ONE,
65 MINUS_ONE, false),
407443a3 66 HOWTO(R_X86_64_GOTPCREL, 0, 4, 32, true,0 , complain_overflow_signed,
fe4770f4
AJ		 67 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", false, 0xffffffff,
68 0xffffffff, true),
407443a3 69 HOWTO(R_X86_64_32, 0, 4, 32, false, 0, complain_overflow_unsigned,
fe4770f4
AJ		 70 bfd_elf_generic_reloc, "R_X86_64_32", false, 0xffffffff, 0xffffffff,
71 false),
407443a3 72 HOWTO(R_X86_64_32S, 0, 4, 32, false, 0, complain_overflow_signed,
fe4770f4
AJ		 73 bfd_elf_generic_reloc, "R_X86_64_32S", false, 0xffffffff, 0xffffffff,
74 false),
407443a3
AJ		 75 HOWTO(R_X86_64_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_X86_64_16", false, 0xffff, 0xffff, false),
77 HOWTO(R_X86_64_PC16,0, 1, 16, true, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_X86_64_PC16", false, 0xffff, 0xffff, true),
79 HOWTO(R_X86_64_8, 0, 0, 8, false, 0, complain_overflow_signed,
80 bfd_elf_generic_reloc, "R_X86_64_8", false, 0xff, 0xff, false),
81 HOWTO(R_X86_64_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
fe4770f4
AJ		 82 bfd_elf_generic_reloc, "R_X86_64_PC8", false, 0xff, 0xff, true),
83
84/* GNU extension to record C++ vtable hierarchy. */
85 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, false, 0, complain_overflow_dont,
86 NULL, "R_X86_64_GNU_VTINHERIT", false, 0, 0, false),
87
88/* GNU extension to record C++ vtable member usage. */
89 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, false, 0, complain_overflow_dont,
90 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", false, 0, 0,
91 false)
8d88c4ca
NC		 92};
93
94/* Map BFD relocs to the x86_64 elf relocs. */
70256ad8
AJ		 95struct elf_reloc_map
96{
8d88c4ca
NC		 97 bfd_reloc_code_real_type bfd_reloc_val;
98 unsigned char elf_reloc_val;
99};
100
101static CONST struct elf_reloc_map x86_64_reloc_map[] =
102{
70256ad8
AJ		 103 { BFD_RELOC_NONE, R_X86_64_NONE, },
104 { BFD_RELOC_64, R_X86_64_64, },
105 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
106 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
107 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
108 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
109 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
110 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
111 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
112 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
113 { BFD_RELOC_32, R_X86_64_32, },
114 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
115 { BFD_RELOC_16, R_X86_64_16, },
116 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
117 { BFD_RELOC_8, R_X86_64_8, },
118 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
fe4770f4
AJ		 119 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
120 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
8d88c4ca
NC		 121};
122
8d88c4ca
NC		 123static reloc_howto_type *elf64_x86_64_reloc_type_lookup
124 PARAMS ((bfd *, bfd_reloc_code_real_type));
125static void elf64_x86_64_info_to_howto
126 PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
127static struct bfd_link_hash_table *elf64_x86_64_link_hash_table_create
128 PARAMS ((bfd *));
70256ad8
AJ		 129
130static struct bfd_hash_entry *elf64_x86_64_link_hash_newfunc
131 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
132static boolean elf64_x86_64_adjust_dynamic_symbol
133 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
134
135static boolean elf64_x86_64_size_dynamic_sections
136 PARAMS ((bfd *, struct bfd_link_info *));
8d88c4ca
NC		 137static boolean elf64_x86_64_relocate_section
138 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
407443a3 139 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
70256ad8
AJ		 140static boolean elf64_x86_64_finish_dynamic_symbol
141 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
142 Elf_Internal_Sym *sym));
143static boolean elf64_x86_64_finish_dynamic_sections
144 PARAMS ((bfd *, struct bfd_link_info *));
8d88c4ca
NC		 145
146/* Given a BFD reloc type, return a HOWTO structure. */
147static reloc_howto_type *
148elf64_x86_64_reloc_type_lookup (abfd, code)
149 bfd *abfd ATTRIBUTE_UNUSED;
150 bfd_reloc_code_real_type code;
151{
152 unsigned int i;
153 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
154 i++)
155 {
156 if (x86_64_reloc_map[i].bfd_reloc_val == code)
8da6118f
KH		 157 return &x86_64_elf_howto_table[(int)
158 x86_64_reloc_map[i].elf_reloc_val];
8d88c4ca
NC		 159 }
160 return 0;
161}
162
8d88c4ca 163/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
8da6118f 164
8d88c4ca
NC		 165static void
166elf64_x86_64_info_to_howto (abfd, cache_ptr, dst)
167 bfd *abfd ATTRIBUTE_UNUSED;
168 arelent *cache_ptr;
169 Elf64_Internal_Rela *dst;
170{
fe4770f4 171 unsigned r_type, i;
8d88c4ca
NC		 172
173 r_type = ELF64_R_TYPE (dst->r_info);
fe4770f4
AJ		 174 if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
175 {
176 BFD_ASSERT (r_type <= (unsigned int) R_X86_64_PC8);
177 i = r_type;
178 }
179 else
180 {
181 BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
182 i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_PC8 - 1);
183 }
184 cache_ptr->howto = &x86_64_elf_howto_table[i];
8d88c4ca
NC		 185 BFD_ASSERT (r_type == cache_ptr->howto->type);
186}
70256ad8 187\f
407443a3 188/* Functions for the x86-64 ELF linker. */
70256ad8 189
407443a3 190/* The name of the dynamic interpreter. This is put in the .interp
70256ad8
AJ		 191 section. */
192
407443a3 193#define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
70256ad8
AJ		 194
195/* The size in bytes of an entry in the global offset table. */
196
197#define GOT_ENTRY_SIZE 8
8d88c4ca 198
70256ad8 199/* The size in bytes of an entry in the procedure linkage table. */
8d88c4ca 200
70256ad8
AJ		 201#define PLT_ENTRY_SIZE 16
202
203/* The first entry in a procedure linkage table looks like this. See the
204 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
205
206static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
207{
653165cc
AJ		 208 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
209 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
210 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */
70256ad8
AJ		 211};
212
213/* Subsequent entries in a procedure linkage table look like this. */
214
215static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
216{
653165cc 217 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
407443a3 218 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653165cc 219 0x68, /* pushq immediate */
70256ad8
AJ		 220 0, 0, 0, 0, /* replaced with index into relocation table. */
221 0xe9, /* jmp relative */
222 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
223};
224
225/* The x86-64 linker needs to keep track of the number of relocs that
407443a3 226 it decides to copy in check_relocs for each symbol. This is so
70256ad8
AJ		 227 that it can discard PC relative relocs if it doesn't need them when
228 linking with -Bsymbolic. We store the information in a field
407443a3 229 extending the regular ELF linker hash table. */
70256ad8
AJ		 230
231/* This structure keeps track of the number of PC relative relocs we
232 have copied for a given symbol. */
233
234struct elf64_x86_64_pcrel_relocs_copied
235{
236 /* Next section. */
237 struct elf64_x86_64_pcrel_relocs_copied *next;
238 /* A section in dynobj. */
239 asection *section;
240 /* Number of relocs copied in this section. */
241 bfd_size_type count;
242};
243
244/* x86-64 ELF linker hash entry. */
245
246struct elf64_x86_64_link_hash_entry
247{
248 struct elf_link_hash_entry root;
249
250 /* Number of PC relative relocs copied for this symbol. */
251 struct elf64_x86_64_pcrel_relocs_copied *pcrel_relocs_copied;
252};
253
254/* x86-64 ELF linker hash table. */
8d88c4ca 255
407443a3
AJ		 256struct elf64_x86_64_link_hash_table
257{
8d88c4ca
NC		 258 struct elf_link_hash_table root;
259};
260
70256ad8
AJ		 261/* Declare this now that the above structures are defined. */
262
263static boolean elf64_x86_64_discard_copies
264 PARAMS ((struct elf64_x86_64_link_hash_entry *, PTR));
265
266/* Traverse an x86-64 ELF linker hash table. */
267
268#define elf64_x86_64_link_hash_traverse(table, func, info) \
269 (elf_link_hash_traverse \
270 (&(table)->root, \
271 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
272 (info)))
273
274/* Get the x86-64 ELF linker hash table from a link_info structure. */
8d88c4ca
NC		 275
276#define elf64_x86_64_hash_table(p) \
277 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
278
407443a3 279/* Create an entry in an x86-64 ELF linker hash table. */
70256ad8
AJ		 280
281static struct bfd_hash_entry *
282elf64_x86_64_link_hash_newfunc (entry, table, string)
283 struct bfd_hash_entry *entry;
284 struct bfd_hash_table *table;
285 const char *string;
286{
287 struct elf64_x86_64_link_hash_entry *ret =
288 (struct elf64_x86_64_link_hash_entry *) entry;
289
290 /* Allocate the structure if it has not already been allocated by a
407443a3 291 subclass. */
70256ad8
AJ		 292 if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
293 ret = ((struct elf64_x86_64_link_hash_entry *)
294 bfd_hash_allocate (table,
295 sizeof (struct elf64_x86_64_link_hash_entry)));
296 if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
297 return (struct bfd_hash_entry *) ret;
298
299 /* Call the allocation method of the superclass. */
300 ret = ((struct elf64_x86_64_link_hash_entry *)
301 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
302 table, string));
303 if (ret != (struct elf64_x86_64_link_hash_entry *) NULL)
304 {
305 ret->pcrel_relocs_copied = NULL;
306 }
307
308 return (struct bfd_hash_entry *) ret;
309}
310
8d88c4ca
NC		 311/* Create an X86-64 ELF linker hash table. */
312
313static struct bfd_link_hash_table *
314elf64_x86_64_link_hash_table_create (abfd)
315 bfd *abfd;
316{
317 struct elf64_x86_64_link_hash_table *ret;
318
319 ret = ((struct elf64_x86_64_link_hash_table *)
8da6118f 320 bfd_alloc (abfd, sizeof (struct elf64_x86_64_link_hash_table)));
8d88c4ca
NC		 321 if (ret == (struct elf64_x86_64_link_hash_table *) NULL)
322 return NULL;
323
324 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
70256ad8 325 elf64_x86_64_link_hash_newfunc))
8d88c4ca
NC		 326 {
327 bfd_release (abfd, ret);
328 return NULL;
329 }
330
331 return &ret->root.root;
332}
333
334boolean
335elf64_x86_64_elf_object_p (abfd)
336 bfd *abfd;
337{
338 /* Set the right machine number for an x86-64 elf64 file. */
339 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
340 return true;
341}
342
70256ad8
AJ		 343/* Look through the relocs for a section during the first phase, and
344 allocate space in the global offset table or procedure linkage
345 table. */
346
347static boolean
348elf64_x86_64_check_relocs (abfd, info, sec, relocs)
349 bfd *abfd;
350 struct bfd_link_info *info;
351 asection *sec;
352 const Elf_Internal_Rela *relocs;
353{
354 bfd *dynobj;
355 Elf_Internal_Shdr *symtab_hdr;
356 struct elf_link_hash_entry **sym_hashes;
357 bfd_signed_vma *local_got_refcounts;
358 const Elf_Internal_Rela *rel;
359 const Elf_Internal_Rela *rel_end;
360 asection *sgot;
361 asection *srelgot;
362 asection *sreloc;
363
364 if (info->relocateable)
365 return true;
366
367 dynobj = elf_hash_table (info)->dynobj;
368 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
369 sym_hashes = elf_sym_hashes (abfd);
370 local_got_refcounts = elf_local_got_refcounts (abfd);
371
372 sgot = srelgot = sreloc = NULL;
373 rel_end = relocs + sec->reloc_count;
374 for (rel = relocs; rel < rel_end; rel++)
375 {
376 unsigned long r_symndx;
377 struct elf_link_hash_entry *h;
378
379 r_symndx = ELF64_R_SYM (rel->r_info);
380 if (r_symndx < symtab_hdr->sh_info)
381 h = NULL;
382 else
383 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
384
385 /* Some relocs require a global offset table. */
386 if (dynobj == NULL)
387 {
388 switch (ELF64_R_TYPE (rel->r_info))
389 {
390 case R_X86_64_GOT32:
391 case R_X86_64_GOTPCREL:
392 elf_hash_table (info)->dynobj = dynobj = abfd;
393 if (! _bfd_elf_create_got_section (dynobj, info))
394 return false;
395 break;
396 }
397 }
398
399 switch (ELF64_R_TYPE (rel->r_info))
400 {
51e0a107 401 case R_X86_64_GOTPCREL:
70256ad8 402 case R_X86_64_GOT32:
407443a3 403 /* This symbol requires a global offset table entry. */
70256ad8
AJ		 404
405 if (sgot == NULL)
406 {
407 sgot = bfd_get_section_by_name (dynobj, ".got");
408 BFD_ASSERT (sgot != NULL);
409 }
410
411 if (srelgot == NULL && (h != NULL || info->shared))
412 {
413 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
414 if (srelgot == NULL)
415 {
416 srelgot = bfd_make_section (dynobj, ".rela.got");
417 if (srelgot == NULL
418 || ! bfd_set_section_flags (dynobj, srelgot,
419 (SEC_ALLOC
420 | SEC_LOAD
421 | SEC_HAS_CONTENTS
422 | SEC_IN_MEMORY
423 | SEC_LINKER_CREATED
424 | SEC_READONLY))
51e0a107 425 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
70256ad8
AJ		 426 return false;
427 }
428 }
429
430 if (h != NULL)
431 {
432 if (h->got.refcount == -1)
433 {
434 h->got.refcount = 1;
435
436 /* Make sure this symbol is output as a dynamic symbol. */
437 if (h->dynindx == -1)
438 {
439 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
440 return false;
441 }
442
443 sgot->_raw_size += GOT_ENTRY_SIZE;
444 srelgot->_raw_size += sizeof (Elf64_External_Rela);
445 }
446 else
447 h->got.refcount += 1;
448 }
449 else
450 {
451 /* This is a global offset table entry for a local symbol. */
452 if (local_got_refcounts == NULL)
453 {
454 size_t size;
455
456 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
457 local_got_refcounts = ((bfd_signed_vma *)
458 bfd_alloc (abfd, size));
459 if (local_got_refcounts == NULL)
460 return false;
461 elf_local_got_refcounts (abfd) = local_got_refcounts;
462 memset (local_got_refcounts, -1, size);
463 }
464 if (local_got_refcounts[r_symndx] == -1)
465 {
466 local_got_refcounts[r_symndx] = 1;
467
468 sgot->_raw_size += GOT_ENTRY_SIZE;
469 if (info->shared)
470 {
471 /* If we are generating a shared object, we need to
472 output a R_X86_64_RELATIVE reloc so that the dynamic
473 linker can adjust this GOT entry. */
474 srelgot->_raw_size += sizeof (Elf64_External_Rela);
475 }
476 }
477 else
478 local_got_refcounts[r_symndx] += 1;
479 }
480 break;
481
482 case R_X86_64_PLT32:
483 /* This symbol requires a procedure linkage table entry. We
407443a3
AJ		 484 actually build the entry in adjust_dynamic_symbol,
485 because this might be a case of linking PIC code which is
486 never referenced by a dynamic object, in which case we
487 don't need to generate a procedure linkage table entry
488 after all. */
70256ad8
AJ		 489
490 /* If this is a local symbol, we resolve it directly without
407443a3 491 creating a procedure linkage table entry. */
70256ad8
AJ		 492 if (h == NULL)
493 continue;
494
495 if (h->plt.refcount == -1)
496 {
497 h->plt.refcount = 1;
498 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
499 }
500 else
501 h->plt.refcount += 1;
502 break;
503
504 case R_X86_64_32:
505 case R_X86_64_32S:
506 case R_X86_64_PC32:
507 if (h != NULL)
508 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
509
510 /* If we are creating a shared library, and this is a reloc
511 against a global symbol, or a non PC relative reloc
512 against a local symbol, then we need to copy the reloc
513 into the shared library. However, if we are linking with
514 -Bsymbolic, we do not need to copy a reloc against a
515 global symbol which is defined in an object we are
407443a3 516 including in the link (i.e., DEF_REGULAR is set). At
70256ad8
AJ		 517 this point we have not seen all the input files, so it is
518 possible that DEF_REGULAR is not set now but will be set
519 later (it is never cleared). We account for that
520 possibility below by storing information in the
521 pcrel_relocs_copied field of the hash table entry.
522 A similar situation occurs when creating shared libraries
523 and symbol visibility changes render the symbol local. */
524 if (info->shared
525 && (sec->flags & SEC_ALLOC) != 0
526 && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC32
527 || (h != NULL
528 && (! info->symbolic
529 || (h->elf_link_hash_flags
530 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
531 {
532 /* When creating a shared object, we must copy these
533 reloc types into the output file. We create a reloc
534 section in dynobj and make room for this reloc. */
535 if (sreloc == NULL)
536 {
537 const char *name;
538
539 name = (bfd_elf_string_from_elf_section
540 (abfd,
541 elf_elfheader (abfd)->e_shstrndx,
542 elf_section_data (sec)->rel_hdr.sh_name));
543 if (name == NULL)
544 return false;
545
546 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
547 && strcmp (bfd_get_section_name (abfd, sec),
548 name + 5) == 0);
549
550 sreloc = bfd_get_section_by_name (dynobj, name);
551 if (sreloc == NULL)
552 {
553 flagword flags;
554
555 sreloc = bfd_make_section (dynobj, name);
556 flags = (SEC_HAS_CONTENTS | SEC_READONLY
557 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
558 if ((sec->flags & SEC_ALLOC) != 0)
559 flags |= SEC_ALLOC | SEC_LOAD;
560 if (sreloc == NULL
561 || ! bfd_set_section_flags (dynobj, sreloc, flags)
562 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
563 return false;
564 }
565 }
566
567 sreloc->_raw_size += sizeof (Elf64_External_Rela);
568
569 /* If this is a global symbol, we count the number of PC
570 relative relocations we have entered for this symbol,
571 so that we can discard them later as necessary. Note
572 that this function is only called if we are using an
573 elf64_x86_64 linker hash table, which means that h is
574 really a pointer to an elf64_x86_64_link_hash_entry. */
fe4770f4 575 if (h != NULL && ELF64_R_TYPE (rel->r_info) == R_X86_64_PC32)
70256ad8
AJ		 576 {
577 struct elf64_x86_64_link_hash_entry *eh;
578 struct elf64_x86_64_pcrel_relocs_copied *p;
579
580 eh = (struct elf64_x86_64_link_hash_entry *) h;
581
582 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
583 if (p->section == sreloc)
584 break;
585
586 if (p == NULL)
587 {
588 p = ((struct elf64_x86_64_pcrel_relocs_copied *)
589 bfd_alloc (dynobj, sizeof *p));
590 if (p == NULL)
591 return false;
592 p->next = eh->pcrel_relocs_copied;
593 eh->pcrel_relocs_copied = p;
594 p->section = sreloc;
595 p->count = 0;
596 }
597
598 ++p->count;
599 }
600 }
601 break;
fe4770f4
AJ		 602
603 /* This relocation describes the C++ object vtable hierarchy.
604 Reconstruct it for later use during GC. */
605 case R_X86_64_GNU_VTINHERIT:
606 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
607 return false;
608 break;
609
610 /* This relocation describes which C++ vtable entries are actually
611 used. Record for later use during GC. */
612 case R_X86_64_GNU_VTENTRY:
613 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
614 return false;
615 break;
70256ad8
AJ		 616 }
617 }
618
619 return true;
620}
621
622/* Return the section that should be marked against GC for a given
407443a3 623 relocation. */
70256ad8
AJ		 624
625static asection *
626elf64_x86_64_gc_mark_hook (abfd, info, rel, h, sym)
627 bfd *abfd;
628 struct bfd_link_info *info ATTRIBUTE_UNUSED;
629 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED;
630 struct elf_link_hash_entry *h;
631 Elf_Internal_Sym *sym;
632{
633 if (h != NULL)
634 {
fe4770f4 635 switch (ELF64_R_TYPE (rel->r_info))
70256ad8 636 {
fe4770f4
AJ		 637 case R_X86_64_GNU_VTINHERIT:
638 case R_X86_64_GNU_VTENTRY:
639 break;
70256ad8
AJ		 640
641 default:
fe4770f4
AJ		 642 switch (h->root.type)
643 {
644 case bfd_link_hash_defined:
645 case bfd_link_hash_defweak:
646 return h->root.u.def.section;
647
648 case bfd_link_hash_common:
649 return h->root.u.c.p->section;
650
651 default:
652 break;
653 }
70256ad8
AJ		 654 }
655 }
656 else
657 {
658 if (!(elf_bad_symtab (abfd)
659 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
660 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
661 && sym->st_shndx != SHN_COMMON))
662 {
663 return bfd_section_from_elf_index (abfd, sym->st_shndx);
664 }
665 }
666
667 return NULL;
668}
669
407443a3 670/* Update the got entry reference counts for the section being removed. */
70256ad8
AJ		 671
672static boolean
673elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
674 bfd *abfd;
675 struct bfd_link_info *info ATTRIBUTE_UNUSED;
676 asection *sec;
677 const Elf_Internal_Rela *relocs;
678{
679 Elf_Internal_Shdr *symtab_hdr;
680 struct elf_link_hash_entry **sym_hashes;
681 bfd_signed_vma *local_got_refcounts;
682 const Elf_Internal_Rela *rel, *relend;
683 unsigned long r_symndx;
684 struct elf_link_hash_entry *h;
685 bfd *dynobj;
686 asection *sgot;
687 asection *srelgot;
688
689 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
690 sym_hashes = elf_sym_hashes (abfd);
691 local_got_refcounts = elf_local_got_refcounts (abfd);
692
693 dynobj = elf_hash_table (info)->dynobj;
694 if (dynobj == NULL)
695 return true;
696
697 sgot = bfd_get_section_by_name (dynobj, ".got");
698 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
699
700 relend = relocs + sec->reloc_count;
701 for (rel = relocs; rel < relend; rel++)
702 switch (ELF64_R_TYPE (rel->r_info))
703 {
704 case R_X86_64_GOT32:
705 case R_X86_64_GOTPCREL:
706 r_symndx = ELF64_R_SYM (rel->r_info);
707 if (r_symndx >= symtab_hdr->sh_info)
708 {
709 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
710 if (h->got.refcount > 0)
711 {
712 h->got.refcount -= 1;
713 if (h->got.refcount == 0)
714 {
715 sgot->_raw_size -= GOT_ENTRY_SIZE;
716 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
717 }
718 }
719 }
720 else if (local_got_refcounts != NULL)
721 {
722 if (local_got_refcounts[r_symndx] > 0)
723 {
724 local_got_refcounts[r_symndx] -= 1;
725 if (local_got_refcounts[r_symndx] == 0)
726 {
727 sgot->_raw_size -= GOT_ENTRY_SIZE;
728 if (info->shared)
729 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
730 }
731 }
732 }
733 break;
734
735 case R_X86_64_PLT32:
736 r_symndx = ELF64_R_SYM (rel->r_info);
737 if (r_symndx >= symtab_hdr->sh_info)
738 {
739 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
740 if (h->plt.refcount > 0)
741 h->plt.refcount -= 1;
742 }
743 break;
744
745 default:
746 break;
747 }
748
749 return true;
750}
751
752/* Adjust a symbol defined by a dynamic object and referenced by a
753 regular object. The current definition is in some section of the
754 dynamic object, but we're not including those sections. We have to
755 change the definition to something the rest of the link can
407443a3 756 understand. */
70256ad8
AJ		 757
758static boolean
759elf64_x86_64_adjust_dynamic_symbol (info, h)
760 struct bfd_link_info *info;
761 struct elf_link_hash_entry *h;
762{
763 bfd *dynobj;
764 asection *s;
765 unsigned int power_of_two;
766
767 dynobj = elf_hash_table (info)->dynobj;
768
769 /* Make sure we know what is going on here. */
770 BFD_ASSERT (dynobj != NULL
771 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
772 || h->weakdef != NULL
773 || ((h->elf_link_hash_flags
774 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
775 && (h->elf_link_hash_flags
776 & ELF_LINK_HASH_REF_REGULAR) != 0
777 && (h->elf_link_hash_flags
778 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
779
780 /* If this is a function, put it in the procedure linkage table. We
781 will fill in the contents of the procedure linkage table later,
782 when we know the address of the .got section. */
783 if (h->type == STT_FUNC
784 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
785 {
407443a3
AJ		 786 if ((! info->shared
787 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
788 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
789 || (info->shared && h->plt.refcount <= 0))
70256ad8 790 {
70256ad8
AJ		 791 /* This case can occur if we saw a PLT32 reloc in an input
792 file, but the symbol was never referred to by a dynamic
793 object, or if all references were garbage collected. In
794 such a case, we don't actually need to build a procedure
795 linkage table, and we can just do a PC32 reloc instead. */
70256ad8
AJ		 796 h->plt.offset = (bfd_vma) -1;
797 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
798 return true;
799 }
800
801 /* Make sure this symbol is output as a dynamic symbol. */
802 if (h->dynindx == -1)
803 {
804 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
805 return false;
806 }
807
808 s = bfd_get_section_by_name (dynobj, ".plt");
809 BFD_ASSERT (s != NULL);
810
811 /* If this is the first .plt entry, make room for the special
812 first entry. */
813 if (s->_raw_size == 0)
814 s->_raw_size = PLT_ENTRY_SIZE;
815
816 /* If this symbol is not defined in a regular file, and we are
817 not generating a shared library, then set the symbol to this
407443a3 818 location in the .plt. This is required to make function
70256ad8
AJ		 819 pointers compare as equal between the normal executable and
820 the shared library. */
821 if (! info->shared
822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
823 {
824 h->root.u.def.section = s;
825 h->root.u.def.value = s->_raw_size;
826 }
827
828 h->plt.offset = s->_raw_size;
829
830 /* Make room for this entry. */
831 s->_raw_size += PLT_ENTRY_SIZE;
832
407443a3
AJ		 833 /* We also need to make an entry in the .got.plt section, which
834 will be placed in the .got section by the linker script. */
835 s = bfd_get_section_by_name (dynobj, ".got.plt");
836 BFD_ASSERT (s != NULL);
837 s->_raw_size += GOT_ENTRY_SIZE;
838
70256ad8
AJ		 839 /* We also need to make an entry in the .rela.plt section. */
840 s = bfd_get_section_by_name (dynobj, ".rela.plt");
841 BFD_ASSERT (s != NULL);
842 s->_raw_size += sizeof (Elf64_External_Rela);
843
844 return true;
845 }
846
847 /* If this is a weak symbol, and there is a real definition, the
848 processor independent code will have arranged for us to see the
407443a3 849 real definition first, and we can just use the same value. */
70256ad8
AJ		 850 if (h->weakdef != NULL)
851 {
852 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
853 || h->weakdef->root.type == bfd_link_hash_defweak);
854 h->root.u.def.section = h->weakdef->root.u.def.section;
855 h->root.u.def.value = h->weakdef->root.u.def.value;
856 return true;
857 }
858
859 /* This is a reference to a symbol defined by a dynamic object which
407443a3 860 is not a function. */
70256ad8
AJ		 861
862 /* If we are creating a shared library, we must presume that the
863 only references to the symbol are via the global offset table.
864 For such cases we need not do anything here; the relocations will
407443a3 865 be handled correctly by relocate_section. */
70256ad8
AJ		 866 if (info->shared)
867 return true;
868
869 /* If there are no references to this symbol that do not use the
870 GOT, we don't need to generate a copy reloc. */
871 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
872 return true;
873
874 /* We must allocate the symbol in our .dynbss section, which will
407443a3 875 become part of the .bss section of the executable. There will be
70256ad8
AJ		 876 an entry for this symbol in the .dynsym section. The dynamic
877 object will contain position independent code, so all references
878 from the dynamic object to this symbol will go through the global
879 offset table. The dynamic linker will use the .dynsym entry to
880 determine the address it must put in the global offset table, so
881 both the dynamic object and the regular object will refer to the
882 same memory location for the variable. */
883
884 s = bfd_get_section_by_name (dynobj, ".dynbss");
885 BFD_ASSERT (s != NULL);
886
887 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
888 to copy the initial value out of the dynamic object and into the
889 runtime process image. We need to remember the offset into the
890 .rela.bss section we are going to use. */
891 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
892 {
893 asection *srel;
894
895 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
896 BFD_ASSERT (srel != NULL);
897 srel->_raw_size += sizeof (Elf64_External_Rela);
898 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
899 }
900
901 /* We need to figure out the alignment required for this symbol. I
407443a3 902 have no idea how ELF linkers handle this. 16-bytes is the size
70256ad8
AJ		 903 of the largest type that requires hard alignment -- long double. */
904 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
905 this construct. */
906 power_of_two = bfd_log2 (h->size);
907 if (power_of_two > 4)
908 power_of_two = 4;
909
910 /* Apply the required alignment. */
911 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
912 if (power_of_two > bfd_get_section_alignment (dynobj, s))
913 {
914 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
915 return false;
916 }
917
918 /* Define the symbol as being at this point in the section. */
919 h->root.u.def.section = s;
920 h->root.u.def.value = s->_raw_size;
921
922 /* Increment the section size to make room for the symbol. */
923 s->_raw_size += h->size;
924
925 return true;
926}
927
928/* Set the sizes of the dynamic sections. */
929
930static boolean
931elf64_x86_64_size_dynamic_sections (output_bfd, info)
932 bfd *output_bfd;
933 struct bfd_link_info *info;
934{
935 bfd *dynobj;
936 asection *s;
937 boolean plt;
938 boolean relocs;
939 boolean reltext;
940
941 dynobj = elf_hash_table (info)->dynobj;
942 BFD_ASSERT (dynobj != NULL);
943
944 if (elf_hash_table (info)->dynamic_sections_created)
945 {
946 /* Set the contents of the .interp section to the interpreter. */
947 if (! info->shared)
948 {
949 s = bfd_get_section_by_name (dynobj, ".interp");
950 BFD_ASSERT (s != NULL);
951 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
952 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
953 }
954 }
955 else
956 {
957 /* We may have created entries in the .rela.got section.
407443a3
AJ		 958 However, if we are not creating the dynamic sections, we will
959 not actually use these entries. Reset the size of .rela.got,
960 which will cause it to get stripped from the output file
961 below. */
70256ad8
AJ		 962 s = bfd_get_section_by_name (dynobj, ".rela.got");
963 if (s != NULL)
964 s->_raw_size = 0;
965 }
966
967 /* If this is a -Bsymbolic shared link, then we need to discard all
968 PC relative relocs against symbols defined in a regular object.
969 We allocated space for them in the check_relocs routine, but we
970 will not fill them in in the relocate_section routine. */
971 if (info->shared)
972 elf64_x86_64_link_hash_traverse (elf64_x86_64_hash_table (info),
973 elf64_x86_64_discard_copies,
974 (PTR) info);
975
976 /* The check_relocs and adjust_dynamic_symbol entry points have
977 determined the sizes of the various dynamic sections. Allocate
978 memory for them. */
979 plt = relocs = reltext = false;
980 for (s = dynobj->sections; s != NULL; s = s->next)
981 {
982 const char *name;
983 boolean strip;
984
985 if ((s->flags & SEC_LINKER_CREATED) == 0)
986 continue;
987
988 /* It's OK to base decisions on the section name, because none
989 of the dynobj section names depend upon the input files. */
990 name = bfd_get_section_name (dynobj, s);
991
992 strip = false;
993 if (strcmp (name, ".plt") == 0)
994 {
995 if (s->_raw_size == 0)
996 {
997 /* Strip this section if we don't need it; see the
407443a3 998 comment below. */
70256ad8
AJ		 999 strip = true;
1000 }
1001 else
1002 {
1003 /* Remember whether there is a PLT. */
1004 plt = true;
1005 }
1006 }
1007 else if (strncmp (name, ".rela", 5) == 0)
1008 {
1009 if (s->_raw_size == 0)
1010 {
1011 /* If we don't need this section, strip it from the
1012 output file. This is mostly to handle .rela.bss and
1013 .rela.plt. We must create both sections in
1014 create_dynamic_sections, because they must be created
1015 before the linker maps input sections to output
1016 sections. The linker does that before
1017 adjust_dynamic_symbol is called, and it is that
1018 function which decides whether anything needs to go
1019 into these sections. */
1020 strip = true;
1021 }
1022 else
1023 {
1024 asection *target;
1025
1026 /* Remember whether there are any reloc sections other
407443a3 1027 than .rela.plt. */
70256ad8
AJ		 1028 if (strcmp (name, ".rela.plt") != 0)
1029 {
1030 const char *outname;
1031
1032 relocs = true;
1033
1034 /* If this relocation section applies to a read only
1035 section, then we probably need a DT_TEXTREL
1036 entry. The entries in the .rela.plt section
1037 really apply to the .got section, which we
1038 created ourselves and so know is not readonly. */
1039 outname = bfd_get_section_name (output_bfd,
1040 s->output_section);
1041 target = bfd_get_section_by_name (output_bfd, outname + 5);
1042 if (target != NULL
1043 && (target->flags & SEC_READONLY) != 0
1044 && (target->flags & SEC_ALLOC) != 0)
1045 reltext = true;
1046 }
1047
1048 /* We use the reloc_count field as a counter if we need
1049 to copy relocs into the output file. */
1050 s->reloc_count = 0;
1051 }
1052 }
1053 else if (strncmp (name, ".got", 4) != 0)
1054 {
1055 /* It's not one of our sections, so don't allocate space. */
1056 continue;
1057 }
1058
1059 if (strip)
1060 {
1061 _bfd_strip_section_from_output (info, s);
1062 continue;
1063 }
1064
1065 /* Allocate memory for the section contents. We use bfd_zalloc
1066 here in case unused entries are not reclaimed before the
1067 section's contents are written out. This should not happen,
1068 but this way if it does, we get a R_X86_64_NONE reloc instead
1069 of garbage. */
1070 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1071 if (s->contents == NULL && s->_raw_size != 0)
1072 return false;
1073 }
1074
1075 if (elf_hash_table (info)->dynamic_sections_created)
1076 {
1077 /* Add some entries to the .dynamic section. We fill in the
1078 values later, in elf64_x86_64_finish_dynamic_sections, but we
1079 must add the entries now so that we get the correct size for
407443a3 1080 the .dynamic section. The DT_DEBUG entry is filled in by the
70256ad8
AJ		 1081 dynamic linker and used by the debugger. */
1082 if (! info->shared)
1083 {
1084 if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
1085 return false;
1086 }
1087
1088 if (plt)
1089 {
70256ad8
AJ		 1090 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
1091 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
407443a3 1092 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
70256ad8
AJ		 1093 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1094 return false;
1095 }
1096
1097 if (relocs)
1098 {
1099 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1100 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1101 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1102 sizeof (Elf64_External_Rela)))
1103 return false;
1104 }
1105
1106 if (reltext)
1107 {
1108 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1109 return false;
1110 info->flags |= DF_TEXTREL;
1111 }
1112 }
1113
1114 return true;
1115}
1116
1117/* This function is called via elf64_x86_64_link_hash_traverse if we are
1118 creating a shared object. In the -Bsymbolic case, it discards the
1119 space allocated to copy PC relative relocs against symbols which
1120 are defined in regular objects. For the normal non-symbolic case,
1121 we also discard space for relocs that have become local due to
1122 symbol visibility changes. We allocated space for them in the
1123 check_relocs routine, but we won't fill them in in the
1124 relocate_section routine. */
1125
1126static boolean
1127elf64_x86_64_discard_copies (h, inf)
1128 struct elf64_x86_64_link_hash_entry *h;
1129 PTR inf;
1130{
1131 struct elf64_x86_64_pcrel_relocs_copied *s;
1132 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1133
1134 /* If a symbol has been forced local or we have found a regular
1135 definition for the symbolic link case, then we won't be needing
1136 any relocs. */
1137 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1138 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1139 || info->symbolic))
1140 {
1141 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1142 s->section->_raw_size -= s->count * sizeof (Elf64_External_Rela);
1143 }
1144
1145 return true;
1146}
1147
8d88c4ca
NC		 1148/* Relocate an x86_64 ELF section. */
1149
1150static boolean
1151elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
fe4770f4 1152 contents, relocs, local_syms, local_sections)
8d88c4ca
NC		 1153 bfd *output_bfd;
1154 struct bfd_link_info *info;
1155 bfd *input_bfd;
1156 asection *input_section;
1157 bfd_byte *contents;
1158 Elf_Internal_Rela *relocs;
1159 Elf_Internal_Sym *local_syms;
1160 asection **local_sections;
1161{
1162 bfd *dynobj;
1163 Elf_Internal_Shdr *symtab_hdr;
1164 struct elf_link_hash_entry **sym_hashes;
1165 bfd_vma *local_got_offsets;
70256ad8
AJ		 1166 asection *sgot;
1167 asection *splt;
8d88c4ca 1168 asection *sreloc;
70256ad8 1169 Elf_Internal_Rela *rela;
8d88c4ca
NC		 1170 Elf_Internal_Rela *relend;
1171
1172 dynobj = elf_hash_table (info)->dynobj;
1173 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1174 sym_hashes = elf_sym_hashes (input_bfd);
1175 local_got_offsets = elf_local_got_offsets (input_bfd);
1176
70256ad8 1177 sreloc = splt = sgot = NULL;
8d88c4ca 1178 if (dynobj != NULL)
70256ad8
AJ		 1179 {
1180 splt = bfd_get_section_by_name (dynobj, ".plt");
1181 sgot = bfd_get_section_by_name (dynobj, ".got");
1182 }
8d88c4ca 1183
70256ad8 1184 rela = relocs;
8d88c4ca 1185 relend = relocs + input_section->reloc_count;
70256ad8 1186 for (; rela < relend; rela++)
8d88c4ca
NC		 1187 {
1188 int r_type;
1189 reloc_howto_type *howto;
1190 unsigned long r_symndx;
1191 struct elf_link_hash_entry *h;
1192 Elf_Internal_Sym *sym;
1193 asection *sec;
1194 bfd_vma relocation;
1195 bfd_reloc_status_type r;
1196 unsigned int indx;
1197
70256ad8 1198 r_type = ELF64_R_TYPE (rela->r_info);
fe4770f4
AJ		 1199 if (r_type == (int) R_X86_64_GNU_VTINHERIT
1200 || r_type == (int) R_X86_64_GNU_VTENTRY)
1201 continue;
8d88c4ca
NC		 1202
1203 if ((indx = (unsigned) r_type) >= R_X86_64_max)
8da6118f
KH		 1204 {
1205 bfd_set_error (bfd_error_bad_value);
1206 return false;
1207 }
8d88c4ca
NC		 1208 howto = x86_64_elf_howto_table + indx;
1209
70256ad8 1210 r_symndx = ELF64_R_SYM (rela->r_info);
8d88c4ca
NC		 1211
1212 if (info->relocateable)
8da6118f
KH		 1213 {
1214 /* This is a relocateable link. We don't have to change
1215 anything, unless the reloc is against a section symbol,
1216 in which case we have to adjust according to where the
1217 section symbol winds up in the output section. */
1218 if (r_symndx < symtab_hdr->sh_info)
1219 {
1220 sym = local_syms + r_symndx;
1221 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1222 {
1223 sec = local_sections[r_symndx];
70256ad8 1224 rela->r_addend += sec->output_offset + sym->st_value;
8da6118f
KH		 1225 }
1226 }
1227
1228 continue;
1229 }
8d88c4ca 1230
407443a3 1231 /* This is a final link. */
8d88c4ca
NC		 1232 h = NULL;
1233 sym = NULL;
1234 sec = NULL;
1235 if (r_symndx < symtab_hdr->sh_info)
8da6118f
KH		 1236 {
1237 sym = local_syms + r_symndx;
1238 sec = local_sections[r_symndx];
1239 relocation = (sec->output_section->vma
1240 + sec->output_offset
1241 + sym->st_value);
1242 }
8d88c4ca 1243 else
8da6118f
KH		 1244 {
1245 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1246 while (h->root.type == bfd_link_hash_indirect
1247 || h->root.type == bfd_link_hash_warning)
1248 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1249 if (h->root.type == bfd_link_hash_defined
1250 || h->root.type == bfd_link_hash_defweak)
1251 {
1252 sec = h->root.u.def.section;
bcdd92f3
AJ		 1253 if (r_type == R_X86_64_GOTPCREL
1254 || (r_type = R_X86_64_PLT32
1255 && splt != NULL
1256 && h->plt.offset != (bfd_vma) -1)
1257 || (r_type = R_X86_64_GOT32
1258 && elf_hash_table (info)->dynamic_sections_created
1259 && (!info->shared
1260 || (! info->symbolic && h->dynindx != -1)
1261 || (h->elf_link_hash_flags
1262 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1263 || (info->shared
1264 && ((! info->symbolic && h->dynindx != -1)
1265 || (h->elf_link_hash_flags
1266 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1267 && ( r_type == R_X86_64_8 ||
1268 r_type == R_X86_64_16 ||
1269 r_type == R_X86_64_32 ||
1270 r_type == R_X86_64_64 ||
1271 r_type == R_X86_64_PC16 ||
1272 r_type == R_X86_64_PC32)
1273 && ((input_section->flags & SEC_ALLOC) != 0
1274 /* DWARF will emit R_X86_64_32 relocations in its
1275 sections against symbols defined externally
1276 in shared libraries. We can't do anything
1277 with them here. */
1278 || ((input_section->flags & SEC_DEBUGGING) != 0
1279 && (h->elf_link_hash_flags
1280 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1281 {
1282 /* In these cases, we don't need the relocation
1283 value. We check specially because in some
1284 obscure cases sec->output_section will be NULL. */
1285 relocation = 0;
1286 }
1287 else if (sec->output_section == NULL)
8da6118f
KH		 1288 {
1289 (*_bfd_error_handler)
1290 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1291 bfd_get_filename (input_bfd), h->root.root.string,
1292 bfd_get_section_name (input_bfd, input_section));
1293 relocation = 0;
1294 }
1295 else
1296 relocation = (h->root.u.def.value
1297 + sec->output_section->vma
1298 + sec->output_offset);
1299 }
1300 else if (h->root.type == bfd_link_hash_undefweak)
1301 relocation = 0;
70256ad8
AJ		 1302 else if (info->shared && !info->symbolic && !info->no_undefined
1303 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1304 relocation = 0;
8da6118f
KH		 1305 else
1306 {
1307 if (! ((*info->callbacks->undefined_symbol)
1308 (info, h->root.root.string, input_bfd,
70256ad8 1309 input_section, rela->r_offset,
8da6118f
KH		 1310 (!info->shared || info->no_undefined
1311 || ELF_ST_VISIBILITY (h->other)))))
1312 return false;
1313 relocation = 0;
1314 }
1315 }
70256ad8
AJ		 1316
1317 /* When generating a shared object, the relocations handled here are
1318 copied into the output file to be resolved at run time. */
1319 switch (r_type)
1320 {
1321 case R_X86_64_GOT32:
1322 /* Relocation is to the entry for this symbol in the global
1323 offset table. */
1324 BFD_ASSERT (sgot != NULL);
1325
1326 if (h != NULL)
1327 {
1328 bfd_vma off = h->got.offset;
1329 BFD_ASSERT (off != (bfd_vma) -1);
1330
1331 if (! elf_hash_table (info)->dynamic_sections_created
1332 || (info->shared
1333 && (info->symbolic || h->dynindx == -1)
1334 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1335 {
1336 /* This is actually a static link, or it is a -Bsymbolic
1337 link and the symbol is defined locally, or the symbol
407443a3 1338 was forced to be local because of a version file. We
70256ad8
AJ		 1339 must initialize this entry in the global offset table.
1340 Since the offset must always be a multiple of 8, we
1341 use the least significant bit to record whether we
1342 have initialized it already.
1343
1344 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 1345 relocation entry to initialize the value. This is
1346 done in the finish_dynamic_symbol routine. */
70256ad8
AJ		 1347 if ((off & 1) != 0)
1348 off &= ~1;
1349 else
1350 {
1351 bfd_put_64 (output_bfd, relocation,
1352 sgot->contents + off);
1353 h->got.offset |= 1;
1354 }
1355 }
1356 relocation = sgot->output_offset + off;
1357 }
1358 else
1359 {
1360 bfd_vma off;
1361
1362 BFD_ASSERT (local_got_offsets != NULL
1363 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1364
1365 off = local_got_offsets[r_symndx];
1366
1367 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 1368 the least significant bit to record whether we have
1369 already generated the necessary reloc. */
70256ad8
AJ		 1370 if ((off & 1) != 0)
1371 off &= ~1;
1372 else
1373 {
1374 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1375
51e0a107 1376 if (info->shared)
70256ad8
AJ		 1377 {
1378 asection *srelgot;
1379 Elf_Internal_Rela outrel;
1380
1381 /* We need to generate a R_X86_64_RELATIVE reloc
1382 for the dynamic linker. */
1383 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1384 BFD_ASSERT (srelgot != NULL);
1385
1386 outrel.r_offset = (sgot->output_section->vma
1387 + sgot->output_offset
1388 + off);
1389 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1390 outrel.r_addend = relocation;
1391 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1392 (((Elf64_External_Rela *)
1393 srelgot->contents)
1394 + srelgot->reloc_count));
1395 ++srelgot->reloc_count;
1396 }
1397
1398 local_got_offsets[r_symndx] |= 1;
1399 }
1400
1401 relocation = sgot->output_offset + off;
1402 }
1403
1404 break;
1405
1406 case R_X86_64_GOTPCREL:
1407 /* Use global offset table as symbol value. */
1408
51e0a107
JH		 1409 BFD_ASSERT (sgot != NULL);
1410 if (h != NULL)
70256ad8 1411 {
51e0a107
JH		 1412 bfd_vma off = h->got.offset;
1413 BFD_ASSERT (off != (bfd_vma) -1);
1414
1415 if (! elf_hash_table (info)->dynamic_sections_created
1416 || (info->shared
1417 && (info->symbolic || h->dynindx == -1)
1418 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1419 {
1420 /* This is actually a static link, or it is a -Bsymbolic
1421 link and the symbol is defined locally, or the symbol
407443a3 1422 was forced to be local because of a version file. We
51e0a107
JH		 1423 must initialize this entry in the global offset table.
1424 Since the offset must always be a multiple of 8, we
1425 use the least significant bit to record whether we
1426 have initialized it already.
1427
1428 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 1429 relocation entry to initialize the value. This is
1430 done in the finish_dynamic_symbol routine. */
51e0a107
JH		 1431 if ((off & 1) != 0)
1432 off &= ~1;
1433 else
1434 {
1435 bfd_put_64 (output_bfd, relocation,
1436 sgot->contents + off);
1437 h->got.offset |= 1;
1438 }
1439 }
1440 relocation = sgot->output_offset + off;
70256ad8 1441 }
51e0a107
JH		 1442 else
1443 {
1444 bfd_vma off;
70256ad8 1445
51e0a107
JH		 1446 BFD_ASSERT (local_got_offsets != NULL
1447 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1448
1449 off = local_got_offsets[r_symndx];
1450
1451 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 1452 the least significant bit to record whether we have
1453 already generated the necessary reloc. */
51e0a107
JH		 1454 if ((off & 1) != 0)
1455 off &= ~1;
1456 else
1457 {
1458 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1459
1460 if (info->shared)
1461 {
1462 asection *srelgot;
1463 Elf_Internal_Rela outrel;
70256ad8 1464
51e0a107
JH		 1465 /* We need to generate a R_X86_64_RELATIVE reloc
1466 for the dynamic linker. */
1467 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1468 BFD_ASSERT (srelgot != NULL);
1469
1470 outrel.r_offset = (sgot->output_section->vma
1471 + sgot->output_offset
1472 + off);
1473 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1474 outrel.r_addend = relocation;
1475 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1476 (((Elf64_External_Rela *)
1477 srelgot->contents)
1478 + srelgot->reloc_count));
1479 ++srelgot->reloc_count;
1480 }
1481
1482 local_got_offsets[r_symndx] |= 1;
1483 }
1484
1485 relocation = sgot->output_section->vma + off;
1486 }
70256ad8
AJ		 1487 break;
1488
1489 case R_X86_64_PLT32:
1490 /* Relocation is to the entry for this symbol in the
1491 procedure linkage table. */
1492
1493 /* Resolve a PLT32 reloc against a local symbol directly,
407443a3 1494 without using the procedure linkage table. */
70256ad8
AJ		 1495 if (h == NULL)
1496 break;
1497
1498 if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
1499 {
1500 /* We didn't make a PLT entry for this symbol. This
407443a3
AJ		 1501 happens when statically linking PIC code, or when
1502 using -Bsymbolic. */
70256ad8
AJ		 1503 break;
1504 }
1505
1506 relocation = (splt->output_section->vma
1507 + splt->output_offset
1508 + h->plt.offset);
1509 break;
1510
1511 case R_X86_64_8:
1512 case R_X86_64_16:
1513 case R_X86_64_32:
1514 case R_X86_64_PC8:
1515 case R_X86_64_PC16:
1516 case R_X86_64_PC32:
1517 /* FIXME: The abi says the linker should make sure the value is
407443a3 1518 the same when it's zeroextended to 64 bit. */
70256ad8
AJ		 1519 if (info->shared
1520 && (input_section->flags & SEC_ALLOC) != 0
1521 && ((r_type != R_X86_64_PC8 && r_type != R_X86_64_PC16
1522 && r_type != R_X86_64_PC32)
1523 || (h != NULL
1524 && h->dynindx != -1
1525 && (! info->symbolic
1526 || (h->elf_link_hash_flags
1527 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1528 {
1529 Elf_Internal_Rela outrel;
1530 boolean skip, relocate;
1531
1532 /* When generating a shared object, these relocations
1533 are copied into the output file to be resolved at run
407443a3 1534 time. */
70256ad8
AJ		 1535
1536 if (sreloc == NULL)
1537 {
1538 const char *name;
1539
1540 name = (bfd_elf_string_from_elf_section
1541 (input_bfd,
1542 elf_elfheader (input_bfd)->e_shstrndx,
1543 elf_section_data (input_section)->rel_hdr.sh_name));
1544 if (name == NULL)
1545 return false;
1546
1547 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1548 && strcmp (bfd_get_section_name (input_bfd,
1549 input_section),
1550 name + 5) == 0);
1551
1552 sreloc = bfd_get_section_by_name (dynobj, name);
1553 BFD_ASSERT (sreloc != NULL);
1554 }
1555
1556 skip = false;
1557
1558 if (elf_section_data (input_section)->stab_info == NULL)
1559 outrel.r_offset = rela->r_offset;
1560 else
1561 {
1562 bfd_vma off;
1563
1564 off = (_bfd_stab_section_offset
1565 (output_bfd, &elf_hash_table (info)->stab_info,
1566 input_section,
1567 &elf_section_data (input_section)->stab_info,
1568 rela->r_offset));
1569 if (off == (bfd_vma) -1)
1570 skip = true;
1571 outrel.r_offset = off;
1572 }
1573
1574 outrel.r_offset += (input_section->output_section->vma
1575 + input_section->output_offset);
1576
1577 if (skip)
1578 {
1579 memset (&outrel, 0, sizeof outrel);
1580 relocate = false;
1581 }
1582 else if ((r_type == R_X86_64_PC8) || (r_type == R_X86_64_PC16)
1583 || (r_type == R_X86_64_PC32))
1584 {
1585 BFD_ASSERT (h != NULL && h->dynindx != -1);
1586 relocate = false;
1587 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
5608e05b 1588 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1589 }
1590 else
1591 {
1592 /* h->dynindx may be -1 if this symbol was marked to
407443a3 1593 become local. */
70256ad8
AJ		 1594 if (h == NULL
1595 || ((info->symbolic || h->dynindx == -1)
1596 && (h->elf_link_hash_flags
1597 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1598 {
1599 relocate = true;
1600 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
5608e05b 1601 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1602 }
1603 else
1604 {
1605 BFD_ASSERT (h->dynindx != -1);
1606 relocate = false;
1607 outrel.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_32);
5608e05b 1608 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1609 }
1610 }
1611
1612 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1613 (((Elf64_External_Rela *)
1614 sreloc->contents)
1615 + sreloc->reloc_count));
1616 ++sreloc->reloc_count;
1617
1618 /* If this reloc is against an external symbol, we do
1619 not want to fiddle with the addend. Otherwise, we
1620 need to include the symbol value so that it becomes
1621 an addend for the dynamic reloc. */
1622 if (! relocate)
1623 continue;
1624 }
1625
1626 break;
1627
1628 default:
1629 break;
1630 }
8d88c4ca
NC		 1631
1632 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
70256ad8
AJ		 1633 contents, rela->r_offset,
1634 relocation, rela->r_addend);
8d88c4ca
NC		 1635
1636 if (r != bfd_reloc_ok)
8da6118f
KH		 1637 {
1638 switch (r)
1639 {
1640 default:
1641 case bfd_reloc_outofrange:
1642 abort ();
1643 case bfd_reloc_overflow:
1644 {
1645 const char *name;
1646
1647 if (h != NULL)
1648 name = h->root.root.string;
1649 else
1650 {
1651 name = bfd_elf_string_from_elf_section (input_bfd,
1652 symtab_hdr->sh_link,
1653 sym->st_name);
1654 if (name == NULL)
1655 return false;
1656 if (*name == '\0')
1657 name = bfd_section_name (input_bfd, sec);
1658 }
1659 if (! ((*info->callbacks->reloc_overflow)
1660 (info, name, howto->name, (bfd_vma) 0,
70256ad8 1661 input_bfd, input_section, rela->r_offset)))
8da6118f
KH		 1662 return false;
1663 }
1664 break;
1665 }
1666 }
8d88c4ca 1667 }
70256ad8
AJ		 1668
1669 return true;
1670}
1671
1672/* Finish up dynamic symbol handling. We set the contents of various
1673 dynamic sections here. */
1674
1675static boolean
1676elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
1677 bfd *output_bfd;
1678 struct bfd_link_info *info;
1679 struct elf_link_hash_entry *h;
1680 Elf_Internal_Sym *sym;
1681{
1682 bfd *dynobj;
1683
1684 dynobj = elf_hash_table (info)->dynobj;
1685
1686 if (h->plt.offset != (bfd_vma) -1)
1687 {
1688 asection *splt;
1689 asection *sgot;
1690 asection *srela;
1691 bfd_vma plt_index;
1692 bfd_vma got_offset;
1693 Elf_Internal_Rela rela;
1694
1695 /* This symbol has an entry in the procedure linkage table. Set
407443a3 1696 it up. */
70256ad8
AJ		 1697
1698 BFD_ASSERT (h->dynindx != -1);
1699
1700 splt = bfd_get_section_by_name (dynobj, ".plt");
1701 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1702 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1703 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1704
1705 /* Get the index in the procedure linkage table which
1706 corresponds to this symbol. This is the index of this symbol
1707 in all the symbols for which we are making plt entries. The
1708 first entry in the procedure linkage table is reserved. */
1709 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1710
1711 /* Get the offset into the .got table of the entry that
407443a3 1712 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
fe4770f4 1713 bytes. The first three are reserved for the dynamic linker. */
70256ad8
AJ		 1714 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
1715
1716 /* Fill in the entry in the procedure linkage table. */
1717 memcpy (splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
1718 PLT_ENTRY_SIZE);
1719
1720 /* Insert the relocation positions of the plt section. The magic
1721 numbers at the end of the statements are the positions of the
1722 relocations in the plt section. */
653165cc
AJ		 1723 /* Put offset for jmp *name@GOTPCREL(%rip), since the
1724 instruction uses 6 bytes, subtract this value. */
1725 bfd_put_32 (output_bfd,
1726 (sgot->output_section->vma
1727 + sgot->output_offset
1728 + got_offset
1729 - splt->output_section->vma
1730 - splt->output_offset
1731 - h->plt.offset
1732 - 6),
1733 splt->contents + h->plt.offset + 2);
1734 /* Put relocation index. */
1735 bfd_put_32 (output_bfd, plt_index,
70256ad8 1736 splt->contents + h->plt.offset + 7);
653165cc
AJ		 1737 /* Put offset for jmp .PLT0. */
1738 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
70256ad8
AJ		 1739 splt->contents + h->plt.offset + 12);
1740
653165cc
AJ		 1741 /* Fill in the entry in the global offset table, initially this
1742 points to the pushq instruction in the PLT which is at offset 6. */
70256ad8
AJ		 1743 bfd_put_64 (output_bfd, (splt->output_section->vma + splt->output_offset
1744 + h->plt.offset + 6),
1745 sgot->contents + got_offset);
1746
1747 /* Fill in the entry in the .rela.plt section. */
1748 rela.r_offset = (sgot->output_section->vma
1749 + sgot->output_offset
1750 + got_offset);
1751 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
1752 rela.r_addend = 0;
1753 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1754 ((Elf64_External_Rela *) srela->contents
1755 + plt_index));
1756
1757 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1758 {
1759 /* Mark the symbol as undefined, rather than as defined in
407443a3 1760 the .plt section. Leave the value alone. */
70256ad8 1761 sym->st_shndx = SHN_UNDEF;
05aa1441
AJ		 1762 /* If the symbol is weak, we do need to clear the value.
1763 Otherwise, the PLT entry would provide a definition for
1764 the symbol even if the symbol wasn't defined anywhere,
1765 and so the symbol would never be NULL. */
1766 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1767 == 0)
1768 sym->st_value = 0;
70256ad8
AJ		 1769 }
1770 }
1771
1772 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1773 {
1774 asection *s;
1775 Elf_Internal_Rela rela;
1776
1777 /* This symbol needs a copy reloc. Set it up. */
1778
1779 BFD_ASSERT (h->dynindx != -1
1780 && (h->root.type == bfd_link_hash_defined
1781 || h->root.type == bfd_link_hash_defweak));
1782
1783 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1784 ".rela.bss");
1785 BFD_ASSERT (s != NULL);
1786
1787 rela.r_offset = (h->root.u.def.value
1788 + h->root.u.def.section->output_section->vma
1789 + h->root.u.def.section->output_offset);
1790 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
1791 rela.r_addend = 0;
1792 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1793 ((Elf64_External_Rela *) s->contents
1794 + s->reloc_count));
1795 ++s->reloc_count;
1796 }
1797
1798 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1799 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1800 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1801 sym->st_shndx = SHN_ABS;
1802
1803 return true;
1804}
1805
1806/* Finish up the dynamic sections. */
1807
1808static boolean
1809elf64_x86_64_finish_dynamic_sections (output_bfd, info)
1810 bfd *output_bfd;
1811 struct bfd_link_info *info;
1812{
1813 bfd *dynobj;
1814 asection *sdyn;
1815 asection *sgot;
1816
1817 dynobj = elf_hash_table (info)->dynobj;
1818
653165cc
AJ		 1819 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1820 BFD_ASSERT (sgot != NULL);
70256ad8
AJ		 1821 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1822
1823 if (elf_hash_table (info)->dynamic_sections_created)
1824 {
1825 asection *splt;
1826 Elf64_External_Dyn *dyncon, *dynconend;
1827
407443a3 1828 BFD_ASSERT (sdyn != NULL);
70256ad8
AJ		 1829
1830 dyncon = (Elf64_External_Dyn *) sdyn->contents;
1831 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1832 for (; dyncon < dynconend; dyncon++)
1833 {
1834 Elf_Internal_Dyn dyn;
1835 const char *name;
1836 asection *s;
1837
1838 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
1839
1840 switch (dyn.d_tag)
1841 {
1842 default:
1843 break;
1844
1845 case DT_PLTGOT:
1846 name = ".got";
1847 goto get_vma;
1848
1849 case DT_JMPREL:
1850 name = ".rela.plt";
1851
1852 get_vma:
1853 s = bfd_get_section_by_name (output_bfd, name);
1854 BFD_ASSERT (s != NULL);
1855 dyn.d_un.d_ptr = s->vma;
1856 break;
1857
1858 case DT_RELASZ:
1859 /* FIXME: This comment and code is from elf64-alpha.c: */
1860 /* My interpretation of the TIS v1.1 ELF document indicates
407443a3 1861 that RELASZ should not include JMPREL. This is not what
70256ad8
AJ		 1862 the rest of the BFD does. It is, however, what the
1863 glibc ld.so wants. Do this fixup here until we found
1864 out who is right. */
1865 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1866 if (s)
1867 {
407443a3 1868 /* Subtract JMPREL size from RELASZ. */
70256ad8
AJ		 1869 dyn.d_un.d_val -=
1870 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
1871 }
1872 break;
1873
1874 case DT_PLTRELSZ:
1875 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1876 BFD_ASSERT (s != NULL);
1877 dyn.d_un.d_val =
1878 (s->_cooked_size != 0 ? s->_cooked_size : s->_raw_size);
1879 break;
1880 }
1881
1882 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
1883 }
1884
1885 /* Initialize the contents of the .plt section. */
407443a3
AJ		 1886 splt = bfd_get_section_by_name (dynobj, ".plt");
1887 BFD_ASSERT (splt != NULL);
70256ad8
AJ		 1888 if (splt->_raw_size > 0)
1889 {
653165cc 1890 /* Fill in the first entry in the procedure linkage table. */
407443a3 1891 memcpy (splt->contents, elf64_x86_64_plt0_entry, PLT_ENTRY_SIZE);
653165cc
AJ		 1892 /* Add offset for pushq GOT+8(%rip), since the instruction
1893 uses 6 bytes subtract this value. */
1894 bfd_put_32 (output_bfd,
1895 (sgot->output_section->vma
1896 + sgot->output_offset
1897 + 8
1898 - splt->output_section->vma
1899 - splt->output_offset
1900 - 6),
1901 splt->contents + 2);
1902 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
1903 the end of the instruction. */
1904 bfd_put_32 (output_bfd,
1905 (sgot->output_section->vma
1906 + sgot->output_offset
1907 + 16
1908 - splt->output_section->vma
1909 - splt->output_offset
1910 - 12),
1911 splt->contents + 8);
1912
70256ad8
AJ		 1913 }
1914
1915 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1916 PLT_ENTRY_SIZE;
1917 }
1918
1919 /* Set the first entry in the global offset table to the address of
1920 the dynamic section. */
70256ad8
AJ		 1921 if (sgot->_raw_size > 0)
1922 {
1923 if (sdyn == NULL)
1924 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
1925 else
1926 bfd_put_64 (output_bfd,
1927 sdyn->output_section->vma + sdyn->output_offset,
1928 sgot->contents);
653165cc 1929 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
70256ad8
AJ		 1930 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE);
1931 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE*2);
1932 }
1933
1934 elf_section_data (sgot->output_section)->this_hdr.sh_entsize =
1935 GOT_ENTRY_SIZE;
1936
8d88c4ca
NC		 1937 return true;
1938}
1939
407443a3
AJ		 1940/*
1941 * Why was the hash table entry size definition changed from
1942 * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
1943 * this is the only reason for the elf64_x86_64_size_info structure.
1944 */
1945
1946const struct elf_size_info elf64_86_64_size_info =
1947{
1948 sizeof (Elf64_External_Ehdr),
1949 sizeof (Elf64_External_Phdr),
1950 sizeof (Elf64_External_Shdr),
1951 sizeof (Elf64_External_Rel),
1952 sizeof (Elf64_External_Rela),
1953 sizeof (Elf64_External_Sym),
1954 sizeof (Elf64_External_Dyn),
1955 sizeof (Elf_External_Note),
1956 8, /* hash-table entry size */
1957 1, /* internal relocations per external relocations */
1958 64, /* arch_size */
1959 8, /* file_align */
1960 ELFCLASS64, EV_CURRENT,
1961 bfd_elf64_write_out_phdrs,
1962 bfd_elf64_write_shdrs_and_ehdr,
1963 bfd_elf64_write_relocs,
1964 bfd_elf64_swap_symbol_out,
1965 bfd_elf64_slurp_reloc_table,
1966 bfd_elf64_slurp_symbol_table,
1967 bfd_elf64_swap_dyn_in,
1968 bfd_elf64_swap_dyn_out,
1969 NULL,
1970 NULL,
1971 NULL,
1972 NULL
1973};
1974
70256ad8
AJ		 1975#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
1976#define TARGET_LITTLE_NAME "elf64-x86-64"
1977#define ELF_ARCH bfd_arch_i386
1978#define ELF_MACHINE_CODE EM_X86_64
1979#define ELF_MAXPAGESIZE 0x100000
1980
407443a3
AJ		 1981#define elf_backend_size_info elf64_86_64_size_info
1982
70256ad8
AJ		 1983#define elf_backend_can_gc_sections 1
1984#define elf_backend_want_got_plt 1
1985#define elf_backend_plt_readonly 1
1986#define elf_backend_want_plt_sym 0
1987#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
1988#define elf_backend_plt_header_size PLT_ENTRY_SIZE
1989
1990#define elf_info_to_howto elf64_x86_64_info_to_howto
70256ad8
AJ		 1991
1992#define bfd_elf64_bfd_final_link _bfd_elf64_gc_common_final_link
1993#define bfd_elf64_bfd_link_hash_table_create \
1994 elf64_x86_64_link_hash_table_create
407443a3 1995#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
70256ad8
AJ		 1996
1997#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
1998#define elf_backend_check_relocs elf64_x86_64_check_relocs
1999#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2000#define elf_backend_finish_dynamic_sections \
2001 elf64_x86_64_finish_dynamic_sections
2002#define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
2003#define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
2004#define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
2005#define elf_backend_relocate_section elf64_x86_64_relocate_section
2006#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
407443a3 2007#define elf_backend_object_p elf64_x86_64_elf_object_p
8d88c4ca
NC		 2008
2009#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.242692 seconds and 4 git commands to generate.