projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* emulparms/elf_x86_64.sh (NONPAGED_TEXT_START_ADDR): Increase.
[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
6b3db546 504 case R_X86_64_64:
70256ad8
AJ		 505 case R_X86_64_32:
506 case R_X86_64_32S:
507 case R_X86_64_PC32:
508 if (h != NULL)
509 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
510
511 /* If we are creating a shared library, and this is a reloc
512 against a global symbol, or a non PC relative reloc
513 against a local symbol, then we need to copy the reloc
514 into the shared library. However, if we are linking with
515 -Bsymbolic, we do not need to copy a reloc against a
516 global symbol which is defined in an object we are
407443a3 517 including in the link (i.e., DEF_REGULAR is set). At
70256ad8
AJ		 518 this point we have not seen all the input files, so it is
519 possible that DEF_REGULAR is not set now but will be set
520 later (it is never cleared). We account for that
521 possibility below by storing information in the
522 pcrel_relocs_copied field of the hash table entry.
523 A similar situation occurs when creating shared libraries
524 and symbol visibility changes render the symbol local. */
525 if (info->shared
526 && (sec->flags & SEC_ALLOC) != 0
527 && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC32
528 || (h != NULL
529 && (! info->symbolic
530 || (h->elf_link_hash_flags
531 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
532 {
533 /* When creating a shared object, we must copy these
534 reloc types into the output file. We create a reloc
535 section in dynobj and make room for this reloc. */
536 if (sreloc == NULL)
537 {
538 const char *name;
539
540 name = (bfd_elf_string_from_elf_section
541 (abfd,
542 elf_elfheader (abfd)->e_shstrndx,
543 elf_section_data (sec)->rel_hdr.sh_name));
544 if (name == NULL)
545 return false;
546
547 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
548 && strcmp (bfd_get_section_name (abfd, sec),
549 name + 5) == 0);
550
551 sreloc = bfd_get_section_by_name (dynobj, name);
552 if (sreloc == NULL)
553 {
554 flagword flags;
555
556 sreloc = bfd_make_section (dynobj, name);
557 flags = (SEC_HAS_CONTENTS | SEC_READONLY
558 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
559 if ((sec->flags & SEC_ALLOC) != 0)
560 flags |= SEC_ALLOC | SEC_LOAD;
561 if (sreloc == NULL
562 || ! bfd_set_section_flags (dynobj, sreloc, flags)
563 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
564 return false;
565 }
566 }
567
568 sreloc->_raw_size += sizeof (Elf64_External_Rela);
569
570 /* If this is a global symbol, we count the number of PC
571 relative relocations we have entered for this symbol,
572 so that we can discard them later as necessary. Note
573 that this function is only called if we are using an
574 elf64_x86_64 linker hash table, which means that h is
575 really a pointer to an elf64_x86_64_link_hash_entry. */
fe4770f4 576 if (h != NULL && ELF64_R_TYPE (rel->r_info) == R_X86_64_PC32)
70256ad8
AJ		 577 {
578 struct elf64_x86_64_link_hash_entry *eh;
579 struct elf64_x86_64_pcrel_relocs_copied *p;
580
581 eh = (struct elf64_x86_64_link_hash_entry *) h;
582
583 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
584 if (p->section == sreloc)
585 break;
586
587 if (p == NULL)
588 {
589 p = ((struct elf64_x86_64_pcrel_relocs_copied *)
590 bfd_alloc (dynobj, sizeof *p));
591 if (p == NULL)
592 return false;
593 p->next = eh->pcrel_relocs_copied;
594 eh->pcrel_relocs_copied = p;
595 p->section = sreloc;
596 p->count = 0;
597 }
598
599 ++p->count;
600 }
601 }
602 break;
fe4770f4
AJ		 603
604 /* This relocation describes the C++ object vtable hierarchy.
605 Reconstruct it for later use during GC. */
606 case R_X86_64_GNU_VTINHERIT:
607 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
608 return false;
609 break;
610
611 /* This relocation describes which C++ vtable entries are actually
612 used. Record for later use during GC. */
613 case R_X86_64_GNU_VTENTRY:
614 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
615 return false;
616 break;
70256ad8
AJ		 617 }
618 }
619
620 return true;
621}
622
623/* Return the section that should be marked against GC for a given
407443a3 624 relocation. */
70256ad8
AJ		 625
626static asection *
627elf64_x86_64_gc_mark_hook (abfd, info, rel, h, sym)
628 bfd *abfd;
629 struct bfd_link_info *info ATTRIBUTE_UNUSED;
630 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED;
631 struct elf_link_hash_entry *h;
632 Elf_Internal_Sym *sym;
633{
634 if (h != NULL)
635 {
fe4770f4 636 switch (ELF64_R_TYPE (rel->r_info))
70256ad8 637 {
fe4770f4
AJ		 638 case R_X86_64_GNU_VTINHERIT:
639 case R_X86_64_GNU_VTENTRY:
640 break;
70256ad8
AJ		 641
642 default:
fe4770f4
AJ		 643 switch (h->root.type)
644 {
645 case bfd_link_hash_defined:
646 case bfd_link_hash_defweak:
647 return h->root.u.def.section;
648
649 case bfd_link_hash_common:
650 return h->root.u.c.p->section;
651
652 default:
653 break;
654 }
70256ad8
AJ		 655 }
656 }
657 else
658 {
659 if (!(elf_bad_symtab (abfd)
660 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
661 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
662 && sym->st_shndx != SHN_COMMON))
663 {
664 return bfd_section_from_elf_index (abfd, sym->st_shndx);
665 }
666 }
667
668 return NULL;
669}
670
407443a3 671/* Update the got entry reference counts for the section being removed. */
70256ad8
AJ		 672
673static boolean
674elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
675 bfd *abfd;
676 struct bfd_link_info *info ATTRIBUTE_UNUSED;
677 asection *sec;
678 const Elf_Internal_Rela *relocs;
679{
680 Elf_Internal_Shdr *symtab_hdr;
681 struct elf_link_hash_entry **sym_hashes;
682 bfd_signed_vma *local_got_refcounts;
683 const Elf_Internal_Rela *rel, *relend;
684 unsigned long r_symndx;
685 struct elf_link_hash_entry *h;
686 bfd *dynobj;
687 asection *sgot;
688 asection *srelgot;
689
690 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
691 sym_hashes = elf_sym_hashes (abfd);
692 local_got_refcounts = elf_local_got_refcounts (abfd);
693
694 dynobj = elf_hash_table (info)->dynobj;
695 if (dynobj == NULL)
696 return true;
697
698 sgot = bfd_get_section_by_name (dynobj, ".got");
699 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
700
701 relend = relocs + sec->reloc_count;
702 for (rel = relocs; rel < relend; rel++)
703 switch (ELF64_R_TYPE (rel->r_info))
704 {
705 case R_X86_64_GOT32:
706 case R_X86_64_GOTPCREL:
707 r_symndx = ELF64_R_SYM (rel->r_info);
708 if (r_symndx >= symtab_hdr->sh_info)
709 {
710 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
711 if (h->got.refcount > 0)
712 {
713 h->got.refcount -= 1;
714 if (h->got.refcount == 0)
715 {
716 sgot->_raw_size -= GOT_ENTRY_SIZE;
717 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
718 }
719 }
720 }
721 else if (local_got_refcounts != NULL)
722 {
723 if (local_got_refcounts[r_symndx] > 0)
724 {
725 local_got_refcounts[r_symndx] -= 1;
726 if (local_got_refcounts[r_symndx] == 0)
727 {
728 sgot->_raw_size -= GOT_ENTRY_SIZE;
729 if (info->shared)
730 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
731 }
732 }
733 }
734 break;
735
736 case R_X86_64_PLT32:
737 r_symndx = ELF64_R_SYM (rel->r_info);
738 if (r_symndx >= symtab_hdr->sh_info)
739 {
740 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
741 if (h->plt.refcount > 0)
742 h->plt.refcount -= 1;
743 }
744 break;
745
746 default:
747 break;
748 }
749
750 return true;
751}
752
753/* Adjust a symbol defined by a dynamic object and referenced by a
754 regular object. The current definition is in some section of the
755 dynamic object, but we're not including those sections. We have to
756 change the definition to something the rest of the link can
407443a3 757 understand. */
70256ad8
AJ		 758
759static boolean
760elf64_x86_64_adjust_dynamic_symbol (info, h)
761 struct bfd_link_info *info;
762 struct elf_link_hash_entry *h;
763{
764 bfd *dynobj;
765 asection *s;
766 unsigned int power_of_two;
767
768 dynobj = elf_hash_table (info)->dynobj;
769
770 /* Make sure we know what is going on here. */
771 BFD_ASSERT (dynobj != NULL
772 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
773 || h->weakdef != NULL
774 || ((h->elf_link_hash_flags
775 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
776 && (h->elf_link_hash_flags
777 & ELF_LINK_HASH_REF_REGULAR) != 0
778 && (h->elf_link_hash_flags
779 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
780
781 /* If this is a function, put it in the procedure linkage table. We
782 will fill in the contents of the procedure linkage table later,
783 when we know the address of the .got section. */
784 if (h->type == STT_FUNC
785 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
786 {
407443a3
AJ		 787 if ((! info->shared
788 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
789 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
790 || (info->shared && h->plt.refcount <= 0))
70256ad8 791 {
70256ad8
AJ		 792 /* This case can occur if we saw a PLT32 reloc in an input
793 file, but the symbol was never referred to by a dynamic
794 object, or if all references were garbage collected. In
795 such a case, we don't actually need to build a procedure
796 linkage table, and we can just do a PC32 reloc instead. */
70256ad8
AJ		 797 h->plt.offset = (bfd_vma) -1;
798 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
799 return true;
800 }
801
802 /* Make sure this symbol is output as a dynamic symbol. */
803 if (h->dynindx == -1)
804 {
805 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
806 return false;
807 }
808
809 s = bfd_get_section_by_name (dynobj, ".plt");
810 BFD_ASSERT (s != NULL);
811
812 /* If this is the first .plt entry, make room for the special
813 first entry. */
814 if (s->_raw_size == 0)
815 s->_raw_size = PLT_ENTRY_SIZE;
816
817 /* If this symbol is not defined in a regular file, and we are
818 not generating a shared library, then set the symbol to this
407443a3 819 location in the .plt. This is required to make function
70256ad8
AJ		 820 pointers compare as equal between the normal executable and
821 the shared library. */
822 if (! info->shared
823 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
824 {
825 h->root.u.def.section = s;
826 h->root.u.def.value = s->_raw_size;
827 }
828
829 h->plt.offset = s->_raw_size;
830
831 /* Make room for this entry. */
832 s->_raw_size += PLT_ENTRY_SIZE;
833
407443a3
AJ		 834 /* We also need to make an entry in the .got.plt section, which
835 will be placed in the .got section by the linker script. */
836 s = bfd_get_section_by_name (dynobj, ".got.plt");
837 BFD_ASSERT (s != NULL);
838 s->_raw_size += GOT_ENTRY_SIZE;
839
70256ad8
AJ		 840 /* We also need to make an entry in the .rela.plt section. */
841 s = bfd_get_section_by_name (dynobj, ".rela.plt");
842 BFD_ASSERT (s != NULL);
843 s->_raw_size += sizeof (Elf64_External_Rela);
844
845 return true;
846 }
847
848 /* If this is a weak symbol, and there is a real definition, the
849 processor independent code will have arranged for us to see the
407443a3 850 real definition first, and we can just use the same value. */
70256ad8
AJ		 851 if (h->weakdef != NULL)
852 {
853 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
854 || h->weakdef->root.type == bfd_link_hash_defweak);
855 h->root.u.def.section = h->weakdef->root.u.def.section;
856 h->root.u.def.value = h->weakdef->root.u.def.value;
857 return true;
858 }
859
860 /* This is a reference to a symbol defined by a dynamic object which
407443a3 861 is not a function. */
70256ad8
AJ		 862
863 /* If we are creating a shared library, we must presume that the
864 only references to the symbol are via the global offset table.
865 For such cases we need not do anything here; the relocations will
407443a3 866 be handled correctly by relocate_section. */
70256ad8
AJ		 867 if (info->shared)
868 return true;
869
870 /* If there are no references to this symbol that do not use the
871 GOT, we don't need to generate a copy reloc. */
872 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
873 return true;
874
875 /* We must allocate the symbol in our .dynbss section, which will
407443a3 876 become part of the .bss section of the executable. There will be
70256ad8
AJ		 877 an entry for this symbol in the .dynsym section. The dynamic
878 object will contain position independent code, so all references
879 from the dynamic object to this symbol will go through the global
880 offset table. The dynamic linker will use the .dynsym entry to
881 determine the address it must put in the global offset table, so
882 both the dynamic object and the regular object will refer to the
883 same memory location for the variable. */
884
885 s = bfd_get_section_by_name (dynobj, ".dynbss");
886 BFD_ASSERT (s != NULL);
887
888 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
889 to copy the initial value out of the dynamic object and into the
890 runtime process image. We need to remember the offset into the
891 .rela.bss section we are going to use. */
892 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
893 {
894 asection *srel;
895
896 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
897 BFD_ASSERT (srel != NULL);
898 srel->_raw_size += sizeof (Elf64_External_Rela);
899 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
900 }
901
902 /* We need to figure out the alignment required for this symbol. I
407443a3 903 have no idea how ELF linkers handle this. 16-bytes is the size
70256ad8
AJ		 904 of the largest type that requires hard alignment -- long double. */
905 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
906 this construct. */
907 power_of_two = bfd_log2 (h->size);
908 if (power_of_two > 4)
909 power_of_two = 4;
910
911 /* Apply the required alignment. */
912 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
913 if (power_of_two > bfd_get_section_alignment (dynobj, s))
914 {
915 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
916 return false;
917 }
918
919 /* Define the symbol as being at this point in the section. */
920 h->root.u.def.section = s;
921 h->root.u.def.value = s->_raw_size;
922
923 /* Increment the section size to make room for the symbol. */
924 s->_raw_size += h->size;
925
926 return true;
927}
928
929/* Set the sizes of the dynamic sections. */
930
931static boolean
932elf64_x86_64_size_dynamic_sections (output_bfd, info)
933 bfd *output_bfd;
934 struct bfd_link_info *info;
935{
936 bfd *dynobj;
937 asection *s;
938 boolean plt;
939 boolean relocs;
940 boolean reltext;
941
942 dynobj = elf_hash_table (info)->dynobj;
943 BFD_ASSERT (dynobj != NULL);
944
945 if (elf_hash_table (info)->dynamic_sections_created)
946 {
947 /* Set the contents of the .interp section to the interpreter. */
948 if (! info->shared)
949 {
950 s = bfd_get_section_by_name (dynobj, ".interp");
951 BFD_ASSERT (s != NULL);
952 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
953 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
954 }
955 }
956 else
957 {
958 /* We may have created entries in the .rela.got section.
407443a3
AJ		 959 However, if we are not creating the dynamic sections, we will
960 not actually use these entries. Reset the size of .rela.got,
961 which will cause it to get stripped from the output file
962 below. */
70256ad8
AJ		 963 s = bfd_get_section_by_name (dynobj, ".rela.got");
964 if (s != NULL)
965 s->_raw_size = 0;
966 }
967
968 /* If this is a -Bsymbolic shared link, then we need to discard all
969 PC relative relocs against symbols defined in a regular object.
970 We allocated space for them in the check_relocs routine, but we
971 will not fill them in in the relocate_section routine. */
972 if (info->shared)
973 elf64_x86_64_link_hash_traverse (elf64_x86_64_hash_table (info),
974 elf64_x86_64_discard_copies,
975 (PTR) info);
976
977 /* The check_relocs and adjust_dynamic_symbol entry points have
978 determined the sizes of the various dynamic sections. Allocate
979 memory for them. */
980 plt = relocs = reltext = false;
981 for (s = dynobj->sections; s != NULL; s = s->next)
982 {
983 const char *name;
984 boolean strip;
985
986 if ((s->flags & SEC_LINKER_CREATED) == 0)
987 continue;
988
989 /* It's OK to base decisions on the section name, because none
990 of the dynobj section names depend upon the input files. */
991 name = bfd_get_section_name (dynobj, s);
992
993 strip = false;
994 if (strcmp (name, ".plt") == 0)
995 {
996 if (s->_raw_size == 0)
997 {
998 /* Strip this section if we don't need it; see the
407443a3 999 comment below. */
70256ad8
AJ		 1000 strip = true;
1001 }
1002 else
1003 {
1004 /* Remember whether there is a PLT. */
1005 plt = true;
1006 }
1007 }
1008 else if (strncmp (name, ".rela", 5) == 0)
1009 {
1010 if (s->_raw_size == 0)
1011 {
1012 /* If we don't need this section, strip it from the
1013 output file. This is mostly to handle .rela.bss and
1014 .rela.plt. We must create both sections in
1015 create_dynamic_sections, because they must be created
1016 before the linker maps input sections to output
1017 sections. The linker does that before
1018 adjust_dynamic_symbol is called, and it is that
1019 function which decides whether anything needs to go
1020 into these sections. */
1021 strip = true;
1022 }
1023 else
1024 {
1025 asection *target;
1026
1027 /* Remember whether there are any reloc sections other
407443a3 1028 than .rela.plt. */
70256ad8
AJ		 1029 if (strcmp (name, ".rela.plt") != 0)
1030 {
1031 const char *outname;
1032
1033 relocs = true;
1034
1035 /* If this relocation section applies to a read only
1036 section, then we probably need a DT_TEXTREL
1037 entry. The entries in the .rela.plt section
1038 really apply to the .got section, which we
1039 created ourselves and so know is not readonly. */
1040 outname = bfd_get_section_name (output_bfd,
1041 s->output_section);
1042 target = bfd_get_section_by_name (output_bfd, outname + 5);
1043 if (target != NULL
1044 && (target->flags & SEC_READONLY) != 0
1045 && (target->flags & SEC_ALLOC) != 0)
1046 reltext = true;
1047 }
1048
1049 /* We use the reloc_count field as a counter if we need
1050 to copy relocs into the output file. */
1051 s->reloc_count = 0;
1052 }
1053 }
1054 else if (strncmp (name, ".got", 4) != 0)
1055 {
1056 /* It's not one of our sections, so don't allocate space. */
1057 continue;
1058 }
1059
1060 if (strip)
1061 {
1062 _bfd_strip_section_from_output (info, s);
1063 continue;
1064 }
1065
1066 /* Allocate memory for the section contents. We use bfd_zalloc
1067 here in case unused entries are not reclaimed before the
1068 section's contents are written out. This should not happen,
1069 but this way if it does, we get a R_X86_64_NONE reloc instead
1070 of garbage. */
1071 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1072 if (s->contents == NULL && s->_raw_size != 0)
1073 return false;
1074 }
1075
1076 if (elf_hash_table (info)->dynamic_sections_created)
1077 {
1078 /* Add some entries to the .dynamic section. We fill in the
1079 values later, in elf64_x86_64_finish_dynamic_sections, but we
1080 must add the entries now so that we get the correct size for
407443a3 1081 the .dynamic section. The DT_DEBUG entry is filled in by the
70256ad8
AJ		 1082 dynamic linker and used by the debugger. */
1083 if (! info->shared)
1084 {
1085 if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
1086 return false;
1087 }
1088
1089 if (plt)
1090 {
70256ad8
AJ		 1091 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
1092 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
407443a3 1093 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
70256ad8
AJ		 1094 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1095 return false;
1096 }
1097
1098 if (relocs)
1099 {
1100 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1101 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1102 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1103 sizeof (Elf64_External_Rela)))
1104 return false;
1105 }
1106
1107 if (reltext)
1108 {
1109 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1110 return false;
1111 info->flags |= DF_TEXTREL;
1112 }
1113 }
1114
1115 return true;
1116}
1117
1118/* This function is called via elf64_x86_64_link_hash_traverse if we are
1119 creating a shared object. In the -Bsymbolic case, it discards the
1120 space allocated to copy PC relative relocs against symbols which
1121 are defined in regular objects. For the normal non-symbolic case,
1122 we also discard space for relocs that have become local due to
1123 symbol visibility changes. We allocated space for them in the
1124 check_relocs routine, but we won't fill them in in the
1125 relocate_section routine. */
1126
1127static boolean
1128elf64_x86_64_discard_copies (h, inf)
1129 struct elf64_x86_64_link_hash_entry *h;
1130 PTR inf;
1131{
1132 struct elf64_x86_64_pcrel_relocs_copied *s;
1133 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1134
1135 /* If a symbol has been forced local or we have found a regular
1136 definition for the symbolic link case, then we won't be needing
1137 any relocs. */
1138 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1139 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1140 || info->symbolic))
1141 {
1142 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1143 s->section->_raw_size -= s->count * sizeof (Elf64_External_Rela);
1144 }
1145
1146 return true;
1147}
1148
8d88c4ca
NC		 1149/* Relocate an x86_64 ELF section. */
1150
1151static boolean
1152elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
fe4770f4 1153 contents, relocs, local_syms, local_sections)
8d88c4ca
NC		 1154 bfd *output_bfd;
1155 struct bfd_link_info *info;
1156 bfd *input_bfd;
1157 asection *input_section;
1158 bfd_byte *contents;
1159 Elf_Internal_Rela *relocs;
1160 Elf_Internal_Sym *local_syms;
1161 asection **local_sections;
1162{
1163 bfd *dynobj;
1164 Elf_Internal_Shdr *symtab_hdr;
1165 struct elf_link_hash_entry **sym_hashes;
1166 bfd_vma *local_got_offsets;
70256ad8
AJ		 1167 asection *sgot;
1168 asection *splt;
8d88c4ca 1169 asection *sreloc;
70256ad8 1170 Elf_Internal_Rela *rela;
8d88c4ca
NC		 1171 Elf_Internal_Rela *relend;
1172
1173 dynobj = elf_hash_table (info)->dynobj;
1174 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1175 sym_hashes = elf_sym_hashes (input_bfd);
1176 local_got_offsets = elf_local_got_offsets (input_bfd);
1177
70256ad8 1178 sreloc = splt = sgot = NULL;
8d88c4ca 1179 if (dynobj != NULL)
70256ad8
AJ		 1180 {
1181 splt = bfd_get_section_by_name (dynobj, ".plt");
1182 sgot = bfd_get_section_by_name (dynobj, ".got");
1183 }
8d88c4ca 1184
70256ad8 1185 rela = relocs;
8d88c4ca 1186 relend = relocs + input_section->reloc_count;
70256ad8 1187 for (; rela < relend; rela++)
8d88c4ca
NC		 1188 {
1189 int r_type;
1190 reloc_howto_type *howto;
1191 unsigned long r_symndx;
1192 struct elf_link_hash_entry *h;
1193 Elf_Internal_Sym *sym;
1194 asection *sec;
1195 bfd_vma relocation;
1196 bfd_reloc_status_type r;
1197 unsigned int indx;
1198
70256ad8 1199 r_type = ELF64_R_TYPE (rela->r_info);
fe4770f4
AJ		 1200 if (r_type == (int) R_X86_64_GNU_VTINHERIT
1201 || r_type == (int) R_X86_64_GNU_VTENTRY)
1202 continue;
8d88c4ca
NC		 1203
1204 if ((indx = (unsigned) r_type) >= R_X86_64_max)
8da6118f
KH		 1205 {
1206 bfd_set_error (bfd_error_bad_value);
1207 return false;
1208 }
8d88c4ca
NC		 1209 howto = x86_64_elf_howto_table + indx;
1210
70256ad8 1211 r_symndx = ELF64_R_SYM (rela->r_info);
8d88c4ca
NC		 1212
1213 if (info->relocateable)
8da6118f
KH		 1214 {
1215 /* This is a relocateable link. We don't have to change
1216 anything, unless the reloc is against a section symbol,
1217 in which case we have to adjust according to where the
1218 section symbol winds up in the output section. */
1219 if (r_symndx < symtab_hdr->sh_info)
1220 {
1221 sym = local_syms + r_symndx;
1222 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1223 {
1224 sec = local_sections[r_symndx];
70256ad8 1225 rela->r_addend += sec->output_offset + sym->st_value;
8da6118f
KH		 1226 }
1227 }
1228
1229 continue;
1230 }
8d88c4ca 1231
407443a3 1232 /* This is a final link. */
8d88c4ca
NC		 1233 h = NULL;
1234 sym = NULL;
1235 sec = NULL;
1236 if (r_symndx < symtab_hdr->sh_info)
8da6118f
KH		 1237 {
1238 sym = local_syms + r_symndx;
1239 sec = local_sections[r_symndx];
1240 relocation = (sec->output_section->vma
1241 + sec->output_offset
1242 + sym->st_value);
1243 }
8d88c4ca 1244 else
8da6118f
KH		 1245 {
1246 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1247 while (h->root.type == bfd_link_hash_indirect
1248 || h->root.type == bfd_link_hash_warning)
1249 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1250 if (h->root.type == bfd_link_hash_defined
1251 || h->root.type == bfd_link_hash_defweak)
1252 {
1253 sec = h->root.u.def.section;
6a2bda3f
AJ		 1254 if ((r_type == R_X86_64_PLT32
1255 && splt != NULL
1256 && h->plt.offset != (bfd_vma) -1)
1257 || ((r_type == R_X86_64_GOT32 || r_type == R_X86_64_GOTPCREL)
bcdd92f3
AJ		 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)
80643fbc
AJ		 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_PC8
1272 || r_type == R_X86_64_PC16
1273 || r_type == R_X86_64_PC32)
bcdd92f3
AJ		 1274 && ((input_section->flags & SEC_ALLOC) != 0
1275 /* DWARF will emit R_X86_64_32 relocations in its
1276 sections against symbols defined externally
1277 in shared libraries. We can't do anything
1278 with them here. */
1279 || ((input_section->flags & SEC_DEBUGGING) != 0
1280 && (h->elf_link_hash_flags
1281 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1282 {
1283 /* In these cases, we don't need the relocation
1284 value. We check specially because in some
1285 obscure cases sec->output_section will be NULL. */
1286 relocation = 0;
1287 }
1288 else if (sec->output_section == NULL)
8da6118f
KH		 1289 {
1290 (*_bfd_error_handler)
1291 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1292 bfd_get_filename (input_bfd), h->root.root.string,
1293 bfd_get_section_name (input_bfd, input_section));
1294 relocation = 0;
1295 }
1296 else
1297 relocation = (h->root.u.def.value
1298 + sec->output_section->vma
1299 + sec->output_offset);
1300 }
1301 else if (h->root.type == bfd_link_hash_undefweak)
1302 relocation = 0;
70256ad8
AJ		 1303 else if (info->shared && !info->symbolic && !info->no_undefined
1304 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1305 relocation = 0;
8da6118f
KH		 1306 else
1307 {
1308 if (! ((*info->callbacks->undefined_symbol)
1309 (info, h->root.root.string, input_bfd,
70256ad8 1310 input_section, rela->r_offset,
8da6118f
KH		 1311 (!info->shared || info->no_undefined
1312 || ELF_ST_VISIBILITY (h->other)))))
1313 return false;
1314 relocation = 0;
1315 }
1316 }
70256ad8
AJ		 1317
1318 /* When generating a shared object, the relocations handled here are
1319 copied into the output file to be resolved at run time. */
1320 switch (r_type)
1321 {
1322 case R_X86_64_GOT32:
1323 /* Relocation is to the entry for this symbol in the global
1324 offset table. */
70256ad8
AJ		 1325 case R_X86_64_GOTPCREL:
1326 /* Use global offset table as symbol value. */
51e0a107 1327 BFD_ASSERT (sgot != NULL);
053579d7 1328
51e0a107 1329 if (h != NULL)
70256ad8 1330 {
51e0a107
JH		 1331 bfd_vma off = h->got.offset;
1332 BFD_ASSERT (off != (bfd_vma) -1);
1333
1334 if (! elf_hash_table (info)->dynamic_sections_created
1335 || (info->shared
1336 && (info->symbolic || h->dynindx == -1)
1337 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1338 {
1339 /* This is actually a static link, or it is a -Bsymbolic
1340 link and the symbol is defined locally, or the symbol
407443a3 1341 was forced to be local because of a version file. We
51e0a107
JH		 1342 must initialize this entry in the global offset table.
1343 Since the offset must always be a multiple of 8, we
1344 use the least significant bit to record whether we
1345 have initialized it already.
1346
1347 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 1348 relocation entry to initialize the value. This is
1349 done in the finish_dynamic_symbol routine. */
51e0a107
JH		 1350 if ((off & 1) != 0)
1351 off &= ~1;
1352 else
1353 {
1354 bfd_put_64 (output_bfd, relocation,
1355 sgot->contents + off);
1356 h->got.offset |= 1;
1357 }
1358 }
053579d7
AJ		 1359 if (r_type == R_X86_64_GOTPCREL)
1360 relocation = sgot->output_section->vma + sgot->output_offset + off;
1361 else
1362 relocation = sgot->output_offset + off;
70256ad8 1363 }
51e0a107
JH		 1364 else
1365 {
1366 bfd_vma off;
70256ad8 1367
51e0a107
JH		 1368 BFD_ASSERT (local_got_offsets != NULL
1369 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1370
1371 off = local_got_offsets[r_symndx];
1372
1373 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 1374 the least significant bit to record whether we have
1375 already generated the necessary reloc. */
51e0a107
JH		 1376 if ((off & 1) != 0)
1377 off &= ~1;
1378 else
1379 {
1380 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1381
1382 if (info->shared)
1383 {
1384 asection *srelgot;
1385 Elf_Internal_Rela outrel;
70256ad8 1386
51e0a107
JH		 1387 /* We need to generate a R_X86_64_RELATIVE reloc
1388 for the dynamic linker. */
1389 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1390 BFD_ASSERT (srelgot != NULL);
1391
1392 outrel.r_offset = (sgot->output_section->vma
1393 + sgot->output_offset
1394 + off);
1395 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1396 outrel.r_addend = relocation;
1397 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1398 (((Elf64_External_Rela *)
1399 srelgot->contents)
1400 + srelgot->reloc_count));
1401 ++srelgot->reloc_count;
1402 }
1403
1404 local_got_offsets[r_symndx] |= 1;
1405 }
1406
053579d7
AJ		 1407 if (r_type == R_X86_64_GOTPCREL)
1408 relocation = sgot->output_section->vma + sgot->output_offset + off;
1409 else
1410 relocation = sgot->output_offset + off;
51e0a107 1411 }
6a2bda3f 1412
70256ad8
AJ		 1413 break;
1414
1415 case R_X86_64_PLT32:
1416 /* Relocation is to the entry for this symbol in the
1417 procedure linkage table. */
1418
1419 /* Resolve a PLT32 reloc against a local symbol directly,
407443a3 1420 without using the procedure linkage table. */
70256ad8
AJ		 1421 if (h == NULL)
1422 break;
1423
1424 if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
1425 {
1426 /* We didn't make a PLT entry for this symbol. This
407443a3
AJ		 1427 happens when statically linking PIC code, or when
1428 using -Bsymbolic. */
70256ad8
AJ		 1429 break;
1430 }
1431
1432 relocation = (splt->output_section->vma
1433 + splt->output_offset
1434 + h->plt.offset);
1435 break;
1436
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:
70256ad8
AJ		 1441 case R_X86_64_PC8:
1442 case R_X86_64_PC16:
1443 case R_X86_64_PC32:
80643fbc 1444 /* FIXME: The ABI says the linker should make sure the value is
407443a3 1445 the same when it's zeroextended to 64 bit. */
70256ad8
AJ		 1446 if (info->shared
1447 && (input_section->flags & SEC_ALLOC) != 0
80643fbc
AJ		 1448 && ((r_type != R_X86_64_PC8
1449 && r_type != R_X86_64_PC16
70256ad8
AJ		 1450 && r_type != R_X86_64_PC32)
1451 || (h != NULL
1452 && h->dynindx != -1
1453 && (! info->symbolic
1454 || (h->elf_link_hash_flags
1455 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1456 {
1457 Elf_Internal_Rela outrel;
1458 boolean skip, relocate;
1459
1460 /* When generating a shared object, these relocations
1461 are copied into the output file to be resolved at run
407443a3 1462 time. */
70256ad8
AJ		 1463
1464 if (sreloc == NULL)
1465 {
1466 const char *name;
1467
1468 name = (bfd_elf_string_from_elf_section
1469 (input_bfd,
1470 elf_elfheader (input_bfd)->e_shstrndx,
1471 elf_section_data (input_section)->rel_hdr.sh_name));
1472 if (name == NULL)
1473 return false;
1474
1475 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1476 && strcmp (bfd_get_section_name (input_bfd,
1477 input_section),
1478 name + 5) == 0);
1479
1480 sreloc = bfd_get_section_by_name (dynobj, name);
1481 BFD_ASSERT (sreloc != NULL);
1482 }
1483
1484 skip = false;
1485
1486 if (elf_section_data (input_section)->stab_info == NULL)
1487 outrel.r_offset = rela->r_offset;
1488 else
1489 {
1490 bfd_vma off;
1491
1492 off = (_bfd_stab_section_offset
1493 (output_bfd, &elf_hash_table (info)->stab_info,
1494 input_section,
1495 &elf_section_data (input_section)->stab_info,
1496 rela->r_offset));
1497 if (off == (bfd_vma) -1)
1498 skip = true;
1499 outrel.r_offset = off;
1500 }
1501
1502 outrel.r_offset += (input_section->output_section->vma
1503 + input_section->output_offset);
1504
1505 if (skip)
1506 {
1507 memset (&outrel, 0, sizeof outrel);
1508 relocate = false;
1509 }
80643fbc
AJ		 1510 else if ((r_type == R_X86_64_PC8)
1511 || (r_type == R_X86_64_PC16)
70256ad8
AJ		 1512 || (r_type == R_X86_64_PC32))
1513 {
1514 BFD_ASSERT (h != NULL && h->dynindx != -1);
1515 relocate = false;
1516 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
5608e05b 1517 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1518 }
1519 else
1520 {
1521 /* h->dynindx may be -1 if this symbol was marked to
407443a3 1522 become local. */
70256ad8
AJ		 1523 if (h == NULL
1524 || ((info->symbolic || h->dynindx == -1)
1525 && (h->elf_link_hash_flags
1526 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1527 {
1528 relocate = true;
1529 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
5608e05b 1530 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1531 }
1532 else
1533 {
1534 BFD_ASSERT (h->dynindx != -1);
1535 relocate = false;
1536 outrel.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_32);
5608e05b 1537 outrel.r_addend = relocation + rela->r_addend;
70256ad8
AJ		 1538 }
1539 }
1540
1541 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1542 (((Elf64_External_Rela *)
1543 sreloc->contents)
1544 + sreloc->reloc_count));
1545 ++sreloc->reloc_count;
1546
1547 /* If this reloc is against an external symbol, we do
1548 not want to fiddle with the addend. Otherwise, we
1549 need to include the symbol value so that it becomes
1550 an addend for the dynamic reloc. */
1551 if (! relocate)
1552 continue;
1553 }
1554
1555 break;
1556
1557 default:
1558 break;
1559 }
8d88c4ca
NC		 1560
1561 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
70256ad8
AJ		 1562 contents, rela->r_offset,
1563 relocation, rela->r_addend);
8d88c4ca
NC		 1564
1565 if (r != bfd_reloc_ok)
8da6118f
KH		 1566 {
1567 switch (r)
1568 {
1569 default:
1570 case bfd_reloc_outofrange:
1571 abort ();
1572 case bfd_reloc_overflow:
1573 {
1574 const char *name;
1575
1576 if (h != NULL)
1577 name = h->root.root.string;
1578 else
1579 {
1580 name = bfd_elf_string_from_elf_section (input_bfd,
1581 symtab_hdr->sh_link,
1582 sym->st_name);
1583 if (name == NULL)
1584 return false;
1585 if (*name == '\0')
1586 name = bfd_section_name (input_bfd, sec);
1587 }
1588 if (! ((*info->callbacks->reloc_overflow)
1589 (info, name, howto->name, (bfd_vma) 0,
70256ad8 1590 input_bfd, input_section, rela->r_offset)))
8da6118f
KH		 1591 return false;
1592 }
1593 break;
1594 }
1595 }
8d88c4ca 1596 }
70256ad8
AJ		 1597
1598 return true;
1599}
1600
1601/* Finish up dynamic symbol handling. We set the contents of various
1602 dynamic sections here. */
1603
1604static boolean
1605elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
1606 bfd *output_bfd;
1607 struct bfd_link_info *info;
1608 struct elf_link_hash_entry *h;
1609 Elf_Internal_Sym *sym;
1610{
1611 bfd *dynobj;
1612
1613 dynobj = elf_hash_table (info)->dynobj;
1614
1615 if (h->plt.offset != (bfd_vma) -1)
1616 {
1617 asection *splt;
1618 asection *sgot;
1619 asection *srela;
1620 bfd_vma plt_index;
1621 bfd_vma got_offset;
1622 Elf_Internal_Rela rela;
1623
1624 /* This symbol has an entry in the procedure linkage table. Set
407443a3 1625 it up. */
70256ad8
AJ		 1626
1627 BFD_ASSERT (h->dynindx != -1);
1628
1629 splt = bfd_get_section_by_name (dynobj, ".plt");
1630 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1631 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1632 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1633
1634 /* Get the index in the procedure linkage table which
1635 corresponds to this symbol. This is the index of this symbol
1636 in all the symbols for which we are making plt entries. The
1637 first entry in the procedure linkage table is reserved. */
1638 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1639
1640 /* Get the offset into the .got table of the entry that
407443a3 1641 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
fe4770f4 1642 bytes. The first three are reserved for the dynamic linker. */
70256ad8
AJ		 1643 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
1644
1645 /* Fill in the entry in the procedure linkage table. */
1646 memcpy (splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
1647 PLT_ENTRY_SIZE);
1648
1649 /* Insert the relocation positions of the plt section. The magic
1650 numbers at the end of the statements are the positions of the
1651 relocations in the plt section. */
653165cc
AJ		 1652 /* Put offset for jmp *name@GOTPCREL(%rip), since the
1653 instruction uses 6 bytes, subtract this value. */
1654 bfd_put_32 (output_bfd,
1655 (sgot->output_section->vma
1656 + sgot->output_offset
1657 + got_offset
1658 - splt->output_section->vma
1659 - splt->output_offset
1660 - h->plt.offset
1661 - 6),
1662 splt->contents + h->plt.offset + 2);
1663 /* Put relocation index. */
1664 bfd_put_32 (output_bfd, plt_index,
70256ad8 1665 splt->contents + h->plt.offset + 7);
653165cc
AJ		 1666 /* Put offset for jmp .PLT0. */
1667 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
70256ad8
AJ		 1668 splt->contents + h->plt.offset + 12);
1669
653165cc
AJ		 1670 /* Fill in the entry in the global offset table, initially this
1671 points to the pushq instruction in the PLT which is at offset 6. */
70256ad8
AJ		 1672 bfd_put_64 (output_bfd, (splt->output_section->vma + splt->output_offset
1673 + h->plt.offset + 6),
1674 sgot->contents + got_offset);
1675
1676 /* Fill in the entry in the .rela.plt section. */
1677 rela.r_offset = (sgot->output_section->vma
1678 + sgot->output_offset
1679 + got_offset);
1680 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
1681 rela.r_addend = 0;
1682 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1683 ((Elf64_External_Rela *) srela->contents
1684 + plt_index));
1685
1686 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1687 {
1688 /* Mark the symbol as undefined, rather than as defined in
407443a3 1689 the .plt section. Leave the value alone. */
70256ad8 1690 sym->st_shndx = SHN_UNDEF;
05aa1441
AJ		 1691 /* If the symbol is weak, we do need to clear the value.
1692 Otherwise, the PLT entry would provide a definition for
1693 the symbol even if the symbol wasn't defined anywhere,
1694 and so the symbol would never be NULL. */
1695 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1696 == 0)
1697 sym->st_value = 0;
70256ad8
AJ		 1698 }
1699 }
1700
053579d7
AJ		 1701 if (h->got.offset != (bfd_vma) -1)
1702 {
1703 asection *sgot;
1704 asection *srela;
1705 Elf_Internal_Rela rela;
1706
1707 /* This symbol has an entry in the global offset table. Set it
1708 up. */
1709
1710 sgot = bfd_get_section_by_name (dynobj, ".got");
1711 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1712 BFD_ASSERT (sgot != NULL && srela != NULL);
1713
1714 rela.r_offset = (sgot->output_section->vma
1715 + sgot->output_offset
1716 + (h->got.offset &~ 1));
1717
1718 /* If this is a static link, or it is a -Bsymbolic link and the
1719 symbol is defined locally or was forced to be local because
1720 of a version file, we just want to emit a RELATIVE reloc.
1721 The entry in the global offset table will already have been
1722 initialized in the relocate_section function. */
1723 if (! elf_hash_table (info)->dynamic_sections_created
1724 || (info->shared
1725 && (info->symbolic || h->dynindx == -1)
1726 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1727 {
1728 rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1729 rela.r_addend = (h->root.u.def.value
1730 + h->root.u.def.section->output_section->vma
1731 + h->root.u.def.section->output_offset);
1732 }
1733 else
1734 {
1735 BFD_ASSERT((h->got.offset & 1) == 0);
1736 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1737 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
1738 rela.r_addend = 0;
1739 }
1740
1741 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1742 ((Elf64_External_Rela *) srela->contents
1743 + srela->reloc_count));
1744 ++srela->reloc_count;
1745 }
1746
70256ad8
AJ		 1747 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1748 {
1749 asection *s;
1750 Elf_Internal_Rela rela;
1751
1752 /* This symbol needs a copy reloc. Set it up. */
1753
1754 BFD_ASSERT (h->dynindx != -1
1755 && (h->root.type == bfd_link_hash_defined
1756 || h->root.type == bfd_link_hash_defweak));
1757
1758 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1759 ".rela.bss");
1760 BFD_ASSERT (s != NULL);
1761
1762 rela.r_offset = (h->root.u.def.value
1763 + h->root.u.def.section->output_section->vma
1764 + h->root.u.def.section->output_offset);
1765 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
1766 rela.r_addend = 0;
1767 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1768 ((Elf64_External_Rela *) s->contents
1769 + s->reloc_count));
1770 ++s->reloc_count;
1771 }
1772
1773 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1774 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1775 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1776 sym->st_shndx = SHN_ABS;
1777
1778 return true;
1779}
1780
1781/* Finish up the dynamic sections. */
1782
1783static boolean
1784elf64_x86_64_finish_dynamic_sections (output_bfd, info)
1785 bfd *output_bfd;
1786 struct bfd_link_info *info;
1787{
1788 bfd *dynobj;
1789 asection *sdyn;
1790 asection *sgot;
1791
1792 dynobj = elf_hash_table (info)->dynobj;
1793
653165cc
AJ		 1794 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1795 BFD_ASSERT (sgot != NULL);
70256ad8
AJ		 1796 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1797
1798 if (elf_hash_table (info)->dynamic_sections_created)
1799 {
1800 asection *splt;
1801 Elf64_External_Dyn *dyncon, *dynconend;
1802
407443a3 1803 BFD_ASSERT (sdyn != NULL);
70256ad8
AJ		 1804
1805 dyncon = (Elf64_External_Dyn *) sdyn->contents;
1806 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1807 for (; dyncon < dynconend; dyncon++)
1808 {
1809 Elf_Internal_Dyn dyn;
1810 const char *name;
1811 asection *s;
1812
1813 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
1814
1815 switch (dyn.d_tag)
1816 {
1817 default:
053579d7 1818 continue;
70256ad8
AJ		 1819
1820 case DT_PLTGOT:
1821 name = ".got";
1822 goto get_vma;
1823
1824 case DT_JMPREL:
1825 name = ".rela.plt";
1826
1827 get_vma:
1828 s = bfd_get_section_by_name (output_bfd, name);
1829 BFD_ASSERT (s != NULL);
1830 dyn.d_un.d_ptr = s->vma;
1831 break;
1832
1833 case DT_RELASZ:
1834 /* FIXME: This comment and code is from elf64-alpha.c: */
1835 /* My interpretation of the TIS v1.1 ELF document indicates
407443a3 1836 that RELASZ should not include JMPREL. This is not what
70256ad8
AJ		 1837 the rest of the BFD does. It is, however, what the
1838 glibc ld.so wants. Do this fixup here until we found
1839 out who is right. */
1840 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1841 if (s)
1842 {
407443a3 1843 /* Subtract JMPREL size from RELASZ. */
70256ad8
AJ		 1844 dyn.d_un.d_val -=
1845 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
1846 }
1847 break;
1848
1849 case DT_PLTRELSZ:
1850 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1851 BFD_ASSERT (s != NULL);
1852 dyn.d_un.d_val =
1853 (s->_cooked_size != 0 ? s->_cooked_size : s->_raw_size);
1854 break;
1855 }
70256ad8
AJ		 1856 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
1857 }
1858
1859 /* Initialize the contents of the .plt section. */
407443a3
AJ		 1860 splt = bfd_get_section_by_name (dynobj, ".plt");
1861 BFD_ASSERT (splt != NULL);
70256ad8
AJ		 1862 if (splt->_raw_size > 0)
1863 {
653165cc 1864 /* Fill in the first entry in the procedure linkage table. */
407443a3 1865 memcpy (splt->contents, elf64_x86_64_plt0_entry, PLT_ENTRY_SIZE);
653165cc
AJ		 1866 /* Add offset for pushq GOT+8(%rip), since the instruction
1867 uses 6 bytes subtract this value. */
1868 bfd_put_32 (output_bfd,
1869 (sgot->output_section->vma
1870 + sgot->output_offset
1871 + 8
1872 - splt->output_section->vma
1873 - splt->output_offset
1874 - 6),
1875 splt->contents + 2);
1876 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
1877 the end of the instruction. */
1878 bfd_put_32 (output_bfd,
1879 (sgot->output_section->vma
1880 + sgot->output_offset
1881 + 16
1882 - splt->output_section->vma
1883 - splt->output_offset
1884 - 12),
1885 splt->contents + 8);
1886
70256ad8
AJ		 1887 }
1888
1889 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1890 PLT_ENTRY_SIZE;
1891 }
1892
1893 /* Set the first entry in the global offset table to the address of
1894 the dynamic section. */
70256ad8
AJ		 1895 if (sgot->_raw_size > 0)
1896 {
1897 if (sdyn == NULL)
1898 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
1899 else
1900 bfd_put_64 (output_bfd,
1901 sdyn->output_section->vma + sdyn->output_offset,
1902 sgot->contents);
653165cc 1903 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
70256ad8
AJ		 1904 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE);
1905 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE*2);
1906 }
1907
1908 elf_section_data (sgot->output_section)->this_hdr.sh_entsize =
1909 GOT_ENTRY_SIZE;
1910
8d88c4ca
NC		 1911 return true;
1912}
1913
70256ad8
AJ		 1914#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
1915#define TARGET_LITTLE_NAME "elf64-x86-64"
1916#define ELF_ARCH bfd_arch_i386
1917#define ELF_MACHINE_CODE EM_X86_64
1918#define ELF_MAXPAGESIZE 0x100000
1919
1920#define elf_backend_can_gc_sections 1
1921#define elf_backend_want_got_plt 1
1922#define elf_backend_plt_readonly 1
1923#define elf_backend_want_plt_sym 0
1924#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
1925#define elf_backend_plt_header_size PLT_ENTRY_SIZE
1926
1927#define elf_info_to_howto elf64_x86_64_info_to_howto
70256ad8
AJ		 1928
1929#define bfd_elf64_bfd_final_link _bfd_elf64_gc_common_final_link
1930#define bfd_elf64_bfd_link_hash_table_create \
1931 elf64_x86_64_link_hash_table_create
407443a3 1932#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
70256ad8
AJ		 1933
1934#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
1935#define elf_backend_check_relocs elf64_x86_64_check_relocs
1936#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
1937#define elf_backend_finish_dynamic_sections \
1938 elf64_x86_64_finish_dynamic_sections
1939#define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
1940#define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
1941#define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
1942#define elf_backend_relocate_section elf64_x86_64_relocate_section
1943#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
407443a3 1944#define elf_backend_object_p elf64_x86_64_elf_object_p
8d88c4ca
NC		 1945
1946#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.160994 seconds and 4 git commands to generate.