X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felf64-alpha.c;h=681f792c7131a58aff32bc659664604e2aba080c;hb=4ad0bb5f3a5b2d03079819cf419b174a762c2d52;hp=fd0d0524842a75dacfa762c369b4c31eb7f35ba3;hpb=a7519a3c057af6f71dcf4720270b3c4cf6e740a1;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c index fd0d052484..681f792c71 100644 --- a/bfd/elf64-alpha.c +++ b/bfd/elf64-alpha.c @@ -1,13 +1,12 @@ /* Alpha specific support for 64-bit ELF - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 - Free Software Foundation, Inc. + Copyright (C) 1996-2016 Free Software Foundation, Inc. Contributed by Richard Henderson . This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,13 +16,15 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + /* We need a published ABI spec for this. Until one comes out, don't assume this'll remain unchanged forever. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "elf-bfd.h" @@ -48,79 +49,137 @@ #include "ecoffswap.h" -struct alpha_elf_link_hash_entry +/* Instruction data for plt generation and relaxation. */ + +#define OP_LDA 0x08 +#define OP_LDAH 0x09 +#define OP_LDQ 0x29 +#define OP_BR 0x30 +#define OP_BSR 0x34 + +#define INSN_LDA (OP_LDA << 26) +#define INSN_LDAH (OP_LDAH << 26) +#define INSN_LDQ (OP_LDQ << 26) +#define INSN_BR (OP_BR << 26) + +#define INSN_ADDQ 0x40000400 +#define INSN_RDUNIQ 0x0000009e +#define INSN_SUBQ 0x40000520 +#define INSN_S4SUBQ 0x40000560 +#define INSN_UNOP 0x2ffe0000 + +#define INSN_JSR 0x68004000 +#define INSN_JMP 0x68000000 +#define INSN_JSR_MASK 0xfc00c000 + +#define INSN_A(I,A) (I | (A << 21)) +#define INSN_AB(I,A,B) (I | (A << 21) | (B << 16)) +#define INSN_ABC(I,A,B,C) (I | (A << 21) | (B << 16) | C) +#define INSN_ABO(I,A,B,O) (I | (A << 21) | (B << 16) | ((O) & 0xffff)) +#define INSN_AD(I,A,D) (I | (A << 21) | (((D) >> 2) & 0x1fffff)) + +/* PLT/GOT Stuff */ + +/* Set by ld emulation. Putting this into the link_info or hash structure + is simply working too hard. */ +#ifdef USE_SECUREPLT +bfd_boolean elf64_alpha_use_secureplt = TRUE; +#else +bfd_boolean elf64_alpha_use_secureplt = FALSE; +#endif + +#define OLD_PLT_HEADER_SIZE 32 +#define OLD_PLT_ENTRY_SIZE 12 +#define NEW_PLT_HEADER_SIZE 36 +#define NEW_PLT_ENTRY_SIZE 4 + +#define PLT_HEADER_SIZE \ + (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE) +#define PLT_ENTRY_SIZE \ + (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE) + +#define MAX_GOT_SIZE (64*1024) + +#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so" + + +/* Used to implement multiple .got subsections. */ +struct alpha_elf_got_entry { - struct elf_link_hash_entry root; + struct alpha_elf_got_entry *next; - /* External symbol information. */ - EXTR esym; + /* Which .got subsection? */ + bfd *gotobj; - /* Cumulative flags for all the .got entries. */ - int flags; + /* The addend in effect for this entry. */ + bfd_vma addend; - /* Contexts in which a literal was referenced. */ -#define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01 -#define ALPHA_ELF_LINK_HASH_LU_MEM 0x02 -#define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04 -#define ALPHA_ELF_LINK_HASH_LU_JSR 0x08 -#define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10 -#define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20 -#define ALPHA_ELF_LINK_HASH_LU_FUNC 0x38 -#define ALPHA_ELF_LINK_HASH_TLS_IE 0x40 -#define ALPHA_ELF_LINK_HASH_PLT_LOC 0x80 - - /* Used to undo the localization of a plt symbol. */ - asection *plt_old_section; - bfd_vma plt_old_value; + /* The .got offset for this entry. */ + int got_offset; - /* Used to implement multiple .got subsections. */ - struct alpha_elf_got_entry - { - struct alpha_elf_got_entry *next; + /* The .plt offset for this entry. */ + int plt_offset; - /* Which .got subsection? */ - bfd *gotobj; + /* How many references to this entry? */ + int use_count; - /* The addend in effect for this entry. */ - bfd_vma addend; + /* The relocation type of this entry. */ + unsigned char reloc_type; - /* The .got offset for this entry. */ - int got_offset; + /* How a LITERAL is used. */ + unsigned char flags; - /* How many references to this entry? */ - int use_count; + /* Have we initialized the dynamic relocation for this entry? */ + unsigned char reloc_done; - /* The relocation type of this entry. */ - unsigned char reloc_type; + /* Have we adjusted this entry for SEC_MERGE? */ + unsigned char reloc_xlated; +}; - /* How a LITERAL is used. */ - unsigned char flags; +struct alpha_elf_reloc_entry +{ + struct alpha_elf_reloc_entry *next; - /* Have we initialized the dynamic relocation for this entry? */ - unsigned char reloc_done; + /* Which .reloc section? */ + asection *srel; - /* Have we adjusted this entry for SEC_MERGE? */ - unsigned char reloc_xlated; - } *got_entries; + /* What kind of relocation? */ + unsigned int rtype; - /* Used to count non-got, non-plt relocations for delayed sizing - of relocation sections. */ - struct alpha_elf_reloc_entry - { - struct alpha_elf_reloc_entry *next; + /* Is this against read-only section? */ + unsigned int reltext : 1; + + /* How many did we find? */ + unsigned long count; +}; + +struct alpha_elf_link_hash_entry +{ + struct elf_link_hash_entry root; - /* Which .reloc section? */ - asection *srel; + /* External symbol information. */ + EXTR esym; + + /* Cumulative flags for all the .got entries. */ + int flags; - /* What kind of relocation? */ - unsigned int rtype; + /* Contexts in which a literal was referenced. */ +#define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01 +#define ALPHA_ELF_LINK_HASH_LU_MEM 0x02 +#define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04 +#define ALPHA_ELF_LINK_HASH_LU_JSR 0x08 +#define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10 +#define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20 +#define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40 +#define ALPHA_ELF_LINK_HASH_LU_PLT 0x38 +#define ALPHA_ELF_LINK_HASH_TLS_IE 0x80 - /* Is this against read-only section? */ - unsigned int reltext : 1; + /* Used to implement multiple .got subsections. */ + struct alpha_elf_got_entry *got_entries; - /* How many did we find? */ - unsigned long count; - } *reloc_entries; + /* Used to count non-got, non-plt relocations for delayed sizing + of relocation sections. */ + struct alpha_elf_reloc_entry *reloc_entries; }; /* Alpha ELF linker hash table. */ @@ -132,6 +191,10 @@ struct alpha_elf_link_hash_table /* The head of a list of .got subsections linked through alpha_elf_tdata(abfd)->got_link_next. */ bfd *got_list; + + /* The most recent relax pass that we've seen. The GOTs + should be regenerated if this doesn't match. */ + int relax_trip; }; /* Look up an entry in a Alpha ELF linker hash table. */ @@ -146,20 +209,21 @@ struct alpha_elf_link_hash_table #define alpha_elf_link_hash_traverse(table, func, info) \ (elf_link_hash_traverse \ (&(table)->root, \ - (bfd_boolean (*) (struct elf_link_hash_entry *, PTR)) (func), \ + (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ (info))) /* Get the Alpha ELF linker hash table from a link_info structure. */ #define alpha_elf_hash_table(p) \ - ((struct alpha_elf_link_hash_table *) ((p)->hash)) + (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ + == ALPHA_ELF_DATA ? ((struct alpha_elf_link_hash_table *) ((p)->hash)) : NULL) /* Get the object's symbols as our own entry type. */ #define alpha_elf_sym_hashes(abfd) \ ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd)) -/* Should we do dynamic things to this symbol? This differs from the +/* Should we do dynamic things to this symbol? This differs from the generic version in that we never need to consider function pointer equality wrt PLT entries -- we don't create a PLT entry if a symbol's address is ever taken. */ @@ -221,8 +285,10 @@ elf64_alpha_bfd_link_hash_table_create (bfd *abfd) if (ret == (struct alpha_elf_link_hash_table *) NULL) return NULL; - if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, - elf64_alpha_link_hash_newfunc)) + if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, + elf64_alpha_link_hash_newfunc, + sizeof (struct alpha_elf_link_hash_entry), + ALPHA_ELF_DATA)) { free (ret); return NULL; @@ -231,6 +297,15 @@ elf64_alpha_bfd_link_hash_table_create (bfd *abfd) return &ret->root.root; } +/* Alpha ELF follows MIPS ELF in using a special find_nearest_line + routine in order to handle the ECOFF debugging information. */ + +struct alpha_elf_find_line +{ + struct ecoff_debug_info d; + struct ecoff_find_line i; +}; + /* We have some private fields hanging off of the elf_tdata structure. */ struct alpha_elf_obj_tdata @@ -260,19 +335,25 @@ struct alpha_elf_obj_tdata /* For every got, this is the sum of the number of words required to hold all of the member object's local got. */ int local_got_size; + + /* Used by elf64_alpha_find_nearest_line entry point. */ + struct alpha_elf_find_line *find_line_info; + }; #define alpha_elf_tdata(abfd) \ ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any) +#define is_alpha_elf(bfd) \ + (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ + && elf_tdata (bfd) != NULL \ + && elf_object_id (bfd) == ALPHA_ELF_DATA) + static bfd_boolean elf64_alpha_mkobject (bfd *abfd) { - bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata); - abfd->tdata.any = bfd_zalloc (abfd, amt); - if (abfd->tdata.any == NULL) - return FALSE; - return TRUE; + return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata), + ALPHA_ELF_DATA); } static bfd_boolean @@ -287,7 +368,7 @@ elf64_alpha_object_p (bfd *abfd) static bfd_reloc_status_type elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc, asymbol *sym ATTRIBUTE_UNUSED, - PTR data ATTRIBUTE_UNUSED, asection *sec, + void * data ATTRIBUTE_UNUSED, asection *sec, bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED) { if (output_bfd) @@ -300,7 +381,7 @@ elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc, static bfd_reloc_status_type elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc, asymbol *sym ATTRIBUTE_UNUSED, - PTR data ATTRIBUTE_UNUSED, asection *sec, + void * data ATTRIBUTE_UNUSED, asection *sec, bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED) { if (output_bfd) @@ -352,7 +433,7 @@ elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah, static bfd_reloc_status_type elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry, - asymbol *sym ATTRIBUTE_UNUSED, PTR data, + asymbol *sym ATTRIBUTE_UNUSED, void * data, asection *input_section, bfd *output_bfd, char **err_msg) { @@ -397,15 +478,16 @@ elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry, from smaller values. Start with zero, widen, *then* decrement. */ #define MINUS_ONE (((bfd_vma)0) - 1) + #define SKIP_HOWTO(N) \ - HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0) + HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0) static reloc_howto_type elf64_alpha_howto_table[] = { HOWTO (R_ALPHA_NONE, /* type */ 0, /* rightshift */ - 0, /* size (0 = byte, 1 = short, 2 = long) */ - 8, /* bitsize */ + 3, /* size (0 = byte, 1 = short, 2 = long) */ + 0, /* bitsize */ TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ @@ -424,7 +506,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "REFLONG", /* name */ FALSE, /* partial_inplace */ 0xffffffff, /* src_mask */ @@ -439,7 +521,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "REFQUAD", /* name */ FALSE, /* partial_inplace */ MINUS_ONE, /* src_mask */ @@ -456,7 +538,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GPREL32", /* name */ FALSE, /* partial_inplace */ 0xffffffff, /* src_mask */ @@ -471,7 +553,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "ELF_LITERAL", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -537,7 +619,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "BRADDR", /* name */ FALSE, /* partial_inplace */ 0x1fffff, /* src_mask */ @@ -552,7 +634,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "HINT", /* name */ FALSE, /* partial_inplace */ 0x3fff, /* src_mask */ @@ -567,7 +649,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "SREL16", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -582,7 +664,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "SREL32", /* name */ FALSE, /* partial_inplace */ 0xffffffff, /* src_mask */ @@ -597,7 +679,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "SREL64", /* name */ FALSE, /* partial_inplace */ MINUS_ONE, /* src_mask */ @@ -619,7 +701,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GPRELHIGH", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -634,7 +716,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GPRELLOW", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -649,7 +731,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GPREL16", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -735,7 +817,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "BRSGP", /* name */ FALSE, /* partial_inplace */ 0x1fffff, /* src_mask */ @@ -750,7 +832,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TLSGD", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -765,7 +847,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TLSLDM", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -780,7 +862,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "DTPMOD64", /* name */ FALSE, /* partial_inplace */ MINUS_ONE, /* src_mask */ @@ -796,7 +878,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GOTDTPREL", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -811,7 +893,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "DTPREL64", /* name */ FALSE, /* partial_inplace */ MINUS_ONE, /* src_mask */ @@ -826,7 +908,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "DTPRELHI", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -841,7 +923,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "DTPRELLO", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -856,7 +938,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "DTPREL16", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -872,7 +954,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "GOTTPREL", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -887,7 +969,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TPREL64", /* name */ FALSE, /* partial_inplace */ MINUS_ONE, /* src_mask */ @@ -902,7 +984,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TPRELHI", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -917,7 +999,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TPRELLO", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -932,7 +1014,7 @@ static reloc_howto_type elf64_alpha_howto_table[] = FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ - 0, /* special_function */ + bfd_elf_generic_reloc, /* special_function */ "TPREL16", /* name */ FALSE, /* partial_inplace */ 0xffff, /* src_mask */ @@ -999,6 +1081,23 @@ elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, return 0; } +static reloc_howto_type * +elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, + const char *r_name) +{ + unsigned int i; + + for (i = 0; + i < (sizeof (elf64_alpha_howto_table) + / sizeof (elf64_alpha_howto_table[0])); + i++) + if (elf64_alpha_howto_table[i].name != NULL + && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0) + return &elf64_alpha_howto_table[i]; + + return NULL; +} + /* Given an Alpha ELF reloc type, fill in an arelent structure. */ static void @@ -1006,7 +1105,14 @@ elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, Elf_Internal_Rela *dst) { unsigned r_type = ELF64_R_TYPE(dst->r_info); - BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max); + + if (r_type >= R_ALPHA_max) + { + (*_bfd_error_handler) (_("%B: unrecognised Alpha reloc number: %d"), + abfd, r_type); + bfd_set_error (bfd_error_bad_value); + r_type = R_ALPHA_NONE; + } cache_ptr->howto = &elf64_alpha_howto_table[r_type]; } @@ -1025,22 +1131,6 @@ elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, - align_power ((bfd_vma) 16, \ elf_hash_table (info)->tls_sec->alignment_power)) -/* PLT/GOT Stuff */ -#define PLT_HEADER_SIZE 32 -#define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */ -#define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */ -#define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */ -#define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */ - -#define PLT_ENTRY_SIZE 12 -#define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */ -#define PLT_ENTRY_WORD2 0 -#define PLT_ENTRY_WORD3 0 - -#define MAX_GOT_SIZE (64*1024) - -#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so" - /* Handle an Alpha specific section when reading an object file. This is called when bfd_section_from_shdr finds a section with an unknown type. @@ -1137,7 +1227,7 @@ elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, asection **secp, bfd_vma *valp) { if (sym->st_shndx == SHN_COMMON - && !info->relocatable + && !bfd_link_relocatable (info) && sym->st_size <= elf_gp_size (abfd)) { /* Common symbols less than or equal to -G nn bytes are @@ -1168,26 +1258,26 @@ static bfd_boolean elf64_alpha_create_got_section (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED) { + flagword flags; asection *s; - if ((s = bfd_get_section_by_name (abfd, ".got"))) - { - /* Check for a non-linker created .got? */ - if (alpha_elf_tdata (abfd)->got == NULL) - alpha_elf_tdata (abfd)->got = s; - return TRUE; - } + if (! is_alpha_elf (abfd)) + return FALSE; - s = bfd_make_section_with_flags (abfd, ".got", (SEC_ALLOC | SEC_LOAD - | SEC_HAS_CONTENTS - | SEC_IN_MEMORY - | SEC_LINKER_CREATED)); + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED); + s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); if (s == NULL || !bfd_set_section_alignment (abfd, s, 3)) return FALSE; alpha_elf_tdata (abfd)->got = s; + /* Make sure the object's gotobj is set to itself so that we default + to every object with its own .got. We'll merge .gots later once + we've collected each object's info. */ + alpha_elf_tdata (abfd)->gotobj = abfd; + return TRUE; } @@ -1197,59 +1287,55 @@ static bfd_boolean elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) { asection *s; + flagword flags; struct elf_link_hash_entry *h; - struct bfd_link_hash_entry *bh; + + if (! is_alpha_elf (abfd)) + return FALSE; /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */ - s = bfd_make_section_with_flags (abfd, ".plt", - (SEC_ALLOC | SEC_LOAD - | SEC_HAS_CONTENTS - | SEC_IN_MEMORY - | SEC_LINKER_CREATED - | SEC_CODE)); - if (s == NULL - || ! bfd_set_section_alignment (abfd, s, 3)) + flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED + | (elf64_alpha_use_secureplt ? SEC_READONLY : 0)); + s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags); + if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4)) return FALSE; /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section. */ - bh = NULL; - if (! (_bfd_generic_link_add_one_symbol - (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, - (bfd_vma) 0, (const char *) NULL, FALSE, - get_elf_backend_data (abfd)->collect, &bh))) + h = _bfd_elf_define_linkage_sym (abfd, info, s, + "_PROCEDURE_LINKAGE_TABLE_"); + elf_hash_table (info)->hplt = h; + if (h == NULL) return FALSE; - h = (struct elf_link_hash_entry *) bh; - h->def_regular = 1; - h->type = STT_OBJECT; - if (info->shared - && ! bfd_elf_link_record_dynamic_symbol (info, h)) + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED | SEC_READONLY); + s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags); + if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3)) return FALSE; - s = bfd_make_section_with_flags (abfd, ".rela.plt", - (SEC_ALLOC | SEC_LOAD - | SEC_HAS_CONTENTS - | SEC_IN_MEMORY - | SEC_LINKER_CREATED - | SEC_READONLY)); - if (s == NULL - || ! bfd_set_section_alignment (abfd, s, 3)) - return FALSE; + if (elf64_alpha_use_secureplt) + { + flags = SEC_ALLOC | SEC_LINKER_CREATED; + s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); + if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3)) + return FALSE; + } /* We may or may not have created a .got section for this object, but we definitely havn't done the rest of the work. */ - if (!elf64_alpha_create_got_section (abfd, info)) - return FALSE; + if (alpha_elf_tdata(abfd)->gotobj == NULL) + { + if (!elf64_alpha_create_got_section (abfd, info)) + return FALSE; + } - s = bfd_make_section_with_flags (abfd, ".rela.got", - (SEC_ALLOC | SEC_LOAD - | SEC_HAS_CONTENTS - | SEC_IN_MEMORY - | SEC_LINKER_CREATED - | SEC_READONLY)); + flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED | SEC_READONLY); + s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags); if (s == NULL || !bfd_set_section_alignment (abfd, s, 3)) return FALSE; @@ -1258,21 +1344,11 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) dynobj's .got section. We don't do this in the linker script because we don't want to define the symbol if we are not creating a global offset table. */ - bh = NULL; - if (!(_bfd_generic_link_add_one_symbol - (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, - alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL, - FALSE, get_elf_backend_data (abfd)->collect, &bh))) - return FALSE; - h = (struct elf_link_hash_entry *) bh; - h->def_regular = 1; - h->type = STT_OBJECT; - - if (info->shared - && ! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - + h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got, + "_GLOBAL_OFFSET_TABLE_"); elf_hash_table (info)->hgot = h; + if (h == NULL) + return FALSE; return TRUE; } @@ -1319,17 +1395,17 @@ elf64_alpha_read_ecoff_info (bfd *abfd, asection *section, } READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *); - READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR); - READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR); - READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR); - READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR); + READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); + READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); + READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); + READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), union aux_ext *); READ (ss, cbSsOffset, issMax, sizeof (char), char *); READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *); - READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR); - READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR); - READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR); + READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); + READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); + READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *); #undef READ debug->fdr = NULL; @@ -1372,28 +1448,20 @@ elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name) return name[0] == '$'; } -/* Alpha ELF follows MIPS ELF in using a special find_nearest_line - routine in order to handle the ECOFF debugging information. We - still call this mips_elf_find_line because of the slot - find_line_info in elf_obj_tdata is declared that way. */ - -struct mips_elf_find_line -{ - struct ecoff_debug_info d; - struct ecoff_find_line i; -}; - static bfd_boolean -elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, - bfd_vma offset, const char **filename_ptr, +elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols, + asection *section, bfd_vma offset, + const char **filename_ptr, const char **functionname_ptr, - unsigned int *line_ptr) + unsigned int *line_ptr, + unsigned int *discriminator_ptr) { asection *msec; - if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, + if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset, filename_ptr, functionname_ptr, - line_ptr, 0, + line_ptr, discriminator_ptr, + dwarf_debug_sections, 0, &elf_tdata (abfd)->dwarf2_find_line_info)) return TRUE; @@ -1401,7 +1469,7 @@ elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, if (msec != NULL) { flagword origflags; - struct mips_elf_find_line *fi; + struct alpha_elf_find_line *fi; const struct ecoff_debug_swap * const swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; @@ -1412,16 +1480,16 @@ elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS) msec->flags |= SEC_HAS_CONTENTS; - fi = elf_tdata (abfd)->find_line_info; + fi = alpha_elf_tdata (abfd)->find_line_info; if (fi == NULL) { bfd_size_type external_fdr_size; char *fraw_src; char *fraw_end; struct fdr *fdr_ptr; - bfd_size_type amt = sizeof (struct mips_elf_find_line); + bfd_size_type amt = sizeof (struct alpha_elf_find_line); - fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt); + fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt); if (fi == NULL) { msec->flags = origflags; @@ -1448,9 +1516,9 @@ elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, fraw_end = (fraw_src + fi->d.symbolic_header.ifdMax * external_fdr_size); for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) - (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr); + (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr); - elf_tdata (abfd)->find_line_info = fi; + alpha_elf_tdata (abfd)->find_line_info = fi; /* Note that we don't bother to ever free this information. find_nearest_line is either called all the time, as in @@ -1473,9 +1541,9 @@ elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, /* Fall back on the generic ELF find_nearest_line routine. */ - return _bfd_elf_find_nearest_line (abfd, section, symbols, offset, + return _bfd_elf_find_nearest_line (abfd, symbols, section, offset, filename_ptr, functionname_ptr, - line_ptr); + line_ptr, discriminator_ptr); } /* Structure used to pass information to alpha_elf_output_extsym. */ @@ -1490,15 +1558,12 @@ struct extsym_info }; static bfd_boolean -elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, PTR data) +elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data) { struct extsym_info *einfo = (struct extsym_info *) data; bfd_boolean strip; asection *sec, *output_section; - if (h->root.root.type == bfd_link_hash_warning) - h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; - if (h->root.indx == -2) strip = FALSE; else if ((h->root.def_dynamic @@ -1592,24 +1657,6 @@ elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, PTR data) else h->esym.asym.value = 0; } - else if (h->root.needs_plt) - { - /* Set type and value for a symbol with a function stub. */ - h->esym.asym.st = stProc; - sec = bfd_get_section_by_name (einfo->abfd, ".plt"); - if (sec == NULL) - h->esym.asym.value = 0; - else - { - output_section = sec->output_section; - if (output_section != NULL) - h->esym.asym.value = (h->root.plt.offset - + sec->output_offset - + output_section->vma); - else - h->esym.asym.value = 0; - } - } if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap, h->root.root.root.string, @@ -1680,6 +1727,7 @@ get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h, gotent->gotobj = abfd; gotent->addend = r_addend; gotent->got_offset = -1; + gotent->plt_offset = -1; gotent->use_count = 1; gotent->reloc_type = r_type; gotent->reloc_done = 0; @@ -1699,6 +1747,28 @@ get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h, return gotent; } +static bfd_boolean +elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah) +{ + return ((ah->root.type == STT_FUNC + || ah->root.root.type == bfd_link_hash_undefweak + || ah->root.root.type == bfd_link_hash_undefined) + && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0 + && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0); +} + +/* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset. + Don't do so for code sections. We want to keep ordering of LITERAL/LITUSE + as is. On the other hand, elf-eh-frame.c processing requires .eh_frame + relocs to be sorted. */ + +static bfd_boolean +elf64_alpha_sort_relocs_p (asection *sec) +{ + return (sec->flags & SEC_CODE) == 0; +} + + /* Handle dynamic relocations when doing an Alpha ELF link. */ static bfd_boolean @@ -1707,14 +1777,12 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, { bfd *dynobj; asection *sreloc; - const char *rel_sec_name; Elf_Internal_Shdr *symtab_hdr; struct alpha_elf_link_hash_entry **sym_hashes; const Elf_Internal_Rela *rel, *relend; - bfd_boolean got_created; bfd_size_type amt; - if (info->relocatable) + if (bfd_link_relocatable (info)) return TRUE; /* Don't do anything special with non-loaded, non-alloced sections. @@ -1726,15 +1794,15 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, if ((sec->flags & SEC_ALLOC) == 0) return TRUE; - dynobj = elf_hash_table(info)->dynobj; + BFD_ASSERT (is_alpha_elf (abfd)); + + dynobj = elf_hash_table (info)->dynobj; if (dynobj == NULL) - elf_hash_table(info)->dynobj = dynobj = abfd; + elf_hash_table (info)->dynobj = dynobj = abfd; sreloc = NULL; - rel_sec_name = NULL; - symtab_hdr = &elf_tdata(abfd)->symtab_hdr; - sym_hashes = alpha_elf_sym_hashes(abfd); - got_created = FALSE; + symtab_hdr = &elf_symtab_hdr (abfd); + sym_hashes = alpha_elf_sym_hashes (abfd); relend = relocs + sec->reloc_count; for (rel = relocs; rel < relend; ++rel) @@ -1763,6 +1831,9 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, || h->root.root.type == bfd_link_hash_warning) h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; + /* PR15323, ref flags aren't set for references in the same + object. */ + h->root.root.non_ir_ref = 1; h->root.ref_regular = 1; } @@ -1771,7 +1842,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, have yet been processed. Do something with what we know, as this may help reduce memory usage and processing time later. */ maybe_dynamic = FALSE; - if (h && ((info->shared + if (h && ((bfd_link_pic (info) && (!info->symbolic || info->unresolved_syms_in_shared_libs == RM_IGNORE)) || !h->root.def_regular @@ -1792,7 +1863,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, This will be important when it comes to decide if we can create a .plt entry for a function symbol. */ while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE) - if (rel->r_addend >= 1 && rel->r_addend <= 5) + if (rel->r_addend >= 1 && rel->r_addend <= 6) gotent_flags |= 1 << rel->r_addend; --rel; @@ -1812,14 +1883,14 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, case R_ALPHA_REFLONG: case R_ALPHA_REFQUAD: - if (info->shared || maybe_dynamic) + if (bfd_link_pic (info) || maybe_dynamic) need = NEED_DYNREL; break; case R_ALPHA_TLSLDM: /* The symbol for a TLSLDM reloc is ignored. Collapse the - reloc to the 0 symbol so that they all match. */ - r_symndx = 0; + reloc to the STN_UNDEF (0) symbol so that they all match. */ + r_symndx = STN_UNDEF; h = 0; maybe_dynamic = FALSE; /* FALLTHRU */ @@ -1832,32 +1903,27 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, case R_ALPHA_GOTTPREL: need = NEED_GOT | NEED_GOT_ENTRY; gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE; - if (info->shared) + if (bfd_link_pic (info)) info->flags |= DF_STATIC_TLS; break; case R_ALPHA_TPREL64: - if (info->shared || maybe_dynamic) + if (bfd_link_dll (info)) + { + info->flags |= DF_STATIC_TLS; + need = NEED_DYNREL; + } + else if (maybe_dynamic) need = NEED_DYNREL; - if (info->shared) - info->flags |= DF_STATIC_TLS; break; } if (need & NEED_GOT) { - if (!got_created) + if (alpha_elf_tdata(abfd)->gotobj == NULL) { if (!elf64_alpha_create_got_section (abfd, info)) return FALSE; - - /* Make sure the object's gotobj is set to itself so - that we default to every object with its own .got. - We'll merge .gots later once we've collected each - object's info. */ - alpha_elf_tdata(abfd)->gotobj = abfd; - - got_created = 1; } } @@ -1878,52 +1944,28 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, h->flags = gotent_flags; /* Make a guess as to whether a .plt entry is needed. */ - if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC) - && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)) - h->root.needs_plt = 1; - else - h->root.needs_plt = 0; - } + /* ??? It appears that we won't make it into + adjust_dynamic_symbol for symbols that remain + totally undefined. Copying this check here means + we can create a plt entry for them too. */ + h->root.needs_plt + = (maybe_dynamic && elf64_alpha_want_plt (h)); + } } } if (need & NEED_DYNREL) { - if (rel_sec_name == NULL) - { - rel_sec_name = (bfd_elf_string_from_elf_section - (abfd, elf_elfheader(abfd)->e_shstrndx, - elf_section_data(sec)->rel_hdr.sh_name)); - if (rel_sec_name == NULL) - return FALSE; - - BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0 - && strcmp (bfd_get_section_name (abfd, sec), - rel_sec_name+5) == 0); - } - /* We need to create the section here now whether we eventually use it or not so that it gets mapped to an output section by - the linker. If not used, we'll kill it in - size_dynamic_sections. */ + the linker. If not used, we'll kill it in size_dynamic_sections. */ if (sreloc == NULL) { - sreloc = bfd_get_section_by_name (dynobj, rel_sec_name); + sreloc = _bfd_elf_make_dynamic_reloc_section + (sec, dynobj, 3, abfd, /*rela?*/ TRUE); + if (sreloc == NULL) - { - flagword flags; - - flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY - | SEC_LINKER_CREATED | SEC_READONLY); - if (sec->flags & SEC_ALLOC) - flags |= SEC_ALLOC | SEC_LOAD; - sreloc = bfd_make_section_with_flags (dynobj, - rel_sec_name, - flags); - if (sreloc == NULL - || !bfd_set_section_alignment (dynobj, sreloc, 3)) - return FALSE; - } + return FALSE; } if (h) @@ -1958,7 +2000,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, else rent->count++; } - else if (info->shared) + else if (bfd_link_pic (info)) { /* If this is a shared library, and the section is to be loaded into memory, we need a RELATIVE reloc. */ @@ -1972,6 +2014,93 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info, return TRUE; } +/* Return the section that should be marked against GC for a given + relocation. */ + +static asection * +elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info, + Elf_Internal_Rela *rel, + struct elf_link_hash_entry *h, Elf_Internal_Sym *sym) +{ + /* These relocations don't really reference a symbol. Instead we store + extra data in their addend slot. Ignore the symbol. */ + switch (ELF64_R_TYPE (rel->r_info)) + { + case R_ALPHA_LITUSE: + case R_ALPHA_GPDISP: + case R_ALPHA_HINT: + return NULL; + } + + return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); +} + +/* Update the got entry reference counts for the section being removed. */ + +static bfd_boolean +elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, + asection *sec, const Elf_Internal_Rela *relocs) +{ + Elf_Internal_Shdr *symtab_hdr; + struct alpha_elf_link_hash_entry **sym_hashes; + const Elf_Internal_Rela *rel, *relend; + + if (bfd_link_relocatable (info)) + return TRUE; + + symtab_hdr = &elf_symtab_hdr (abfd); + sym_hashes = alpha_elf_sym_hashes (abfd); + + relend = relocs + sec->reloc_count; + for (rel = relocs; rel < relend; rel++) + { + unsigned long r_symndx, r_type; + struct alpha_elf_link_hash_entry *h = NULL; + struct alpha_elf_got_entry *gotent; + + r_symndx = ELF64_R_SYM (rel->r_info); + if (r_symndx >= symtab_hdr->sh_info) + { + h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + while (h->root.root.type == bfd_link_hash_indirect + || h->root.root.type == bfd_link_hash_warning) + h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; + } + + r_type = ELF64_R_TYPE (rel->r_info); + switch (r_type) + { + case R_ALPHA_LITERAL: + /* ??? Ignore re-computation of gotent_flags. We're not + carrying a use-count for each bit in that mask. */ + + case R_ALPHA_TLSGD: + case R_ALPHA_GOTDTPREL: + case R_ALPHA_GOTTPREL: + /* Fetch the got entry from the tables. */ + gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend); + + /* The got entry *must* exist, since we should have created it + before during check_relocs. Also note that get_got_entry + assumed this was going to be another use, and so incremented + the use count again. Thus the use count must be at least the + one real use and the "use" we just added. */ + if (gotent == NULL || gotent->use_count < 2) + { + abort (); + return FALSE; + } + gotent->use_count -= 2; + break; + + default: + break; + } + } + + return TRUE; +} + /* Adjust a symbol defined by a dynamic object and referenced by a regular object. The current definition is in some section of the dynamic object, but we're not including those sections. We have to @@ -1990,56 +2119,26 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info, ah = (struct alpha_elf_link_hash_entry *)h; /* Now that we've seen all of the input symbols, finalize our decision - about whether this symbol should get a .plt entry. */ - - if (alpha_elf_dynamic_symbol_p (h, info) - && ((h->type == STT_FUNC - && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR)) - || (h->type == STT_NOTYPE - && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC) - && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))) - /* Don't prevent otherwise valid programs from linking by attempting - to create a new .got entry somewhere. A Correct Solution would be - to add a new .got section to a new object file and let it be merged - somewhere later. But for now don't bother. */ - && ah->got_entries) + about whether this symbol should get a .plt entry. Irritatingly, it + is common for folk to leave undefined symbols in shared libraries, + and they still expect lazy binding; accept undefined symbols in lieu + of STT_FUNC. */ + if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah)) { - h->needs_plt = 1; + h->needs_plt = TRUE; - s = bfd_get_section_by_name(dynobj, ".plt"); + s = bfd_get_linker_section (dynobj, ".plt"); if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info)) return FALSE; - /* The first bit of the .plt is reserved. */ - if (s->size == 0) - s->size = PLT_HEADER_SIZE; - - h->plt.offset = s->size; - s->size += PLT_ENTRY_SIZE; - - /* If this symbol is not defined in a regular file, and we are not - generating a shared library, then set the symbol to the location - in the .plt. This is required to make function pointers compare - equal between the normal executable and the shared library. */ - if (! info->shared - && h->root.type != bfd_link_hash_defweak) - { - ah->plt_old_section = h->root.u.def.section; - ah->plt_old_value = h->root.u.def.value; - ah->flags |= ALPHA_ELF_LINK_HASH_PLT_LOC; - h->root.u.def.section = s; - h->root.u.def.value = h->plt.offset; - } - - /* We also need a JMP_SLOT entry in the .rela.plt section. */ - s = bfd_get_section_by_name (dynobj, ".rela.plt"); - BFD_ASSERT (s != NULL); - s->size += sizeof (Elf64_External_Rela); + /* We need one plt entry per got subsection. Delay allocation of + the actual plt entries until size_plt_section, called from + size_dynamic_sections or during relaxation. */ return TRUE; } else - h->needs_plt = 0; + h->needs_plt = FALSE; /* If this is a weak symbol, and there is a real definition, the processor independent code will have arranged for us to see the @@ -2061,27 +2160,46 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info, return TRUE; } +/* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */ + +static void +elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h, + const Elf_Internal_Sym *isym, + bfd_boolean definition, + bfd_boolean dynamic) +{ + if (!dynamic && definition) + h->other = ((h->other & ELF_ST_VISIBILITY (-1)) + | (isym->st_other & ~ELF_ST_VISIBILITY (-1))); +} + /* Symbol versioning can create new symbols, and make our old symbols indirect to the new ones. Consolidate the got and reloc information in these situations. */ -static bfd_boolean -elf64_alpha_merge_ind_symbols (struct alpha_elf_link_hash_entry *hi, - PTR dummy ATTRIBUTE_UNUSED) +static void +elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info, + struct elf_link_hash_entry *dir, + struct elf_link_hash_entry *ind) { - struct alpha_elf_link_hash_entry *hs; + struct alpha_elf_link_hash_entry *hi + = (struct alpha_elf_link_hash_entry *) ind; + struct alpha_elf_link_hash_entry *hs + = (struct alpha_elf_link_hash_entry *) dir; - if (hi->root.root.type != bfd_link_hash_indirect) - return TRUE; - hs = hi; - do { - hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link; - } while (hs->root.root.type == bfd_link_hash_indirect); + /* Do the merging in the superclass. */ + _bfd_elf_link_hash_copy_indirect(info, dir, ind); /* Merge the flags. Whee. */ - hs->flags |= hi->flags; + /* ??? It's unclear to me what's really supposed to happen when + "merging" defweak and defined symbols, given that we don't + actually throw away the defweak. This more-or-less copies + the logic related to got and plt entries in the superclass. */ + if (ind->root.type != bfd_link_hash_indirect) + return; + /* Merge the .got entries. Cannibalize the old symbol's list in doing so, since we don't need it anymore. */ @@ -2134,8 +2252,6 @@ elf64_alpha_merge_ind_symbols (struct alpha_elf_link_hash_entry *hi, } } hi->reloc_entries = NULL; - - return TRUE; } /* Is it possible to merge two object file's .got tables? */ @@ -2300,14 +2416,10 @@ elf64_alpha_merge_gots (bfd *a, bfd *b) static bfd_boolean elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h, - PTR arg ATTRIBUTE_UNUSED) + void * arg ATTRIBUTE_UNUSED) { - bfd_boolean result = TRUE; struct alpha_elf_got_entry *gotent; - if (h->root.root.type == bfd_link_hash_warning) - h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; - for (gotent = h->got_entries; gotent; gotent = gotent->next) if (gotent->use_count > 0) { @@ -2315,25 +2427,24 @@ elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h, bfd_size_type *plge; td = alpha_elf_tdata (gotent->gotobj); - if (td == NULL) - { - _bfd_error_handler (_("Symbol %s has no GOT subsection for offset 0x%x"), - h->root.root.root.string, gotent->got_offset); - result = FALSE; - continue; - } plge = &td->got->size; gotent->got_offset = *plge; *plge += alpha_got_entry_size (gotent->reloc_type); } - return result; + return TRUE; } static void elf64_alpha_calc_got_offsets (struct bfd_link_info *info) { - bfd *i, *got_list = alpha_elf_hash_table(info)->got_list; + bfd *i, *got_list; + struct alpha_elf_link_hash_table * htab; + + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return; + got_list = htab->got_list; /* First, zero out the .got sizes, as we may be recalculating the .got after optimizing it. */ @@ -2341,7 +2452,7 @@ elf64_alpha_calc_got_offsets (struct bfd_link_info *info) alpha_elf_tdata(i)->got->size = 0; /* Next, fill in the offsets for all the global entries. */ - alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), + alpha_elf_link_hash_traverse (htab, elf64_alpha_calc_got_offsets_for_symbol, NULL); @@ -2376,20 +2487,29 @@ elf64_alpha_calc_got_offsets (struct bfd_link_info *info) /* Constructs the gots. */ static bfd_boolean -elf64_alpha_size_got_sections (struct bfd_link_info *info) +elf64_alpha_size_got_sections (struct bfd_link_info *info, + bfd_boolean may_merge) { bfd *i, *got_list, *cur_got_obj = NULL; - int something_changed = 0; + struct alpha_elf_link_hash_table * htab; - got_list = alpha_elf_hash_table (info)->got_list; + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return FALSE; + got_list = htab->got_list; /* On the first time through, pretend we have an existing got list consisting of all of the input files. */ if (got_list == NULL) { - for (i = info->input_bfds; i ; i = i->link_next) + for (i = info->input_bfds; i ; i = i->link.next) { - bfd *this_got = alpha_elf_tdata (i)->gotobj; + bfd *this_got; + + if (! is_alpha_elf (i)) + continue; + + this_got = alpha_elf_tdata (i)->gotobj; if (this_got == NULL) continue; @@ -2416,112 +2536,117 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info) if (got_list == NULL) return TRUE; - alpha_elf_hash_table (info)->got_list = got_list; - - /* Force got offsets to be recalculated. */ - something_changed = 1; + htab->got_list = got_list; } cur_got_obj = got_list; - i = alpha_elf_tdata(cur_got_obj)->got_link_next; - while (i != NULL) + if (cur_got_obj == NULL) + return FALSE; + + if (may_merge) { - if (elf64_alpha_can_merge_gots (cur_got_obj, i)) + i = alpha_elf_tdata(cur_got_obj)->got_link_next; + while (i != NULL) { - elf64_alpha_merge_gots (cur_got_obj, i); + if (elf64_alpha_can_merge_gots (cur_got_obj, i)) + { + elf64_alpha_merge_gots (cur_got_obj, i); - alpha_elf_tdata(i)->got->size = 0; - i = alpha_elf_tdata(i)->got_link_next; - alpha_elf_tdata(cur_got_obj)->got_link_next = i; - - something_changed = 1; - } - else - { - cur_got_obj = i; - i = alpha_elf_tdata(i)->got_link_next; + alpha_elf_tdata(i)->got->size = 0; + i = alpha_elf_tdata(i)->got_link_next; + alpha_elf_tdata(cur_got_obj)->got_link_next = i; + } + else + { + cur_got_obj = i; + i = alpha_elf_tdata(i)->got_link_next; + } } } /* Once the gots have been merged, fill in the got offsets for everything therein. */ - if (1 || something_changed) - elf64_alpha_calc_got_offsets (info); + elf64_alpha_calc_got_offsets (info); return TRUE; } static bfd_boolean -elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h, PTR data) +elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h, + void * data) { asection *splt = (asection *) data; struct alpha_elf_got_entry *gotent; + bfd_boolean saw_one = FALSE; /* If we didn't need an entry before, we still don't. */ if (!h->root.needs_plt) return TRUE; - /* There must still be a LITERAL got entry for the function. */ + /* For each LITERAL got entry still in use, allocate a plt entry. */ for (gotent = h->got_entries; gotent ; gotent = gotent->next) if (gotent->reloc_type == R_ALPHA_LITERAL && gotent->use_count > 0) - break; - - /* If there is, reset the PLT offset. If not, there's no longer - a need for the PLT entry. */ - if (gotent) - { - if (splt->size == 0) - splt->size = PLT_HEADER_SIZE; - h->root.plt.offset = splt->size; - splt->size += PLT_ENTRY_SIZE; - } - else - { - h->root.needs_plt = 0; - h->root.plt.offset = -1; + { + if (splt->size == 0) + splt->size = PLT_HEADER_SIZE; + gotent->plt_offset = splt->size; + splt->size += PLT_ENTRY_SIZE; + saw_one = TRUE; + } - /* Undo the definition frobbing begun in adjust_dynamic_symbol. */ - if (h->flags & ALPHA_ELF_LINK_HASH_PLT_LOC) - { - h->root.root.u.def.section = h->plt_old_section; - h->root.root.u.def.value = h->plt_old_value; - h->flags &= ~ALPHA_ELF_LINK_HASH_PLT_LOC; - } - } + /* If there weren't any, there's no longer a need for the PLT entry. */ + if (!saw_one) + h->root.needs_plt = FALSE; return TRUE; } -/* Called from relax_section to rebuild the PLT in light of - potential changes in the function's status. */ +/* Called from relax_section to rebuild the PLT in light of potential changes + in the function's status. */ -static bfd_boolean +static void elf64_alpha_size_plt_section (struct bfd_link_info *info) { - asection *splt, *spltrel; + asection *splt, *spltrel, *sgotplt; unsigned long entries; bfd *dynobj; + struct alpha_elf_link_hash_table * htab; + + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return; dynobj = elf_hash_table(info)->dynobj; - splt = bfd_get_section_by_name(dynobj, ".plt"); + splt = bfd_get_linker_section (dynobj, ".plt"); if (splt == NULL) - return TRUE; + return; splt->size = 0; - alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), + alpha_elf_link_hash_traverse (htab, elf64_alpha_size_plt_section_1, splt); /* Every plt entry requires a JMP_SLOT relocation. */ - spltrel = bfd_get_section_by_name (dynobj, ".rela.plt"); + spltrel = bfd_get_linker_section (dynobj, ".rela.plt"); + entries = 0; if (splt->size) - entries = (splt->size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; - else - entries = 0; + { + if (elf64_alpha_use_secureplt) + entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE; + else + entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE; + } spltrel->size = entries * sizeof (Elf64_External_Rela); - return TRUE; + /* When using the secureplt, we need two words somewhere in the data + segment for the dynamic linker to tell us where to go. This is the + entire contents of the .got.plt section. */ + if (elf64_alpha_use_secureplt) + { + sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); + sgotplt->size = entries ? 16 : 0; + } } static bfd_boolean @@ -2529,20 +2654,20 @@ elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) { bfd *i; + struct alpha_elf_link_hash_table * htab; - if (info->relocatable) + if (bfd_link_relocatable (info)) return TRUE; - /* First, take care of the indirect symbols created by versioning. */ - alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), - elf64_alpha_merge_ind_symbols, - NULL); + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return FALSE; - if (!elf64_alpha_size_got_sections (info)) + if (!elf64_alpha_size_got_sections (info, TRUE)) return FALSE; /* Allocate space for all of the .got subsections. */ - i = alpha_elf_hash_table (info)->got_list; + i = htab->got_list; for ( ; i ; i = alpha_elf_tdata(i)->got_link_next) { asection *s = alpha_elf_tdata(i)->got; @@ -2560,7 +2685,7 @@ elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, /* The number of dynamic relocations required by a static relocation. */ static int -alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared) +alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie) { switch (r_type) { @@ -2570,16 +2695,18 @@ alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared) case R_ALPHA_TLSLDM: return shared; case R_ALPHA_LITERAL: - case R_ALPHA_GOTTPREL: return dynamic || shared; + case R_ALPHA_GOTTPREL: + return dynamic || (shared && !pie); case R_ALPHA_GOTDTPREL: return dynamic; /* May appear in data sections. */ case R_ALPHA_REFLONG: case R_ALPHA_REFQUAD: - case R_ALPHA_TPREL64: return dynamic || shared; + case R_ALPHA_TPREL64: + return dynamic || (shared && !pie); /* Everything else is illegal. We'll issue an error during relocate_section. */ @@ -2598,9 +2725,6 @@ elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h, struct alpha_elf_reloc_entry *relent; unsigned long entries; - if (h->root.root.type == bfd_link_hash_warning) - h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; - /* If the symbol was defined as a common symbol in a regular object file, and there was no definition in any dynamic object, then the linker will have allocated space for the symbol in a common @@ -2623,14 +2747,15 @@ elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h, /* If the symbol is a hidden undefined weak, then we never have any relocations. Avoid the loop which may want to add RELATIVE relocs - based on info->shared. */ + based on bfd_link_pic (info). */ if (h->root.root.type == bfd_link_hash_undefweak && !dynamic) return TRUE; for (relent = h->reloc_entries; relent; relent = relent->next) { entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic, - info->shared); + bfd_link_pic (info), + bfd_link_pie (info)); if (entries) { relent->srel->size += @@ -2654,8 +2779,10 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h, struct alpha_elf_got_entry *gotent; unsigned long entries; - if (h->root.root.type == bfd_link_hash_warning) - h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; + /* If we're using a plt for this symbol, then all of its relocations + for its got entries go into .rela.plt. */ + if (h->root.needs_plt) + return TRUE; /* If the symbol is dynamic, we'll need all the relocations in their natural form. If this is a shared object, and it has been forced @@ -2664,25 +2791,21 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h, /* If the symbol is a hidden undefined weak, then we never have any relocations. Avoid the loop which may want to add RELATIVE relocs - based on info->shared. */ + based on bfd_link_pic (info). */ if (h->root.root.type == bfd_link_hash_undefweak && !dynamic) return TRUE; entries = 0; for (gotent = h->got_entries; gotent ; gotent = gotent->next) if (gotent->use_count > 0) - entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, - dynamic, info->shared); - - /* If we are using a .plt entry, subtract one, as the first - reference uses a .rela.plt entry instead. */ - if (h->root.plt.offset != MINUS_ONE) - entries--; + entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic, + bfd_link_pic (info), + bfd_link_pie (info)); if (entries > 0) { bfd *dynobj = elf_hash_table(info)->dynobj; - asection *srel = bfd_get_section_by_name (dynobj, ".rela.got"); + asection *srel = bfd_get_linker_section (dynobj, ".rela.got"); BFD_ASSERT (srel != NULL); srel->size += sizeof (Elf64_External_Rela) * entries; } @@ -2692,18 +2815,23 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h, /* Set the sizes of the dynamic relocation sections. */ -static bfd_boolean +static void elf64_alpha_size_rela_got_section (struct bfd_link_info *info) { unsigned long entries; bfd *i, *dynobj; asection *srel; + struct alpha_elf_link_hash_table * htab; + + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return; /* Shared libraries often require RELATIVE relocs, and some relocs require attention for the main application as well. */ entries = 0; - for (i = alpha_elf_hash_table(info)->got_list; + for (i = htab->got_list; i ; i = alpha_elf_tdata(i)->got_link_next) { bfd *j; @@ -2722,24 +2850,23 @@ elf64_alpha_size_rela_got_section (struct bfd_link_info *info) gotent ; gotent = gotent->next) if (gotent->use_count > 0) entries += (alpha_dynamic_entries_for_reloc - (gotent->reloc_type, 0, info->shared)); + (gotent->reloc_type, 0, bfd_link_pic (info), + bfd_link_pie (info))); } } dynobj = elf_hash_table(info)->dynobj; - srel = bfd_get_section_by_name (dynobj, ".rela.got"); + srel = bfd_get_linker_section (dynobj, ".rela.got"); if (!srel) { BFD_ASSERT (entries == 0); - return TRUE; + return; } srel->size = sizeof (Elf64_External_Rela) * entries; /* Now do the non-local symbols. */ - alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), + alpha_elf_link_hash_traverse (htab, elf64_alpha_size_rela_got_1, info); - - return TRUE; } /* Set the sizes of the dynamic sections. */ @@ -2751,6 +2878,11 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *dynobj; asection *s; bfd_boolean relplt; + struct alpha_elf_link_hash_table * htab; + + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return FALSE; dynobj = elf_hash_table(info)->dynobj; BFD_ASSERT(dynobj != NULL); @@ -2758,9 +2890,9 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, if (elf_hash_table (info)->dynamic_sections_created) { /* Set the contents of the .interp section to the interpreter. */ - if (info->executable) + if (bfd_link_executable (info) && !info->nointerp) { - s = bfd_get_section_by_name (dynobj, ".interp"); + s = bfd_get_linker_section (dynobj, ".interp"); BFD_ASSERT (s != NULL); s->size = sizeof ELF_DYNAMIC_INTERPRETER; s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; @@ -2770,10 +2902,11 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, symbols need dynamic relocation entries and which don't. We've collected information in check_relocs that we can now apply to size the dynamic relocation sections. */ - alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), + alpha_elf_link_hash_traverse (htab, elf64_alpha_calc_dynrel_sizes, info); elf64_alpha_size_rela_got_section (info); + elf64_alpha_size_plt_section (info); } /* else we're not dynamic and by definition we don't need such things. */ @@ -2784,7 +2917,6 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, for (s = dynobj->sections; s != NULL; s = s->next) { const char *name; - bfd_boolean strip; if (!(s->flags & SEC_LINKER_CREATED)) continue; @@ -2793,23 +2925,11 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, of the dynobj section names depend upon the input files. */ name = bfd_get_section_name (dynobj, s); - /* If we don't need this section, strip it from the output file. - This is to handle .rela.bss and .rela.plt. We must create it - in create_dynamic_sections, because it must be created before - the linker maps input sections to output sections. The - linker does that before adjust_dynamic_symbol is called, and - it is that function which decides whether anything needs to - go into these sections. */ - - strip = FALSE; - - if (strncmp (name, ".rela", 5) == 0) + if (CONST_STRNEQ (name, ".rela")) { - strip = (s->size == 0); - - if (!strip) + if (s->size != 0) { - if (strcmp(name, ".rela.plt") == 0) + if (strcmp (name, ".rela.plt") == 0) relplt = TRUE; /* We use the reloc_count field as a counter if we need @@ -2817,19 +2937,31 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, s->reloc_count = 0; } } - else if (strcmp (name, ".plt") != 0) + else if (! CONST_STRNEQ (name, ".got") + && strcmp (name, ".plt") != 0 + && strcmp (name, ".dynbss") != 0) { /* It's not one of our dynamic sections, so don't allocate space. */ continue; } - if (strip) - s->flags |= SEC_EXCLUDE; - else + if (s->size == 0) + { + /* If we don't need this section, strip it from the output file. + This is to handle .rela.bss and .rela.plt. We must create it + in create_dynamic_sections, because it must be created before + the linker maps input sections to output sections. The + linker does that before adjust_dynamic_symbol is called, and + it is that function which decides whether anything needs to + go into these sections. */ + if (!CONST_STRNEQ (name, ".got")) + s->flags |= SEC_EXCLUDE; + } + else if ((s->flags & SEC_HAS_CONTENTS) != 0) { /* Allocate memory for the section contents. */ s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); - if (s->contents == NULL && s->size != 0) + if (s->contents == NULL) return FALSE; } } @@ -2844,7 +2976,7 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, #define add_dynamic_entry(TAG, VAL) \ _bfd_elf_add_dynamic_entry (info, TAG, VAL) - if (info->executable) + if (bfd_link_executable (info)) { if (!add_dynamic_entry (DT_DEBUG, 0)) return FALSE; @@ -2857,6 +2989,10 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, || !add_dynamic_entry (DT_PLTREL, DT_RELA) || !add_dynamic_entry (DT_JMPREL, 0)) return FALSE; + + if (elf64_alpha_use_secureplt + && !add_dynamic_entry (DT_ALPHA_PLTRO, 1)) + return FALSE; } if (!add_dynamic_entry (DT_RELA, 0) @@ -2888,17 +3024,6 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, related to Alpha in particular. They are by David Wall, then of DEC WRL. */ -#define OP_LDA 0x08 -#define OP_LDAH 0x09 -#define INSN_JSR 0x68004000 -#define INSN_JSR_MASK 0xfc00c000 -#define OP_LDQ 0x29 -#define OP_BR 0x30 -#define OP_BSR 0x34 -#define INSN_UNOP 0x2ffe0000 -#define INSN_ADDQ 0x40000400 -#define INSN_RDUNIQ 0x0000009e - struct alpha_relax_info { bfd *abfd; @@ -2958,7 +3083,8 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval, return TRUE; /* Can't use local-exec relocations in shared libraries. */ - if (r_type == R_ALPHA_GOTTPREL && info->link_info->shared) + if (r_type == R_ALPHA_GOTTPREL + && bfd_link_dll (info->link_info)) return TRUE; if (r_type == R_ALPHA_LITERAL) @@ -2966,7 +3092,7 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval, /* Look for nice constant addresses. This includes the not-uncommon special case of 0 for undefweak symbols. */ if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak) - || (!info->link_info->shared + || (!bfd_link_pic (info->link_info) && (symval >= (bfd_vma)-0x8000 || symval < 0x8000))) { disp = 0; @@ -2976,6 +3102,10 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval, } else { + /* We may only create GPREL relocs during the second pass. */ + if (info->link_info->relax_pass == 0) + return TRUE; + disp = symval - info->gp; insn = (OP_LDA << 26) | (insn & 0x03ff0000); r_type = R_ALPHA_GPREL16; @@ -3076,7 +3206,7 @@ elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval) else { tsec_relocs = (_bfd_elf_link_read_relocs - (info->abfd, info->tsec, (PTR) NULL, + (info->abfd, info->tsec, NULL, (Elf_Internal_Rela *) NULL, info->link_info->keep_memory)); if (tsec_relocs == NULL) @@ -3105,7 +3235,7 @@ elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval) /* We've now determined that we can skip an initial gp load. Verify that the call and the target use the same gp. */ - if (info->link_info->hash->creator != info->tsec->owner->xvec + if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj) return 0; @@ -3116,21 +3246,27 @@ static bfd_boolean elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, bfd_vma symval, Elf_Internal_Rela *irel) { - Elf_Internal_Rela *urel, *irelend = info->relend; - int flags, count, i; + Elf_Internal_Rela *urel, *erel, *irelend = info->relend; + int flags; bfd_signed_vma disp; bfd_boolean fits16; bfd_boolean fits32; bfd_boolean lit_reused = FALSE; bfd_boolean all_optimized = TRUE; + bfd_boolean changed_contents; + bfd_boolean changed_relocs; + bfd_byte *contents = info->contents; + bfd *abfd = info->abfd; + bfd_vma sec_output_vma; unsigned int lit_insn; + int relax_pass; - lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset); + lit_insn = bfd_get_32 (abfd, contents + irel->r_offset); if (lit_insn >> 26 != OP_LDQ) { ((*_bfd_error_handler) ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn", - info->abfd, info->sec, + abfd, info->sec, (unsigned long) irel->r_offset)); return TRUE; } @@ -3139,25 +3275,32 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info)) return TRUE; + changed_contents = info->changed_contents; + changed_relocs = info->changed_relocs; + sec_output_vma = info->sec->output_section->vma + info->sec->output_offset; + relax_pass = info->link_info->relax_pass; + /* Summarize how this particular LITERAL is used. */ - for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count) + for (erel = irel+1, flags = 0; erel < irelend; ++erel) { - if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE) + if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE) break; - if (urel->r_addend <= 3) - flags |= 1 << urel->r_addend; + if (erel->r_addend <= 6) + flags |= 1 << erel->r_addend; } /* A little preparation for the loop... */ disp = symval - info->gp; - for (urel = irel+1, i = 0; i < count; ++i, ++urel) + for (urel = irel+1; urel < erel; ++urel) { + bfd_vma urel_r_offset = urel->r_offset; unsigned int insn; int insn_disp; bfd_signed_vma xdisp; + Elf_Internal_Rela nrel; - insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset); + insn = bfd_get_32 (abfd, contents + urel_r_offset); switch (urel->r_addend) { @@ -3169,6 +3312,13 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, break; case LITUSE_ALPHA_BASE: + /* We may only create GPREL relocs during the second pass. */ + if (relax_pass == 0) + { + all_optimized = FALSE; + break; + } + /* We can always optimize 16-bit displacements. */ /* Extract the displacement from the instruction, sign-extending @@ -3186,14 +3336,20 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, /* Take the op code and dest from this insn, take the base register from the literal insn. Leave the offset alone. */ insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000); - urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), - R_ALPHA_GPREL16); - urel->r_addend = irel->r_addend; - info->changed_relocs = TRUE; - - bfd_put_32 (info->abfd, (bfd_vma) insn, - info->contents + urel->r_offset); - info->changed_contents = TRUE; + bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset); + changed_contents = TRUE; + + nrel = *urel; + nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_ALPHA_GPREL16); + nrel.r_addend = irel->r_addend; + + /* As we adjust, move the reloc to the end so that we don't + break the LITERAL+LITUSE chain. */ + if (urel < --erel) + *urel-- = *erel; + *erel = nrel; + changed_relocs = TRUE; } /* If all mem+byte, we can optimize 32-bit mem displacements. */ @@ -3204,15 +3360,16 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELHIGH); lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000); - bfd_put_32 (info->abfd, (bfd_vma) lit_insn, - info->contents + irel->r_offset); + bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset); lit_reused = TRUE; - info->changed_contents = TRUE; + changed_contents = TRUE; + /* Since all relocs must be optimized, don't bother swapping + this relocation to the end. */ urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW); urel->r_addend = irel->r_addend; - info->changed_relocs = TRUE; + changed_relocs = TRUE; } else all_optimized = FALSE; @@ -3226,19 +3383,25 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, insn &= ~ (unsigned) 0x001ff000; insn |= ((symval & 7) << 13) | 0x1000; - - urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE); - urel->r_addend = 0; - info->changed_relocs = TRUE; - - bfd_put_32 (info->abfd, (bfd_vma) insn, - info->contents + urel->r_offset); - info->changed_contents = TRUE; + bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset); + changed_contents = TRUE; + + nrel = *urel; + nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE); + nrel.r_addend = 0; + + /* As we adjust, move the reloc to the end so that we don't + break the LITERAL+LITUSE chain. */ + if (urel < --erel) + *urel-- = *erel; + *erel = nrel; + changed_relocs = TRUE; break; case LITUSE_ALPHA_JSR: case LITUSE_ALPHA_TLSGD: case LITUSE_ALPHA_TLSLDM: + case LITUSE_ALPHA_JSRDIRECT: { bfd_vma optdest, org; bfd_signed_vma odisp; @@ -3249,18 +3412,15 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, if (info->h && info->h->root.root.type == bfd_link_hash_undefweak) { insn |= 31 << 16; - bfd_put_32 (info->abfd, (bfd_vma) insn, - info->contents + urel->r_offset); + bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset); - info->changed_contents = TRUE; + changed_contents = TRUE; break; } /* If not zero, place to jump without needing pv. */ optdest = elf64_alpha_relax_opt_call (info, symval); - org = (info->sec->output_section->vma - + info->sec->output_offset - + urel->r_offset + 4); + org = sec_output_vma + urel_r_offset + 4; odisp = (optdest ? optdest : symval) - org; if (odisp >= -0x400000 && odisp < 0x400000) @@ -3272,27 +3432,32 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, insn = (OP_BSR << 26) | (insn & 0x03e00000); else insn = (OP_BR << 26) | (insn & 0x03e00000); + bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset); + changed_contents = TRUE; - urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), - R_ALPHA_BRADDR); - urel->r_addend = irel->r_addend; + nrel = *urel; + nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_ALPHA_BRADDR); + nrel.r_addend = irel->r_addend; if (optdest) - urel->r_addend += optdest - symval; + nrel.r_addend += optdest - symval; else all_optimized = FALSE; - bfd_put_32 (info->abfd, (bfd_vma) insn, - info->contents + urel->r_offset); - /* Kill any HINT reloc that might exist for this insn. */ xrel = (elf64_alpha_find_reloc_at_ofs - (info->relocs, info->relend, urel->r_offset, + (info->relocs, info->relend, urel_r_offset, R_ALPHA_HINT)); if (xrel) xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE); - info->changed_contents = TRUE; + /* As we adjust, move the reloc to the end so that we don't + break the LITERAL+LITUSE chain. */ + if (urel < --erel) + *urel-- = *erel; + *erel = nrel; + info->changed_relocs = TRUE; } else @@ -3304,14 +3469,14 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, { Elf_Internal_Rela *gpdisp = (elf64_alpha_find_reloc_at_ofs - (info->relocs, irelend, urel->r_offset + 4, + (info->relocs, irelend, urel_r_offset + 4, R_ALPHA_GPDISP)); if (gpdisp) { - bfd_byte *p_ldah = info->contents + gpdisp->r_offset; + bfd_byte *p_ldah = contents + gpdisp->r_offset; bfd_byte *p_lda = p_ldah + gpdisp->r_addend; - unsigned int ldah = bfd_get_32 (info->abfd, p_ldah); - unsigned int lda = bfd_get_32 (info->abfd, p_lda); + unsigned int ldah = bfd_get_32 (abfd, p_ldah); + unsigned int lda = bfd_get_32 (abfd, p_lda); /* Verify that the instruction is "ldah $29,0($26)". Consider a function that ends in a noreturn call, @@ -3320,12 +3485,12 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, In that case the insn would use $27 as the base. */ if (ldah == 0x27ba0000 && lda == 0x23bd0000) { - bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah); - bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda); + bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah); + bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda); gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE); - info->changed_contents = TRUE; - info->changed_relocs = TRUE; + changed_contents = TRUE; + changed_relocs = TRUE; } } } @@ -3334,6 +3499,9 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, } } + /* If we reused the literal instruction, we must have optimized all. */ + BFD_ASSERT(!lit_reused || all_optimized); + /* If all cases were optimized, we can reduce the use count on this got entry by one, possibly eliminating it. */ if (all_optimized) @@ -3353,17 +3521,19 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info, if (!lit_reused) { irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE); - info->changed_relocs = TRUE; + changed_relocs = TRUE; - bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, - info->contents + irel->r_offset); - info->changed_contents = TRUE; + bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset); + changed_contents = TRUE; } - - return TRUE; } - else - return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL); + + info->changed_contents = changed_contents; + info->changed_relocs = changed_relocs; + + if (all_optimized || relax_pass == 0) + return TRUE; + return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL); } static bfd_boolean @@ -3371,9 +3541,9 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, Elf_Internal_Rela *irel, bfd_boolean is_gd) { bfd_byte *pos[5]; - unsigned int insn; + unsigned int insn, tlsgd_reg; Elf_Internal_Rela *gpdisp, *hint; - bfd_boolean dynamic, use_gottprel, pos1_unusable; + bfd_boolean dynamic, use_gottprel; unsigned long new_symndx; dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info); @@ -3385,12 +3555,12 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, /* If the symbol is local, and we've already committed to DF_STATIC_TLS, then we might as well relax to IE. */ - else if (info->link_info->shared && !dynamic + else if (bfd_link_pic (info->link_info) && !dynamic && (info->link_info->flags & DF_STATIC_TLS)) ; /* Otherwise we must be building an executable to do anything. */ - else if (info->link_info->shared) + else if (bfd_link_pic (info->link_info)) return TRUE; /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and @@ -3414,7 +3584,13 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, pos[2] = info->contents + irel[2].r_offset; pos[3] = info->contents + gpdisp->r_offset; pos[4] = pos[3] + gpdisp->r_addend; - pos1_unusable = FALSE; + + /* Beware of the compiler hoisting part of the sequence out a loop + and adjusting the destination register for the TLSGD insn. If this + happens, there will be a move into $16 before the JSR insn, so only + transformations of the first insn pair should use this register. */ + tlsgd_reg = bfd_get_32 (info->abfd, pos[0]); + tlsgd_reg = (tlsgd_reg >> 21) & 31; /* Generally, the positions are not allowed to be out of order, lest the modified insn sequence have different register lifetimes. We can make @@ -3425,8 +3601,6 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, pos[0] = pos[1]; pos[1] = tmp; } - else if (pos[1] < pos[0]) - pos1_unusable = TRUE; if (pos[1] >= pos[2] || pos[2] >= pos[3]) return TRUE; @@ -3483,8 +3657,11 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, as appropriate. */ use_gottprel = FALSE; - new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : 0; - switch (!dynamic && !info->link_info->shared) + new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF; + + /* Some compilers warn about a Boolean-looking expression being + used in a switch. The explicit cast silences them. */ + switch ((int) (!dynamic && !bfd_link_pic (info->link_info))) { case 1: { @@ -3497,7 +3674,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, if (disp >= -0x8000 && disp < 0x8000) { - insn = (OP_LDA << 26) | (16 << 21) | (31 << 16); + insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16); bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]); bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]); @@ -3508,11 +3685,11 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, } else if (disp >= -(bfd_signed_vma) 0x80000000 && disp < (bfd_signed_vma) 0x7fff8000 - && !pos1_unusable) + && pos[0] + 4 == pos[1]) { - insn = (OP_LDAH << 26) | (16 << 21) | (31 << 16); + insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16); bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]); - insn = (OP_LDA << 26) | (16 << 21) | (16 << 16); + insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16); bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]); irel[0].r_offset = pos[0] - info->contents; @@ -3527,7 +3704,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval, default: use_gottprel = TRUE; - insn = (OP_LDQ << 26) | (16 << 21) | (29 << 16); + insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16); bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]); bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]); @@ -3617,22 +3794,50 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec, Elf_Internal_Sym *isymbuf = NULL; struct alpha_elf_got_entry **local_got_entries; struct alpha_relax_info info; + struct alpha_elf_link_hash_table * htab; + int relax_pass; - /* We are not currently changing any sizes, so only one pass. */ + htab = alpha_elf_hash_table (link_info); + if (htab == NULL) + return FALSE; + + /* There's nothing to change, yet. */ *again = FALSE; - if (link_info->relocatable + if (bfd_link_relocatable (link_info) || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC)) != (SEC_CODE | SEC_RELOC | SEC_ALLOC)) || sec->reloc_count == 0) return TRUE; - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + BFD_ASSERT (is_alpha_elf (abfd)); + relax_pass = link_info->relax_pass; + + /* Make sure our GOT and PLT tables are up-to-date. */ + if (htab->relax_trip != link_info->relax_trip) + { + htab->relax_trip = link_info->relax_trip; + + /* This should never fail after the initial round, since the only error + is GOT overflow, and relaxation only shrinks the table. However, we + may only merge got sections during the first pass. If we merge + sections after we've created GPREL relocs, the GP for the merged + section backs up which may put the relocs out of range. */ + if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0)) + abort (); + if (elf_hash_table (link_info)->dynamic_sections_created) + { + elf64_alpha_size_plt_section (link_info); + elf64_alpha_size_rela_got_section (link_info); + } + } + + symtab_hdr = &elf_symtab_hdr (abfd); local_got_entries = alpha_elf_tdata(abfd)->local_got_entries; /* Load the relocations for this section. */ internal_relocs = (_bfd_elf_link_read_relocs - (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, + (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, link_info->keep_memory)); if (internal_relocs == NULL) return FALSE; @@ -3673,24 +3878,21 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec, unsigned long r_symndx = ELF64_R_SYM (irel->r_info); /* Early exit for unhandled or unrelaxable relocations. */ - switch (r_type) - { - case R_ALPHA_LITERAL: - case R_ALPHA_GPRELHIGH: - case R_ALPHA_GPRELLOW: - case R_ALPHA_GOTDTPREL: - case R_ALPHA_GOTTPREL: - case R_ALPHA_TLSGD: - break; - - case R_ALPHA_TLSLDM: - /* The symbol for a TLSLDM reloc is ignored. Collapse the - reloc to the 0 symbol so that they all match. */ - r_symndx = 0; - break; - - default: - continue; + if (r_type != R_ALPHA_LITERAL) + { + /* We complete everything except LITERAL in the first pass. */ + if (relax_pass != 0) + continue; + if (r_type == R_ALPHA_TLSLDM) + { + /* The symbol for a TLSLDM reloc is ignored. Collapse the + reloc to the STN_UNDEF (0) symbol so that they all match. */ + r_symndx = STN_UNDEF; + } + else if (r_type != R_ALPHA_GOTDTPREL + && r_type != R_ALPHA_GOTTPREL + && r_type != R_ALPHA_TLSGD) + continue; } /* Get the value of the symbol referred to by the reloc. */ @@ -3836,13 +4038,6 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec, } } - if (!elf64_alpha_size_plt_section (link_info)) - return FALSE; - if (!elf64_alpha_size_got_sections (link_info)) - return FALSE; - if (!elf64_alpha_size_rela_got_section (link_info)) - return FALSE; - if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) { @@ -3938,9 +4133,11 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED, unsigned long symtab_hdr_sh_info; Elf_Internal_Rela *rel; Elf_Internal_Rela *relend; + struct elf_link_hash_entry **sym_hashes; bfd_boolean ret_val = TRUE; - symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info; + symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info; + sym_hashes = elf_sym_hashes (input_bfd); relend = relocs + input_section->reloc_count; for (rel = relocs; rel < relend; rel++) @@ -3950,7 +4147,7 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec; unsigned long r_type; - r_type = ELF64_R_TYPE(rel->r_info); + r_type = ELF64_R_TYPE (rel->r_info); if (r_type >= R_ALPHA_max) { (*_bfd_error_handler) @@ -3961,22 +4158,43 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED, continue; } - r_symndx = ELF64_R_SYM(rel->r_info); - /* The symbol associated with GPDISP and LITUSE is immaterial. Only the addend is significant. */ if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE) continue; + r_symndx = ELF64_R_SYM (rel->r_info); if (r_symndx < symtab_hdr_sh_info) { sym = local_syms + r_symndx; - if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) - { - sec = local_sections[r_symndx]; - rel->r_addend += sec->output_offset + sym->st_value; - } + sec = local_sections[r_symndx]; } + else + { + struct elf_link_hash_entry *h; + + h = sym_hashes[r_symndx - symtab_hdr_sh_info]; + + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + if (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak) + continue; + + sym = NULL; + sec = h->root.u.def.section; + } + + if (sec != NULL && discarded_section (sec)) + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, 1, relend, + elf64_alpha_howto_table + r_type, 0, + contents); + + if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION) + rel->r_addend += sec->output_offset; } return ret_val; @@ -4000,8 +4218,10 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, struct alpha_elf_got_entry **local_got_entries; bfd_boolean ret_val; + BFD_ASSERT (is_alpha_elf (input_bfd)); + /* Handle relocatable links with a smaller loop. */ - if (info->relocatable) + if (bfd_link_relocatable (info)) return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section, contents, relocs, local_syms, local_sections); @@ -4010,11 +4230,11 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, ret_val = TRUE; - symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; + symtab_hdr = &elf_symtab_hdr (input_bfd); dynobj = elf_hash_table (info)->dynobj; if (dynobj) - srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); + srelgot = bfd_get_linker_section (dynobj, ".rela.got"); else srelgot = NULL; @@ -4023,9 +4243,9 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, const char *section_name; section_name = (bfd_elf_string_from_elf_section (input_bfd, elf_elfheader(input_bfd)->e_shstrndx, - elf_section_data(input_section)->rel_hdr.sh_name)); + _bfd_elf_single_rel_hdr (input_section)->sh_name)); BFD_ASSERT(section_name != NULL); - srel = bfd_get_section_by_name (dynobj, section_name); + srel = bfd_get_linker_section (dynobj, section_name); } else srel = NULL; @@ -4073,6 +4293,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, bfd_vma value; bfd_vma addend; bfd_boolean dynamic_symbol_p; + bfd_boolean unresolved_reloc = FALSE; bfd_boolean undef_weak_ref = FALSE; unsigned long r_type; @@ -4091,9 +4312,9 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, r_symndx = ELF64_R_SYM(rel->r_info); /* The symbol for a TLSLDM reloc is ignored. Collapse the - reloc to the 0 symbol so that they all match. */ + reloc to the STN_UNDEF (0) symbol so that they all match. */ if (r_type == R_ALPHA_TLSLDM) - r_symndx = 0; + r_symndx = STN_UNDEF; if (r_symndx < symtab_hdr->sh_info) { @@ -4103,17 +4324,17 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, msec = sec; value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel); - /* If this is a tp-relative relocation against sym 0, + /* If this is a tp-relative relocation against sym STN_UNDEF (0), this is hackery from relax_section. Force the value to - be the tls base. */ - if (r_symndx == 0 + be the tls module base. */ + if (r_symndx == STN_UNDEF && (r_type == R_ALPHA_TLSLDM || r_type == R_ALPHA_GOTTPREL || r_type == R_ALPHA_TPREL64 || r_type == R_ALPHA_TPRELHI || r_type == R_ALPHA_TPRELLO || r_type == R_ALPHA_TPREL16)) - value = tp_base; + value = dtp_base; if (local_got_entries) gotent = local_got_entries[r_symndx]; @@ -4124,7 +4345,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, unless it has been done already. */ if ((sec->flags & SEC_MERGE) && ELF_ST_TYPE (sym->st_info) == STT_SECTION - && sec->sec_info_type == ELF_INFO_TYPE_MERGE + && sec->sec_info_type == SEC_INFO_TYPE_MERGE && gotent && !gotent->reloc_xlated) { @@ -4153,15 +4374,14 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, } else { - bfd_boolean warned; - bfd_boolean unresolved_reloc; + bfd_boolean warned, ignored; struct elf_link_hash_entry *hh; struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, r_symndx, symtab_hdr, sym_hashes, hh, sec, value, - unresolved_reloc, warned); + unresolved_reloc, warned, ignored); if (warned) continue; @@ -4176,6 +4396,10 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, gotent = h->got_entries; } + if (sec != NULL && discarded_section (sec)) + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, 1, relend, howto, 0, contents); + addend = rel->r_addend; value += addend; @@ -4222,7 +4446,9 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, /* If the symbol has been forced local, output a RELATIVE reloc, otherwise it will be handled in finish_dynamic_symbol. */ - if (info->shared && !dynamic_symbol_p && !undef_weak_ref) + if (bfd_link_pic (info) + && !dynamic_symbol_p + && !undef_weak_ref) elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot, gotent->got_offset, 0, R_ALPHA_RELATIVE, value); @@ -4235,18 +4461,6 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, goto default_reloc; case R_ALPHA_GPREL32: - /* If the target section was a removed linkonce section, - r_symndx will be zero. In this case, assume that the - switch will not be used, so don't fill it in. If we - do nothing here, we'll get relocation truncated messages, - due to the placement of the application above 4GB. */ - if (r_symndx == 0) - { - r = bfd_reloc_ok; - break; - } - /* FALLTHRU */ - case R_ALPHA_GPREL16: case R_ALPHA_GPRELLOW: if (dynamic_symbol_p) @@ -4384,7 +4598,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, else if (r_type == R_ALPHA_TPREL64) { BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL); - if (!info->shared) + if (!bfd_link_dll (info)) { value -= tp_base; goto default_reloc; @@ -4392,10 +4606,15 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, dynindx = 0; dynaddend = value - dtp_base; } - else if (info->shared - && r_symndx != 0 + else if (bfd_link_pic (info) + && r_symndx != STN_UNDEF && (input_section->flags & SEC_ALLOC) - && !undef_weak_ref) + && !undef_weak_ref + && !(unresolved_reloc + && (_bfd_elf_section_offset (output_bfd, info, + input_section, + rel->r_offset) + == (bfd_vma) -1))) { if (r_type == R_ALPHA_REFLONG) { @@ -4429,7 +4648,8 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, input_bfd, h->root.root.root.string); ret_val = FALSE; } - else if ((info->shared || info->pie) && undef_weak_ref) + else if (bfd_link_pic (info) + && undef_weak_ref) { (*_bfd_error_handler) (_("%B: pc-relative relocation against undefined weak symbol %s"), @@ -4441,7 +4661,11 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, /* ??? .eh_frame references to discarded sections will be smashed to relocations against SHN_UNDEF. The .eh_frame format allows NULL to be encoded as 0 in any format, so this works here. */ - if (r_symndx == 0) + if (r_symndx == STN_UNDEF + || (unresolved_reloc + && _bfd_elf_section_offset (output_bfd, info, + input_section, + rel->r_offset) == (bfd_vma) -1)) howto = (elf64_alpha_howto_table + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG)); goto default_reloc; @@ -4458,13 +4682,14 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, gotent->reloc_done = 1; /* Note that the module index for the main program is 1. */ - bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p, + bfd_put_64 (output_bfd, + !bfd_link_pic (info) && !dynamic_symbol_p, sgot->contents + gotent->got_offset); /* If the symbol has been forced local, output a DTPMOD64 reloc, otherwise it will be handled in finish_dynamic_symbol. */ - if (info->shared && !dynamic_symbol_p) + if (bfd_link_pic (info) && !dynamic_symbol_p) elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot, gotent->got_offset, 0, R_ALPHA_DTPMOD64, 0); @@ -4505,7 +4730,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, case R_ALPHA_TPRELHI: case R_ALPHA_TPRELLO: case R_ALPHA_TPREL16: - if (info->shared) + if (bfd_link_dll (info)) { (*_bfd_error_handler) (_("%B: TLS local exec code cannot be linked into shared objects"), @@ -4543,7 +4768,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL); if (r_type == R_ALPHA_GOTDTPREL) value -= dtp_base; - else if (!info->shared) + else if (!bfd_link_pic (info)) value -= tp_base; else { @@ -4586,7 +4811,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, if (r_symndx < symtab_hdr->sh_info && sec != NULL && howto->pc_relative - && elf_discarded_section (sec)) + && discarded_section (sec)) break; if (h != NULL) @@ -4600,11 +4825,9 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info, if (*name == '\0') name = bfd_section_name (input_bfd, sec); } - if (! ((*info->callbacks->reloc_overflow) - (info, (h ? &h->root.root : NULL), name, howto->name, - (bfd_vma) 0, input_bfd, input_section, - rel->r_offset))) - ret_val = FALSE; + (*info->callbacks->reloc_overflow) + (info, (h ? &h->root.root : NULL), name, howto->name, + (bfd_vma) 0, input_bfd, input_section, rel->r_offset); } break; @@ -4625,9 +4848,10 @@ elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, struct elf_link_hash_entry *h, Elf_Internal_Sym *sym) { + struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h; bfd *dynobj = elf_hash_table(info)->dynobj; - if (h->plt.offset != MINUS_ONE) + if (h->needs_plt) { /* Fill in the .plt entry for this symbol. */ asection *splt, *sgot, *srel; @@ -4639,83 +4863,71 @@ elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, BFD_ASSERT (h->dynindx != -1); - /* The first .got entry will be updated by the .plt with the - address of the target function. */ - gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries; - BFD_ASSERT (gotent && gotent->addend == 0); - - splt = bfd_get_section_by_name (dynobj, ".plt"); + splt = bfd_get_linker_section (dynobj, ".plt"); BFD_ASSERT (splt != NULL); - srel = bfd_get_section_by_name (dynobj, ".rela.plt"); + srel = bfd_get_linker_section (dynobj, ".rela.plt"); BFD_ASSERT (srel != NULL); - sgot = alpha_elf_tdata (gotent->gotobj)->got; - BFD_ASSERT (sgot != NULL); - - got_addr = (sgot->output_section->vma - + sgot->output_offset - + gotent->got_offset); - plt_addr = (splt->output_section->vma - + splt->output_offset - + h->plt.offset); - plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; - - /* Fill in the entry in the procedure linkage table. */ - { - bfd_vma insn1, insn2, insn3; - - insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff); - insn2 = PLT_ENTRY_WORD2; - insn3 = PLT_ENTRY_WORD3; + for (gotent = ah->got_entries; gotent ; gotent = gotent->next) + if (gotent->reloc_type == R_ALPHA_LITERAL + && gotent->use_count > 0) + { + unsigned int insn; + int disp; - bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset); - bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4); - bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8); - } + sgot = alpha_elf_tdata (gotent->gotobj)->got; + BFD_ASSERT (sgot != NULL); - /* Fill in the entry in the .rela.plt section. */ - outrel.r_offset = got_addr; - outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT); - outrel.r_addend = 0; + BFD_ASSERT (gotent->got_offset != -1); + BFD_ASSERT (gotent->plt_offset != -1); - loc = srel->contents + plt_index * sizeof (Elf64_External_Rela); - bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); + got_addr = (sgot->output_section->vma + + sgot->output_offset + + gotent->got_offset); + plt_addr = (splt->output_section->vma + + splt->output_offset + + gotent->plt_offset); - if (!h->def_regular) - { - /* Mark the symbol as undefined, rather than as defined in the - .plt section. Leave the value alone. */ - sym->st_shndx = SHN_UNDEF; - } + plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; - /* Fill in the entries in the .got. */ - bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset); + /* Fill in the entry in the procedure linkage table. */ + if (elf64_alpha_use_secureplt) + { + disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4); + insn = INSN_AD (INSN_BR, 31, disp); + bfd_put_32 (output_bfd, insn, + splt->contents + gotent->plt_offset); - /* Subsequent .got entries will continue to bounce through the .plt. */ - if (gotent->next) - { - srel = bfd_get_section_by_name (dynobj, ".rela.got"); - BFD_ASSERT (! info->shared || srel != NULL); + plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE) + / NEW_PLT_ENTRY_SIZE); + } + else + { + disp = -(gotent->plt_offset + 4); + insn = INSN_AD (INSN_BR, 28, disp); + bfd_put_32 (output_bfd, insn, + splt->contents + gotent->plt_offset); + bfd_put_32 (output_bfd, INSN_UNOP, + splt->contents + gotent->plt_offset + 4); + bfd_put_32 (output_bfd, INSN_UNOP, + splt->contents + gotent->plt_offset + 8); + + plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE) + / OLD_PLT_ENTRY_SIZE); + } - gotent = gotent->next; - do - { - sgot = alpha_elf_tdata(gotent->gotobj)->got; - BFD_ASSERT(sgot != NULL); - BFD_ASSERT(gotent->addend == 0); + /* Fill in the entry in the .rela.plt section. */ + outrel.r_offset = got_addr; + outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT); + outrel.r_addend = 0; - bfd_put_64 (output_bfd, plt_addr, - sgot->contents + gotent->got_offset); + loc = srel->contents + plt_index * sizeof (Elf64_External_Rela); + bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); - if (info->shared) - elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, - gotent->got_offset, 0, - R_ALPHA_RELATIVE, plt_addr); - - gotent = gotent->next; - } - while (gotent != NULL); - } + /* Fill in the entry in the .got. */ + bfd_put_64 (output_bfd, plt_addr, + sgot->contents + gotent->got_offset); + } } else if (alpha_elf_dynamic_symbol_p (h, info)) { @@ -4723,7 +4935,7 @@ elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, asection *srel; struct alpha_elf_got_entry *gotent; - srel = bfd_get_section_by_name (dynobj, ".rela.got"); + srel = bfd_get_linker_section (dynobj, ".rela.got"); BFD_ASSERT (srel != NULL); for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries; @@ -4758,21 +4970,21 @@ elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, abort (); } - elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, + elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, gotent->got_offset, h->dynindx, r_type, gotent->addend); if (gotent->reloc_type == R_ALPHA_TLSGD) - elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, + elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel, gotent->got_offset + 8, h->dynindx, R_ALPHA_DTPREL64, gotent->addend); } } /* Mark some specially defined symbols as absolute. */ - if (strcmp (h->root.root.string, "_DYNAMIC") == 0 - || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 - || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) + if (h == elf_hash_table (info)->hdynamic + || h == elf_hash_table (info)->hgot + || h == elf_hash_table (info)->hplt) sym->st_shndx = SHN_ABS; return TRUE; @@ -4788,37 +5000,50 @@ elf64_alpha_finish_dynamic_sections (bfd *output_bfd, asection *sdyn; dynobj = elf_hash_table (info)->dynobj; - sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); + sdyn = bfd_get_linker_section (dynobj, ".dynamic"); if (elf_hash_table (info)->dynamic_sections_created) { - asection *splt; + asection *splt, *sgotplt, *srelaplt; Elf64_External_Dyn *dyncon, *dynconend; + bfd_vma plt_vma, gotplt_vma; - splt = bfd_get_section_by_name (dynobj, ".plt"); + splt = bfd_get_linker_section (dynobj, ".plt"); + srelaplt = bfd_get_linker_section (dynobj, ".rela.plt"); BFD_ASSERT (splt != NULL && sdyn != NULL); + plt_vma = splt->output_section->vma + splt->output_offset; + + gotplt_vma = 0; + if (elf64_alpha_use_secureplt) + { + sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); + BFD_ASSERT (sgotplt != NULL); + if (sgotplt->size > 0) + gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset; + } + dyncon = (Elf64_External_Dyn *) sdyn->contents; dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); for (; dyncon < dynconend; dyncon++) { Elf_Internal_Dyn dyn; - const char *name; - asection *s; bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); switch (dyn.d_tag) { case DT_PLTGOT: - name = ".plt"; - goto get_vma; + dyn.d_un.d_ptr + = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma; + break; case DT_PLTRELSZ: - name = ".rela.plt"; - goto get_size; + dyn.d_un.d_val = srelaplt ? srelaplt->size : 0; + break; case DT_JMPREL: - name = ".rela.plt"; - goto get_vma; + dyn.d_un.d_ptr = srelaplt ? (srelaplt->output_section->vma + + srelaplt->output_offset) : 0; + break; case DT_RELASZ: /* My interpretation of the TIS v1.1 ELF document indicates @@ -4826,36 +5051,69 @@ elf64_alpha_finish_dynamic_sections (bfd *output_bfd, the rest of the BFD does. It is, however, what the glibc ld.so wants. Do this fixup here until we found out who is right. */ - s = bfd_get_section_by_name (output_bfd, ".rela.plt"); - if (s) - dyn.d_un.d_val -= s->size; - break; - - get_vma: - s = bfd_get_section_by_name (output_bfd, name); - dyn.d_un.d_ptr = (s ? s->vma : 0); - break; - - get_size: - s = bfd_get_section_by_name (output_bfd, name); - dyn.d_un.d_val = s->size; + if (srelaplt) + dyn.d_un.d_val -= srelaplt->size; break; } bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); } - /* Initialize the PLT0 entry. */ + /* Initialize the plt header. */ if (splt->size > 0) { - bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents); - bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4); - bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8); - bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12); + unsigned int insn; + int ofs; + + if (elf64_alpha_use_secureplt) + { + ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE); + + insn = INSN_ABC (INSN_SUBQ, 27, 28, 25); + bfd_put_32 (output_bfd, insn, splt->contents); + + insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16); + bfd_put_32 (output_bfd, insn, splt->contents + 4); + + insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25); + bfd_put_32 (output_bfd, insn, splt->contents + 8); + + insn = INSN_ABO (INSN_LDA, 28, 28, ofs); + bfd_put_32 (output_bfd, insn, splt->contents + 12); - /* The next two words will be filled in by ld.so */ - bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16); - bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24); + insn = INSN_ABO (INSN_LDQ, 27, 28, 0); + bfd_put_32 (output_bfd, insn, splt->contents + 16); + + insn = INSN_ABC (INSN_ADDQ, 25, 25, 25); + bfd_put_32 (output_bfd, insn, splt->contents + 20); + + insn = INSN_ABO (INSN_LDQ, 28, 28, 8); + bfd_put_32 (output_bfd, insn, splt->contents + 24); + + insn = INSN_AB (INSN_JMP, 31, 27); + bfd_put_32 (output_bfd, insn, splt->contents + 28); + + insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE); + bfd_put_32 (output_bfd, insn, splt->contents + 32); + } + else + { + insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */ + bfd_put_32 (output_bfd, insn, splt->contents); + + insn = INSN_ABO (INSN_LDQ, 27, 27, 12); + bfd_put_32 (output_bfd, insn, splt->contents + 4); + + insn = INSN_UNOP; + bfd_put_32 (output_bfd, insn, splt->contents + 8); + + insn = INSN_AB (INSN_JMP, 27, 27); + bfd_put_32 (output_bfd, insn, splt->contents + 12); + + /* The next two words will be filled in by ld.so. */ + bfd_put_64 (output_bfd, 0, splt->contents + 16); + bfd_put_64 (output_bfd, 0, splt->contents + 24); + } elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0; } @@ -4878,7 +5136,12 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) const struct ecoff_debug_swap *swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; HDRR *symhdr = &debug.symbolic_header; - PTR mdebug_handle = NULL; + void * mdebug_handle = NULL; + struct alpha_elf_link_hash_table * htab; + + htab = alpha_elf_hash_table (info); + if (htab == NULL) + return FALSE; /* Go through the sections and collect the mdebug information. */ mdebug_sec = NULL; @@ -4922,7 +5185,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) debug.external_ext = debug.external_ext_end = NULL; mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info); - if (mdebug_handle == (PTR) NULL) + if (mdebug_handle == NULL) return FALSE; if (1) @@ -4987,15 +5250,11 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) input_section = p->u.indirect.section; input_bfd = input_section->owner; - if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour - || (get_elf_backend_data (input_bfd) - ->elf_backend_ecoff_debug_swap) == NULL) - { - /* I don't know what a non ALPHA ELF bfd would be - doing with a .mdebug section, but I don't really - want to deal with it. */ - continue; - } + if (! is_alpha_elf (input_bfd)) + /* I don't know what a non ALPHA ELF bfd would be + doing with a .mdebug section, but I don't really + want to deal with it. */ + continue; input_swap = (get_elf_backend_data (input_bfd) ->elf_backend_ecoff_debug_swap); @@ -5018,7 +5277,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) interesting information, try to find the symbol in the linker global hash table and save the information for the output external symbols. */ - eraw_src = input_debug.external_ext; + eraw_src = (char *) input_debug.external_ext; eraw_end = (eraw_src + (input_debug.symbolic_header.iextMax * input_swap->external_ext_size)); @@ -5030,15 +5289,14 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) const char *name; struct alpha_elf_link_hash_entry *h; - (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext); + (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext); if (ext.asym.sc == scNil || ext.asym.sc == scUndefined || ext.asym.sc == scSUndefined) continue; name = input_debug.ssext + ext.asym.iss; - h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info), - name, FALSE, FALSE, TRUE); + h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE); if (h == NULL || h->esym.ifd != -2) continue; @@ -5078,7 +5336,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) einfo.failed = FALSE; elf_link_hash_traverse (elf_hash_table (info), elf64_alpha_output_extsym, - (PTR) &einfo); + &einfo); if (einfo.failed) return FALSE; @@ -5102,7 +5360,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) /* The .got subsections... */ { bfd *i, *dynobj = elf_hash_table(info)->dynobj; - for (i = alpha_elf_hash_table(info)->got_list; + for (i = htab->got_list; i != NULL; i = alpha_elf_tdata(i)->got_link_next) { @@ -5136,7 +5394,9 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info) } static enum elf_reloc_type_class -elf64_alpha_reloc_type_class (const Elf_Internal_Rela *rela) +elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, + const asection *rel_sec ATTRIBUTE_UNUSED, + const Elf_Internal_Rela *rela) { switch ((int) ELF64_R_TYPE (rela->r_info)) { @@ -5151,44 +5411,11 @@ elf64_alpha_reloc_type_class (const Elf_Internal_Rela *rela) } } -static struct bfd_elf_special_section const - alpha_special_sections_s[]= +static const struct bfd_elf_special_section elf64_alpha_special_sections[] = { - { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL }, - { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL }, - { NULL, 0, 0, 0, 0 } -}; - -static struct bfd_elf_special_section const * - elf64_alpha_special_sections[27] = -{ - NULL, /* 'a' */ - NULL, /* 'b' */ - NULL, /* 'c' */ - NULL, /* 'd' */ - NULL, /* 'e' */ - NULL, /* 'f' */ - NULL, /* 'g' */ - NULL, /* 'h' */ - NULL, /* 'i' */ - NULL, /* 'j' */ - NULL, /* 'k' */ - NULL, /* 'l' */ - NULL, /* 'm' */ - NULL, /* 'n' */ - NULL, /* 'o' */ - NULL, /* 'p' */ - NULL, /* 'q' */ - NULL, /* 'r' */ - alpha_special_sections_s, /* 's' */ - NULL, /* 't' */ - NULL, /* 'u' */ - NULL, /* 'v' */ - NULL, /* 'w' */ - NULL, /* 'x' */ - NULL, /* 'y' */ - NULL, /* 'z' */ - NULL /* other */ + { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL }, + { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL }, + { NULL, 0, 0, 0, 0 } }; /* ECOFF swapping routines. These are used when dealing with the @@ -5254,6 +5481,7 @@ static const struct elf_size_info alpha_elf_size_info = ELFCLASS64, EV_CURRENT, bfd_elf64_write_out_phdrs, bfd_elf64_write_shdrs_and_ehdr, + bfd_elf64_checksum_contents, bfd_elf64_write_relocs, bfd_elf64_swap_symbol_in, bfd_elf64_swap_symbol_out, @@ -5267,17 +5495,21 @@ static const struct elf_size_info alpha_elf_size_info = bfd_elf64_swap_reloca_out }; -#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec +#define TARGET_LITTLE_SYM alpha_elf64_vec #define TARGET_LITTLE_NAME "elf64-alpha" #define ELF_ARCH bfd_arch_alpha +#define ELF_TARGET_ID ALPHA_ELF_DATA #define ELF_MACHINE_CODE EM_ALPHA #define ELF_MAXPAGESIZE 0x10000 +#define ELF_COMMONPAGESIZE 0x2000 #define bfd_elf64_bfd_link_hash_table_create \ elf64_alpha_bfd_link_hash_table_create #define bfd_elf64_bfd_reloc_type_lookup \ elf64_alpha_bfd_reloc_type_lookup +#define bfd_elf64_bfd_reloc_name_lookup \ + elf64_alpha_bfd_reloc_name_lookup #define elf_info_to_howto \ elf64_alpha_info_to_howto @@ -5302,16 +5534,26 @@ static const struct elf_size_info alpha_elf_size_info = #define elf_backend_add_symbol_hook \ elf64_alpha_add_symbol_hook +#define elf_backend_relocs_compatible \ + _bfd_elf_relocs_compatible +#define elf_backend_sort_relocs_p \ + elf64_alpha_sort_relocs_p #define elf_backend_check_relocs \ elf64_alpha_check_relocs #define elf_backend_create_dynamic_sections \ elf64_alpha_create_dynamic_sections #define elf_backend_adjust_dynamic_symbol \ elf64_alpha_adjust_dynamic_symbol +#define elf_backend_merge_symbol_attribute \ + elf64_alpha_merge_symbol_attribute +#define elf_backend_copy_indirect_symbol \ + elf64_alpha_copy_indirect_symbol #define elf_backend_always_size_sections \ elf64_alpha_always_size_sections #define elf_backend_size_dynamic_sections \ elf64_alpha_size_dynamic_sections +#define elf_backend_omit_section_dynsym \ + ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) #define elf_backend_relocate_section \ elf64_alpha_relocate_section #define elf_backend_finish_dynamic_symbol \ @@ -5323,6 +5565,10 @@ static const struct elf_size_info alpha_elf_size_info = #define elf_backend_reloc_type_class \ elf64_alpha_reloc_type_class +#define elf_backend_can_gc_sections 1 +#define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook +#define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook + #define elf_backend_ecoff_debug_swap \ &elf64_alpha_ecoff_debug_swap @@ -5343,9 +5589,11 @@ static const struct elf_size_info alpha_elf_size_info = /* FreeBSD support. */ #undef TARGET_LITTLE_SYM -#define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec +#define TARGET_LITTLE_SYM alpha_elf64_fbsd_vec #undef TARGET_LITTLE_NAME #define TARGET_LITTLE_NAME "elf64-alpha-freebsd" +#undef ELF_OSABI +#define ELF_OSABI ELFOSABI_FREEBSD /* The kernel recognizes executables as valid only if they carry a "FreeBSD" label in the ELF header. So we put this label on all @@ -5360,7 +5608,7 @@ elf64_alpha_fbsd_post_process_headers (bfd * abfd, i_ehdrp = elf_elfheader (abfd); /* Put an ABI label supported by FreeBSD >= 4.1. */ - i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; + i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; #ifdef OLD_FREEBSD_ABI_LABEL /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */ memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);