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