X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felf64-sparc.c;h=ca2e7c1d2f4f5355bb15d88dd7c68383fcf68406;hb=157090f728a99fff42b3d3cc576b0c2a953e9916;hp=a5657543a3af69d307083d4695a6f6604c32aedf;hpb=70e818d42344e8f5cea57089b539952b5d0b64b5;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf64-sparc.c b/bfd/elf64-sparc.c index a5657543a3..3669a35244 100644 --- a/bfd/elf64-sparc.c +++ b/bfd/elf64-sparc.c @@ -1,626 +1,924 @@ /* SPARC-specific support for 64-bit ELF - Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, + 2003, 2004, 2005, 2007 Free Software Foundation, Inc. -This file is part of BFD, the Binary File Descriptor library. + 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 -(at your option) any later version. + 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 + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + 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. */ #include "bfd.h" #include "sysdep.h" #include "libbfd.h" #include "elf-bfd.h" - -/* This is defined if one wants to build upward compatible binaries - with the original sparc64-elf toolchain. The support is kept in for - now but is turned off by default. dje 970930 */ -/*#define SPARC64_OLD_RELOCS*/ - #include "elf/sparc.h" +#include "opcode/sparc.h" +#include "elfxx-sparc.h" /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ #define MINUS_ONE (~ (bfd_vma) 0) -static reloc_howto_type *sparc64_elf_reloc_type_lookup - PARAMS ((bfd *, bfd_reloc_code_real_type)); -static void sparc64_elf_info_to_howto - PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); +/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA + section can represent up to two relocs, we must tell the user to allocate + more space. */ -static boolean sparc64_elf_relocate_section - PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, - Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); -static boolean sparc64_elf_object_p PARAMS ((bfd *)); - -/* The relocation "howto" table. */ - -static bfd_reloc_status_type sparc_elf_notsup_reloc - PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); -static bfd_reloc_status_type sparc_elf_wdisp16_reloc - PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); -static bfd_reloc_status_type sparc_elf_hix22_reloc - PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); -static bfd_reloc_status_type sparc_elf_lox10_reloc - PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); - -static reloc_howto_type sparc64_elf_howto_table[] = +static long +elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) { - HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), - HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true), - HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true), - HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true), - HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true), - HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true), - HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true), - HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true), - HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true), - HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true), - HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true), - HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true), - HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true), - HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true), - HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true), - HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true), - HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true), - HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true), - HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true), - HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true), - HOWTO(R_SPARC_GLOB_DAT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_DAT",false,0,0x00000000,true), - HOWTO(R_SPARC_JMP_SLOT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_SLOT",false,0,0x00000000,true), - HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true), - HOWTO(R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0x00000000,true), -#ifndef SPARC64_OLD_RELOCS - /* These aren't implemented yet. */ - HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PLT32", false,0,0x00000000,true), - HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true), - HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true), - HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true), - HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true), - HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true), -#endif - HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true), - HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true), - HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true), - HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true), - HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true), - HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true), - HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true), - HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true), - HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true), - HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true), - HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true), - HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true), - HOWTO(R_SPARC_UNUSED_42, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UNUSED_42",false,0,0x00000000,true), - HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true), - HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true), - HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true), - HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true), - HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, false), - HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false), - HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false), - HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false), - HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false), - HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false), - HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false) -}; - -struct elf_reloc_map { - unsigned char bfd_reloc_val; - unsigned char elf_reloc_val; -}; + return (sec->reloc_count * 2 + 1) * sizeof (arelent *); +} -static CONST struct elf_reloc_map sparc_reloc_map[] = +static long +elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd) { - { BFD_RELOC_NONE, R_SPARC_NONE, }, - { BFD_RELOC_16, R_SPARC_16, }, - { BFD_RELOC_8, R_SPARC_8 }, - { BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, - { BFD_RELOC_CTOR, R_SPARC_64 }, - { BFD_RELOC_32, R_SPARC_32 }, - { BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, - { BFD_RELOC_HI22, R_SPARC_HI22 }, - { BFD_RELOC_LO10, R_SPARC_LO10, }, - { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 }, - { BFD_RELOC_SPARC22, R_SPARC_22 }, - { BFD_RELOC_SPARC13, R_SPARC_13 }, - { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 }, - { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 }, - { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 }, - { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 }, - { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 }, - { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 }, - { BFD_RELOC_SPARC_COPY, R_SPARC_COPY }, - { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT }, - { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT }, - { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE }, - { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 }, - /* ??? Doesn't dwarf use this? */ -/*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */ - {BFD_RELOC_SPARC_10, R_SPARC_10}, - {BFD_RELOC_SPARC_11, R_SPARC_11}, - {BFD_RELOC_SPARC_64, R_SPARC_64}, - {BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10}, - {BFD_RELOC_SPARC_HH22, R_SPARC_HH22}, - {BFD_RELOC_SPARC_HM10, R_SPARC_HM10}, - {BFD_RELOC_SPARC_LM22, R_SPARC_LM22}, - {BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22}, - {BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10}, - {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22}, - {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16}, - {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19}, - {BFD_RELOC_SPARC_7, R_SPARC_7}, - {BFD_RELOC_SPARC_5, R_SPARC_5}, - {BFD_RELOC_SPARC_6, R_SPARC_6}, - {BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64}, - {BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64}, - {BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22}, - {BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10}, - {BFD_RELOC_SPARC_H44, R_SPARC_H44}, - {BFD_RELOC_SPARC_M44, R_SPARC_M44}, - {BFD_RELOC_SPARC_L44, R_SPARC_L44}, - {BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER} -}; + return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2; +} -static reloc_howto_type * -sparc64_elf_reloc_type_lookup (abfd, code) - bfd *abfd; - bfd_reloc_code_real_type code; +/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of + them. We cannot use generic elf routines for this, because R_SPARC_OLO10 + has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations + for the same location, R_SPARC_LO10 and R_SPARC_13. */ + +static bfd_boolean +elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect, + Elf_Internal_Shdr *rel_hdr, + asymbol **symbols, bfd_boolean dynamic) { + PTR allocated = NULL; + bfd_byte *native_relocs; + arelent *relent; unsigned int i; - for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++) + int entsize; + bfd_size_type count; + arelent *relents; + + allocated = (PTR) bfd_malloc (rel_hdr->sh_size); + if (allocated == NULL) + goto error_return; + + if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0 + || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size) + goto error_return; + + native_relocs = (bfd_byte *) allocated; + + relents = asect->relocation + canon_reloc_count (asect); + + entsize = rel_hdr->sh_entsize; + BFD_ASSERT (entsize == sizeof (Elf64_External_Rela)); + + count = rel_hdr->sh_size / entsize; + + for (i = 0, relent = relents; i < count; + i++, relent++, native_relocs += entsize) { - if (sparc_reloc_map[i].bfd_reloc_val == code) - return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val]; + Elf_Internal_Rela rela; + unsigned int r_type; + + bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela); + + /* The address of an ELF reloc is section relative for an object + file, and absolute for an executable file or shared library. + The address of a normal BFD reloc is always section relative, + and the address of a dynamic reloc is absolute.. */ + if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) + relent->address = rela.r_offset; + else + relent->address = rela.r_offset - asect->vma; + + if (ELF64_R_SYM (rela.r_info) == 0) + relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; + else + { + asymbol **ps, *s; + + ps = symbols + ELF64_R_SYM (rela.r_info) - 1; + s = *ps; + + /* Canonicalize ELF section symbols. FIXME: Why? */ + if ((s->flags & BSF_SECTION_SYM) == 0) + relent->sym_ptr_ptr = ps; + else + relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; + } + + relent->addend = rela.r_addend; + + r_type = ELF64_R_TYPE_ID (rela.r_info); + if (r_type == R_SPARC_OLO10) + { + relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10); + relent[1].address = relent->address; + relent++; + relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; + relent->addend = ELF64_R_TYPE_DATA (rela.r_info); + relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13); + } + else + relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type); } - return 0; -} -static void -sparc64_elf_info_to_howto (abfd, cache_ptr, dst) - bfd *abfd; - arelent *cache_ptr; - Elf64_Internal_Rela *dst; -{ - BFD_ASSERT (ELF64_R_TYPE (dst->r_info) < (unsigned int) R_SPARC_max); - cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE (dst->r_info)]; + canon_reloc_count (asect) += relent - relents; + + if (allocated != NULL) + free (allocated); + + return TRUE; + + error_return: + if (allocated != NULL) + free (allocated); + return FALSE; } - -/* Utility for performing the standard initial work of an instruction - relocation. - *PRELOCATION will contain the relocated item. - *PINSN will contain the instruction from the input stream. - If the result is `bfd_reloc_other' the caller can continue with - performing the relocation. Otherwise it must stop and return the - value to its caller. */ - -static bfd_reloc_status_type -init_insn_reloc (abfd, - reloc_entry, - symbol, - data, - input_section, - output_bfd, - prelocation, - pinsn) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - bfd_vma *prelocation; - bfd_vma *pinsn; + +/* Read in and swap the external relocs. */ + +static bfd_boolean +elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect, + asymbol **symbols, bfd_boolean dynamic) { - bfd_vma relocation; - reloc_howto_type *howto = reloc_entry->howto; + struct bfd_elf_section_data * const d = elf_section_data (asect); + Elf_Internal_Shdr *rel_hdr; + Elf_Internal_Shdr *rel_hdr2; + bfd_size_type amt; - if (output_bfd != (bfd *) NULL - && (symbol->flags & BSF_SECTION_SYM) == 0 - && (! howto->partial_inplace - || reloc_entry->addend == 0)) - { - reloc_entry->address += input_section->output_offset; - return bfd_reloc_ok; - } + if (asect->relocation != NULL) + return TRUE; - /* This works because partial_inplace == false. */ - if (output_bfd != NULL) - return bfd_reloc_continue; + if (! dynamic) + { + if ((asect->flags & SEC_RELOC) == 0 + || asect->reloc_count == 0) + return TRUE; - if (reloc_entry->address > input_section->_cooked_size) - return bfd_reloc_outofrange; + rel_hdr = &d->rel_hdr; + rel_hdr2 = d->rel_hdr2; - relocation = (symbol->value - + symbol->section->output_section->vma - + symbol->section->output_offset); - relocation += reloc_entry->addend; - if (howto->pc_relative) + BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset + || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); + } + else { - relocation -= (input_section->output_section->vma - + input_section->output_offset); - relocation -= reloc_entry->address; + /* Note that ASECT->RELOC_COUNT tends not to be accurate in this + case because relocations against this section may use the + dynamic symbol table, and in that case bfd_section_from_shdr + in elf.c does not update the RELOC_COUNT. */ + if (asect->size == 0) + return TRUE; + + rel_hdr = &d->this_hdr; + asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr); + rel_hdr2 = NULL; } - *prelocation = relocation; - *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); - return bfd_reloc_other; -} + amt = asect->reloc_count; + amt *= 2 * sizeof (arelent); + asect->relocation = (arelent *) bfd_alloc (abfd, amt); + if (asect->relocation == NULL) + return FALSE; -/* For unsupported relocs. */ - -static bfd_reloc_status_type -sparc_elf_notsup_reloc (abfd, - reloc_entry, - symbol, - data, - input_section, - output_bfd, - error_message) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - char **error_message; -{ - return bfd_reloc_notsupported; -} + /* The elf64_sparc_slurp_one_reloc_table routine increments + canon_reloc_count. */ + canon_reloc_count (asect) = 0; -/* Handle the WDISP16 reloc. */ - -static bfd_reloc_status_type -sparc_elf_wdisp16_reloc (abfd, - reloc_entry, - symbol, - data, - input_section, - output_bfd, - error_message) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - char **error_message; -{ - bfd_vma relocation; - bfd_vma insn; - bfd_reloc_status_type status; - - status = init_insn_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, &relocation, &insn); - if (status != bfd_reloc_other) - return status; - - insn = (insn & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6) - | ((relocation >> 2) & 0x3fff)); - bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); - - if ((bfd_signed_vma) relocation < - 0x40000 - || (bfd_signed_vma) relocation > 0x3ffff) - return bfd_reloc_overflow; - else - return bfd_reloc_ok; + if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, + dynamic)) + return FALSE; + + if (rel_hdr2 + && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols, + dynamic)) + return FALSE; + + return TRUE; } -/* Handle the HIX22 reloc. */ - -static bfd_reloc_status_type -sparc_elf_hix22_reloc (abfd, - reloc_entry, - symbol, - data, - input_section, - output_bfd, - error_message) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - char **error_message; +/* Canonicalize the relocs. */ + +static long +elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section, + arelent **relptr, asymbol **symbols) { - bfd_vma relocation; - bfd_vma insn; - bfd_reloc_status_type status; + arelent *tblptr; + unsigned int i; + const struct elf_backend_data *bed = get_elf_backend_data (abfd); - status = init_insn_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, &relocation, &insn); - if (status != bfd_reloc_other) - return status; + if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE)) + return -1; - relocation ^= MINUS_ONE; - insn = (insn & ~0x3fffff) | ((relocation >> 10) & 0x3fffff); - bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); + tblptr = section->relocation; + for (i = 0; i < canon_reloc_count (section); i++) + *relptr++ = tblptr++; - if ((relocation & ~ (bfd_vma) 0xffffffff) != 0) - return bfd_reloc_overflow; - else - return bfd_reloc_ok; + *relptr = NULL; + + return canon_reloc_count (section); } -/* Handle the LOX10 reloc. */ - -static bfd_reloc_status_type -sparc_elf_lox10_reloc (abfd, - reloc_entry, - symbol, - data, - input_section, - output_bfd, - error_message) - bfd *abfd; - arelent *reloc_entry; - asymbol *symbol; - PTR data; - asection *input_section; - bfd *output_bfd; - char **error_message; + +/* Canonicalize the dynamic relocation entries. Note that we return + the dynamic relocations as a single block, although they are + actually associated with particular sections; the interface, which + was designed for SunOS style shared libraries, expects that there + is only one set of dynamic relocs. Any section that was actually + installed in the BFD, and has type SHT_REL or SHT_RELA, and uses + the dynamic symbol table, is considered to be a dynamic reloc + section. */ + +static long +elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage, + asymbol **syms) { - bfd_vma relocation; - bfd_vma insn; - bfd_reloc_status_type status; + asection *s; + long ret; + + if (elf_dynsymtab (abfd) == 0) + { + bfd_set_error (bfd_error_invalid_operation); + return -1; + } - status = init_insn_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, &relocation, &insn); - if (status != bfd_reloc_other) - return status; + ret = 0; + for (s = abfd->sections; s != NULL; s = s->next) + { + if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) + && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) + { + arelent *p; + long count, i; + + if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE)) + return -1; + count = canon_reloc_count (s); + p = s->relocation; + for (i = 0; i < count; i++) + *storage++ = p++; + ret += count; + } + } - insn = (insn & ~0x1fff) | 0x1c00 | (relocation & 0x3ff); - bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); + *storage = NULL; - return bfd_reloc_ok; + return ret; } - -/* Relocate a SPARC64 ELF section. */ - -static boolean -sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section, - contents, relocs, local_syms, local_sections) - bfd *output_bfd; - struct bfd_link_info *info; - bfd *input_bfd; - asection *input_section; - bfd_byte *contents; - Elf_Internal_Rela *relocs; - Elf_Internal_Sym *local_syms; - asection **local_sections; -{ - Elf_Internal_Shdr *symtab_hdr; - struct elf_link_hash_entry **sym_hashes; - Elf_Internal_Rela *rel; - Elf_Internal_Rela *relend; - symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; - sym_hashes = elf_sym_hashes (input_bfd); +/* Write out the relocs. */ - rel = relocs; - relend = relocs + input_section->reloc_count; - for (; rel < relend; rel++) +static void +elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data) +{ + bfd_boolean *failedp = (bfd_boolean *) data; + Elf_Internal_Shdr *rela_hdr; + bfd_vma addr_offset; + Elf64_External_Rela *outbound_relocas, *src_rela; + unsigned int idx, count; + asymbol *last_sym = 0; + int last_sym_idx = 0; + + /* If we have already failed, don't do anything. */ + if (*failedp) + return; + + if ((sec->flags & SEC_RELOC) == 0) + return; + + /* The linker backend writes the relocs out itself, and sets the + reloc_count field to zero to inhibit writing them here. Also, + sometimes the SEC_RELOC flag gets set even when there aren't any + relocs. */ + if (sec->reloc_count == 0) + return; + + /* We can combine two relocs that refer to the same address + into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the + latter is R_SPARC_13 with no associated symbol. */ + count = 0; + for (idx = 0; idx < sec->reloc_count; idx++) { - int r_type; - reloc_howto_type *howto; - long r_symndx; - struct elf_link_hash_entry *h; - Elf_Internal_Sym *sym; - asection *sec; - bfd_vma relocation; - bfd_reloc_status_type r; - - r_type = ELF64_R_TYPE (rel->r_info); - if (r_type < 0 || r_type >= (int) R_SPARC_max) + bfd_vma addr; + + ++count; + + addr = sec->orelocation[idx]->address; + if (sec->orelocation[idx]->howto->type == R_SPARC_LO10 + && idx < sec->reloc_count - 1) { - bfd_set_error (bfd_error_bad_value); - return false; + arelent *r = sec->orelocation[idx + 1]; + + if (r->howto->type == R_SPARC_13 + && r->address == addr + && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) + && (*r->sym_ptr_ptr)->value == 0) + ++idx; } - howto = sparc64_elf_howto_table + r_type; + } + + rela_hdr = &elf_section_data (sec)->rel_hdr; + + rela_hdr->sh_size = rela_hdr->sh_entsize * count; + rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size); + if (rela_hdr->contents == NULL) + { + *failedp = TRUE; + return; + } - r_symndx = ELF64_R_SYM (rel->r_info); + /* Figure out whether the relocations are RELA or REL relocations. */ + if (rela_hdr->sh_type != SHT_RELA) + abort (); - if (info->relocateable) + /* The address of an ELF reloc is section relative for an object + file, and absolute for an executable file or shared library. + The address of a BFD reloc is always section relative. */ + addr_offset = 0; + if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) + addr_offset = sec->vma; + + /* orelocation has the data, reloc_count has the count... */ + outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents; + src_rela = outbound_relocas; + + for (idx = 0; idx < sec->reloc_count; idx++) + { + Elf_Internal_Rela dst_rela; + arelent *ptr; + asymbol *sym; + int n; + + ptr = sec->orelocation[idx]; + sym = *ptr->sym_ptr_ptr; + if (sym == last_sym) + n = last_sym_idx; + else if (bfd_is_abs_section (sym->section) && sym->value == 0) + n = STN_UNDEF; + else { - /* This is a relocateable link. We don't have to change - anything, unless the reloc is against a section symbol, - in which case we have to adjust according to where the - section symbol winds up in the output section. */ - if (r_symndx < symtab_hdr->sh_info) + last_sym = sym; + n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); + if (n < 0) { - 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; - } + *failedp = TRUE; + return; } + last_sym_idx = n; + } - continue; + if ((*ptr->sym_ptr_ptr)->the_bfd != NULL + && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec + && ! _bfd_elf_validate_reloc (abfd, ptr)) + { + *failedp = TRUE; + return; } - /* This is a final link. */ - h = NULL; - sym = NULL; - sec = NULL; - if (r_symndx < symtab_hdr->sh_info) + if (ptr->howto->type == R_SPARC_LO10 + && idx < sec->reloc_count - 1) { - sym = local_syms + r_symndx; - sec = local_sections[r_symndx]; - relocation = (sec->output_section->vma - + sec->output_offset - + sym->st_value); + arelent *r = sec->orelocation[idx + 1]; + + if (r->howto->type == R_SPARC_13 + && r->address == ptr->address + && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) + && (*r->sym_ptr_ptr)->value == 0) + { + idx++; + dst_rela.r_info + = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend, + R_SPARC_OLO10)); + } + else + dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10); } else + dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type); + + dst_rela.r_offset = ptr->address + addr_offset; + dst_rela.r_addend = ptr->addend; + + bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela); + ++src_rela; + } +} + +/* Hook called by the linker routine which adds symbols from an object + file. We use it for STT_REGISTER symbols. */ + +static bfd_boolean +elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, + Elf_Internal_Sym *sym, const char **namep, + flagword *flagsp ATTRIBUTE_UNUSED, + asection **secp ATTRIBUTE_UNUSED, + bfd_vma *valp ATTRIBUTE_UNUSED) +{ + static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" }; + + if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER) + { + int reg; + struct _bfd_sparc_elf_app_reg *p; + + reg = (int)sym->st_value; + switch (reg & ~1) + { + case 2: reg -= 2; break; + case 6: reg -= 4; break; + default: + (*_bfd_error_handler) + (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"), + abfd); + return FALSE; + } + + if (info->hash->creator != abfd->xvec + || (abfd->flags & DYNAMIC) != 0) + { + /* STT_REGISTER only works when linking an elf64_sparc object. + If STT_REGISTER comes from a dynamic object, don't put it into + the output bfd. The dynamic linker will recheck it. */ + *namep = NULL; + return TRUE; + } + + p = _bfd_sparc_elf_hash_table(info)->app_regs + reg; + + if (p->name != NULL && strcmp (p->name, *namep)) + { + (*_bfd_error_handler) + (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"), + abfd, p->abfd, (int) sym->st_value, + **namep ? *namep : "#scratch", + *p->name ? p->name : "#scratch"); + return FALSE; + } + + if (p->name == NULL) { - 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) + if (**namep) { - sec = h->root.u.def.section; - relocation = (h->root.u.def.value - + sec->output_section->vma - + sec->output_offset); + struct elf_link_hash_entry *h; + + h = (struct elf_link_hash_entry *) + bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE); + + if (h != NULL) + { + unsigned char type = h->type; + + if (type > STT_FUNC) + type = 0; + (*_bfd_error_handler) + (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"), + abfd, p->abfd, *namep, stt_types[type]); + return FALSE; + } + + p->name = bfd_hash_allocate (&info->hash->table, + strlen (*namep) + 1); + if (!p->name) + return FALSE; + + strcpy (p->name, *namep); } - else if (h->root.type == bfd_link_hash_undefweak) - relocation = 0; else + p->name = ""; + p->bind = ELF_ST_BIND (sym->st_info); + p->abfd = abfd; + p->shndx = sym->st_shndx; + } + else + { + if (p->bind == STB_WEAK + && ELF_ST_BIND (sym->st_info) == STB_GLOBAL) { - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.string, input_bfd, - input_section, rel->r_offset))) - return false; - relocation = 0; + p->bind = STB_GLOBAL; + p->abfd = abfd; } } + *namep = NULL; + return TRUE; + } + else if (*namep && **namep + && info->hash->creator == abfd->xvec) + { + int i; + struct _bfd_sparc_elf_app_reg *p; - switch (r_type) - { - case R_SPARC_OLO10: + p = _bfd_sparc_elf_hash_table(info)->app_regs; + for (i = 0; i < 4; i++, p++) + if (p->name != NULL && ! strcmp (p->name, *namep)) { - bfd_vma x; + unsigned char type = ELF_ST_TYPE (sym->st_info); + + if (type > STT_FUNC) + type = 0; + (*_bfd_error_handler) + (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"), + abfd, p->abfd, *namep, stt_types[type]); + return FALSE; + } + } + return TRUE; +} - relocation += rel->r_addend; - relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info); +/* This function takes care of emitting STT_REGISTER symbols + which we cannot easily keep in the symbol hash table. */ - x = bfd_get_32 (input_bfd, contents + rel->r_offset); - x = (x & ~0x1fff) | (relocation & 0x1fff); - bfd_put_32 (input_bfd, x, contents + rel->r_offset); +static bfd_boolean +elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info, + PTR finfo, bfd_boolean (*func) (PTR, const char *, + Elf_Internal_Sym *, + asection *, + struct elf_link_hash_entry *)) +{ + int reg; + struct _bfd_sparc_elf_app_reg *app_regs = + _bfd_sparc_elf_hash_table(info)->app_regs; + Elf_Internal_Sym sym; + + /* We arranged in size_dynamic_sections to put the STT_REGISTER entries + at the end of the dynlocal list, so they came at the end of the local + symbols in the symtab. Except that they aren't STB_LOCAL, so we need + to back up symtab->sh_info. */ + if (elf_hash_table (info)->dynlocal) + { + bfd * dynobj = elf_hash_table (info)->dynobj; + asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym"); + struct elf_link_local_dynamic_entry *e; - r = bfd_check_overflow (howto->complain_on_overflow, - howto->bitsize, howto->rightshift, - relocation); - } + for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) + if (e->input_indx == -1) break; + if (e) + { + elf_section_data (dynsymsec->output_section)->this_hdr.sh_info + = e->dynindx; + } + } - case R_SPARC_WDISP16: - { - bfd_vma x; - - relocation += rel->r_addend; - /* Adjust for pc-relative-ness. */ - relocation -= (input_section->output_section->vma - + input_section->output_offset); - relocation -= rel->r_offset; - - x = bfd_get_32 (input_bfd, contents + rel->r_offset); - x = (x & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6) - | ((relocation >> 2) & 0x3fff)); - bfd_put_32 (input_bfd, x, contents + rel->r_offset); - - r = bfd_check_overflow (howto->complain_on_overflow, - howto->bitsize, howto->rightshift, - relocation); - } - break; + if (info->strip == strip_all) + return TRUE; - case R_SPARC_HIX22: - { - bfd_vma x; + for (reg = 0; reg < 4; reg++) + if (app_regs [reg].name != NULL) + { + if (info->strip == strip_some + && bfd_hash_lookup (info->keep_hash, + app_regs [reg].name, + FALSE, FALSE) == NULL) + continue; - relocation += rel->r_addend; - relocation = relocation ^ MINUS_ONE; + sym.st_value = reg < 2 ? reg + 2 : reg + 4; + sym.st_size = 0; + sym.st_other = 0; + sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER); + sym.st_shndx = app_regs [reg].shndx; + if (! (*func) (finfo, app_regs [reg].name, &sym, + sym.st_shndx == SHN_ABS + ? bfd_abs_section_ptr : bfd_und_section_ptr, + NULL)) + return FALSE; + } + + return TRUE; +} - x = bfd_get_32 (input_bfd, contents + rel->r_offset); - x = (x & ~0x3fffff) | ((relocation >> 10) & 0x3fffff); - bfd_put_32 (input_bfd, x, contents + rel->r_offset); +static int +elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type) +{ + if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER) + return STT_REGISTER; + else + return type; +} - r = bfd_check_overflow (howto->complain_on_overflow, - howto->bitsize, howto->rightshift, - relocation); - } - break; +/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL + even in SHN_UNDEF section. */ - case R_SPARC_LOX10: - { - bfd_vma x; +static void +elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym) +{ + elf_symbol_type *elfsym; - relocation += rel->r_addend; - relocation = (relocation & 0x3ff) | 0x1c00; + elfsym = (elf_symbol_type *) asym; + if (elfsym->internal_elf_sym.st_info + == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER)) + { + asym->flags |= BSF_GLOBAL; + } +} - x = bfd_get_32 (input_bfd, contents + rel->r_offset); - x = (x & ~0x1fff) | relocation; - bfd_put_32 (input_bfd, x, contents + rel->r_offset); + +/* Functions for dealing with the e_flags field. */ - r = bfd_reloc_ok; - } - break; +/* Merge backend specific data from an object file to the output + object file when linking. */ - default: - r = _bfd_final_link_relocate (howto, input_bfd, input_section, - contents, rel->r_offset, - relocation, rel->r_addend); - break; - } +static bfd_boolean +elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +{ + bfd_boolean error; + flagword new_flags, old_flags; + int new_mm, old_mm; + + if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour + || bfd_get_flavour (obfd) != bfd_target_elf_flavour) + return TRUE; + + new_flags = elf_elfheader (ibfd)->e_flags; + old_flags = elf_elfheader (obfd)->e_flags; - if (r != bfd_reloc_ok) + if (!elf_flags_init (obfd)) /* First call, no flags set */ + { + elf_flags_init (obfd) = TRUE; + elf_elfheader (obfd)->e_flags = new_flags; + } + + else if (new_flags == old_flags) /* Compatible flags are ok */ + ; + + else /* Incompatible flags */ + { + error = FALSE; + +#define EF_SPARC_ISA_EXTENSIONS \ + (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1) + + if ((ibfd->flags & DYNAMIC) != 0) + { + /* We don't want dynamic objects memory ordering and + architecture to have any role. That's what dynamic linker + should do. */ + new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS); + new_flags |= (old_flags + & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS)); + } + else { - switch (r) + /* Choose the highest architecture requirements. */ + old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS); + new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS); + if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3)) + && (old_flags & EF_SPARC_HAL_R1)) { - default: - case bfd_reloc_outofrange: - abort (); - case bfd_reloc_overflow: - { - const char *name; - - if (h != NULL) - name = h->root.root.string; - else - { - name = (bfd_elf_string_from_elf_section - (input_bfd, - symtab_hdr->sh_link, - sym->st_name)); - if (name == NULL) - return false; - if (*name == '\0') - name = bfd_section_name (input_bfd, sec); - } - if (! ((*info->callbacks->reloc_overflow) - (info, name, howto->name, (bfd_vma) 0, - input_bfd, input_section, rel->r_offset))) - return false; - } - break; + error = TRUE; + (*_bfd_error_handler) + (_("%B: linking UltraSPARC specific with HAL specific code"), + ibfd); } + /* Choose the most restrictive memory ordering. */ + old_mm = (old_flags & EF_SPARCV9_MM); + new_mm = (new_flags & EF_SPARCV9_MM); + old_flags &= ~EF_SPARCV9_MM; + new_flags &= ~EF_SPARCV9_MM; + if (new_mm < old_mm) + old_mm = new_mm; + old_flags |= old_mm; + new_flags |= old_mm; } - } - return true; + /* Warn about any other mismatches */ + if (new_flags != old_flags) + { + error = TRUE; + (*_bfd_error_handler) + (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), + ibfd, (long) new_flags, (long) old_flags); + } + + elf_elfheader (obfd)->e_flags = old_flags; + + if (error) + { + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + } + return TRUE; } -/* Set the right machine number for a SPARC64 ELF file. */ +/* MARCO: Set the correct entry size for the .stab section. */ -static boolean -sparc64_elf_object_p (abfd) - bfd *abfd; +static bfd_boolean +elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, + Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED, + asection *sec) { - return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc_v9); + const char *name; + + name = bfd_get_section_name (abfd, sec); + + if (strcmp (name, ".stab") == 0) + { + /* Even in the 64bit case the stab entries are only 12 bytes long. */ + elf_section_data (sec)->this_hdr.sh_entsize = 12; + } + + return TRUE; } + +/* Print a STT_REGISTER symbol to file FILE. */ + +static const char * +elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep, + asymbol *symbol) +{ + FILE *file = (FILE *) filep; + int reg, type; + + if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info) + != STT_REGISTER) + return NULL; + + reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value; + type = symbol->flags; + fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "", + ((type & BSF_LOCAL) + ? (type & BSF_GLOBAL) ? '!' : 'l' + : (type & BSF_GLOBAL) ? 'g' : ' '), + (type & BSF_WEAK) ? 'w' : ' '); + if (symbol->name == NULL || symbol->name [0] == '\0') + return "#scratch"; + else + return symbol->name; +} + +static enum elf_reloc_type_class +elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela) +{ + switch ((int) ELF64_R_TYPE (rela->r_info)) + { + case R_SPARC_RELATIVE: + return reloc_class_relative; + case R_SPARC_JMP_SLOT: + return reloc_class_plt; + case R_SPARC_COPY: + return reloc_class_copy; + default: + return reloc_class_normal; + } +} + +/* Relocations in the 64 bit SPARC ELF ABI are more complex than in + standard ELF, because R_SPARC_OLO10 has secondary addend in + ELF64_R_TYPE_DATA field. This structure is used to redirect the + relocation handling routines. */ + +const struct elf_size_info elf64_sparc_size_info = +{ + sizeof (Elf64_External_Ehdr), + sizeof (Elf64_External_Phdr), + sizeof (Elf64_External_Shdr), + sizeof (Elf64_External_Rel), + sizeof (Elf64_External_Rela), + sizeof (Elf64_External_Sym), + sizeof (Elf64_External_Dyn), + sizeof (Elf_External_Note), + 4, /* hash-table entry size. */ + /* Internal relocations per external relocations. + For link purposes we use just 1 internal per + 1 external, for assembly and slurp symbol table + we use 2. */ + 1, + 64, /* arch_size. */ + 3, /* log_file_align. */ + ELFCLASS64, + EV_CURRENT, + bfd_elf64_write_out_phdrs, + bfd_elf64_write_shdrs_and_ehdr, + elf64_sparc_write_relocs, + bfd_elf64_swap_symbol_in, + bfd_elf64_swap_symbol_out, + elf64_sparc_slurp_reloc_table, + bfd_elf64_slurp_symbol_table, + bfd_elf64_swap_dyn_in, + bfd_elf64_swap_dyn_out, + bfd_elf64_swap_reloc_in, + bfd_elf64_swap_reloc_out, + bfd_elf64_swap_reloca_in, + bfd_elf64_swap_reloca_out +}; #define TARGET_BIG_SYM bfd_elf64_sparc_vec #define TARGET_BIG_NAME "elf64-sparc" #define ELF_ARCH bfd_arch_sparc -#define ELF_MACHINE_CODE EM_SPARC64 #define ELF_MAXPAGESIZE 0x100000 +#define ELF_COMMONPAGESIZE 0x2000 + +/* This is the official ABI value. */ +#define ELF_MACHINE_CODE EM_SPARCV9 + +/* This is the value that we used before the ABI was released. */ +#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9 + +#define elf_backend_reloc_type_class \ + elf64_sparc_reloc_type_class +#define bfd_elf64_get_reloc_upper_bound \ + elf64_sparc_get_reloc_upper_bound +#define bfd_elf64_get_dynamic_reloc_upper_bound \ + elf64_sparc_get_dynamic_reloc_upper_bound +#define bfd_elf64_canonicalize_reloc \ + elf64_sparc_canonicalize_reloc +#define bfd_elf64_canonicalize_dynamic_reloc \ + elf64_sparc_canonicalize_dynamic_reloc +#define elf_backend_add_symbol_hook \ + elf64_sparc_add_symbol_hook +#define elf_backend_get_symbol_type \ + elf64_sparc_get_symbol_type +#define elf_backend_symbol_processing \ + elf64_sparc_symbol_processing +#define elf_backend_print_symbol_all \ + elf64_sparc_print_symbol_all +#define elf_backend_output_arch_syms \ + elf64_sparc_output_arch_syms +#define bfd_elf64_bfd_merge_private_bfd_data \ + elf64_sparc_merge_private_bfd_data +#define elf_backend_fake_sections \ + elf64_sparc_fake_sections +#define elf_backend_size_info \ + elf64_sparc_size_info + +#define elf_backend_plt_sym_val \ + _bfd_sparc_elf_plt_sym_val +#define bfd_elf64_bfd_link_hash_table_create \ + _bfd_sparc_elf_link_hash_table_create +#define elf_info_to_howto \ + _bfd_sparc_elf_info_to_howto +#define elf_backend_copy_indirect_symbol \ + _bfd_sparc_elf_copy_indirect_symbol +#define bfd_elf64_bfd_reloc_type_lookup \ + _bfd_sparc_elf_reloc_type_lookup +#define bfd_elf64_bfd_reloc_name_lookup \ + _bfd_sparc_elf_reloc_name_lookup +#define bfd_elf64_bfd_relax_section \ + _bfd_sparc_elf_relax_section +#define bfd_elf64_new_section_hook \ + _bfd_sparc_elf_new_section_hook + +#define elf_backend_create_dynamic_sections \ + _bfd_sparc_elf_create_dynamic_sections +#define elf_backend_check_relocs \ + _bfd_sparc_elf_check_relocs +#define elf_backend_adjust_dynamic_symbol \ + _bfd_sparc_elf_adjust_dynamic_symbol +#define elf_backend_omit_section_dynsym \ + _bfd_sparc_elf_omit_section_dynsym +#define elf_backend_size_dynamic_sections \ + _bfd_sparc_elf_size_dynamic_sections +#define elf_backend_relocate_section \ + _bfd_sparc_elf_relocate_section +#define elf_backend_finish_dynamic_symbol \ + _bfd_sparc_elf_finish_dynamic_symbol +#define elf_backend_finish_dynamic_sections \ + _bfd_sparc_elf_finish_dynamic_sections + +#define bfd_elf64_mkobject \ + _bfd_sparc_elf_mkobject +#define elf_backend_object_p \ + _bfd_sparc_elf_object_p +#define elf_backend_gc_mark_hook \ + _bfd_sparc_elf_gc_mark_hook +#define elf_backend_gc_sweep_hook \ + _bfd_sparc_elf_gc_sweep_hook +#define elf_backend_init_index_section \ + _bfd_elf_init_1_index_section + +#define elf_backend_can_gc_sections 1 +#define elf_backend_can_refcount 1 +#define elf_backend_want_got_plt 0 +#define elf_backend_plt_readonly 0 +#define elf_backend_want_plt_sym 1 +#define elf_backend_got_header_size 8 +#define elf_backend_rela_normal 1 + +/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */ +#define elf_backend_plt_alignment 8 + +#include "elf64-target.h" -#define elf_info_to_howto sparc64_elf_info_to_howto -#define bfd_elf64_bfd_reloc_type_lookup sparc64_elf_reloc_type_lookup -#define elf_backend_relocate_section sparc64_elf_relocate_section -#define elf_backend_object_p sparc64_elf_object_p +/* FreeBSD support */ +#undef TARGET_BIG_SYM +#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec +#undef TARGET_BIG_NAME +#define TARGET_BIG_NAME "elf64-sparc-freebsd" +#undef ELF_OSABI +#define ELF_OSABI ELFOSABI_FREEBSD + +#undef elf_backend_post_process_headers +#define elf_backend_post_process_headers _bfd_elf_set_osabi +#undef elf64_bed +#define elf64_bed elf64_sparc_fbsd_bed #include "elf64-target.h" +