1 /* X86-64 specific support for 64-bit ELF
2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "elf/x86-64.h"
28 /* We use only the RELA entries. */
31 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
32 #define MINUS_ONE (~ (bfd_vma) 0)
34 /* The relocation "howto" table. Order of fields:
35 type, size, bitsize, pc_relative, complain_on_overflow,
36 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
37 static reloc_howto_type x86_64_elf_howto_table
[] =
39 HOWTO(R_X86_64_NONE
, 0, 0, 0, false, 0, complain_overflow_dont
,
40 bfd_elf_generic_reloc
, "R_X86_64_NONE", false, 0x00000000, 0x00000000,
42 HOWTO(R_X86_64_64
, 0, 4, 64, false, 0, complain_overflow_bitfield
,
43 bfd_elf_generic_reloc
, "R_X86_64_64", false, MINUS_ONE
, MINUS_ONE
,
45 HOWTO(R_X86_64_PC32
, 0, 4, 32, true, 0, complain_overflow_signed
,
46 bfd_elf_generic_reloc
, "R_X86_64_PC32", false, 0xffffffff, 0xffffffff,
48 HOWTO(R_X86_64_GOT32
, 0, 4, 32, false, 0, complain_overflow_signed
,
49 bfd_elf_generic_reloc
, "R_X86_64_GOT32", false, 0xffffffff, 0xffffffff,
51 HOWTO(R_X86_64_PLT32
, 0, 4, 32, true, 0, complain_overflow_signed
,
52 bfd_elf_generic_reloc
, "R_X86_64_PLT32", false, 0xffffffff, 0xffffffff,
54 HOWTO(R_X86_64_COPY
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
55 bfd_elf_generic_reloc
, "R_X86_64_COPY", false, 0xffffffff, 0xffffffff,
57 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, false, 0, complain_overflow_bitfield
,
58 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", false, MINUS_ONE
,
60 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, false, 0, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", false, MINUS_ONE
,
63 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, false, 0, complain_overflow_bitfield
,
64 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", false, MINUS_ONE
,
66 HOWTO(R_X86_64_GOTPCREL
, 0, 4, 32, true,0 , complain_overflow_signed
,
67 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", false, 0xffffffff,
69 HOWTO(R_X86_64_32
, 0, 4, 32, false, 0, complain_overflow_unsigned
,
70 bfd_elf_generic_reloc
, "R_X86_64_32", false, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_32S
, 0, 4, 32, false, 0, complain_overflow_signed
,
73 bfd_elf_generic_reloc
, "R_X86_64_32S", false, 0xffffffff, 0xffffffff,
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
,
82 bfd_elf_generic_reloc
, "R_X86_64_PC8", false, 0xff, 0xff, true),
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),
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,
94 /* Map BFD relocs to the x86_64 elf relocs. */
97 bfd_reloc_code_real_type bfd_reloc_val
;
98 unsigned char elf_reloc_val
;
101 static CONST
struct elf_reloc_map x86_64_reloc_map
[] =
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
, },
119 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
120 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
123 static reloc_howto_type
*elf64_x86_64_reloc_type_lookup
124 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
125 static void elf64_x86_64_info_to_howto
126 PARAMS ((bfd
*, arelent
*, Elf64_Internal_Rela
*));
127 static struct bfd_link_hash_table
*elf64_x86_64_link_hash_table_create
130 static struct bfd_hash_entry
*elf64_x86_64_link_hash_newfunc
131 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
132 static boolean elf64_x86_64_adjust_dynamic_symbol
133 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
135 static boolean elf64_x86_64_size_dynamic_sections
136 PARAMS ((bfd
*, struct bfd_link_info
*));
137 static boolean elf64_x86_64_relocate_section
138 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
139 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
140 static boolean elf64_x86_64_finish_dynamic_symbol
141 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
142 Elf_Internal_Sym
*sym
));
143 static boolean elf64_x86_64_finish_dynamic_sections
144 PARAMS ((bfd
*, struct bfd_link_info
*));
146 /* Given a BFD reloc type, return a HOWTO structure. */
147 static reloc_howto_type
*
148 elf64_x86_64_reloc_type_lookup (abfd
, code
)
149 bfd
*abfd ATTRIBUTE_UNUSED
;
150 bfd_reloc_code_real_type code
;
153 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
156 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
157 return &x86_64_elf_howto_table
[(int)
158 x86_64_reloc_map
[i
].elf_reloc_val
];
163 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
166 elf64_x86_64_info_to_howto (abfd
, cache_ptr
, dst
)
167 bfd
*abfd ATTRIBUTE_UNUSED
;
169 Elf64_Internal_Rela
*dst
;
173 r_type
= ELF64_R_TYPE (dst
->r_info
);
174 if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
)
176 BFD_ASSERT (r_type
<= (unsigned int) R_X86_64_PC8
);
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);
184 cache_ptr
->howto
= &x86_64_elf_howto_table
[i
];
185 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
188 /* Functions for the x86-64 ELF linker. */
190 /* The name of the dynamic interpreter. This is put in the .interp
193 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
195 /* The size in bytes of an entry in the global offset table. */
197 #define GOT_ENTRY_SIZE 8
199 /* The size in bytes of an entry in the procedure linkage table. */
201 #define PLT_ENTRY_SIZE 16
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. */
206 static const bfd_byte elf64_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
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. */
213 /* Subsequent entries in a procedure linkage table look like this. */
215 static const bfd_byte elf64_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
217 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
218 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
219 0x68, /* pushq immediate */
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. */
225 /* The x86-64 linker needs to keep track of the number of relocs that
226 it decides to copy in check_relocs for each symbol. This is so
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
229 extending the regular ELF linker hash table. */
231 /* This structure keeps track of the number of PC relative relocs we
232 have copied for a given symbol. */
234 struct elf64_x86_64_pcrel_relocs_copied
237 struct elf64_x86_64_pcrel_relocs_copied
*next
;
238 /* A section in dynobj. */
240 /* Number of relocs copied in this section. */
244 /* x86-64 ELF linker hash entry. */
246 struct elf64_x86_64_link_hash_entry
248 struct elf_link_hash_entry root
;
250 /* Number of PC relative relocs copied for this symbol. */
251 struct elf64_x86_64_pcrel_relocs_copied
*pcrel_relocs_copied
;
254 /* x86-64 ELF linker hash table. */
256 struct elf64_x86_64_link_hash_table
258 struct elf_link_hash_table root
;
261 /* Declare this now that the above structures are defined. */
263 static boolean elf64_x86_64_discard_copies
264 PARAMS ((struct elf64_x86_64_link_hash_entry
*, PTR
));
266 /* Traverse an x86-64 ELF linker hash table. */
268 #define elf64_x86_64_link_hash_traverse(table, func, info) \
269 (elf_link_hash_traverse \
271 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
274 /* Get the x86-64 ELF linker hash table from a link_info structure. */
276 #define elf64_x86_64_hash_table(p) \
277 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
279 /* Create an entry in an x86-64 ELF linker hash table. */
281 static struct bfd_hash_entry
*
282 elf64_x86_64_link_hash_newfunc (entry
, table
, string
)
283 struct bfd_hash_entry
*entry
;
284 struct bfd_hash_table
*table
;
287 struct elf64_x86_64_link_hash_entry
*ret
=
288 (struct elf64_x86_64_link_hash_entry
*) entry
;
290 /* Allocate the structure if it has not already been allocated by a
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
;
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
,
303 if (ret
!= (struct elf64_x86_64_link_hash_entry
*) NULL
)
305 ret
->pcrel_relocs_copied
= NULL
;
308 return (struct bfd_hash_entry
*) ret
;
311 /* Create an X86-64 ELF linker hash table. */
313 static struct bfd_link_hash_table
*
314 elf64_x86_64_link_hash_table_create (abfd
)
317 struct elf64_x86_64_link_hash_table
*ret
;
319 ret
= ((struct elf64_x86_64_link_hash_table
*)
320 bfd_alloc (abfd
, sizeof (struct elf64_x86_64_link_hash_table
)));
321 if (ret
== (struct elf64_x86_64_link_hash_table
*) NULL
)
324 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
325 elf64_x86_64_link_hash_newfunc
))
327 bfd_release (abfd
, ret
);
331 return &ret
->root
.root
;
335 elf64_x86_64_elf_object_p (abfd
)
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
);
343 /* Look through the relocs for a section during the first phase, and
344 allocate space in the global offset table or procedure linkage
348 elf64_x86_64_check_relocs (abfd
, info
, sec
, relocs
)
350 struct bfd_link_info
*info
;
352 const Elf_Internal_Rela
*relocs
;
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
;
364 if (info
->relocateable
)
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
);
372 sgot
= srelgot
= sreloc
= NULL
;
373 rel_end
= relocs
+ sec
->reloc_count
;
374 for (rel
= relocs
; rel
< rel_end
; rel
++)
376 unsigned long r_symndx
;
377 struct elf_link_hash_entry
*h
;
379 r_symndx
= ELF64_R_SYM (rel
->r_info
);
380 if (r_symndx
< symtab_hdr
->sh_info
)
383 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
385 /* Some relocs require a global offset table. */
388 switch (ELF64_R_TYPE (rel
->r_info
))
391 case R_X86_64_GOTPCREL
:
392 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
393 if (! _bfd_elf_create_got_section (dynobj
, info
))
399 switch (ELF64_R_TYPE (rel
->r_info
))
401 case R_X86_64_GOTPCREL
:
403 /* This symbol requires a global offset table entry. */
407 sgot
= bfd_get_section_by_name (dynobj
, ".got");
408 BFD_ASSERT (sgot
!= NULL
);
411 if (srelgot
== NULL
&& (h
!= NULL
|| info
->shared
))
413 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
416 srelgot
= bfd_make_section (dynobj
, ".rela.got");
418 || ! bfd_set_section_flags (dynobj
, srelgot
,
425 || ! bfd_set_section_alignment (dynobj
, srelgot
, 3))
432 if (h
->got
.refcount
== -1)
436 /* Make sure this symbol is output as a dynamic symbol. */
437 if (h
->dynindx
== -1)
439 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
443 sgot
->_raw_size
+= GOT_ENTRY_SIZE
;
444 srelgot
->_raw_size
+= sizeof (Elf64_External_Rela
);
447 h
->got
.refcount
+= 1;
451 /* This is a global offset table entry for a local symbol. */
452 if (local_got_refcounts
== NULL
)
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
)
461 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
462 memset (local_got_refcounts
, -1, size
);
464 if (local_got_refcounts
[r_symndx
] == -1)
466 local_got_refcounts
[r_symndx
] = 1;
468 sgot
->_raw_size
+= GOT_ENTRY_SIZE
;
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
);
478 local_got_refcounts
[r_symndx
] += 1;
483 /* This symbol requires a procedure linkage table entry. We
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
490 /* If this is a local symbol, we resolve it directly without
491 creating a procedure linkage table entry. */
495 if (h
->plt
.refcount
== -1)
498 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
501 h
->plt
.refcount
+= 1;
509 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
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
517 including in the link (i.e., DEF_REGULAR is set). At
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. */
526 && (sec
->flags
& SEC_ALLOC
) != 0
527 && (ELF64_R_TYPE (rel
->r_info
) != R_X86_64_PC32
530 || (h
->elf_link_hash_flags
531 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
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. */
540 name
= (bfd_elf_string_from_elf_section
542 elf_elfheader (abfd
)->e_shstrndx
,
543 elf_section_data (sec
)->rel_hdr
.sh_name
));
547 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
548 && strcmp (bfd_get_section_name (abfd
, sec
),
551 sreloc
= bfd_get_section_by_name (dynobj
, name
);
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
;
562 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
563 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
568 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
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. */
576 if (h
!= NULL
&& ELF64_R_TYPE (rel
->r_info
) == R_X86_64_PC32
)
578 struct elf64_x86_64_link_hash_entry
*eh
;
579 struct elf64_x86_64_pcrel_relocs_copied
*p
;
581 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
583 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
584 if (p
->section
== sreloc
)
589 p
= ((struct elf64_x86_64_pcrel_relocs_copied
*)
590 bfd_alloc (dynobj
, sizeof *p
));
593 p
->next
= eh
->pcrel_relocs_copied
;
594 eh
->pcrel_relocs_copied
= p
;
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
))
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
))
623 /* Return the section that should be marked against GC for a given
627 elf64_x86_64_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
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
;
636 switch (ELF64_R_TYPE (rel
->r_info
))
638 case R_X86_64_GNU_VTINHERIT
:
639 case R_X86_64_GNU_VTENTRY
:
643 switch (h
->root
.type
)
645 case bfd_link_hash_defined
:
646 case bfd_link_hash_defweak
:
647 return h
->root
.u
.def
.section
;
649 case bfd_link_hash_common
:
650 return h
->root
.u
.c
.p
->section
;
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
))
664 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
671 /* Update the got entry reference counts for the section being removed. */
674 elf64_x86_64_gc_sweep_hook (abfd
, info
, sec
, relocs
)
676 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
678 const Elf_Internal_Rela
*relocs
;
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
;
690 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
691 sym_hashes
= elf_sym_hashes (abfd
);
692 local_got_refcounts
= elf_local_got_refcounts (abfd
);
694 dynobj
= elf_hash_table (info
)->dynobj
;
698 sgot
= bfd_get_section_by_name (dynobj
, ".got");
699 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
701 relend
= relocs
+ sec
->reloc_count
;
702 for (rel
= relocs
; rel
< relend
; rel
++)
703 switch (ELF64_R_TYPE (rel
->r_info
))
706 case R_X86_64_GOTPCREL
:
707 r_symndx
= ELF64_R_SYM (rel
->r_info
);
708 if (r_symndx
>= symtab_hdr
->sh_info
)
710 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
711 if (h
->got
.refcount
> 0)
713 h
->got
.refcount
-= 1;
714 if (h
->got
.refcount
== 0)
716 sgot
->_raw_size
-= GOT_ENTRY_SIZE
;
717 srelgot
->_raw_size
-= sizeof (Elf64_External_Rela
);
721 else if (local_got_refcounts
!= NULL
)
723 if (local_got_refcounts
[r_symndx
] > 0)
725 local_got_refcounts
[r_symndx
] -= 1;
726 if (local_got_refcounts
[r_symndx
] == 0)
728 sgot
->_raw_size
-= GOT_ENTRY_SIZE
;
730 srelgot
->_raw_size
-= sizeof (Elf64_External_Rela
);
737 r_symndx
= ELF64_R_SYM (rel
->r_info
);
738 if (r_symndx
>= symtab_hdr
->sh_info
)
740 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
741 if (h
->plt
.refcount
> 0)
742 h
->plt
.refcount
-= 1;
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
760 elf64_x86_64_adjust_dynamic_symbol (info
, h
)
761 struct bfd_link_info
*info
;
762 struct elf_link_hash_entry
*h
;
766 unsigned int power_of_two
;
768 dynobj
= elf_hash_table (info
)->dynobj
;
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)));
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)
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))
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. */
797 h
->plt
.offset
= (bfd_vma
) -1;
798 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
802 /* Make sure this symbol is output as a dynamic symbol. */
803 if (h
->dynindx
== -1)
805 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
809 s
= bfd_get_section_by_name (dynobj
, ".plt");
810 BFD_ASSERT (s
!= NULL
);
812 /* If this is the first .plt entry, make room for the special
814 if (s
->_raw_size
== 0)
815 s
->_raw_size
= PLT_ENTRY_SIZE
;
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
819 location in the .plt. This is required to make function
820 pointers compare as equal between the normal executable and
821 the shared library. */
823 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
825 h
->root
.u
.def
.section
= s
;
826 h
->root
.u
.def
.value
= s
->_raw_size
;
829 h
->plt
.offset
= s
->_raw_size
;
831 /* Make room for this entry. */
832 s
->_raw_size
+= PLT_ENTRY_SIZE
;
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
;
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
);
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
850 real definition first, and we can just use the same value. */
851 if (h
->weakdef
!= NULL
)
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
;
860 /* This is a reference to a symbol defined by a dynamic object which
861 is not a function. */
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
866 be handled correctly by relocate_section. */
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)
875 /* We must allocate the symbol in our .dynbss section, which will
876 become part of the .bss section of the executable. There will be
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. */
885 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
886 BFD_ASSERT (s
!= NULL
);
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)
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
;
902 /* We need to figure out the alignment required for this symbol. I
903 have no idea how ELF linkers handle this. 16-bytes is the size
904 of the largest type that requires hard alignment -- long double. */
905 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
907 power_of_two
= bfd_log2 (h
->size
);
908 if (power_of_two
> 4)
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
))
915 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
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
;
923 /* Increment the section size to make room for the symbol. */
924 s
->_raw_size
+= h
->size
;
929 /* Set the sizes of the dynamic sections. */
932 elf64_x86_64_size_dynamic_sections (output_bfd
, info
)
934 struct bfd_link_info
*info
;
942 dynobj
= elf_hash_table (info
)->dynobj
;
943 BFD_ASSERT (dynobj
!= NULL
);
945 if (elf_hash_table (info
)->dynamic_sections_created
)
947 /* Set the contents of the .interp section to the interpreter. */
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
;
958 /* We may have created entries in the .rela.got section.
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
963 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
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. */
973 elf64_x86_64_link_hash_traverse (elf64_x86_64_hash_table (info
),
974 elf64_x86_64_discard_copies
,
977 /* The check_relocs and adjust_dynamic_symbol entry points have
978 determined the sizes of the various dynamic sections. Allocate
980 plt
= relocs
= reltext
= false;
981 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
986 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
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
);
994 if (strcmp (name
, ".plt") == 0)
996 if (s
->_raw_size
== 0)
998 /* Strip this section if we don't need it; see the
1004 /* Remember whether there is a PLT. */
1008 else if (strncmp (name
, ".rela", 5) == 0)
1010 if (s
->_raw_size
== 0)
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. */
1027 /* Remember whether there are any reloc sections other
1029 if (strcmp (name
, ".rela.plt") != 0)
1031 const char *outname
;
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
,
1042 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
1044 && (target
->flags
& SEC_READONLY
) != 0
1045 && (target
->flags
& SEC_ALLOC
) != 0)
1049 /* We use the reloc_count field as a counter if we need
1050 to copy relocs into the output file. */
1054 else if (strncmp (name
, ".got", 4) != 0)
1056 /* It's not one of our sections, so don't allocate space. */
1062 _bfd_strip_section_from_output (info
, s
);
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
1071 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1072 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1076 if (elf_hash_table (info
)->dynamic_sections_created
)
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
1081 the .dynamic section. The DT_DEBUG entry is filled in by the
1082 dynamic linker and used by the debugger. */
1085 if (! bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0))
1091 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1092 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1093 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
1094 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
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
)))
1109 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1111 info
->flags
|= DF_TEXTREL
;
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. */
1128 elf64_x86_64_discard_copies (h
, inf
)
1129 struct elf64_x86_64_link_hash_entry
*h
;
1132 struct elf64_x86_64_pcrel_relocs_copied
*s
;
1133 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
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
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
1142 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1143 s
->section
->_raw_size
-= s
->count
* sizeof (Elf64_External_Rela
);
1149 /* Relocate an x86_64 ELF section. */
1152 elf64_x86_64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1153 contents
, relocs
, local_syms
, local_sections
)
1155 struct bfd_link_info
*info
;
1157 asection
*input_section
;
1159 Elf_Internal_Rela
*relocs
;
1160 Elf_Internal_Sym
*local_syms
;
1161 asection
**local_sections
;
1164 Elf_Internal_Shdr
*symtab_hdr
;
1165 struct elf_link_hash_entry
**sym_hashes
;
1166 bfd_vma
*local_got_offsets
;
1170 Elf_Internal_Rela
*rela
;
1171 Elf_Internal_Rela
*relend
;
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
);
1178 sreloc
= splt
= sgot
= NULL
;
1181 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1182 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1186 relend
= relocs
+ input_section
->reloc_count
;
1187 for (; rela
< relend
; rela
++)
1190 reloc_howto_type
*howto
;
1191 unsigned long r_symndx
;
1192 struct elf_link_hash_entry
*h
;
1193 Elf_Internal_Sym
*sym
;
1196 bfd_reloc_status_type r
;
1199 r_type
= ELF64_R_TYPE (rela
->r_info
);
1200 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
1201 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
1204 if ((indx
= (unsigned) r_type
) >= R_X86_64_max
)
1206 bfd_set_error (bfd_error_bad_value
);
1209 howto
= x86_64_elf_howto_table
+ indx
;
1211 r_symndx
= ELF64_R_SYM (rela
->r_info
);
1213 if (info
->relocateable
)
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
)
1221 sym
= local_syms
+ r_symndx
;
1222 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1224 sec
= local_sections
[r_symndx
];
1225 rela
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1232 /* This is a final link. */
1236 if (r_symndx
< symtab_hdr
->sh_info
)
1238 sym
= local_syms
+ r_symndx
;
1239 sec
= local_sections
[r_symndx
];
1240 relocation
= (sec
->output_section
->vma
1241 + sec
->output_offset
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
)
1253 sec
= h
->root
.u
.def
.section
;
1254 if ((r_type
== R_X86_64_PLT32
1256 && h
->plt
.offset
!= (bfd_vma
) -1)
1257 || ((r_type
== R_X86_64_GOT32
|| r_type
== R_X86_64_GOTPCREL
)
1258 && elf_hash_table (info
)->dynamic_sections_created
1260 || (! info
->symbolic
&& h
->dynindx
!= -1)
1261 || (h
->elf_link_hash_flags
1262 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1264 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1265 || (h
->elf_link_hash_flags
1266 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1267 && (r_type
== R_X86_64_8
1268 || r_type
== R_X86_64_16
1269 || r_type
== R_X86_64_32
1270 || r_type
== R_X86_64_64
1271 || r_type
== R_X86_64_PC8
1272 || r_type
== R_X86_64_PC16
1273 || r_type
== R_X86_64_PC32
)
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
1279 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1280 && (h
->elf_link_hash_flags
1281 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
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. */
1288 else if (sec
->output_section
== NULL
)
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
));
1297 relocation
= (h
->root
.u
.def
.value
1298 + sec
->output_section
->vma
1299 + sec
->output_offset
);
1301 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1303 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
1304 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1308 if (! ((*info
->callbacks
->undefined_symbol
)
1309 (info
, h
->root
.root
.string
, input_bfd
,
1310 input_section
, rela
->r_offset
,
1311 (!info
->shared
|| info
->no_undefined
1312 || ELF_ST_VISIBILITY (h
->other
)))))
1318 /* When generating a shared object, the relocations handled here are
1319 copied into the output file to be resolved at run time. */
1322 case R_X86_64_GOT32
:
1323 /* Relocation is to the entry for this symbol in the global
1325 case R_X86_64_GOTPCREL
:
1326 /* Use global offset table as symbol value. */
1327 BFD_ASSERT (sgot
!= NULL
);
1331 bfd_vma off
= h
->got
.offset
;
1332 BFD_ASSERT (off
!= (bfd_vma
) -1);
1334 if (! elf_hash_table (info
)->dynamic_sections_created
1336 && (info
->symbolic
|| h
->dynindx
== -1)
1337 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1339 /* This is actually a static link, or it is a -Bsymbolic
1340 link and the symbol is defined locally, or the symbol
1341 was forced to be local because of a version file. We
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.
1347 When doing a dynamic link, we create a .rela.got
1348 relocation entry to initialize the value. This is
1349 done in the finish_dynamic_symbol routine. */
1354 bfd_put_64 (output_bfd
, relocation
,
1355 sgot
->contents
+ off
);
1359 if (r_type
== R_X86_64_GOTPCREL
)
1360 relocation
= sgot
->output_section
->vma
+ sgot
->output_offset
+ off
;
1362 relocation
= sgot
->output_offset
+ off
;
1368 BFD_ASSERT (local_got_offsets
!= NULL
1369 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1371 off
= local_got_offsets
[r_symndx
];
1373 /* The offset must always be a multiple of 8. We use
1374 the least significant bit to record whether we have
1375 already generated the necessary reloc. */
1380 bfd_put_64 (output_bfd
, relocation
, sgot
->contents
+ off
);
1385 Elf_Internal_Rela outrel
;
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
);
1392 outrel
.r_offset
= (sgot
->output_section
->vma
1393 + sgot
->output_offset
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
*)
1400 + srelgot
->reloc_count
));
1401 ++srelgot
->reloc_count
;
1404 local_got_offsets
[r_symndx
] |= 1;
1407 if (r_type
== R_X86_64_GOTPCREL
)
1408 relocation
= sgot
->output_section
->vma
+ sgot
->output_offset
+ off
;
1410 relocation
= sgot
->output_offset
+ off
;
1415 case R_X86_64_PLT32
:
1416 /* Relocation is to the entry for this symbol in the
1417 procedure linkage table. */
1419 /* Resolve a PLT32 reloc against a local symbol directly,
1420 without using the procedure linkage table. */
1424 if (h
->plt
.offset
== (bfd_vma
) -1 || splt
== NULL
)
1426 /* We didn't make a PLT entry for this symbol. This
1427 happens when statically linking PIC code, or when
1428 using -Bsymbolic. */
1432 relocation
= (splt
->output_section
->vma
1433 + splt
->output_offset
1444 /* FIXME: The ABI says the linker should make sure the value is
1445 the same when it's zeroextended to 64 bit. */
1447 && (input_section
->flags
& SEC_ALLOC
) != 0
1448 && ((r_type
!= R_X86_64_PC8
1449 && r_type
!= R_X86_64_PC16
1450 && r_type
!= R_X86_64_PC32
)
1453 && (! info
->symbolic
1454 || (h
->elf_link_hash_flags
1455 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1457 Elf_Internal_Rela outrel
;
1458 boolean skip
, relocate
;
1460 /* When generating a shared object, these relocations
1461 are copied into the output file to be resolved at run
1468 name
= (bfd_elf_string_from_elf_section
1470 elf_elfheader (input_bfd
)->e_shstrndx
,
1471 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1475 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1476 && strcmp (bfd_get_section_name (input_bfd
,
1480 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1481 BFD_ASSERT (sreloc
!= NULL
);
1486 if (elf_section_data (input_section
)->stab_info
== NULL
)
1487 outrel
.r_offset
= rela
->r_offset
;
1492 off
= (_bfd_stab_section_offset
1493 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1495 &elf_section_data (input_section
)->stab_info
,
1497 if (off
== (bfd_vma
) -1)
1499 outrel
.r_offset
= off
;
1502 outrel
.r_offset
+= (input_section
->output_section
->vma
1503 + input_section
->output_offset
);
1507 memset (&outrel
, 0, sizeof outrel
);
1510 else if ((r_type
== R_X86_64_PC8
)
1511 || (r_type
== R_X86_64_PC16
)
1512 || (r_type
== R_X86_64_PC32
))
1514 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1516 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
1517 outrel
.r_addend
= relocation
+ rela
->r_addend
;
1521 /* h->dynindx may be -1 if this symbol was marked to
1524 || ((info
->symbolic
|| h
->dynindx
== -1)
1525 && (h
->elf_link_hash_flags
1526 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1529 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
1530 outrel
.r_addend
= relocation
+ rela
->r_addend
;
1534 BFD_ASSERT (h
->dynindx
!= -1);
1536 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_32
);
1537 outrel
.r_addend
= relocation
+ rela
->r_addend
;
1541 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
1542 (((Elf64_External_Rela
*)
1544 + sreloc
->reloc_count
));
1545 ++sreloc
->reloc_count
;
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. */
1561 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1562 contents
, rela
->r_offset
,
1563 relocation
, rela
->r_addend
);
1565 if (r
!= bfd_reloc_ok
)
1570 case bfd_reloc_outofrange
:
1572 case bfd_reloc_overflow
:
1577 name
= h
->root
.root
.string
;
1580 name
= bfd_elf_string_from_elf_section (input_bfd
,
1581 symtab_hdr
->sh_link
,
1586 name
= bfd_section_name (input_bfd
, sec
);
1588 if (! ((*info
->callbacks
->reloc_overflow
)
1589 (info
, name
, howto
->name
, (bfd_vma
) 0,
1590 input_bfd
, input_section
, rela
->r_offset
)))
1601 /* Finish up dynamic symbol handling. We set the contents of various
1602 dynamic sections here. */
1605 elf64_x86_64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1607 struct bfd_link_info
*info
;
1608 struct elf_link_hash_entry
*h
;
1609 Elf_Internal_Sym
*sym
;
1613 dynobj
= elf_hash_table (info
)->dynobj
;
1615 if (h
->plt
.offset
!= (bfd_vma
) -1)
1622 Elf_Internal_Rela rela
;
1624 /* This symbol has an entry in the procedure linkage table. Set
1627 BFD_ASSERT (h
->dynindx
!= -1);
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
);
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;
1640 /* Get the offset into the .got table of the entry that
1641 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
1642 bytes. The first three are reserved for the dynamic linker. */
1643 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
1645 /* Fill in the entry in the procedure linkage table. */
1646 memcpy (splt
->contents
+ h
->plt
.offset
, elf64_x86_64_plt_entry
,
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. */
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
1658 - splt
->output_section
->vma
1659 - splt
->output_offset
1662 splt
->contents
+ h
->plt
.offset
+ 2);
1663 /* Put relocation index. */
1664 bfd_put_32 (output_bfd
, plt_index
,
1665 splt
->contents
+ h
->plt
.offset
+ 7);
1666 /* Put offset for jmp .PLT0. */
1667 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1668 splt
->contents
+ h
->plt
.offset
+ 12);
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. */
1672 bfd_put_64 (output_bfd
, (splt
->output_section
->vma
+ splt
->output_offset
1673 + h
->plt
.offset
+ 6),
1674 sgot
->contents
+ got_offset
);
1676 /* Fill in the entry in the .rela.plt section. */
1677 rela
.r_offset
= (sgot
->output_section
->vma
1678 + sgot
->output_offset
1680 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_JUMP_SLOT
);
1682 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
1683 ((Elf64_External_Rela
*) srela
->contents
1686 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1688 /* Mark the symbol as undefined, rather than as defined in
1689 the .plt section. Leave the value alone. */
1690 sym
->st_shndx
= SHN_UNDEF
;
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
)
1701 if (h
->got
.offset
!= (bfd_vma
) -1)
1705 Elf_Internal_Rela rela
;
1707 /* This symbol has an entry in the global offset table. Set it
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
);
1714 rela
.r_offset
= (sgot
->output_section
->vma
1715 + sgot
->output_offset
1716 + (h
->got
.offset
&~ 1));
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
1725 && (info
->symbolic
|| h
->dynindx
== -1)
1726 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
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
);
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
);
1741 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
1742 ((Elf64_External_Rela
*) srela
->contents
1743 + srela
->reloc_count
));
1744 ++srela
->reloc_count
;
1747 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1750 Elf_Internal_Rela rela
;
1752 /* This symbol needs a copy reloc. Set it up. */
1754 BFD_ASSERT (h
->dynindx
!= -1
1755 && (h
->root
.type
== bfd_link_hash_defined
1756 || h
->root
.type
== bfd_link_hash_defweak
));
1758 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1760 BFD_ASSERT (s
!= NULL
);
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
);
1767 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
1768 ((Elf64_External_Rela
*) s
->contents
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
;
1781 /* Finish up the dynamic sections. */
1784 elf64_x86_64_finish_dynamic_sections (output_bfd
, info
)
1786 struct bfd_link_info
*info
;
1792 dynobj
= elf_hash_table (info
)->dynobj
;
1794 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1795 BFD_ASSERT (sgot
!= NULL
);
1796 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1798 if (elf_hash_table (info
)->dynamic_sections_created
)
1801 Elf64_External_Dyn
*dyncon
, *dynconend
;
1803 BFD_ASSERT (sdyn
!= NULL
);
1805 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
1806 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1807 for (; dyncon
< dynconend
; dyncon
++)
1809 Elf_Internal_Dyn dyn
;
1813 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1828 s
= bfd_get_section_by_name (output_bfd
, name
);
1829 BFD_ASSERT (s
!= NULL
);
1830 dyn
.d_un
.d_ptr
= s
->vma
;
1834 /* FIXME: This comment and code is from elf64-alpha.c: */
1835 /* My interpretation of the TIS v1.1 ELF document indicates
1836 that RELASZ should not include JMPREL. This is not what
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");
1843 /* Subtract JMPREL size from RELASZ. */
1845 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
1850 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
1851 BFD_ASSERT (s
!= NULL
);
1853 (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
);
1856 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1859 /* Initialize the contents of the .plt section. */
1860 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1861 BFD_ASSERT (splt
!= NULL
);
1862 if (splt
->_raw_size
> 0)
1864 /* Fill in the first entry in the procedure linkage table. */
1865 memcpy (splt
->contents
, elf64_x86_64_plt0_entry
, PLT_ENTRY_SIZE
);
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
1872 - splt
->output_section
->vma
1873 - splt
->output_offset
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
1882 - splt
->output_section
->vma
1883 - splt
->output_offset
1885 splt
->contents
+ 8);
1889 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1893 /* Set the first entry in the global offset table to the address of
1894 the dynamic section. */
1895 if (sgot
->_raw_size
> 0)
1898 bfd_put_64 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1900 bfd_put_64 (output_bfd
,
1901 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1903 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
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);
1908 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
=
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
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
1927 #define elf_info_to_howto elf64_x86_64_info_to_howto
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
1932 #define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
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
1944 #define elf_backend_object_p elf64_x86_64_elf_object_p
1946 #include "elf64-target.h"