X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felf64-x86-64.c;h=f214fa1420d64d15b18b2a5f2e60b1b5b70cb9e5;hb=8aaaf7577f070c91086533d959ac36a15d1d604f;hp=10da82051800d8f92172b264c61aef43b5e6e60b;hpb=7a382c1c50fca0d4bc4c2e618ff6ac222c4e2137;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf64-x86-64.c b/bfd/elf64-x86-64.c index 10da820518..f214fa1420 100644 --- a/bfd/elf64-x86-64.c +++ b/bfd/elf64-x86-64.c @@ -1,5 +1,5 @@ /* X86-64 specific support for ELF - Copyright (C) 2000-2017 Free Software Foundation, Inc. + Copyright (C) 2000-2019 Free Software Foundation, Inc. Contributed by Jan Hubicka . This file is part of BFD, the Binary File Descriptor library. @@ -199,13 +199,16 @@ static reloc_howto_type x86_64_elf_howto_table[] = /* Set if a relocation is converted from a GOTPCREL relocation. */ #define R_X86_64_converted_reloc_bit (1 << 7) -#define IS_X86_64_PCREL_TYPE(TYPE) \ +#define X86_PCREL_TYPE_P(TYPE) \ ( ((TYPE) == R_X86_64_PC8) \ || ((TYPE) == R_X86_64_PC16) \ || ((TYPE) == R_X86_64_PC32) \ || ((TYPE) == R_X86_64_PC32_BND) \ || ((TYPE) == R_X86_64_PC64)) +#define X86_SIZE_TYPE_P(TYPE) \ + ((TYPE) == R_X86_64_SIZE32 || (TYPE) == R_X86_64_SIZE64) + /* Map BFD relocs to the x86_64 elf relocs. */ struct elf_reloc_map { @@ -279,9 +282,10 @@ elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type) if (r_type >= (unsigned int) R_X86_64_standard) { /* xgettext:c-format */ - _bfd_error_handler (_("%B: invalid relocation type %d"), - abfd, (int) r_type); - r_type = R_X86_64_NONE; + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + abfd, r_type); + bfd_set_error (bfd_error_bad_value); + return NULL; } i = r_type; } @@ -333,18 +337,18 @@ elf_x86_64_reloc_name_lookup (bfd *abfd, /* Given an x86_64 ELF reloc type, fill in an arelent structure. */ -static void -elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, +static bfd_boolean +elf_x86_64_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst) { unsigned r_type; r_type = ELF32_R_TYPE (dst->r_info); - if (r_type != (unsigned int) R_X86_64_GNU_VTINHERIT - && r_type != (unsigned int) R_X86_64_GNU_VTENTRY) - r_type &= ~R_X86_64_converted_reloc_bit; cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type); - BFD_ASSERT (r_type == cache_ptr->howto->type); + if (cache_ptr->howto == NULL) + return FALSE; + BFD_ASSERT (r_type == cache_ptr->howto->type || cache_ptr->howto->type == R_X86_64_NONE); + return TRUE; } /* Support for core dump NOTE sections. */ @@ -435,6 +439,10 @@ elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) } #ifdef CORE_HEADER +# if GCC_VERSION >= 8000 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wstringop-truncation" +# endif static char * elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...) @@ -520,6 +528,9 @@ elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, } /* NOTREACHED */ } +# if GCC_VERSION >= 8000 +# pragma GCC diagnostic pop +# endif #endif /* Functions for the x86-64 ELF linker. */ @@ -565,9 +576,9 @@ static const bfd_byte elf_x86_64_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry[LAZY_PLT_ENTRY_SIZE] = { - 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ + 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */ - 0x0f, 0x1f, 0 /* nopl (%rax) */ + 0x0f, 0x1f, 0 /* nopl (%rax) */ }; /* Subsequent entries for branches with BND prefx in a lazy procedure @@ -575,9 +586,9 @@ static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x86_64_lazy_bnd_plt_entry[LAZY_PLT_ENTRY_SIZE] = { - 0x68, 0, 0, 0, 0, /* pushq immediate */ - 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */ - 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */ + 0x68, 0, 0, 0, 0, /* pushq immediate */ + 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */ + 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */ }; /* The first entry in the IBT-enabled lazy procedure linkage table is the @@ -588,10 +599,10 @@ static const bfd_byte elf_x86_64_lazy_bnd_plt_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x86_64_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = { - 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ - 0x68, 0, 0, 0, 0, /* pushq immediate */ - 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */ - 0x90 /* nop */ + 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ + 0x68, 0, 0, 0, 0, /* pushq immediate */ + 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */ + 0x90 /* nop */ }; /* The first entry in the x32 IBT-enabled lazy procedure linkage table @@ -600,19 +611,19 @@ static const bfd_byte elf_x86_64_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x32_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = { - 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ - 0x68, 0, 0, 0, 0, /* pushq immediate */ - 0xe9, 0, 0, 0, 0, /* jmpq relative */ - 0x66, 0x90 /* xchg %ax,%ax */ + 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ + 0x68, 0, 0, 0, 0, /* pushq immediate */ + 0xe9, 0, 0, 0, 0, /* jmpq relative */ + 0x66, 0x90 /* xchg %ax,%ax */ }; /* Entries in the non-lazey procedure linkage table look like this. */ static const bfd_byte elf_x86_64_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] = { - 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ - 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ - 0x66, 0x90 /* xchg %ax,%ax */ + 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ + 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ + 0x66, 0x90 /* xchg %ax,%ax */ }; /* Entries for branches with BND prefix in the non-lazey procedure @@ -620,9 +631,9 @@ static const bfd_byte elf_x86_64_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] = { - 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */ - 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ - 0x90 /* nop */ + 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */ + 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ + 0x90 /* nop */ }; /* Entries for branches with IBT-enabled in the non-lazey procedure @@ -631,10 +642,10 @@ static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = { - 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ - 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */ + 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ + 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */ 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ - 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */ + 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */ }; /* Entries for branches with IBT-enabled in the x32 non-lazey procedure @@ -643,12 +654,20 @@ static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x32_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = { - 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ - 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ + 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ + 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */ }; +/* The TLSDESC entry in a lazy procedure linkage table. */ +static const bfd_byte elf_x86_64_tlsdesc_plt_entry[LAZY_PLT_ENTRY_SIZE] = +{ + 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */ + 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ + 0xff, 0x25, 16, 0, 0, 0 /* jmpq *GOT+TDG(%rip) */ +}; + /* .eh_frame covering the lazy .plt section. */ static const bfd_byte elf_x86_64_eh_frame_lazy_plt[] = @@ -816,156 +835,162 @@ static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt[] = DW_CFA_nop, DW_CFA_nop, DW_CFA_nop }; -/* Architecture-specific backend data for x86-64. */ - -struct elf_x86_64_backend_data -{ - /* Target system. */ - enum - { - is_normal, - is_nacl - } os; -}; - -#define get_elf_x86_64_arch_data(bed) \ - ((const struct elf_x86_64_backend_data *) (bed)->arch_data) - -#define get_elf_x86_64_backend_data(abfd) \ - get_elf_x86_64_arch_data (get_elf_backend_data (abfd)) - /* These are the standard parameters. */ static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_plt = { - elf_x86_64_lazy_plt0_entry, /* plt0_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ - elf_x86_64_lazy_plt_entry, /* plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt0_got1_offset */ - 8, /* plt0_got2_offset */ - 12, /* plt0_got2_insn_end */ - 2, /* plt_got_offset */ - 7, /* plt_reloc_offset */ - 12, /* plt_plt_offset */ - 6, /* plt_got_insn_size */ - LAZY_PLT_ENTRY_SIZE, /* plt_plt_insn_end */ - 6, /* plt_lazy_offset */ - elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */ - elf_x86_64_lazy_plt_entry, /* pic_plt_entry */ - elf_x86_64_eh_frame_lazy_plt, /* eh_frame_plt */ + elf_x86_64_lazy_plt0_entry, /* plt0_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ + elf_x86_64_lazy_plt_entry, /* plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + elf_x86_64_tlsdesc_plt_entry, /* plt_tlsdesc_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_tlsdesc_entry_size */ + 6, /* plt_tlsdesc_got1_offset */ + 12, /* plt_tlsdesc_got2_offset */ + 10, /* plt_tlsdesc_got1_insn_end */ + 16, /* plt_tlsdesc_got2_insn_end */ + 2, /* plt0_got1_offset */ + 8, /* plt0_got2_offset */ + 12, /* plt0_got2_insn_end */ + 2, /* plt_got_offset */ + 7, /* plt_reloc_offset */ + 12, /* plt_plt_offset */ + 6, /* plt_got_insn_size */ + LAZY_PLT_ENTRY_SIZE, /* plt_plt_insn_end */ + 6, /* plt_lazy_offset */ + elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */ + elf_x86_64_lazy_plt_entry, /* pic_plt_entry */ + elf_x86_64_eh_frame_lazy_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_lazy_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_plt = { - elf_x86_64_non_lazy_plt_entry, /* plt_entry */ - elf_x86_64_non_lazy_plt_entry, /* pic_plt_entry */ - NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt_got_offset */ - 6, /* plt_got_insn_size */ - elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ + elf_x86_64_non_lazy_plt_entry, /* plt_entry */ + elf_x86_64_non_lazy_plt_entry, /* pic_plt_entry */ + NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + 2, /* plt_got_offset */ + 6, /* plt_got_insn_size */ + elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_bnd_plt = { - elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ - elf_x86_64_lazy_bnd_plt_entry, /* plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt0_got1_offset */ - 1+8, /* plt0_got2_offset */ - 1+12, /* plt0_got2_insn_end */ - 1+2, /* plt_got_offset */ - 1, /* plt_reloc_offset */ - 7, /* plt_plt_offset */ - 1+6, /* plt_got_insn_size */ - 11, /* plt_plt_insn_end */ - 0, /* plt_lazy_offset */ - elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */ - elf_x86_64_lazy_bnd_plt_entry, /* pic_plt_entry */ - elf_x86_64_eh_frame_lazy_bnd_plt, /* eh_frame_plt */ + elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ + elf_x86_64_lazy_bnd_plt_entry, /* plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + elf_x86_64_tlsdesc_plt_entry, /* plt_tlsdesc_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_tlsdesc_entry_size */ + 6, /* plt_tlsdesc_got1_offset */ + 12, /* plt_tlsdesc_got2_offset */ + 10, /* plt_tlsdesc_got1_insn_end */ + 16, /* plt_tlsdesc_got2_insn_end */ + 2, /* plt0_got1_offset */ + 1+8, /* plt0_got2_offset */ + 1+12, /* plt0_got2_insn_end */ + 1+2, /* plt_got_offset */ + 1, /* plt_reloc_offset */ + 7, /* plt_plt_offset */ + 1+6, /* plt_got_insn_size */ + 11, /* plt_plt_insn_end */ + 0, /* plt_lazy_offset */ + elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */ + elf_x86_64_lazy_bnd_plt_entry, /* pic_plt_entry */ + elf_x86_64_eh_frame_lazy_bnd_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_lazy_bnd_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt = { - elf_x86_64_non_lazy_bnd_plt_entry, /* plt_entry */ - elf_x86_64_non_lazy_bnd_plt_entry, /* pic_plt_entry */ - NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 1+2, /* plt_got_offset */ - 1+6, /* plt_got_insn_size */ - elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ + elf_x86_64_non_lazy_bnd_plt_entry, /* plt_entry */ + elf_x86_64_non_lazy_bnd_plt_entry, /* pic_plt_entry */ + NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + 1+2, /* plt_got_offset */ + 1+6, /* plt_got_insn_size */ + elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_ibt_plt = { - elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ - elf_x86_64_lazy_ibt_plt_entry, /* plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt0_got1_offset */ - 1+8, /* plt0_got2_offset */ - 1+12, /* plt0_got2_insn_end */ - 4+1+2, /* plt_got_offset */ - 4+1, /* plt_reloc_offset */ - 4+1+6, /* plt_plt_offset */ - 4+1+6, /* plt_got_insn_size */ - 4+1+5+5, /* plt_plt_insn_end */ - 0, /* plt_lazy_offset */ - elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */ - elf_x86_64_lazy_ibt_plt_entry, /* pic_plt_entry */ - elf_x86_64_eh_frame_lazy_ibt_plt, /* eh_frame_plt */ + elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ + elf_x86_64_lazy_ibt_plt_entry, /* plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + elf_x86_64_tlsdesc_plt_entry, /* plt_tlsdesc_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_tlsdesc_entry_size */ + 6, /* plt_tlsdesc_got1_offset */ + 12, /* plt_tlsdesc_got2_offset */ + 10, /* plt_tlsdesc_got1_insn_end */ + 16, /* plt_tlsdesc_got2_insn_end */ + 2, /* plt0_got1_offset */ + 1+8, /* plt0_got2_offset */ + 1+12, /* plt0_got2_insn_end */ + 4+1+2, /* plt_got_offset */ + 4+1, /* plt_reloc_offset */ + 4+1+6, /* plt_plt_offset */ + 4+1+6, /* plt_got_insn_size */ + 4+1+5+5, /* plt_plt_insn_end */ + 0, /* plt_lazy_offset */ + elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */ + elf_x86_64_lazy_ibt_plt_entry, /* pic_plt_entry */ + elf_x86_64_eh_frame_lazy_ibt_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_lazy_plt_layout elf_x32_lazy_ibt_plt = { - elf_x86_64_lazy_plt0_entry, /* plt0_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ - elf_x32_lazy_ibt_plt_entry, /* plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt0_got1_offset */ - 8, /* plt0_got2_offset */ - 12, /* plt0_got2_insn_end */ - 4+2, /* plt_got_offset */ - 4+1, /* plt_reloc_offset */ - 4+6, /* plt_plt_offset */ - 4+6, /* plt_got_insn_size */ - 4+5+5, /* plt_plt_insn_end */ - 0, /* plt_lazy_offset */ - elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */ - elf_x32_lazy_ibt_plt_entry, /* pic_plt_entry */ - elf_x32_eh_frame_lazy_ibt_plt, /* eh_frame_plt */ + elf_x86_64_lazy_plt0_entry, /* plt0_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */ + elf_x32_lazy_ibt_plt_entry, /* plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + elf_x86_64_tlsdesc_plt_entry, /* plt_tlsdesc_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_tlsdesc_entry_size */ + 6, /* plt_tlsdesc_got1_offset */ + 12, /* plt_tlsdesc_got2_offset */ + 10, /* plt_tlsdesc_got1_insn_end */ + 16, /* plt_tlsdesc_got2_insn_end */ + 2, /* plt0_got1_offset */ + 8, /* plt0_got2_offset */ + 12, /* plt0_got2_insn_end */ + 4+2, /* plt_got_offset */ + 4+1, /* plt_reloc_offset */ + 4+6, /* plt_plt_offset */ + 4+6, /* plt_got_insn_size */ + 4+5+5, /* plt_plt_insn_end */ + 0, /* plt_lazy_offset */ + elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */ + elf_x32_lazy_ibt_plt_entry, /* pic_plt_entry */ + elf_x32_eh_frame_lazy_ibt_plt, /* eh_frame_plt */ sizeof (elf_x32_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt = { - elf_x86_64_non_lazy_ibt_plt_entry, /* plt_entry */ - elf_x86_64_non_lazy_ibt_plt_entry, /* pic_plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 4+1+2, /* plt_got_offset */ - 4+1+6, /* plt_got_insn_size */ - elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ + elf_x86_64_non_lazy_ibt_plt_entry, /* plt_entry */ + elf_x86_64_non_lazy_ibt_plt_entry, /* pic_plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + 4+1+2, /* plt_got_offset */ + 4+1+6, /* plt_got_insn_size */ + elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */ }; static const struct elf_x86_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt = { - elf_x32_non_lazy_ibt_plt_entry, /* plt_entry */ - elf_x32_non_lazy_ibt_plt_entry, /* pic_plt_entry */ - LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ - 4+2, /* plt_got_offset */ - 4+6, /* plt_got_insn_size */ - elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ + elf_x32_non_lazy_ibt_plt_entry, /* plt_entry */ + elf_x32_non_lazy_ibt_plt_entry, /* pic_plt_entry */ + LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */ + 4+2, /* plt_got_offset */ + 4+6, /* plt_got_insn_size */ + elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */ sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */ }; -static const struct elf_x86_64_backend_data elf_x86_64_arch_bed = +static const struct elf_x86_backend_data elf_x86_64_arch_bed = { - is_normal /* os */ + is_normal /* os */ }; #define elf_backend_arch_data &elf_x86_64_arch_bed @@ -1040,15 +1065,15 @@ elf_x86_64_check_tls_transition (bfd *abfd, addr32 call __tls_get_addr can transit to different access model. For largepic, we also support: - leaq foo@tlsgd(%rip), %rdi - movabsq $__tls_get_addr@pltoff, %rax - addq $r15, %rax - call *%rax + leaq foo@tlsgd(%rip), %rdi + movabsq $__tls_get_addr@pltoff, %rax + addq $r15, %rax + call *%rax or - leaq foo@tlsgd(%rip), %rdi - movabsq $__tls_get_addr@pltoff, %rax - addq $rbx, %rax - call *%rax */ + leaq foo@tlsgd(%rip), %rdi + movabsq $__tls_get_addr@pltoff, %rax + addq $rbx, %rax + call *%rax */ static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d }; @@ -1099,22 +1124,22 @@ elf_x86_64_check_tls_transition (bfd *abfd, /* Check transition from LD access model. Only leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@PLT - or + or leaq foo@tlsld(%rip), %rdi; call *__tls_get_addr@GOTPCREL(%rip) which may be converted to addr32 call __tls_get_addr can transit to different access model. For largepic we also support: - leaq foo@tlsld(%rip), %rdi - movabsq $__tls_get_addr@pltoff, %rax - addq $r15, %rax - call *%rax + leaq foo@tlsld(%rip), %rdi + movabsq $__tls_get_addr@pltoff, %rax + addq $r15, %rax + call *%rax or - leaq foo@tlsld(%rip), %rdi - movabsq $__tls_get_addr@pltoff, %rax - addq $rbx, %rax - call *%rax */ + leaq foo@tlsld(%rip), %rdi + movabsq $__tls_get_addr@pltoff, %rax + addq $rbx, %rax + call *%rax */ static const unsigned char lea[] = { 0x48, 0x8d, 0x3d }; @@ -1280,10 +1305,7 @@ elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, { unsigned int new_to_type = to_type; - if (bfd_link_executable (info) - && h != NULL - && h->dynindx == -1 - && tls_type == GOT_TLS_IE) + if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type)) new_to_type = R_X86_64_TPOFF32; if (to_type == R_X86_64_TLSGD @@ -1328,6 +1350,9 @@ elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, from = elf_x86_64_rtype_to_howto (abfd, from_type); to = elf_x86_64_rtype_to_howto (abfd, to_type); + if (from == NULL || to == NULL) + return FALSE; + if (h) name = h->root.root.string; else @@ -1349,9 +1374,9 @@ elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, _bfd_error_handler /* xgettext:c-format */ - (_("%B: TLS transition from %s to %s against `%s' at %#Lx " - "in section `%A' failed"), - abfd, from->name, to->name, name, rel->r_offset, sec); + (_("%pB: TLS transition from %s to %s against `%s' at %#" PRIx64 + " in section `%pA' failed"), + abfd, from->name, to->name, name, (uint64_t) rel->r_offset, sec); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -1397,28 +1422,37 @@ elf_x86_64_need_pic (struct bfd_link_info *info, v = _("protected symbol "); else v = _("symbol "); - pic = _("; recompile with -fPIC"); + pic = NULL; break; } - if (!h->def_regular && !h->def_dynamic) + if (!SYMBOL_DEFINED_NON_SHARED_P (h) && !h->def_dynamic) und = _("undefined "); } else { name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL); - pic = _("; recompile with -fPIC"); + pic = NULL; } if (bfd_link_dll (info)) - object = _("a shared object"); - else if (bfd_link_pie (info)) - object = _("a PIE object"); + { + object = _("a shared object"); + if (!pic) + pic = _("; recompile with -fPIC"); + } else - object = _("a PDE object"); + { + if (bfd_link_pie (info)) + object = _("a PIE object"); + else + object = _("a PDE object"); + if (!pic) + pic = _("; recompile with -fPIE"); + } /* xgettext:c-format */ - _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can " + _bfd_error_handler (_("%pB: relocation %s against %s%s`%s' can " "not be used when making %s%s"), input_bfd, howto->name, und, v, name, object, pic); @@ -1537,11 +1571,15 @@ elf_x86_64_convert_load_reloc (bfd *abfd, GOTPCRELX relocations since we need to modify REX byte. It is OK convert mov with R_X86_64_GOTPCREL to R_X86_64_PC32. */ + bfd_boolean local_ref; + struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); + + /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */ + local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h); if ((relocx || opcode == 0x8b) - && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, - X86_64_ELF_DATA, - TRUE, - elf_x86_hash_entry (h))) + && (h->root.type == bfd_link_hash_undefweak + && !eh->linker_def + && local_ref)) { if (opcode == 0xff) { @@ -1568,11 +1606,12 @@ elf_x86_64_convert_load_reloc (bfd *abfd, /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since ld.so may use its link-time address. */ else if (h->start_stop + || eh->linker_def || ((h->def_regular || h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak) && h != htab->elf.hdynamic - && SYMBOL_REFERENCES_LOCAL_P (link_info, h))) + && local_ref)) { /* bfd_link_hash_new or bfd_link_hash_undefined is set by an assignment in a linker script in @@ -1580,6 +1619,7 @@ elf_x86_64_convert_load_reloc (bfd *abfd, on __start_SECNAME/__stop_SECNAME which mark section SECNAME. */ if (h->start_stop + || eh->linker_def || (h->def_regular && (h->root.type == bfd_link_hash_new || h->root.type == bfd_link_hash_undefined @@ -1645,8 +1685,8 @@ convert: } else { - nop = link_info->call_nop_byte; - if (link_info->call_nop_as_suffix) + nop = htab->params->call_nop_byte; + if (htab->params->call_nop_as_suffix) { nop_offset = irel->r_offset + 3; disp = bfd_get_32 (abfd, contents + irel->r_offset); @@ -1774,6 +1814,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Rela *rel_end; asection *sreloc; bfd_byte *contents; + bfd_boolean converted; if (bfd_link_relocatable (info)) return TRUE; @@ -1808,6 +1849,8 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, symtab_hdr = &elf_symtab_hdr (abfd); sym_hashes = elf_sym_hashes (abfd); + converted = FALSE; + sreloc = NULL; rel_end = relocs + sec->reloc_count; @@ -1828,7 +1871,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) { /* xgettext:c-format */ - _bfd_error_handler (_("%B: bad symbol index: %d"), + _bfd_error_handler (_("%pB: bad symbol index: %d"), abfd, r_symndx); goto error_return; } @@ -1894,7 +1937,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, NULL); _bfd_error_handler /* xgettext:c-format */ - (_("%B: relocation %s against symbol `%s' isn't " + (_("%pB: relocation %s against symbol `%s' isn't " "supported in x32 mode"), abfd, x86_64_elf_howto_table[r_type].name, name); bfd_set_error (bfd_error_bad_value); @@ -1907,11 +1950,6 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, { /* It is referenced by a non-shared object. */ h->ref_regular = 1; - h->root.non_ir_ref_regular = 1; - - if (h->type == STT_GNU_IFUNC) - elf_tdata (info->output_bfd)->has_gnu_symbols - |= elf_gnu_symbol_ifunc; } converted_reloc = FALSE; @@ -1925,6 +1963,9 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, irel, h, &converted_reloc, info)) goto error_return; + + if (converted_reloc) + converted = TRUE; } if (! elf_x86_64_tls_transition (info, abfd, sec, contents, @@ -1933,11 +1974,15 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, rel, rel_end, h, r_symndx, FALSE)) goto error_return; + /* Check if _GLOBAL_OFFSET_TABLE_ is referenced. */ + if (h == htab->elf.hgot) + htab->got_referenced = TRUE; + eh = (struct elf_x86_link_hash_entry *) h; switch (r_type) { case R_X86_64_TLSLD: - htab->tls_ld_or_ldm_got.refcount += 1; + htab->tls_ld_or_ldm_got.refcount = 1; goto create_got; case R_X86_64_TPOFF32: @@ -1945,7 +1990,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, return elf_x86_64_need_pic (info, abfd, sec, h, symtab_hdr, isym, &x86_64_elf_howto_table[r_type]); if (eh != NULL) - eh->has_got_reloc = 1; + eh->zero_undefweak &= 0x2; break; case R_X86_64_GOTTPOFF: @@ -1979,7 +2024,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, if (h != NULL) { - h->got.refcount += 1; + h->got.refcount = 1; old_tls_type = eh->tls_type; } else @@ -2005,7 +2050,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, elf_x86_local_got_tls_type (abfd) = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info); } - local_got_refcounts[r_symndx] += 1; + local_got_refcounts[r_symndx] = 1; old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx]; } @@ -2030,7 +2075,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, isym, NULL); _bfd_error_handler /* xgettext:c-format */ - (_("%B: '%s' accessed both as normal and" + (_("%pB: '%s' accessed both as normal and" " thread local symbol"), abfd, name); bfd_set_error (bfd_error_bad_value); @@ -2053,7 +2098,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, case R_X86_64_GOTPC64: create_got: if (eh != NULL) - eh->has_got_reloc = 1; + eh->zero_undefweak &= 0x2; break; case R_X86_64_PLT32: @@ -2070,9 +2115,9 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, if (h == NULL) continue; - eh->has_got_reloc = 1; + eh->zero_undefweak &= 0x2; h->needs_plt = 1; - h->plt.refcount += 1; + h->plt.refcount = 1; break; case R_X86_64_PLTOFF64: @@ -2081,7 +2126,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, if (h != NULL) { h->needs_plt = 1; - h->plt.refcount += 1; + h->plt.refcount = 1; } goto create_got; @@ -2101,7 +2146,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, run-time relocation overflow. Don't error out for sections we don't care about, such as debug sections or when relocation overflow check is disabled. */ - if (!info->no_reloc_overflow_check + if (!htab->params->no_reloc_overflow_check && !converted_reloc && (bfd_link_pic (info) || (bfd_link_executable (info) @@ -2121,7 +2166,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, case R_X86_64_64: pointer: if (eh != NULL && (sec->flags & SEC_CODE) != 0) - eh->has_non_got_reloc = 1; + eh->zero_undefweak |= 0x2; /* We are called after all symbols have been resolved. Only relocation against STT_GNU_IFUNC symbol must go through PLT. */ @@ -2129,20 +2174,7 @@ pointer: && (bfd_link_executable (info) || h->type == STT_GNU_IFUNC)) { - /* If this reloc is in a read-only section, we might - need a copy reloc. We can't check reliably at this - stage whether the section is read-only, as input - sections have not yet been mapped to output sections. - Tentatively set the flag for now, and correct in - adjust_dynamic_symbol. */ - h->non_got_ref = 1; - - /* We may need a .plt entry if the symbol is a function - defined in a shared lib or is a STT_GNU_IFUNC function - referenced from the code or read-only section. */ - if (!h->def_regular - || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0) - h->plt.refcount += 1; + bfd_boolean func_pointer_ref = FALSE; if (r_type == R_X86_64_PC32) { @@ -2150,7 +2182,17 @@ pointer: as pointer, make sure that PLT is used if foo is a function defined in a shared library. */ if ((sec->flags & SEC_CODE) == 0) - h->pointer_equality_needed = 1; + { + h->pointer_equality_needed = 1; + if (bfd_link_pie (info) + && h->type == STT_FUNC + && !h->def_regular + && h->def_dynamic) + { + h->needs_plt = 1; + h->plt.refcount = 1; + } + } } else if (r_type != R_X86_64_PC32_BND && r_type != R_X86_64_PC64) @@ -2164,52 +2206,32 @@ pointer: || (!ABI_64_P (abfd) && (r_type == R_X86_64_32 || r_type == R_X86_64_32S)))) - eh->func_pointer_refcount += 1; + func_pointer_ref = TRUE; + } + + if (!func_pointer_ref) + { + /* If this reloc is in a read-only section, we might + need a copy reloc. We can't check reliably at this + stage whether the section is read-only, as input + sections have not yet been mapped to output sections. + Tentatively set the flag for now, and correct in + adjust_dynamic_symbol. */ + h->non_got_ref = 1; + + /* We may need a .plt entry if the symbol is a function + defined in a shared lib or is a function referenced + from the code or read-only section. */ + if (!h->def_regular + || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0) + h->plt.refcount = 1; } } size_reloc = FALSE; do_size: - /* If we are creating a shared library, and this is a reloc - against a global symbol, or a non PC relative reloc - against a local symbol, then we need to copy the reloc - into the shared library. However, if we are linking with - -Bsymbolic, we do not need to copy a reloc against a - global symbol which is defined in an object we are - including in the link (i.e., DEF_REGULAR is set). At - this point we have not seen all the input files, so it is - possible that DEF_REGULAR is not set now but will be set - later (it is never cleared). In case of a weak definition, - DEF_REGULAR may be cleared later by a strong definition in - a shared library. We account for that possibility below by - storing information in the relocs_copied field of the hash - table entry. A similar situation occurs when creating - shared libraries and symbol visibility changes render the - symbol local. - - If on the other hand, we are creating an executable, we - may need to keep relocations for symbols satisfied by a - dynamic library if we manage to avoid copy relocs for the - symbol. - - Generate dynamic pointer relocation against STT_GNU_IFUNC - symbol in the non-code section. */ - if ((bfd_link_pic (info) - && (! IS_X86_64_PCREL_TYPE (r_type) - || (h != NULL - && (! (bfd_link_pie (info) - || SYMBOLIC_BIND (info, h)) - || h->root.type == bfd_link_hash_defweak - || !h->def_regular)))) - || (h != NULL - && h->type == STT_GNU_IFUNC - && r_type == htab->pointer_r_type - && (sec->flags & SEC_CODE) == 0) - || (ELIMINATE_COPY_RELOCS - && !bfd_link_pic (info) - && h != NULL - && (h->root.type == bfd_link_hash_defweak - || !h->def_regular))) + if (NEED_DYNAMIC_RELOCATION_P (info, TRUE, h, sec, r_type, + htab->pointer_r_type)) { struct elf_dyn_relocs *p; struct elf_dyn_relocs **head; @@ -2272,7 +2294,7 @@ do_size: p->count += 1; /* Count size relocation as PC-relative relocation. */ - if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc) + if (X86_PCREL_TYPE_P (r_type) || size_reloc) p->pc_count += 1; } break; @@ -2287,9 +2309,7 @@ do_size: /* This relocation describes which C++ vtable entries are actually used. Record for later use during GC. */ case R_X86_64_GNU_VTENTRY: - BFD_ASSERT (h != NULL); - if (h != NULL - && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) + if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) goto error_return; break; @@ -2300,15 +2320,20 @@ do_size: if (elf_section_data (sec)->this_hdr.contents != contents) { - if (!info->keep_memory) + if (!converted && !info->keep_memory) free (contents); else { - /* Cache the section contents for elf_link_input_bfd. */ + /* Cache the section contents for elf_link_input_bfd if any + load is converted or --no-keep-memory isn't used. */ elf_section_data (sec)->this_hdr.contents = contents; } } + /* Cache relocations if any load is converted. */ + if (elf_section_data (sec)->relocs != relocs && converted) + elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs; + return TRUE; error_return: @@ -2337,24 +2362,6 @@ elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address) return address - static_tls_size - htab->tls_sec->vma; } -/* Is the instruction before OFFSET in CONTENTS a 32bit relative - branch? */ - -static bfd_boolean -is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset) -{ - /* Opcode Instruction - 0xe8 call - 0xe9 jump - 0x0f 0x8x conditional jump */ - return ((offset > 0 - && (contents [offset - 1] == 0xe8 - || contents [offset - 1] == 0xe9)) - || (offset > 1 - && contents [offset - 2] == 0x0f - && (contents [offset - 1] & 0xf0) == 0x80)); -} - /* Relocate an x86_64 ELF section. */ static bfd_boolean @@ -2385,7 +2392,11 @@ elf_x86_64_relocate_section (bfd *output_bfd, if (htab == NULL) return FALSE; - BFD_ASSERT (is_x86_elf (input_bfd, htab)); + if (!is_x86_elf (input_bfd, htab)) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } plt_entry_size = htab->plt.plt_entry_size; symtab_hdr = &elf_symtab_hdr (input_bfd); @@ -2416,6 +2427,8 @@ elf_x86_64_relocate_section (bfd *output_bfd, bfd_boolean resolved_to_zero; bfd_boolean relative_reloc; bfd_boolean converted_reloc; + bfd_boolean need_copy_reloc_in_pie; + bfd_boolean no_copyreloc_p; r_type = ELF32_R_TYPE (rel->r_info); if (r_type == (int) R_X86_64_GNU_VTINHERIT @@ -2426,19 +2439,18 @@ elf_x86_64_relocate_section (bfd *output_bfd, continue; } + r_symndx = htab->r_sym (rel->r_info); converted_reloc = (r_type & R_X86_64_converted_reloc_bit) != 0; - r_type &= ~R_X86_64_converted_reloc_bit; + if (converted_reloc) + { + r_type &= ~R_X86_64_converted_reloc_bit; + rel->r_info = htab->r_info (r_symndx, r_type); + } - if (r_type >= (int) R_X86_64_standard) + howto = elf_x86_64_rtype_to_howto (input_bfd, r_type); + if (howto == NULL) return _bfd_unrecognized_reloc (input_bfd, input_section, r_type); - if (r_type != (int) R_X86_64_32 - || ABI_64_P (output_bfd)) - howto = x86_64_elf_howto_table + r_type; - else - howto = (x86_64_elf_howto_table - + ARRAY_SIZE (x86_64_elf_howto_table) - 1); - r_symndx = htab->r_sym (rel->r_info); h = NULL; sym = NULL; sec = NULL; @@ -2481,7 +2493,7 @@ elf_x86_64_relocate_section (bfd *output_bfd, if (sec != NULL && discarded_section (sec)) { _bfd_clear_contents (howto, input_bfd, input_section, - contents + rel->r_offset); + contents, rel->r_offset); wrel->r_offset = rel->r_offset; wrel->r_info = 0; wrel->r_addend = 0; @@ -2534,6 +2546,10 @@ elf_x86_64_relocate_section (bfd *output_bfd, if ((input_section->flags & SEC_ALLOC) == 0) { + /* If this is a SHT_NOTE section without SHF_ALLOC, treat + STT_GNU_IFUNC symbol as STT_FUNC. */ + if (elf_section_type (input_section) == SHT_NOTE) + goto skip_ifunc; /* Dynamic relocs are not propagated for SEC_DEBUGGING sections because such sections are not SEC_ALLOC and thus ld.so will not process them. */ @@ -2655,7 +2671,7 @@ bad_ifunc_reloc: NULL); _bfd_error_handler /* xgettext:c-format */ - (_("%B: relocation %s against STT_GNU_IFUNC " + (_("%pB: relocation %s against STT_GNU_IFUNC " "symbol `%s' isn't supported"), input_bfd, howto->name, name); bfd_set_error (bfd_error_bad_value); @@ -2681,9 +2697,9 @@ do_ifunc_pointer: sym, NULL); _bfd_error_handler /* xgettext:c-format */ - (_("%B: relocation %s against STT_GNU_IFUNC " - "symbol `%s' has non-zero addend: %Ld"), - input_bfd, howto->name, name, rel->r_addend); + (_("%pB: relocation %s against STT_GNU_IFUNC " + "symbol `%s' has non-zero addend: %" PRId64), + input_bfd, howto->name, name, (int64_t) rel->r_addend); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -2710,11 +2726,9 @@ do_ifunc_pointer: outrel.r_offset += (input_section->output_section->vma + input_section->output_offset); - if (h->dynindx == -1 - || h->forced_local - || bfd_link_executable (info)) + if (POINTER_LOCAL_IFUNC_P (info, h)) { - info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"), + info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"), h->root.root.string, h->root.u.def.section->owner); @@ -2759,11 +2773,9 @@ do_ifunc_pointer: } } +skip_ifunc: resolved_to_zero = (eh != NULL - && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - X86_64_ELF_DATA, - eh->has_got_reloc, - eh)); + && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh)); /* When generating a shared object, the relocations handled here are copied into the output file to be resolved at run time. */ @@ -2788,8 +2800,6 @@ do_ifunc_pointer: relative_reloc = FALSE; if (h != NULL) { - bfd_boolean dyn; - off = h->got.offset; if (h->needs_plt && h->plt.offset != (bfd_vma)-1 @@ -2805,21 +2815,12 @@ do_ifunc_pointer: base_got = htab->elf.sgotplt; } - dyn = htab->elf.dynamic_sections_created; - - if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) - || (bfd_link_pic (info) - && SYMBOL_REFERENCES_LOCAL_P (info, h)) - || (ELF_ST_VISIBILITY (h->other) - && h->root.type == bfd_link_hash_undefweak)) + if (RESOLVED_LOCALLY_P (info, h, htab)) { - /* This is actually a static link, or it is a -Bsymbolic - link and the symbol is defined locally, or the symbol - was forced to be local because of a version file. We - must initialize this entry in the global offset table. - Since the offset must always be a multiple of 8, we - use the least significant bit to record whether we - have initialized it already. + /* We must initialize this entry in the global offset + table. Since the offset must always be a multiple + of 8, we use the least significant bit to record + whether we have initialized it already. When doing a dynamic link, we create a .rela.got relocation entry to initialize the value. This is @@ -2834,10 +2835,7 @@ do_ifunc_pointer: as -1 | 1 still is -1. */ h->got.offset |= 1; - if (h->dynindx == -1 - && !h->forced_local - && h->root.type != bfd_link_hash_undefweak - && bfd_link_pic (info)) + if (GENERATE_RELATIVE_RELOC_P (info, h)) { /* If this symbol isn't dynamic in PIC, generate R_X86_64_RELATIVE here. */ @@ -2937,7 +2935,7 @@ do_ifunc_pointer: _bfd_error_handler /* xgettext:c-format */ - (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s" + (_("%pB: relocation R_X86_64_GOTOFF64 against undefined %s" " `%s' can not be used when making a shared object"), input_bfd, v, h->root.root.string); bfd_set_error (bfd_error_bad_value); @@ -2950,14 +2948,14 @@ do_ifunc_pointer: && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED) { _bfd_error_handler - /* xgettext:c-format */ - (_("%B: relocation R_X86_64_GOTOFF64 against protected %s" + /* xgettext:c-format */ + (_("%pB: relocation R_X86_64_GOTOFF64 against protected %s" " `%s' can not be used when making a shared object"), input_bfd, h->type == STT_FUNC ? "function" : "data", h->root.root.string); bfd_set_error (bfd_error_bad_value); - return FALSE; + return FALSE; } } @@ -3034,6 +3032,7 @@ do_ifunc_pointer: break; } +use_plt: if (h->plt.offset != (bfd_vma) -1) { if (htab->plt_second != NULL) @@ -3071,48 +3070,73 @@ do_ifunc_pointer: case R_X86_64_PC32: case R_X86_64_PC32_BND: /* Don't complain about -fPIC if the symbol is undefined when - building executable unless it is unresolved weak symbol or - -z nocopyreloc is used. */ - if ((input_section->flags & SEC_ALLOC) != 0 + building executable unless it is unresolved weak symbol, + references a dynamic definition in PIE or -z nocopyreloc + is used. */ + no_copyreloc_p + = (info->nocopyreloc + || (h != NULL + && !h->root.linker_def + && !h->root.ldscript_def + && eh->def_protected + && elf_has_no_copy_on_protected (h->root.u.def.section->owner))); + + if ((input_section->flags & SEC_ALLOC) != 0 && (input_section->flags & SEC_READONLY) != 0 && h != NULL && ((bfd_link_executable (info) && ((h->root.type == bfd_link_hash_undefweak - && !resolved_to_zero) - || ((info->nocopyreloc - || (eh->def_protected - && elf_has_no_copy_on_protected (h->root.u.def.section->owner))) + && (eh == NULL + || !UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, + eh))) + || (bfd_link_pie (info) + && !SYMBOL_DEFINED_NON_SHARED_P (h) + && h->def_dynamic) + || (no_copyreloc_p && h->def_dynamic && !(h->root.u.def.section->flags & SEC_CODE)))) || bfd_link_dll (info))) { bfd_boolean fail = FALSE; - bfd_boolean branch - = ((r_type == R_X86_64_PC32 - || r_type == R_X86_64_PC32_BND) - && is_32bit_relative_branch (contents, rel->r_offset)); - if (SYMBOL_REFERENCES_LOCAL_P (info, h)) { /* Symbol is referenced locally. Make sure it is - defined locally or for a branch. */ - fail = (!(h->def_regular || ELF_COMMON_DEF_P (h)) - && !branch); + defined locally. */ + fail = !SYMBOL_DEFINED_NON_SHARED_P (h); } - else if (!(bfd_link_pie (info) - && (h->needs_copy || eh->needs_copy))) + else if (bfd_link_pie (info)) { - /* Symbol doesn't need copy reloc and isn't referenced - locally. We only allow branch to symbol with - non-default visibility. */ - fail = (!branch - || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT); + /* We can only use PC-relative relocations in PIE + from non-code sections. */ + if (h->type == STT_FUNC + && (sec->flags & SEC_CODE) != 0) + fail = TRUE; + } + else if (no_copyreloc_p || bfd_link_dll (info)) + { + /* Symbol doesn't need copy reloc and isn't + referenced locally. Don't allow PC-relative + relocations against default and protected + symbols since address of protected function + and location of protected data may not be in + the shared object. */ + fail = (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT + || ELF_ST_VISIBILITY (h->other) == STV_PROTECTED); } if (fail) return elf_x86_64_need_pic (info, input_bfd, input_section, h, NULL, NULL, howto); } + /* Since x86-64 has PC-relative PLT, we can use PLT in PIE + as function address. */ + else if (h != NULL + && (input_section->flags & SEC_CODE) == 0 + && bfd_link_pie (info) + && h->type == STT_FUNC + && !h->def_regular + && h->def_dynamic) + goto use_plt; /* Fall through. */ case R_X86_64_8: @@ -3127,40 +3151,18 @@ direct: if ((input_section->flags & SEC_ALLOC) == 0) break; - /* Don't copy a pc-relative relocation into the output file - if the symbol needs copy reloc or the symbol is undefined - when building executable. Copy dynamic function pointer - relocations. Don't generate dynamic relocations against - resolved undefined weak symbols in PIE. */ - if ((bfd_link_pic (info) - && !(bfd_link_pie (info) - && h != NULL - && (h->needs_copy - || eh->needs_copy - || h->root.type == bfd_link_hash_undefined) - && (IS_X86_64_PCREL_TYPE (r_type) - || r_type == R_X86_64_SIZE32 - || r_type == R_X86_64_SIZE64)) - && (h == NULL - || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT - && !resolved_to_zero) - || h->root.type != bfd_link_hash_undefweak)) - && ((! IS_X86_64_PCREL_TYPE (r_type) - && r_type != R_X86_64_SIZE32 - && r_type != R_X86_64_SIZE64) - || ! SYMBOL_CALLS_LOCAL (info, h))) - || (ELIMINATE_COPY_RELOCS - && !bfd_link_pic (info) - && h != NULL - && h->dynindx != -1 - && (!h->non_got_ref - || eh->func_pointer_refcount > 0 - || (h->root.type == bfd_link_hash_undefweak - && !resolved_to_zero)) - && ((h->def_dynamic && !h->def_regular) - /* Undefined weak symbol is bound locally when - PIC is false. */ - || h->root.type == bfd_link_hash_undefined))) + need_copy_reloc_in_pie = (bfd_link_pie (info) + && h != NULL + && (h->needs_copy + || eh->needs_copy + || (h->root.type + == bfd_link_hash_undefined)) + && (X86_PCREL_TYPE_P (r_type) + || X86_SIZE_TYPE_P (r_type))); + + if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type, + need_copy_reloc_in_pie, + resolved_to_zero, FALSE)) { Elf_Internal_Rela outrel; bfd_boolean skip, relocate; @@ -3186,14 +3188,7 @@ direct: if (skip) memset (&outrel, 0, sizeof outrel); - /* h->dynindx may be -1 if this symbol was marked to - become local. */ - else if (h != NULL - && h->dynindx != -1 - && (IS_X86_64_PCREL_TYPE (r_type) - || !(bfd_link_executable (info) - || SYMBOLIC_BIND (info, h)) - || ! h->def_regular)) + else if (COPY_INPUT_RELOC_P (info, h, r_type)) { outrel.r_info = htab->r_info (h->dynindx, r_type); outrel.r_addend = rel->r_addend; @@ -3205,7 +3200,7 @@ direct: convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */ if (r_type == htab->pointer_r_type || (r_type == R_X86_64_32 - && info->no_reloc_overflow_check)) + && htab->params->no_reloc_overflow_check)) { relocate = TRUE; outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE); @@ -3231,11 +3226,12 @@ direct: sym, NULL); _bfd_error_handler /* xgettext:c-format */ - (_("%B: addend %s%#x in relocation %s against " - "symbol `%s' at %#Lx in section `%A' is " - "out of range"), + (_("%pB: addend %s%#x in relocation %s against " + "symbol `%s' at %#" PRIx64 + " in section `%pA' is out of range"), input_bfd, addend < 0 ? "-" : "", addend, - howto->name, name, rel->r_offset, input_section); + howto->name, name, (uint64_t) rel->r_offset, + input_section); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -3359,20 +3355,39 @@ direct: { if (contents[roff + 5] == 0xb8) { + if (roff < 3 + || (roff - 3 + 22) > input_section->size) + { +corrupt_input: + info->callbacks->einfo + (_("%F%P: corrupt input: %pB\n"), + input_bfd); + return FALSE; + } memcpy (contents + roff - 3, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80" "\0\0\0\0\x66\x0f\x1f\x44\0", 22); largepic = 1; } else - memcpy (contents + roff - 4, - "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", - 16); + { + if (roff < 4 + || (roff - 4 + 16) > input_section->size) + goto corrupt_input; + memcpy (contents + roff - 4, + "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", + 16); + } } else - memcpy (contents + roff - 3, - "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", - 15); + { + if (roff < 3 + || (roff - 3 + 15) > input_section->size) + goto corrupt_input; + memcpy (contents + roff - 3, + "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", + 15); + } bfd_put_32 (output_bfd, elf_x86_64_tpoff (info, relocation), contents + roff + 8 + largepic); @@ -3393,6 +3408,8 @@ direct: unsigned int val, type; + if (roff < 3) + goto corrupt_input; type = bfd_get_8 (input_bfd, contents + roff - 3); val = bfd_get_8 (input_bfd, contents + roff - 1); bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1), @@ -3439,7 +3456,11 @@ direct: if (roff >= 3) val = bfd_get_8 (input_bfd, contents + roff - 3); else - val = 0; + { + if (roff < 2) + goto corrupt_input; + val = 0; + } type = bfd_get_8 (input_bfd, contents + roff - 2); reg = bfd_get_8 (input_bfd, contents + roff - 1); reg >>= 3; @@ -3447,11 +3468,19 @@ direct: { /* movq */ if (val == 0x4c) - bfd_put_8 (output_bfd, 0x49, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x49, + contents + roff - 3); + } else if (!ABI_64_P (output_bfd) && val == 0x44) - bfd_put_8 (output_bfd, 0x41, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x41, + contents + roff - 3); + } bfd_put_8 (output_bfd, 0xc7, contents + roff - 2); bfd_put_8 (output_bfd, 0xc0 | reg, @@ -3462,11 +3491,19 @@ direct: /* addq/addl -> addq/addl - addressing with %rsp/%r12 is special */ if (val == 0x4c) - bfd_put_8 (output_bfd, 0x49, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x49, + contents + roff - 3); + } else if (!ABI_64_P (output_bfd) && val == 0x44) - bfd_put_8 (output_bfd, 0x41, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x41, + contents + roff - 3); + } bfd_put_8 (output_bfd, 0x81, contents + roff - 2); bfd_put_8 (output_bfd, 0xc0 | reg, @@ -3476,11 +3513,19 @@ direct: { /* addq/addl -> leaq/leal */ if (val == 0x4c) - bfd_put_8 (output_bfd, 0x4d, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x4d, + contents + roff - 3); + } else if (!ABI_64_P (output_bfd) && val == 0x44) - bfd_put_8 (output_bfd, 0x45, - contents + roff - 3); + { + if (roff < 3) + goto corrupt_input; + bfd_put_8 (output_bfd, 0x45, + contents + roff - 3); + } bfd_put_8 (output_bfd, 0x8d, contents + roff - 2); bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3), @@ -3650,20 +3695,33 @@ direct: { if (contents[roff + 5] == 0xb8) { + if (roff < 3 + || (roff - 3 + 22) > input_section->size) + goto corrupt_input; memcpy (contents + roff - 3, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05" "\0\0\0\0\x66\x0f\x1f\x44\0", 22); largepic = 1; } else - memcpy (contents + roff - 4, - "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", - 16); + { + if (roff < 4 + || (roff - 4 + 16) > input_section->size) + goto corrupt_input; + memcpy (contents + roff - 4, + "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", + 16); + } } else - memcpy (contents + roff - 3, - "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", - 15); + { + if (roff < 3 + || (roff - 3 + 15) > input_section->size) + goto corrupt_input; + memcpy (contents + roff - 3, + "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", + 15); + } relocation = (htab->elf.sgot->output_section->vma + htab->elf.sgot->output_offset + off @@ -3692,6 +3750,8 @@ direct: turn a leaq into a movq in the form we use it, it suffices to change the second byte from 0x8d to 0x8b. */ + if (roff < 2) + goto corrupt_input; bfd_put_8 (output_bfd, 0x8b, contents + roff - 2); bfd_put_32 (output_bfd, @@ -3760,28 +3820,58 @@ direct: BFD_ASSERT (r_type == R_X86_64_TPOFF32); if (ABI_64_P (output_bfd)) { + if ((rel->r_offset + 5) >= input_section->size) + goto corrupt_input; if (contents[rel->r_offset + 5] == 0xb8) - memcpy (contents + rel->r_offset - 3, - "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0" - "\x64\x48\x8b\x04\x25\0\0\0", 22); + { + if (rel->r_offset < 3 + || (rel->r_offset - 3 + 22) > input_section->size) + goto corrupt_input; + memcpy (contents + rel->r_offset - 3, + "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0" + "\x64\x48\x8b\x04\x25\0\0\0", 22); + } else if (contents[rel->r_offset + 4] == 0xff || contents[rel->r_offset + 4] == 0x67) - memcpy (contents + rel->r_offset - 3, - "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", - 13); + { + if (rel->r_offset < 3 + || (rel->r_offset - 3 + 13) > input_section->size) + goto corrupt_input; + memcpy (contents + rel->r_offset - 3, + "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", + 13); + + } else - memcpy (contents + rel->r_offset - 3, - "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12); + { + if (rel->r_offset < 3 + || (rel->r_offset - 3 + 12) > input_section->size) + goto corrupt_input; + memcpy (contents + rel->r_offset - 3, + "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12); + } } else { + if ((rel->r_offset + 4) >= input_section->size) + goto corrupt_input; if (contents[rel->r_offset + 4] == 0xff) - memcpy (contents + rel->r_offset - 3, - "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", - 13); + { + if (rel->r_offset < 3 + || (rel->r_offset - 3 + 13) > input_section->size) + goto corrupt_input; + memcpy (contents + rel->r_offset - 3, + "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", + 13); + } else - memcpy (contents + rel->r_offset - 3, - "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12); + { + if (rel->r_offset < 3 + || (rel->r_offset - 3 + 12) > input_section->size) + goto corrupt_input; + memcpy (contents + rel->r_offset - 3, + "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12); + } } /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */ @@ -3868,10 +3958,11 @@ direct: default: _bfd_error_handler /* xgettext:c-format */ - (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"), + (_("%pB(%pA+%#" PRIx64 "): " + "unresolvable %s relocation against symbol `%s'"), input_bfd, input_section, - rel->r_offset, + (uint64_t) rel->r_offset, howto->name, h->root.root.string); return FALSE; @@ -3898,7 +3989,7 @@ check_relocation_error: if (name == NULL) return FALSE; if (*name == '\0') - name = bfd_section_name (input_bfd, sec); + name = bfd_section_name (sec); } if (r == bfd_reloc_overflow) @@ -3917,9 +4008,9 @@ check_relocation_error: { _bfd_error_handler /* xgettext:c-format */ - (_("%B(%A+%#Lx): reloc against `%s': error %d"), + (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"), input_bfd, input_section, - rel->r_offset, name, (int) r); + (uint64_t) rel->r_offset, name, (int) r); return FALSE; } } @@ -3979,10 +4070,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for resolved undefined weak symbols in executable so that their references have value 0 at run-time. */ - local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - X86_64_ELF_DATA, - eh->has_got_reloc, - eh); + local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); if (h->plt.offset != (bfd_vma) -1) { @@ -4009,17 +4097,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, relplt = htab->elf.irelplt; } - /* This symbol has an entry in the procedure linkage table. Set - it up. */ - if ((h->dynindx == -1 - && !local_undefweak - && !((h->forced_local || bfd_link_executable (info)) - && h->def_regular - && h->type == STT_GNU_IFUNC)) - || plt == NULL - || gotplt == NULL - || relplt == NULL) - abort (); + VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak) /* Get the index in the procedure linkage table which corresponds to this symbol. This is the index of this symbol @@ -4077,7 +4155,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, /* Check PC-relative offset overflow in PLT entry. */ if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff) /* xgettext:c-format */ - info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"), + info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in PLT entry for `%s'\n"), output_bfd, h->root.root.string); bfd_put_32 (output_bfd, plt_got_pcrel_offset, @@ -4101,13 +4179,9 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, rela.r_offset = (gotplt->output_section->vma + gotplt->output_offset + got_offset); - if (h->dynindx == -1 - || ((bfd_link_executable (info) - || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) - && h->def_regular - && h->type == STT_GNU_IFUNC)) + if (PLT_LOCAL_IFUNC_P (info, h)) { - info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"), + info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"), h->root.root.string, h->root.u.def.section->owner); @@ -4144,7 +4218,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, will overflow first. */ if (plt0_offset > 0x80000000) /* xgettext:c-format */ - info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"), + info->callbacks->einfo (_("%F%pB: branch displacement overflow in PLT entry for `%s'\n"), output_bfd, h->root.root.string); bfd_put_32 (output_bfd, - plt0_offset, (plt->contents + h->plt.offset @@ -4197,7 +4271,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, if ((got_after_plt && got_pcrel_offset < 0) || (!got_after_plt && got_pcrel_offset > 0)) /* xgettext:c-format */ - info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"), + info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in GOT PLT entry for `%s'\n"), output_bfd, h->root.root.string); bfd_put_32 (output_bfd, got_pcrel_offset, @@ -4223,6 +4297,8 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, sym->st_value = 0; } + _bfd_x86_elf_link_fixup_ifunc_symbol (info, htab, h, sym); + /* Don't generate dynamic GOT relocation against undefined weak symbol in executable. */ if (h->got.offset != (bfd_vma) -1 @@ -4261,8 +4337,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, } if (SYMBOL_REFERENCES_LOCAL_P (info, h)) { - info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"), - output_bfd, + info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"), h->root.root.string, h->root.u.def.section->owner); @@ -4311,7 +4386,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, else if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL_P (info, h)) { - if (!(h->def_regular || ELF_COMMON_DEF_P (h))) + if (!SYMBOL_DEFINED_NON_SHARED_P (h)) return FALSE; BFD_ASSERT((h->got.offset & 1) != 0); rela.r_info = htab->r_info (0, R_X86_64_RELATIVE); @@ -4338,13 +4413,7 @@ do_glob_dat: asection *s; /* This symbol needs a copy reloc. Set it up. */ - - if (h->dynindx == -1 - || (h->root.type != bfd_link_hash_defined - && h->root.type != bfd_link_hash_defweak) - || htab->elf.srelbss == NULL - || htab->elf.sreldynrelro == NULL) - abort (); + VERIFY_COPY_RELOC (h, htab) rela.r_offset = (h->root.u.def.value + h->root.u.def.section->output_section->vma @@ -4412,7 +4481,7 @@ elf_x86_64_reloc_type_class (const struct bfd_link_info *info, && htab->elf.dynsym->contents != NULL) { /* Check relocation against STT_GNU_IFUNC symbol if there are - dynamic symbols. */ + dynamic symbols. */ unsigned long r_symndx = htab->r_sym (rela->r_info); if (r_symndx != STN_UNDEF) { @@ -4451,273 +4520,91 @@ elf_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) { struct elf_x86_link_hash_table *htab; - bfd *dynobj; - asection *sdyn; - htab = elf_x86_hash_table (info, X86_64_ELF_DATA); + htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info); if (htab == NULL) return FALSE; - dynobj = htab->elf.dynobj; - sdyn = bfd_get_linker_section (dynobj, ".dynamic"); - - if (htab->elf.dynamic_sections_created) - { - bfd_byte *dyncon, *dynconend; - const struct elf_backend_data *bed; - bfd_size_type sizeof_dyn; - - if (sdyn == NULL || htab->elf.sgot == NULL) - abort (); - - bed = get_elf_backend_data (dynobj); - sizeof_dyn = bed->s->sizeof_dyn; - dyncon = sdyn->contents; - dynconend = sdyn->contents + sdyn->size; - for (; dyncon < dynconend; dyncon += sizeof_dyn) - { - Elf_Internal_Dyn dyn; - asection *s; - - (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn); - - switch (dyn.d_tag) - { - default: - continue; - - case DT_PLTGOT: - s = htab->elf.sgotplt; - dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; - break; - - case DT_JMPREL: - dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; - break; - - case DT_PLTRELSZ: - s = htab->elf.srelplt->output_section; - dyn.d_un.d_val = s->size; - break; - - case DT_TLSDESC_PLT: - s = htab->elf.splt; - dyn.d_un.d_ptr = s->output_section->vma + s->output_offset - + htab->tlsdesc_plt; - break; - - case DT_TLSDESC_GOT: - s = htab->elf.sgot; - dyn.d_un.d_ptr = s->output_section->vma + s->output_offset - + htab->tlsdesc_got; - break; - } - - (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon); - } - - if (htab->elf.splt && htab->elf.splt->size > 0) - { - elf_section_data (htab->elf.splt->output_section) - ->this_hdr.sh_entsize = htab->plt.plt_entry_size; - - if (htab->plt.has_plt0) - { - /* Fill in the special first entry in the procedure linkage - table. */ - memcpy (htab->elf.splt->contents, - htab->lazy_plt->plt0_entry, - htab->lazy_plt->plt0_entry_size); - /* Add offset for pushq GOT+8(%rip), since the instruction - uses 6 bytes subtract this value. */ - bfd_put_32 (output_bfd, - (htab->elf.sgotplt->output_section->vma - + htab->elf.sgotplt->output_offset - + 8 - - htab->elf.splt->output_section->vma - - htab->elf.splt->output_offset - - 6), - (htab->elf.splt->contents - + htab->lazy_plt->plt0_got1_offset)); - /* Add offset for the PC-relative instruction accessing - GOT+16, subtracting the offset to the end of that - instruction. */ - bfd_put_32 (output_bfd, - (htab->elf.sgotplt->output_section->vma - + htab->elf.sgotplt->output_offset - + 16 - - htab->elf.splt->output_section->vma - - htab->elf.splt->output_offset - - htab->lazy_plt->plt0_got2_insn_end), - (htab->elf.splt->contents - + htab->lazy_plt->plt0_got2_offset)); - - if (htab->tlsdesc_plt) - { - bfd_put_64 (output_bfd, (bfd_vma) 0, - htab->elf.sgot->contents + htab->tlsdesc_got); - - memcpy (htab->elf.splt->contents + htab->tlsdesc_plt, - htab->lazy_plt->plt0_entry, - htab->lazy_plt->plt0_entry_size); - - /* Add offset for pushq GOT+8(%rip), since the - instruction uses 6 bytes subtract this value. */ - bfd_put_32 (output_bfd, - (htab->elf.sgotplt->output_section->vma - + htab->elf.sgotplt->output_offset - + 8 - - htab->elf.splt->output_section->vma - - htab->elf.splt->output_offset - - htab->tlsdesc_plt - - 6), - (htab->elf.splt->contents - + htab->tlsdesc_plt - + htab->lazy_plt->plt0_got1_offset)); - /* Add offset for the PC-relative instruction accessing - GOT+TDG, where TDG stands for htab->tlsdesc_got, - subtracting the offset to the end of that - instruction. */ - bfd_put_32 (output_bfd, - (htab->elf.sgot->output_section->vma - + htab->elf.sgot->output_offset - + htab->tlsdesc_got - - htab->elf.splt->output_section->vma - - htab->elf.splt->output_offset - - htab->tlsdesc_plt - - htab->lazy_plt->plt0_got2_insn_end), - (htab->elf.splt->contents - + htab->tlsdesc_plt - + htab->lazy_plt->plt0_got2_offset)); - } - } - } - - if (htab->plt_got != NULL && htab->plt_got->size > 0) - elf_section_data (htab->plt_got->output_section) - ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; - - if (htab->plt_second != NULL && htab->plt_second->size > 0) - elf_section_data (htab->plt_second->output_section) - ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; - } - - /* GOT is always created in setup_gnu_properties. But it may not be - needed. */ - if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0) - { - if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) - { - _bfd_error_handler - (_("discarded output section: `%A'"), htab->elf.sgotplt); - return FALSE; - } - - /* Set the first entry in the global offset table to the address of - the dynamic section. */ - if (sdyn == NULL) - bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents); - else - bfd_put_64 (output_bfd, - sdyn->output_section->vma + sdyn->output_offset, - htab->elf.sgotplt->contents); - /* Write GOT[1] and GOT[2], needed for the dynamic linker. */ - bfd_put_64 (output_bfd, (bfd_vma) 0, - htab->elf.sgotplt->contents + GOT_ENTRY_SIZE); - bfd_put_64 (output_bfd, (bfd_vma) 0, - htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2); - - elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize - = GOT_ENTRY_SIZE; - } + if (! htab->elf.dynamic_sections_created) + return TRUE; - /* Adjust .eh_frame for .plt section. */ - if (htab->plt_eh_frame != NULL - && htab->plt_eh_frame->contents != NULL) + if (htab->elf.splt && htab->elf.splt->size > 0) { - if (htab->elf.splt != NULL - && htab->elf.splt->size != 0 - && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 - && htab->elf.splt->output_section != NULL - && htab->plt_eh_frame->output_section != NULL) - { - bfd_vma plt_start = htab->elf.splt->output_section->vma; - bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma - + htab->plt_eh_frame->output_offset - + PLT_FDE_START_OFFSET; - bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, - htab->plt_eh_frame->contents - + PLT_FDE_START_OFFSET); - } - if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) - { - if (! _bfd_elf_write_section_eh_frame (output_bfd, info, - htab->plt_eh_frame, - htab->plt_eh_frame->contents)) - return FALSE; - } - } + elf_section_data (htab->elf.splt->output_section) + ->this_hdr.sh_entsize = htab->plt.plt_entry_size; - /* Adjust .eh_frame for .plt.got section. */ - if (htab->plt_got_eh_frame != NULL - && htab->plt_got_eh_frame->contents != NULL) - { - if (htab->plt_got != NULL - && htab->plt_got->size != 0 - && (htab->plt_got->flags & SEC_EXCLUDE) == 0 - && htab->plt_got->output_section != NULL - && htab->plt_got_eh_frame->output_section != NULL) - { - bfd_vma plt_start = htab->plt_got->output_section->vma; - bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma - + htab->plt_got_eh_frame->output_offset - + PLT_FDE_START_OFFSET; - bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, - htab->plt_got_eh_frame->contents - + PLT_FDE_START_OFFSET); - } - if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) + if (htab->plt.has_plt0) { - if (! _bfd_elf_write_section_eh_frame (output_bfd, info, - htab->plt_got_eh_frame, - htab->plt_got_eh_frame->contents)) - return FALSE; + /* Fill in the special first entry in the procedure linkage + table. */ + memcpy (htab->elf.splt->contents, + htab->lazy_plt->plt0_entry, + htab->lazy_plt->plt0_entry_size); + /* Add offset for pushq GOT+8(%rip), since the instruction + uses 6 bytes subtract this value. */ + bfd_put_32 (output_bfd, + (htab->elf.sgotplt->output_section->vma + + htab->elf.sgotplt->output_offset + + 8 + - htab->elf.splt->output_section->vma + - htab->elf.splt->output_offset + - 6), + (htab->elf.splt->contents + + htab->lazy_plt->plt0_got1_offset)); + /* Add offset for the PC-relative instruction accessing + GOT+16, subtracting the offset to the end of that + instruction. */ + bfd_put_32 (output_bfd, + (htab->elf.sgotplt->output_section->vma + + htab->elf.sgotplt->output_offset + + 16 + - htab->elf.splt->output_section->vma + - htab->elf.splt->output_offset + - htab->lazy_plt->plt0_got2_insn_end), + (htab->elf.splt->contents + + htab->lazy_plt->plt0_got2_offset)); } - } - /* Adjust .eh_frame for the second PLT section. */ - if (htab->plt_second_eh_frame != NULL - && htab->plt_second_eh_frame->contents != NULL) - { - if (htab->plt_second != NULL - && htab->plt_second->size != 0 - && (htab->plt_second->flags & SEC_EXCLUDE) == 0 - && htab->plt_second->output_section != NULL - && htab->plt_second_eh_frame->output_section != NULL) - { - bfd_vma plt_start = htab->plt_second->output_section->vma; - bfd_vma eh_frame_start - = (htab->plt_second_eh_frame->output_section->vma - + htab->plt_second_eh_frame->output_offset - + PLT_FDE_START_OFFSET); - bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, - htab->plt_second_eh_frame->contents - + PLT_FDE_START_OFFSET); - } - if (htab->plt_second_eh_frame->sec_info_type - == SEC_INFO_TYPE_EH_FRAME) + if (htab->tlsdesc_plt) { - if (! _bfd_elf_write_section_eh_frame (output_bfd, info, - htab->plt_second_eh_frame, - htab->plt_second_eh_frame->contents)) - return FALSE; + bfd_put_64 (output_bfd, (bfd_vma) 0, + htab->elf.sgot->contents + htab->tlsdesc_got); + + memcpy (htab->elf.splt->contents + htab->tlsdesc_plt, + htab->lazy_plt->plt_tlsdesc_entry, + htab->lazy_plt->plt_tlsdesc_entry_size); + + /* Add offset for pushq GOT+8(%rip), since ENDBR64 uses 4 + bytes and the instruction uses 6 bytes, subtract these + values. */ + bfd_put_32 (output_bfd, + (htab->elf.sgotplt->output_section->vma + + htab->elf.sgotplt->output_offset + + 8 + - htab->elf.splt->output_section->vma + - htab->elf.splt->output_offset + - htab->tlsdesc_plt + - htab->lazy_plt->plt_tlsdesc_got1_insn_end), + (htab->elf.splt->contents + + htab->tlsdesc_plt + + htab->lazy_plt->plt_tlsdesc_got1_offset)); + /* Add offset for indirect branch via GOT+TDG, where TDG + stands for htab->tlsdesc_got, subtracting the offset + to the end of that instruction. */ + bfd_put_32 (output_bfd, + (htab->elf.sgot->output_section->vma + + htab->elf.sgot->output_offset + + htab->tlsdesc_got + - htab->elf.splt->output_section->vma + - htab->elf.splt->output_offset + - htab->tlsdesc_plt + - htab->lazy_plt->plt_tlsdesc_got2_insn_end), + (htab->elf.splt->contents + + htab->tlsdesc_plt + + htab->lazy_plt->plt_tlsdesc_got2_offset)); } } - if (htab->elf.sgot && htab->elf.sgot->size > 0) - elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize - = GOT_ENTRY_SIZE; - /* Fill PLT entries for undefined weak symbols in PIE. */ if (bfd_link_pie (info)) bfd_hash_traverse (&info->hash->table, @@ -4802,7 +4689,7 @@ elf_x86_64_get_synthetic_symtab (bfd *abfd, if (relsize <= 0) return -1; - if (get_elf_x86_64_backend_data (abfd)->os == is_normal) + if (get_elf_x86_backend_data (abfd)->target_os != is_nacl) { lazy_plt = &elf_x86_64_lazy_plt; non_lazy_plt = &elf_x86_64_non_lazy_plt; @@ -5140,7 +5027,7 @@ elf_x86_64_relocs_compatible (const bfd_target *input, static bfd * elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info) { - struct elf_x86_plt_layout_table plt_layout; + struct elf_x86_init_table init_table; if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit || (int) R_X86_64_max <= (int) R_X86_64_converted_reloc_bit @@ -5150,53 +5037,59 @@ elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info) != (int) R_X86_64_GNU_VTENTRY)) abort (); - plt_layout.is_vxworks = FALSE; - if (get_elf_x86_64_backend_data (info->output_bfd)->os == is_normal) + /* This is unused for x86-64. */ + init_table.plt0_pad_byte = 0x90; + + if (get_elf_x86_backend_data (info->output_bfd)->target_os != is_nacl) { - if (info->bndplt) + const struct elf_backend_data *bed + = get_elf_backend_data (info->output_bfd); + struct elf_x86_link_hash_table *htab + = elf_x86_hash_table (info, bed->target_id); + if (!htab) + abort (); + if (htab->params->bndplt) { - plt_layout.lazy_plt = &elf_x86_64_lazy_bnd_plt; - plt_layout.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt; + init_table.lazy_plt = &elf_x86_64_lazy_bnd_plt; + init_table.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt; } else { - plt_layout.lazy_plt = &elf_x86_64_lazy_plt; - plt_layout.non_lazy_plt = &elf_x86_64_non_lazy_plt; + init_table.lazy_plt = &elf_x86_64_lazy_plt; + init_table.non_lazy_plt = &elf_x86_64_non_lazy_plt; } if (ABI_64_P (info->output_bfd)) { - plt_layout.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt; - plt_layout.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt; + init_table.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt; + init_table.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt; } else { - plt_layout.lazy_ibt_plt = &elf_x32_lazy_ibt_plt; - plt_layout.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt; + init_table.lazy_ibt_plt = &elf_x32_lazy_ibt_plt; + init_table.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt; } - plt_layout.normal_target = TRUE; } else { - plt_layout.lazy_plt = &elf_x86_64_nacl_plt; - plt_layout.non_lazy_plt = NULL; - plt_layout.lazy_ibt_plt = NULL; - plt_layout.non_lazy_ibt_plt = NULL; - plt_layout.normal_target = FALSE; + init_table.lazy_plt = &elf_x86_64_nacl_plt; + init_table.non_lazy_plt = NULL; + init_table.lazy_ibt_plt = NULL; + init_table.non_lazy_ibt_plt = NULL; } if (ABI_64_P (info->output_bfd)) { - plt_layout.r_info = elf64_r_info; - plt_layout.r_sym = elf64_r_sym; + init_table.r_info = elf64_r_info; + init_table.r_sym = elf64_r_sym; } else { - plt_layout.r_info = elf32_r_info; - plt_layout.r_sym = elf32_r_sym; + init_table.r_info = elf32_r_info; + init_table.r_sym = elf32_r_sym; } - return _bfd_x86_elf_link_setup_gnu_properties (info, &plt_layout); + return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table); } static const struct bfd_elf_special_section @@ -5205,10 +5098,10 @@ elf_x86_64_special_sections[]= { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE}, { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE}, - { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, + { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE}, - { NULL, 0, 0, 0, 0 } + { NULL, 0, 0, 0, 0 } }; #define TARGET_LITTLE_SYM x86_64_elf64_vec @@ -5216,7 +5109,11 @@ elf_x86_64_special_sections[]= #define ELF_ARCH bfd_arch_i386 #define ELF_TARGET_ID X86_64_ELF_DATA #define ELF_MACHINE_CODE EM_X86_64 -#define ELF_MAXPAGESIZE 0x200000 +#if DEFAULT_LD_Z_SEPARATE_CODE +# define ELF_MAXPAGESIZE 0x1000 +#else +# define ELF_MAXPAGESIZE 0x200000 +#endif #define ELF_MINPAGESIZE 0x1000 #define ELF_COMMONPAGESIZE 0x1000 @@ -5227,7 +5124,7 @@ elf_x86_64_special_sections[]= #define elf_backend_want_plt_sym 0 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3) #define elf_backend_rela_normal 1 -#define elf_backend_plt_alignment 4 +#define elf_backend_plt_alignment 4 #define elf_backend_extern_protected_data 1 #define elf_backend_caches_rawsize 1 #define elf_backend_dtrel_excludes_plt 1 @@ -5278,36 +5175,41 @@ elf_x86_64_special_sections[]= #define elf_backend_additional_program_headers \ elf_x86_64_additional_program_headers #define elf_backend_setup_gnu_properties \ - elf_x86_64_link_setup_gnu_properties + elf_x86_64_link_setup_gnu_properties +#define elf_backend_hide_symbol \ + _bfd_x86_elf_hide_symbol + +#undef elf64_bed +#define elf64_bed elf64_x86_64_bed #include "elf64-target.h" /* CloudABI support. */ -#undef TARGET_LITTLE_SYM +#undef TARGET_LITTLE_SYM #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec -#undef TARGET_LITTLE_NAME +#undef TARGET_LITTLE_NAME #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi" #undef ELF_OSABI #define ELF_OSABI ELFOSABI_CLOUDABI -#undef elf64_bed +#undef elf64_bed #define elf64_bed elf64_x86_64_cloudabi_bed #include "elf64-target.h" /* FreeBSD support. */ -#undef TARGET_LITTLE_SYM +#undef TARGET_LITTLE_SYM #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec -#undef TARGET_LITTLE_NAME +#undef TARGET_LITTLE_NAME #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd" #undef ELF_OSABI #define ELF_OSABI ELFOSABI_FREEBSD -#undef elf64_bed +#undef elf64_bed #define elf64_bed elf64_x86_64_fbsd_bed #include "elf64-target.h" @@ -5319,6 +5221,14 @@ elf_x86_64_special_sections[]= #undef TARGET_LITTLE_NAME #define TARGET_LITTLE_NAME "elf64-x86-64-sol2" +static const struct elf_x86_backend_data elf_x86_64_solaris_arch_bed = + { + is_solaris /* os */ + }; + +#undef elf_backend_arch_data +#define elf_backend_arch_data &elf_x86_64_solaris_arch_bed + /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE objects won't be recognized. */ #undef ELF_OSABI @@ -5398,11 +5308,11 @@ elf64_x86_64_nacl_elf_object_p (bfd *abfd) static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] = { - 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ + 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */ - 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ - 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ - 0x41, 0xff, 0xe3, /* jmpq *%r11 */ + 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ + 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ + 0x41, 0xff, 0xe3, /* jmpq *%r11 */ /* 9-byte nop sequence to pad out to the next 32-byte boundary. */ 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */ @@ -5412,49 +5322,49 @@ static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] = 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ - 0x66, /* excess data16 prefix */ - 0x90 /* nop */ + 0x66, /* excess data16 prefix */ + 0x90 /* nop */ }; static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] = { 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */ - 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ - 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ - 0x41, 0xff, 0xe3, /* jmpq *%r11 */ + 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ + 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ + 0x41, 0xff, 0xe3, /* jmpq *%r11 */ /* 15-byte nop sequence to pad out to the next 32-byte boundary. */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ /* Lazy GOT entries point here (32-byte aligned). */ - 0x68, /* pushq immediate */ - 0, 0, 0, 0, /* replaced with index into relocation table. */ - 0xe9, /* jmp relative */ - 0, 0, 0, 0, /* replaced with offset to start of .plt0. */ + 0x68, /* pushq immediate */ + 0, 0, 0, 0, /* replaced with index into relocation table. */ + 0xe9, /* jmp relative */ + 0, 0, 0, 0, /* replaced with offset to start of .plt0. */ - /* 22 bytes of nop to pad out to the standard size. */ + /* 22 bytes of nop to pad out to the standard size. */ 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ - 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */ + 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */ }; /* .eh_frame covering the .plt section. */ static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] = { -#if (PLT_CIE_LENGTH != 20 \ - || PLT_FDE_LENGTH != 36 \ - || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \ +#if (PLT_CIE_LENGTH != 20 \ + || PLT_FDE_LENGTH != 36 \ + || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \ || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12) -# error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!" +# error "Need elf_x86_backend_data parameters for eh_frame_plt offsets!" #endif PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 0, 0, 0, 0, /* CIE ID */ 1, /* CIE version */ - 'z', 'R', 0, /* Augmentation string */ + 'z', 'R', 0, /* Augmentation string */ 1, /* Code alignment factor */ - 0x78, /* Data alignment factor */ + 0x78, /* Data alignment factor */ 16, /* Return address column */ 1, /* Augmentation size */ DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */ @@ -5482,28 +5392,34 @@ static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] = static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt = { - elf_x86_64_nacl_plt0_entry, /* plt0_entry */ - NACL_PLT_ENTRY_SIZE, /* plt0_entry_size */ - elf_x86_64_nacl_plt_entry, /* plt_entry */ - NACL_PLT_ENTRY_SIZE, /* plt_entry_size */ - 2, /* plt0_got1_offset */ - 9, /* plt0_got2_offset */ - 13, /* plt0_got2_insn_end */ - 3, /* plt_got_offset */ - 33, /* plt_reloc_offset */ - 38, /* plt_plt_offset */ - 7, /* plt_got_insn_size */ - 42, /* plt_plt_insn_end */ - 32, /* plt_lazy_offset */ - elf_x86_64_nacl_plt0_entry, /* pic_plt0_entry */ - elf_x86_64_nacl_plt_entry, /* pic_plt_entry */ - elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */ + elf_x86_64_nacl_plt0_entry, /* plt0_entry */ + NACL_PLT_ENTRY_SIZE, /* plt0_entry_size */ + elf_x86_64_nacl_plt_entry, /* plt_entry */ + NACL_PLT_ENTRY_SIZE, /* plt_entry_size */ + elf_x86_64_nacl_plt0_entry, /* plt_tlsdesc_entry */ + NACL_PLT_ENTRY_SIZE, /* plt_tlsdesc_entry_size */ + 2, /* plt_tlsdesc_got1_offset */ + 9, /* plt_tlsdesc_got2_offset */ + 6, /* plt_tlsdesc_got1_insn_end */ + 13, /* plt_tlsdesc_got2_insn_end */ + 2, /* plt0_got1_offset */ + 9, /* plt0_got2_offset */ + 13, /* plt0_got2_insn_end */ + 3, /* plt_got_offset */ + 33, /* plt_reloc_offset */ + 38, /* plt_plt_offset */ + 7, /* plt_got_insn_size */ + 42, /* plt_plt_insn_end */ + 32, /* plt_lazy_offset */ + elf_x86_64_nacl_plt0_entry, /* pic_plt0_entry */ + elf_x86_64_nacl_plt_entry, /* pic_plt_entry */ + elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */ sizeof (elf_x86_64_nacl_eh_frame_plt) /* eh_frame_plt_size */ }; -static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed = +static const struct elf_x86_backend_data elf_x86_64_nacl_arch_bed = { - is_nacl /* os */ + is_nacl /* os */ }; #undef elf_backend_arch_data @@ -5513,8 +5429,8 @@ static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed = #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p #undef elf_backend_modify_segment_map #define elf_backend_modify_segment_map nacl_modify_segment_map -#undef elf_backend_modify_program_headers -#define elf_backend_modify_program_headers nacl_modify_program_headers +#undef elf_backend_modify_headers +#define elf_backend_modify_headers nacl_modify_headers #undef elf_backend_final_write_processing #define elf_backend_final_write_processing nacl_final_write_processing @@ -5530,9 +5446,9 @@ elf32_x86_64_nacl_elf_object_p (bfd *abfd) return TRUE; } -#undef TARGET_LITTLE_SYM +#undef TARGET_LITTLE_SYM #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec -#undef TARGET_LITTLE_NAME +#undef TARGET_LITTLE_NAME #define TARGET_LITTLE_NAME "elf32-x86-64-nacl" #undef elf32_bed #define elf32_bed elf32_x86_64_nacl_bed @@ -5556,6 +5472,9 @@ elf32_x86_64_nacl_elf_object_p (bfd *abfd) #define elf_backend_size_info \ _bfd_elf32_size_info +#undef elf32_bed +#define elf32_bed elf32_x86_64_bed + #include "elf32-target.h" /* Restore defaults. */ @@ -5564,7 +5483,7 @@ elf32_x86_64_nacl_elf_object_p (bfd *abfd) #undef elf_backend_bfd_from_remote_memory #undef elf_backend_size_info #undef elf_backend_modify_segment_map -#undef elf_backend_modify_program_headers +#undef elf_backend_modify_headers #undef elf_backend_final_write_processing /* Intel L1OM support. */ @@ -5599,7 +5518,11 @@ elf64_l1om_elf_object_p (bfd *abfd) #undef ELF_MAXPAGESIZE #undef ELF_MINPAGESIZE #undef ELF_COMMONPAGESIZE -#define ELF_MAXPAGESIZE 0x200000 +#if DEFAULT_LD_Z_SEPARATE_CODE +# define ELF_MAXPAGESIZE 0x1000 +#else +# define ELF_MAXPAGESIZE 0x200000 +#endif #define ELF_MINPAGESIZE 0x1000 #define ELF_COMMONPAGESIZE 0x1000 #undef elf_backend_plt_alignment