bfd/elf64-sparc.c

   1 /* SPARC-specific support for 64-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "opcode/sparc.h"
  26
  27 /* This is defined if one wants to build upward compatible binaries
  28    with the original sparc64-elf toolchain.  The support is kept in for
  29    now but is turned off by default.  dje 970930  */
  30 /*#define SPARC64_OLD_RELOCS*/
  31
  32 #include "elf/sparc.h"
  33
  34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  35 #define MINUS_ONE (~ (bfd_vma) 0)
  36
  37 static struct bfd_link_hash_table * sparc64_elf_bfd_link_hash_table_create
  38   PARAMS ((bfd *));
  39 static bfd_reloc_status_type init_insn_reloc
  40   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *,
  41            bfd *, bfd_vma *, bfd_vma *));
  42 static reloc_howto_type *sparc64_elf_reloc_type_lookup
  43   PARAMS ((bfd *, bfd_reloc_code_real_type));
  44 static void sparc64_elf_info_to_howto
  45   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  46
  47 static void sparc64_elf_build_plt
  48   PARAMS ((bfd *, unsigned char *, int));
  49 static bfd_vma sparc64_elf_plt_entry_offset
  50   PARAMS ((bfd_vma));
  51 static bfd_vma sparc64_elf_plt_ptr_offset
  52   PARAMS ((bfd_vma, bfd_vma));
  53
  54 static bfd_boolean sparc64_elf_check_relocs
  55   PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
  56            const Elf_Internal_Rela *));
  57 static bfd_boolean sparc64_elf_adjust_dynamic_symbol
  58   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  59 static bfd_boolean sparc64_elf_size_dynamic_sections
  60   PARAMS ((bfd *, struct bfd_link_info *));
  61 static int sparc64_elf_get_symbol_type
  62   PARAMS (( Elf_Internal_Sym *, int));
  63 static bfd_boolean sparc64_elf_add_symbol_hook
  64   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
  65            const char **, flagword *, asection **, bfd_vma *));
  66 static bfd_boolean sparc64_elf_output_arch_syms
  67   PARAMS ((bfd *, struct bfd_link_info *, PTR,
  68            bfd_boolean (*) (PTR, const char *, Elf_Internal_Sym *, asection *)));
  69 static void sparc64_elf_symbol_processing
  70   PARAMS ((bfd *, asymbol *));
  71
  72 static bfd_boolean sparc64_elf_merge_private_bfd_data
  73   PARAMS ((bfd *, bfd *));
  74
  75 static bfd_boolean sparc64_elf_fake_sections
  76   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
  77
  78 static const char *sparc64_elf_print_symbol_all
  79   PARAMS ((bfd *, PTR, asymbol *));
  80 static bfd_boolean sparc64_elf_new_section_hook
  81   PARAMS ((bfd *, asection *));
  82 static bfd_boolean sparc64_elf_relax_section
  83   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  84 static bfd_boolean sparc64_elf_relocate_section
  85   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  86            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  87 static bfd_boolean sparc64_elf_finish_dynamic_symbol
  88   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  89            Elf_Internal_Sym *));
  90 static bfd_boolean sparc64_elf_finish_dynamic_sections
  91   PARAMS ((bfd *, struct bfd_link_info *));
  92 static bfd_boolean sparc64_elf_object_p PARAMS ((bfd *));
  93 static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *));
  94 static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
  95 static bfd_boolean sparc64_elf_slurp_one_reloc_table
  96   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, bfd_boolean));
  97 static bfd_boolean sparc64_elf_slurp_reloc_table
  98   PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
  99 static long sparc64_elf_canonicalize_dynamic_reloc
 100   PARAMS ((bfd *, arelent **, asymbol **));
 101 static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR));
 102 static enum elf_reloc_type_class sparc64_elf_reloc_type_class
 103   PARAMS ((const Elf_Internal_Rela *));
 104 \f
 105 /* The relocation "howto" table.  */
 106
 107 static bfd_reloc_status_type sparc_elf_notsup_reloc
 108   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 109 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
 110   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 111 static bfd_reloc_status_type sparc_elf_hix22_reloc
 112   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 113 static bfd_reloc_status_type sparc_elf_lox10_reloc
 114   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 115
 116 static reloc_howto_type sparc64_elf_howto_table[] =
 117 {
 118   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 119   HOWTO(R_SPARC_8,         0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_8",       FALSE,0,0x000000ff,TRUE),
 120   HOWTO(R_SPARC_16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_16",      FALSE,0,0x0000ffff,TRUE),
 121   HOWTO(R_SPARC_32,        0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_32",      FALSE,0,0xffffffff,TRUE),
 122   HOWTO(R_SPARC_DISP8,     0,0, 8,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP8",   FALSE,0,0x000000ff,TRUE),
 123   HOWTO(R_SPARC_DISP16,    0,1,16,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP16",  FALSE,0,0x0000ffff,TRUE),
 124   HOWTO(R_SPARC_DISP32,    0,2,32,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP32",  FALSE,0,0xffffffff,TRUE),
 125   HOWTO(R_SPARC_WDISP30,   2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
 126   HOWTO(R_SPARC_WDISP22,   2,2,22,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
 127   HOWTO(R_SPARC_HI22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HI22",    FALSE,0,0x003fffff,TRUE),
 128   HOWTO(R_SPARC_22,        0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_22",      FALSE,0,0x003fffff,TRUE),
 129   HOWTO(R_SPARC_13,        0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_13",      FALSE,0,0x00001fff,TRUE),
 130   HOWTO(R_SPARC_LO10,      0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LO10",    FALSE,0,0x000003ff,TRUE),
 131   HOWTO(R_SPARC_GOT10,     0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT10",   FALSE,0,0x000003ff,TRUE),
 132   HOWTO(R_SPARC_GOT13,     0,2,13,FALSE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_GOT13",   FALSE,0,0x00001fff,TRUE),
 133   HOWTO(R_SPARC_GOT22,    10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT22",   FALSE,0,0x003fffff,TRUE),
 134   HOWTO(R_SPARC_PC10,      0,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC10",    FALSE,0,0x000003ff,TRUE),
 135   HOWTO(R_SPARC_PC22,     10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PC22",    FALSE,0,0x003fffff,TRUE),
 136   HOWTO(R_SPARC_WPLT30,    2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WPLT30",  FALSE,0,0x3fffffff,TRUE),
 137   HOWTO(R_SPARC_COPY,      0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_COPY",    FALSE,0,0x00000000,TRUE),
 138   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),
 139   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),
 140   HOWTO(R_SPARC_RELATIVE,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
 141   HOWTO(R_SPARC_UA32,      0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA32",    FALSE,0,0xffffffff,TRUE),
 142 #ifndef SPARC64_OLD_RELOCS
 143   HOWTO(R_SPARC_PLT32,     0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT32",   FALSE,0,0xffffffff,TRUE),
 144   /* These aren't implemented yet.  */
 145   HOWTO(R_SPARC_HIPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_HIPLT22",  FALSE,0,0x00000000,TRUE),
 146   HOWTO(R_SPARC_LOPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_LOPLT10",  FALSE,0,0x00000000,TRUE),
 147   HOWTO(R_SPARC_PCPLT32,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT32",  FALSE,0,0x00000000,TRUE),
 148   HOWTO(R_SPARC_PCPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT22",  FALSE,0,0x00000000,TRUE),
 149   HOWTO(R_SPARC_PCPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT10",  FALSE,0,0x00000000,TRUE),
 150 #endif
 151   HOWTO(R_SPARC_10,        0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      FALSE,0,0x000003ff,TRUE),
 152   HOWTO(R_SPARC_11,        0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      FALSE,0,0x000007ff,TRUE),
 153   HOWTO(R_SPARC_64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_64",      FALSE,0,MINUS_ONE, TRUE),
 154   HOWTO(R_SPARC_OLO10,     0,2,13,FALSE,0,complain_overflow_signed,  sparc_elf_notsup_reloc, "R_SPARC_OLO10",   FALSE,0,0x00001fff,TRUE),
 155   HOWTO(R_SPARC_HH22,     42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_HH22",    FALSE,0,0x003fffff,TRUE),
 156   HOWTO(R_SPARC_HM10,     32,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HM10",    FALSE,0,0x000003ff,TRUE),
 157   HOWTO(R_SPARC_LM22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LM22",    FALSE,0,0x003fffff,TRUE),
 158   HOWTO(R_SPARC_PC_HH22,  42,2,22,TRUE, 0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_PC_HH22",    FALSE,0,0x003fffff,TRUE),
 159   HOWTO(R_SPARC_PC_HM10,  32,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC_HM10",    FALSE,0,0x000003ff,TRUE),
 160   HOWTO(R_SPARC_PC_LM22,  10,2,22,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC_LM22",    FALSE,0,0x003fffff,TRUE),
 161   HOWTO(R_SPARC_WDISP16,   2,2,16,TRUE, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
 162   HOWTO(R_SPARC_WDISP19,   2,2,19,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
 163   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),
 164   HOWTO(R_SPARC_7,         0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       FALSE,0,0x0000007f,TRUE),
 165   HOWTO(R_SPARC_5,         0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       FALSE,0,0x0000001f,TRUE),
 166   HOWTO(R_SPARC_6,         0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       FALSE,0,0x0000003f,TRUE),
 167   HOWTO(R_SPARC_DISP64,    0,4,64,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP64",  FALSE,0,MINUS_ONE, TRUE),
 168   HOWTO(R_SPARC_PLT64,     0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT64",   FALSE,0,MINUS_ONE, TRUE),
 169   HOWTO(R_SPARC_HIX22,     0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,  "R_SPARC_HIX22",   FALSE,0,MINUS_ONE, FALSE),
 170   HOWTO(R_SPARC_LOX10,     0,4, 0,FALSE,0,complain_overflow_dont,    sparc_elf_lox10_reloc,  "R_SPARC_LOX10",   FALSE,0,MINUS_ONE, FALSE),
 171   HOWTO(R_SPARC_H44,      22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_H44",     FALSE,0,0x003fffff,FALSE),
 172   HOWTO(R_SPARC_M44,      12,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_M44",     FALSE,0,0x000003ff,FALSE),
 173   HOWTO(R_SPARC_L44,       0,2,13,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_L44",     FALSE,0,0x00000fff,FALSE),
 174   HOWTO(R_SPARC_REGISTER,  0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
 175   HOWTO(R_SPARC_UA64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA64",      FALSE,0,MINUS_ONE, TRUE),
 176   HOWTO(R_SPARC_UA16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA16",      FALSE,0,0x0000ffff,TRUE),
 177   HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
 178   HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
 179   HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
 180   HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
 181   HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
 182   HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
 183   HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
 184   HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
 185   HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
 186   HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont,  sparc_elf_lox10_reloc,  "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
 187   HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
 188   HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
 189   HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
 190   HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont,     bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
 191   HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
 192   HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
 193   HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
 194   HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont,   sparc_elf_lox10_reloc,  "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
 195   HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
 196   HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
 197   HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
 198   HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE),
 199   HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
 200   HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE)
 201 };
 202
 203 struct elf_reloc_map {
 204   bfd_reloc_code_real_type bfd_reloc_val;
 205   unsigned char elf_reloc_val;
 206 };
 207
 208 static const struct elf_reloc_map sparc_reloc_map[] =
 209 {
 210   { BFD_RELOC_NONE, R_SPARC_NONE, },
 211   { BFD_RELOC_16, R_SPARC_16, },
 212   { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
 213   { BFD_RELOC_8, R_SPARC_8 },
 214   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
 215   { BFD_RELOC_CTOR, R_SPARC_64 },
 216   { BFD_RELOC_32, R_SPARC_32 },
 217   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
 218   { BFD_RELOC_HI22, R_SPARC_HI22 },
 219   { BFD_RELOC_LO10, R_SPARC_LO10, },
 220   { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
 221   { BFD_RELOC_64_PCREL, R_SPARC_DISP64 },
 222   { BFD_RELOC_SPARC22, R_SPARC_22 },
 223   { BFD_RELOC_SPARC13, R_SPARC_13 },
 224   { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
 225   { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
 226   { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
 227   { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
 228   { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
 229   { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
 230   { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
 231   { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
 232   { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
 233   { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
 234   { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
 235   { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
 236   { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
 237   { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
 238   { BFD_RELOC_SPARC_10, R_SPARC_10 },
 239   { BFD_RELOC_SPARC_11, R_SPARC_11 },
 240   { BFD_RELOC_SPARC_64, R_SPARC_64 },
 241   { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
 242   { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
 243   { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
 244   { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
 245   { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
 246   { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
 247   { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
 248   { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
 249   { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
 250   { BFD_RELOC_SPARC_7, R_SPARC_7 },
 251   { BFD_RELOC_SPARC_5, R_SPARC_5 },
 252   { BFD_RELOC_SPARC_6, R_SPARC_6 },
 253   { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 },
 254   { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
 255   { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
 256   { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
 257   { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
 258   { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
 259   { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
 260   { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
 261   { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
 262   { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
 263   { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
 264   { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
 265   { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
 266   { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
 267   { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
 268   { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
 269   { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
 270   { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
 271   { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
 272   { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
 273   { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
 274   { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
 275   { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
 276   { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
 277   { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
 278 #ifndef SPARC64_OLD_RELOCS
 279   { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
 280 #endif
 281   { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 },
 282   { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 },
 283   { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 },
 284   { BFD_RELOC_SPARC_H44, R_SPARC_H44 },
 285   { BFD_RELOC_SPARC_M44, R_SPARC_M44 },
 286   { BFD_RELOC_SPARC_L44, R_SPARC_L44 },
 287   { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER }
 288 };
 289
 290 static reloc_howto_type *
 291 sparc64_elf_reloc_type_lookup (abfd, code)
 292      bfd *abfd ATTRIBUTE_UNUSED;
 293      bfd_reloc_code_real_type code;
 294 {
 295   unsigned int i;
 296   for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
 297     {
 298       if (sparc_reloc_map[i].bfd_reloc_val == code)
 299         return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
 300     }
 301   return 0;
 302 }
 303
 304 static void
 305 sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
 306      bfd *abfd ATTRIBUTE_UNUSED;
 307      arelent *cache_ptr;
 308      Elf_Internal_Rela *dst;
 309 {
 310   BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std);
 311   cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)];
 312 }
 313 \f
 314 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
 315    section can represent up to two relocs, we must tell the user to allocate
 316    more space.  */
 317
 318 static long
 319 sparc64_elf_get_reloc_upper_bound (abfd, sec)
 320      bfd *abfd ATTRIBUTE_UNUSED;
 321      asection *sec;
 322 {
 323   return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
 324 }
 325
 326 static long
 327 sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
 328      bfd *abfd;
 329 {
 330   return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
 331 }
 332
 333 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
 334    them.  We cannot use generic elf routines for this,  because R_SPARC_OLO10
 335    has secondary addend in ELF64_R_TYPE_DATA.  We handle it as two relocations
 336    for the same location,  R_SPARC_LO10 and R_SPARC_13.  */
 337
 338 static bfd_boolean
 339 sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
 340      bfd *abfd;
 341      asection *asect;
 342      Elf_Internal_Shdr *rel_hdr;
 343      asymbol **symbols;
 344      bfd_boolean dynamic;
 345 {
 346   PTR allocated = NULL;
 347   bfd_byte *native_relocs;
 348   arelent *relent;
 349   unsigned int i;
 350   int entsize;
 351   bfd_size_type count;
 352   arelent *relents;
 353
 354   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
 355   if (allocated == NULL)
 356     goto error_return;
 357
 358   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
 359       || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
 360     goto error_return;
 361
 362   native_relocs = (bfd_byte *) allocated;
 363
 364   relents = asect->relocation + asect->reloc_count;
 365
 366   entsize = rel_hdr->sh_entsize;
 367   BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
 368
 369   count = rel_hdr->sh_size / entsize;
 370
 371   for (i = 0, relent = relents; i < count;
 372        i++, relent++, native_relocs += entsize)
 373     {
 374       Elf_Internal_Rela rela;
 375
 376       bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
 377
 378       /* The address of an ELF reloc is section relative for an object
 379          file, and absolute for an executable file or shared library.
 380          The address of a normal BFD reloc is always section relative,
 381          and the address of a dynamic reloc is absolute..  */
 382       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
 383         relent->address = rela.r_offset;
 384       else
 385         relent->address = rela.r_offset - asect->vma;
 386
 387       if (ELF64_R_SYM (rela.r_info) == 0)
 388         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 389       else
 390         {
 391           asymbol **ps, *s;
 392
 393           ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
 394           s = *ps;
 395
 396           /* Canonicalize ELF section symbols.  FIXME: Why?  */
 397           if ((s->flags & BSF_SECTION_SYM) == 0)
 398             relent->sym_ptr_ptr = ps;
 399           else
 400             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
 401         }
 402
 403       relent->addend = rela.r_addend;
 404
 405       BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std);
 406       if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10)
 407         {
 408           relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10];
 409           relent[1].address = relent->address;
 410           relent++;
 411           relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 412           relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
 413           relent->howto = &sparc64_elf_howto_table[R_SPARC_13];
 414         }
 415       else
 416         relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)];
 417     }
 418
 419   asect->reloc_count += relent - relents;
 420
 421   if (allocated != NULL)
 422     free (allocated);
 423
 424   return TRUE;
 425
 426  error_return:
 427   if (allocated != NULL)
 428     free (allocated);
 429   return FALSE;
 430 }
 431
 432 /* Read in and swap the external relocs.  */
 433
 434 static bfd_boolean
 435 sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
 436      bfd *abfd;
 437      asection *asect;
 438      asymbol **symbols;
 439      bfd_boolean dynamic;
 440 {
 441   struct bfd_elf_section_data * const d = elf_section_data (asect);
 442   Elf_Internal_Shdr *rel_hdr;
 443   Elf_Internal_Shdr *rel_hdr2;
 444   bfd_size_type amt;
 445
 446   if (asect->relocation != NULL)
 447     return TRUE;
 448
 449   if (! dynamic)
 450     {
 451       if ((asect->flags & SEC_RELOC) == 0
 452           || asect->reloc_count == 0)
 453         return TRUE;
 454
 455       rel_hdr = &d->rel_hdr;
 456       rel_hdr2 = d->rel_hdr2;
 457
 458       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
 459                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
 460     }
 461   else
 462     {
 463       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
 464          case because relocations against this section may use the
 465          dynamic symbol table, and in that case bfd_section_from_shdr
 466          in elf.c does not update the RELOC_COUNT.  */
 467       if (asect->_raw_size == 0)
 468         return TRUE;
 469
 470       rel_hdr = &d->this_hdr;
 471       asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
 472       rel_hdr2 = NULL;
 473     }
 474
 475   amt = asect->reloc_count;
 476   amt *= 2 * sizeof (arelent);
 477   asect->relocation = (arelent *) bfd_alloc (abfd, amt);
 478   if (asect->relocation == NULL)
 479     return FALSE;
 480
 481   /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count.  */
 482   asect->reloc_count = 0;
 483
 484   if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
 485                                           dynamic))
 486     return FALSE;
 487
 488   if (rel_hdr2
 489       && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
 490                                              dynamic))
 491     return FALSE;
 492
 493   return TRUE;
 494 }
 495
 496 /* Canonicalize the dynamic relocation entries.  Note that we return
 497    the dynamic relocations as a single block, although they are
 498    actually associated with particular sections; the interface, which
 499    was designed for SunOS style shared libraries, expects that there
 500    is only one set of dynamic relocs.  Any section that was actually
 501    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
 502    the dynamic symbol table, is considered to be a dynamic reloc
 503    section.  */
 504
 505 static long
 506 sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
 507      bfd *abfd;
 508      arelent **storage;
 509      asymbol **syms;
 510 {
 511   asection *s;
 512   long ret;
 513
 514   if (elf_dynsymtab (abfd) == 0)
 515     {
 516       bfd_set_error (bfd_error_invalid_operation);
 517       return -1;
 518     }
 519
 520   ret = 0;
 521   for (s = abfd->sections; s != NULL; s = s->next)
 522     {
 523       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
 524           && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
 525         {
 526           arelent *p;
 527           long count, i;
 528
 529           if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, TRUE))
 530             return -1;
 531           count = s->reloc_count;
 532           p = s->relocation;
 533           for (i = 0; i < count; i++)
 534             *storage++ = p++;
 535           ret += count;
 536         }
 537     }
 538
 539   *storage = NULL;
 540
 541   return ret;
 542 }
 543
 544 /* Write out the relocs.  */
 545
 546 static void
 547 sparc64_elf_write_relocs (abfd, sec, data)
 548      bfd *abfd;
 549      asection *sec;
 550      PTR data;
 551 {
 552   bfd_boolean *failedp = (bfd_boolean *) data;
 553   Elf_Internal_Shdr *rela_hdr;
 554   Elf64_External_Rela *outbound_relocas, *src_rela;
 555   unsigned int idx, count;
 556   asymbol *last_sym = 0;
 557   int last_sym_idx = 0;
 558
 559   /* If we have already failed, don't do anything.  */
 560   if (*failedp)
 561     return;
 562
 563   if ((sec->flags & SEC_RELOC) == 0)
 564     return;
 565
 566   /* The linker backend writes the relocs out itself, and sets the
 567      reloc_count field to zero to inhibit writing them here.  Also,
 568      sometimes the SEC_RELOC flag gets set even when there aren't any
 569      relocs.  */
 570   if (sec->reloc_count == 0)
 571     return;
 572
 573   /* We can combine two relocs that refer to the same address
 574      into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
 575      latter is R_SPARC_13 with no associated symbol.  */
 576   count = 0;
 577   for (idx = 0; idx < sec->reloc_count; idx++)
 578     {
 579       bfd_vma addr;
 580
 581       ++count;
 582
 583       addr = sec->orelocation[idx]->address;
 584       if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
 585           && idx < sec->reloc_count - 1)
 586         {
 587           arelent *r = sec->orelocation[idx + 1];
 588
 589           if (r->howto->type == R_SPARC_13
 590               && r->address == addr
 591               && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
 592               && (*r->sym_ptr_ptr)->value == 0)
 593             ++idx;
 594         }
 595     }
 596
 597   rela_hdr = &elf_section_data (sec)->rel_hdr;
 598
 599   rela_hdr->sh_size = rela_hdr->sh_entsize * count;
 600   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
 601   if (rela_hdr->contents == NULL)
 602     {
 603       *failedp = TRUE;
 604       return;
 605     }
 606
 607   /* Figure out whether the relocations are RELA or REL relocations.  */
 608   if (rela_hdr->sh_type != SHT_RELA)
 609     abort ();
 610
 611   /* orelocation has the data, reloc_count has the count...  */
 612   outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
 613   src_rela = outbound_relocas;
 614
 615   for (idx = 0; idx < sec->reloc_count; idx++)
 616     {
 617       Elf_Internal_Rela dst_rela;
 618       arelent *ptr;
 619       asymbol *sym;
 620       int n;
 621
 622       ptr = sec->orelocation[idx];
 623
 624       /* The address of an ELF reloc is section relative for an object
 625          file, and absolute for an executable file or shared library.
 626          The address of a BFD reloc is always section relative.  */
 627       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
 628         dst_rela.r_offset = ptr->address;
 629       else
 630         dst_rela.r_offset = ptr->address + sec->vma;
 631
 632       sym = *ptr->sym_ptr_ptr;
 633       if (sym == last_sym)
 634         n = last_sym_idx;
 635       else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 636         n = STN_UNDEF;
 637       else
 638         {
 639           last_sym = sym;
 640           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 641           if (n < 0)
 642             {
 643               *failedp = TRUE;
 644               return;
 645             }
 646           last_sym_idx = n;
 647         }
 648
 649       if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 650           && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 651           && ! _bfd_elf_validate_reloc (abfd, ptr))
 652         {
 653           *failedp = TRUE;
 654           return;
 655         }
 656
 657       if (ptr->howto->type == R_SPARC_LO10
 658           && idx < sec->reloc_count - 1)
 659         {
 660           arelent *r = sec->orelocation[idx + 1];
 661
 662           if (r->howto->type == R_SPARC_13
 663               && r->address == ptr->address
 664               && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
 665               && (*r->sym_ptr_ptr)->value == 0)
 666             {
 667               idx++;
 668               dst_rela.r_info
 669                 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
 670                                                       R_SPARC_OLO10));
 671             }
 672           else
 673             dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
 674         }
 675       else
 676         dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
 677
 678       dst_rela.r_addend = ptr->addend;
 679       bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
 680       ++src_rela;
 681     }
 682 }
 683 \f
 684 /* Sparc64 ELF linker hash table.  */
 685
 686 struct sparc64_elf_app_reg
 687 {
 688   unsigned char bind;
 689   unsigned short shndx;
 690   bfd *abfd;
 691   char *name;
 692 };
 693
 694 struct sparc64_elf_link_hash_table
 695 {
 696   struct elf_link_hash_table root;
 697
 698   struct sparc64_elf_app_reg app_regs [4];
 699 };
 700
 701 /* Get the Sparc64 ELF linker hash table from a link_info structure.  */
 702
 703 #define sparc64_elf_hash_table(p) \
 704   ((struct sparc64_elf_link_hash_table *) ((p)->hash))
 705
 706 /* Create a Sparc64 ELF linker hash table.  */
 707
 708 static struct bfd_link_hash_table *
 709 sparc64_elf_bfd_link_hash_table_create (abfd)
 710      bfd *abfd;
 711 {
 712   struct sparc64_elf_link_hash_table *ret;
 713   bfd_size_type amt = sizeof (struct sparc64_elf_link_hash_table);
 714
 715   ret = (struct sparc64_elf_link_hash_table *) bfd_zmalloc (amt);
 716   if (ret == (struct sparc64_elf_link_hash_table *) NULL)
 717     return NULL;
 718
 719   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
 720                                        _bfd_elf_link_hash_newfunc))
 721     {
 722       free (ret);
 723       return NULL;
 724     }
 725
 726   return &ret->root.root;
 727 }
 728 \f
 729 /* Utility for performing the standard initial work of an instruction
 730    relocation.
 731    *PRELOCATION will contain the relocated item.
 732    *PINSN will contain the instruction from the input stream.
 733    If the result is `bfd_reloc_other' the caller can continue with
 734    performing the relocation.  Otherwise it must stop and return the
 735    value to its caller.  */
 736
 737 static bfd_reloc_status_type
 738 init_insn_reloc (abfd,
 739                  reloc_entry,
 740                  symbol,
 741                  data,
 742                  input_section,
 743                  output_bfd,
 744                  prelocation,
 745                  pinsn)
 746      bfd *abfd;
 747      arelent *reloc_entry;
 748      asymbol *symbol;
 749      PTR data;
 750      asection *input_section;
 751      bfd *output_bfd;
 752      bfd_vma *prelocation;
 753      bfd_vma *pinsn;
 754 {
 755   bfd_vma relocation;
 756   reloc_howto_type *howto = reloc_entry->howto;
 757
 758   if (output_bfd != (bfd *) NULL
 759       && (symbol->flags & BSF_SECTION_SYM) == 0
 760       && (! howto->partial_inplace
 761           || reloc_entry->addend == 0))
 762     {
 763       reloc_entry->address += input_section->output_offset;
 764       return bfd_reloc_ok;
 765     }
 766
 767   /* This works because partial_inplace is FALSE.  */
 768   if (output_bfd != NULL)
 769     return bfd_reloc_continue;
 770
 771   if (reloc_entry->address > input_section->_cooked_size)
 772     return bfd_reloc_outofrange;
 773
 774   relocation = (symbol->value
 775                 + symbol->section->output_section->vma
 776                 + symbol->section->output_offset);
 777   relocation += reloc_entry->addend;
 778   if (howto->pc_relative)
 779     {
 780       relocation -= (input_section->output_section->vma
 781                      + input_section->output_offset);
 782       relocation -= reloc_entry->address;
 783     }
 784
 785   *prelocation = relocation;
 786   *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 787   return bfd_reloc_other;
 788 }
 789
 790 /* For unsupported relocs.  */
 791
 792 static bfd_reloc_status_type
 793 sparc_elf_notsup_reloc (abfd,
 794                         reloc_entry,
 795                         symbol,
 796                         data,
 797                         input_section,
 798                         output_bfd,
 799                         error_message)
 800      bfd *abfd ATTRIBUTE_UNUSED;
 801      arelent *reloc_entry ATTRIBUTE_UNUSED;
 802      asymbol *symbol ATTRIBUTE_UNUSED;
 803      PTR data ATTRIBUTE_UNUSED;
 804      asection *input_section ATTRIBUTE_UNUSED;
 805      bfd *output_bfd ATTRIBUTE_UNUSED;
 806      char **error_message ATTRIBUTE_UNUSED;
 807 {
 808   return bfd_reloc_notsupported;
 809 }
 810
 811 /* Handle the WDISP16 reloc.  */
 812
 813 static bfd_reloc_status_type
 814 sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section,
 815                          output_bfd, error_message)
 816      bfd *abfd;
 817      arelent *reloc_entry;
 818      asymbol *symbol;
 819      PTR data;
 820      asection *input_section;
 821      bfd *output_bfd;
 822      char **error_message ATTRIBUTE_UNUSED;
 823 {
 824   bfd_vma relocation;
 825   bfd_vma insn;
 826   bfd_reloc_status_type status;
 827
 828   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 829                             input_section, output_bfd, &relocation, &insn);
 830   if (status != bfd_reloc_other)
 831     return status;
 832
 833   insn &= ~ (bfd_vma) 0x303fff;
 834   insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
 835   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 836
 837   if ((bfd_signed_vma) relocation < - 0x40000
 838       || (bfd_signed_vma) relocation > 0x3ffff)
 839     return bfd_reloc_overflow;
 840   else
 841     return bfd_reloc_ok;
 842 }
 843
 844 /* Handle the HIX22 reloc.  */
 845
 846 static bfd_reloc_status_type
 847 sparc_elf_hix22_reloc (abfd,
 848                        reloc_entry,
 849                        symbol,
 850                        data,
 851                        input_section,
 852                        output_bfd,
 853                        error_message)
 854      bfd *abfd;
 855      arelent *reloc_entry;
 856      asymbol *symbol;
 857      PTR data;
 858      asection *input_section;
 859      bfd *output_bfd;
 860      char **error_message ATTRIBUTE_UNUSED;
 861 {
 862   bfd_vma relocation;
 863   bfd_vma insn;
 864   bfd_reloc_status_type status;
 865
 866   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 867                             input_section, output_bfd, &relocation, &insn);
 868   if (status != bfd_reloc_other)
 869     return status;
 870
 871   relocation ^= MINUS_ONE;
 872   insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
 873   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 874
 875   if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
 876     return bfd_reloc_overflow;
 877   else
 878     return bfd_reloc_ok;
 879 }
 880
 881 /* Handle the LOX10 reloc.  */
 882
 883 static bfd_reloc_status_type
 884 sparc_elf_lox10_reloc (abfd,
 885                        reloc_entry,
 886                        symbol,
 887                        data,
 888                        input_section,
 889                        output_bfd,
 890                        error_message)
 891      bfd *abfd;
 892      arelent *reloc_entry;
 893      asymbol *symbol;
 894      PTR data;
 895      asection *input_section;
 896      bfd *output_bfd;
 897      char **error_message ATTRIBUTE_UNUSED;
 898 {
 899   bfd_vma relocation;
 900   bfd_vma insn;
 901   bfd_reloc_status_type status;
 902
 903   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 904                             input_section, output_bfd, &relocation, &insn);
 905   if (status != bfd_reloc_other)
 906     return status;
 907
 908   insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
 909   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 910
 911   return bfd_reloc_ok;
 912 }
 913 \f
 914 /* PLT/GOT stuff */
 915
 916 /* Both the headers and the entries are icache aligned.  */
 917 #define PLT_ENTRY_SIZE          32
 918 #define PLT_HEADER_SIZE         (4 * PLT_ENTRY_SIZE)
 919 #define LARGE_PLT_THRESHOLD     32768
 920 #define GOT_RESERVED_ENTRIES    1
 921
 922 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
 923
 924 /* Fill in the .plt section.  */
 925
 926 static void
 927 sparc64_elf_build_plt (output_bfd, contents, nentries)
 928      bfd *output_bfd;
 929      unsigned char *contents;
 930      int nentries;
 931 {
 932   const unsigned int nop = 0x01000000;
 933   int i, j;
 934
 935   /* The first four entries are reserved, and are initially undefined.
 936      We fill them with `illtrap 0' to force ld.so to do something.  */
 937
 938   for (i = 0; i < PLT_HEADER_SIZE/4; ++i)
 939     bfd_put_32 (output_bfd, (bfd_vma) 0, contents+i*4);
 940
 941   /* The first 32768 entries are close enough to plt1 to get there via
 942      a straight branch.  */
 943
 944   for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i)
 945     {
 946       unsigned char *entry = contents + i * PLT_ENTRY_SIZE;
 947       unsigned int sethi, ba;
 948
 949       /* sethi (. - plt0), %g1 */
 950       sethi = 0x03000000 | (i * PLT_ENTRY_SIZE);
 951
 952       /* ba,a,pt %xcc, plt1 */
 953       ba = 0x30680000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff);
 954
 955       bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
 956       bfd_put_32 (output_bfd, (bfd_vma) ba,    entry + 4);
 957       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 8);
 958       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 12);
 959       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 16);
 960       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 20);
 961       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 24);
 962       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 28);
 963     }
 964
 965   /* Now the tricky bit.  Entries 32768 and higher are grouped in blocks of
 966      160: 160 entries and 160 pointers.  This is to separate code from data,
 967      which is much friendlier on the cache.  */
 968
 969   for (; i < nentries; i += 160)
 970     {
 971       int block = (i + 160 <= nentries ? 160 : nentries - i);
 972       for (j = 0; j < block; ++j)
 973         {
 974           unsigned char *entry, *ptr;
 975           unsigned int ldx;
 976
 977           entry = contents + i*PLT_ENTRY_SIZE + j*4*6;
 978           ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8;
 979
 980           /* ldx [%o7 + ptr - (entry+4)], %g1 */
 981           ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
 982
 983           /* mov %o7,%g5
 984              call .+8
 985              nop
 986              ldx [%o7+P],%g1
 987              jmpl %o7+%g1,%g1
 988              mov %g5,%o7  */
 989           bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
 990           bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
 991           bfd_put_32 (output_bfd, (bfd_vma) nop,        entry + 8);
 992           bfd_put_32 (output_bfd, (bfd_vma) ldx,        entry + 12);
 993           bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
 994           bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
 995
 996           bfd_put_64 (output_bfd, (bfd_vma) (contents - (entry + 4)), ptr);
 997         }
 998     }
 999 }
1000
1001 /* Return the offset of a particular plt entry within the .plt section.  */
1002
1003 static bfd_vma
1004 sparc64_elf_plt_entry_offset (index)
1005      bfd_vma index;
1006 {
1007   bfd_vma block, ofs;
1008
1009   if (index < LARGE_PLT_THRESHOLD)
1010     return index * PLT_ENTRY_SIZE;
1011
1012   /* See above for details.  */
1013
1014   block = (index - LARGE_PLT_THRESHOLD) / 160;
1015   ofs = (index - LARGE_PLT_THRESHOLD) % 160;
1016
1017   return (LARGE_PLT_THRESHOLD + block * 160) * PLT_ENTRY_SIZE + ofs * 6 * 4;
1018 }
1019
1020 static bfd_vma
1021 sparc64_elf_plt_ptr_offset (index, max)
1022      bfd_vma index;
1023      bfd_vma max;
1024 {
1025   bfd_vma block, ofs, last;
1026
1027   BFD_ASSERT(index >= LARGE_PLT_THRESHOLD);
1028
1029   /* See above for details.  */
1030
1031   block = (((index - LARGE_PLT_THRESHOLD) / 160) * 160) + LARGE_PLT_THRESHOLD;
1032   ofs = index - block;
1033   if (block + 160 > max)
1034     last = (max - LARGE_PLT_THRESHOLD) % 160;
1035   else
1036     last = 160;
1037
1038   return (block * PLT_ENTRY_SIZE
1039           + last * 6*4
1040           + ofs * 8);
1041 }
1042 \f
1043 /* Look through the relocs for a section during the first phase, and
1044    allocate space in the global offset table or procedure linkage
1045    table.  */
1046
1047 static bfd_boolean
1048 sparc64_elf_check_relocs (abfd, info, sec, relocs)
1049      bfd *abfd;
1050      struct bfd_link_info *info;
1051      asection *sec;
1052      const Elf_Internal_Rela *relocs;
1053 {
1054   bfd *dynobj;
1055   Elf_Internal_Shdr *symtab_hdr;
1056   struct elf_link_hash_entry **sym_hashes;
1057   bfd_vma *local_got_offsets;
1058   const Elf_Internal_Rela *rel;
1059   const Elf_Internal_Rela *rel_end;
1060   asection *sgot;
1061   asection *srelgot;
1062   asection *sreloc;
1063
1064   if (info->relocateable || !(sec->flags & SEC_ALLOC))
1065     return TRUE;
1066
1067   dynobj = elf_hash_table (info)->dynobj;
1068   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1069   sym_hashes = elf_sym_hashes (abfd);
1070   local_got_offsets = elf_local_got_offsets (abfd);
1071
1072   sgot = NULL;
1073   srelgot = NULL;
1074   sreloc = NULL;
1075
1076   rel_end = relocs + NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1077   for (rel = relocs; rel < rel_end; rel++)
1078     {
1079       unsigned long r_symndx;
1080       struct elf_link_hash_entry *h;
1081
1082       r_symndx = ELF64_R_SYM (rel->r_info);
1083       if (r_symndx < symtab_hdr->sh_info)
1084         h = NULL;
1085       else
1086         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1087
1088       switch (ELF64_R_TYPE_ID (rel->r_info))
1089         {
1090         case R_SPARC_GOT10:
1091         case R_SPARC_GOT13:
1092         case R_SPARC_GOT22:
1093           /* This symbol requires a global offset table entry.  */
1094
1095           if (dynobj == NULL)
1096             {
1097               /* Create the .got section.  */
1098               elf_hash_table (info)->dynobj = dynobj = abfd;
1099               if (! _bfd_elf_create_got_section (dynobj, info))
1100                 return FALSE;
1101             }
1102
1103           if (sgot == NULL)
1104             {
1105               sgot = bfd_get_section_by_name (dynobj, ".got");
1106               BFD_ASSERT (sgot != NULL);
1107             }
1108
1109           if (srelgot == NULL && (h != NULL || info->shared))
1110             {
1111               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1112               if (srelgot == NULL)
1113                 {
1114                   srelgot = bfd_make_section (dynobj, ".rela.got");
1115                   if (srelgot == NULL
1116                       || ! bfd_set_section_flags (dynobj, srelgot,
1117                                                   (SEC_ALLOC
1118                                                    | SEC_LOAD
1119                                                    | SEC_HAS_CONTENTS
1120                                                    | SEC_IN_MEMORY
1121                                                    | SEC_LINKER_CREATED
1122                                                    | SEC_READONLY))
1123                       || ! bfd_set_section_alignment (dynobj, srelgot, 3))
1124                     return FALSE;
1125                 }
1126             }
1127
1128           if (h != NULL)
1129             {
1130               if (h->got.offset != (bfd_vma) -1)
1131                 {
1132                   /* We have already allocated space in the .got.  */
1133                   break;
1134                 }
1135               h->got.offset = sgot->_raw_size;
1136
1137               /* Make sure this symbol is output as a dynamic symbol.  */
1138               if (h->dynindx == -1)
1139                 {
1140                   if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1141                     return FALSE;
1142                 }
1143
1144               srelgot->_raw_size += sizeof (Elf64_External_Rela);
1145             }
1146           else
1147             {
1148               /* This is a global offset table entry for a local
1149                  symbol.  */
1150               if (local_got_offsets == NULL)
1151                 {
1152                   bfd_size_type size;
1153                   register unsigned int i;
1154
1155                   size = symtab_hdr->sh_info;
1156                   size *= sizeof (bfd_vma);
1157                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1158                   if (local_got_offsets == NULL)
1159                     return FALSE;
1160                   elf_local_got_offsets (abfd) = local_got_offsets;
1161                   for (i = 0; i < symtab_hdr->sh_info; i++)
1162                     local_got_offsets[i] = (bfd_vma) -1;
1163                 }
1164               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1165                 {
1166                   /* We have already allocated space in the .got.  */
1167                   break;
1168                 }
1169               local_got_offsets[r_symndx] = sgot->_raw_size;
1170
1171               if (info->shared)
1172                 {
1173                   /* If we are generating a shared object, we need to
1174                      output a R_SPARC_RELATIVE reloc so that the
1175                      dynamic linker can adjust this GOT entry.  */
1176                   srelgot->_raw_size += sizeof (Elf64_External_Rela);
1177                 }
1178             }
1179
1180           sgot->_raw_size += 8;
1181
1182 #if 0
1183           /* Doesn't work for 64-bit -fPIC, since sethi/or builds
1184              unsigned numbers.  If we permit ourselves to modify
1185              code so we get sethi/xor, this could work.
1186              Question: do we consider conditionally re-enabling
1187              this for -fpic, once we know about object code models?  */
1188           /* If the .got section is more than 0x1000 bytes, we add
1189              0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1190              bit relocations have a greater chance of working.  */
1191           if (sgot->_raw_size >= 0x1000
1192               && elf_hash_table (info)->hgot->root.u.def.value == 0)
1193             elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1194 #endif
1195
1196           break;
1197
1198         case R_SPARC_WPLT30:
1199         case R_SPARC_PLT32:
1200         case R_SPARC_HIPLT22:
1201         case R_SPARC_LOPLT10:
1202         case R_SPARC_PCPLT32:
1203         case R_SPARC_PCPLT22:
1204         case R_SPARC_PCPLT10:
1205         case R_SPARC_PLT64:
1206           /* This symbol requires a procedure linkage table entry.  We
1207              actually build the entry in adjust_dynamic_symbol,
1208              because this might be a case of linking PIC code without
1209              linking in any dynamic objects, in which case we don't
1210              need to generate a procedure linkage table after all.  */
1211
1212           if (h == NULL)
1213             {
1214               /* It does not make sense to have a procedure linkage
1215                  table entry for a local symbol.  */
1216               bfd_set_error (bfd_error_bad_value);
1217               return FALSE;
1218             }
1219
1220           /* Make sure this symbol is output as a dynamic symbol.  */
1221           if (h->dynindx == -1)
1222             {
1223               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1224                 return FALSE;
1225             }
1226
1227           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1228           if (ELF64_R_TYPE_ID (rel->r_info) != R_SPARC_PLT32
1229               && ELF64_R_TYPE_ID (rel->r_info) != R_SPARC_PLT64)
1230             break;
1231           /* Fall through.  */
1232         case R_SPARC_PC10:
1233         case R_SPARC_PC22:
1234         case R_SPARC_PC_HH22:
1235         case R_SPARC_PC_HM10:
1236         case R_SPARC_PC_LM22:
1237           if (h != NULL
1238               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1239             break;
1240           /* Fall through.  */
1241         case R_SPARC_DISP8:
1242         case R_SPARC_DISP16:
1243         case R_SPARC_DISP32:
1244         case R_SPARC_DISP64:
1245         case R_SPARC_WDISP30:
1246         case R_SPARC_WDISP22:
1247         case R_SPARC_WDISP19:
1248         case R_SPARC_WDISP16:
1249           if (h == NULL)
1250             break;
1251           /* Fall through.  */
1252         case R_SPARC_8:
1253         case R_SPARC_16:
1254         case R_SPARC_32:
1255         case R_SPARC_HI22:
1256         case R_SPARC_22:
1257         case R_SPARC_13:
1258         case R_SPARC_LO10:
1259         case R_SPARC_UA32:
1260         case R_SPARC_10:
1261         case R_SPARC_11:
1262         case R_SPARC_64:
1263         case R_SPARC_OLO10:
1264         case R_SPARC_HH22:
1265         case R_SPARC_HM10:
1266         case R_SPARC_LM22:
1267         case R_SPARC_7:
1268         case R_SPARC_5:
1269         case R_SPARC_6:
1270         case R_SPARC_HIX22:
1271         case R_SPARC_LOX10:
1272         case R_SPARC_H44:
1273         case R_SPARC_M44:
1274         case R_SPARC_L44:
1275         case R_SPARC_UA64:
1276         case R_SPARC_UA16:
1277           /* When creating a shared object, we must copy these relocs
1278              into the output file.  We create a reloc section in
1279              dynobj and make room for the reloc.
1280
1281              But don't do this for debugging sections -- this shows up
1282              with DWARF2 -- first because they are not loaded, and
1283              second because DWARF sez the debug info is not to be
1284              biased by the load address.  */
1285           if (info->shared && (sec->flags & SEC_ALLOC))
1286             {
1287               if (sreloc == NULL)
1288                 {
1289                   const char *name;
1290
1291                   name = (bfd_elf_string_from_elf_section
1292                           (abfd,
1293                            elf_elfheader (abfd)->e_shstrndx,
1294                            elf_section_data (sec)->rel_hdr.sh_name));
1295                   if (name == NULL)
1296                     return FALSE;
1297
1298                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1299                               && strcmp (bfd_get_section_name (abfd, sec),
1300                                          name + 5) == 0);
1301
1302                   sreloc = bfd_get_section_by_name (dynobj, name);
1303                   if (sreloc == NULL)
1304                     {
1305                       flagword flags;
1306
1307                       sreloc = bfd_make_section (dynobj, name);
1308                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1309                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1310                       if ((sec->flags & SEC_ALLOC) != 0)
1311                         flags |= SEC_ALLOC | SEC_LOAD;
1312                       if (sreloc == NULL
1313                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
1314                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1315                         return FALSE;
1316                     }
1317                   if (sec->flags & SEC_READONLY)
1318                     info->flags |= DF_TEXTREL;
1319                 }
1320
1321               sreloc->_raw_size += sizeof (Elf64_External_Rela);
1322             }
1323           break;
1324
1325         case R_SPARC_REGISTER:
1326           /* Nothing to do.  */
1327           break;
1328
1329         default:
1330           (*_bfd_error_handler) (_("%s: check_relocs: unhandled reloc type %d"),
1331                                 bfd_archive_filename (abfd),
1332                                 ELF64_R_TYPE_ID (rel->r_info));
1333           return FALSE;
1334         }
1335     }
1336
1337   return TRUE;
1338 }
1339
1340 /* Hook called by the linker routine which adds symbols from an object
1341    file.  We use it for STT_REGISTER symbols.  */
1342
1343 static bfd_boolean
1344 sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1345      bfd *abfd;
1346      struct bfd_link_info *info;
1347      const Elf_Internal_Sym *sym;
1348      const char **namep;
1349      flagword *flagsp ATTRIBUTE_UNUSED;
1350      asection **secp ATTRIBUTE_UNUSED;
1351      bfd_vma *valp ATTRIBUTE_UNUSED;
1352 {
1353   static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
1354
1355   if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
1356     {
1357       int reg;
1358       struct sparc64_elf_app_reg *p;
1359
1360       reg = (int)sym->st_value;
1361       switch (reg & ~1)
1362         {
1363         case 2: reg -= 2; break;
1364         case 6: reg -= 4; break;
1365         default:
1366           (*_bfd_error_handler)
1367             (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"),
1368              bfd_archive_filename (abfd));
1369           return FALSE;
1370         }
1371
1372       if (info->hash->creator != abfd->xvec
1373           || (abfd->flags & DYNAMIC) != 0)
1374         {
1375           /* STT_REGISTER only works when linking an elf64_sparc object.
1376              If STT_REGISTER comes from a dynamic object, don't put it into
1377              the output bfd.  The dynamic linker will recheck it.  */
1378           *namep = NULL;
1379           return TRUE;
1380         }
1381
1382       p = sparc64_elf_hash_table(info)->app_regs + reg;
1383
1384       if (p->name != NULL && strcmp (p->name, *namep))
1385         {
1386           (*_bfd_error_handler)
1387             (_("Register %%g%d used incompatibly: %s in %s, previously %s in %s"),
1388              (int) sym->st_value,
1389              **namep ? *namep : "#scratch", bfd_archive_filename (abfd),
1390              *p->name ? p->name : "#scratch", bfd_archive_filename (p->abfd));
1391           return FALSE;
1392         }
1393
1394       if (p->name == NULL)
1395         {
1396           if (**namep)
1397             {
1398               struct elf_link_hash_entry *h;
1399
1400               h = (struct elf_link_hash_entry *)
1401                 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
1402
1403               if (h != NULL)
1404                 {
1405                   unsigned char type = h->type;
1406
1407                   if (type > STT_FUNC)
1408                     type = 0;
1409                   (*_bfd_error_handler)
1410                     (_("Symbol `%s' has differing types: REGISTER in %s, previously %s in %s"),
1411                      *namep, bfd_archive_filename (abfd),
1412                      stt_types[type], bfd_archive_filename (p->abfd));
1413                   return FALSE;
1414                 }
1415
1416               p->name = bfd_hash_allocate (&info->hash->table,
1417                                            strlen (*namep) + 1);
1418               if (!p->name)
1419                 return FALSE;
1420
1421               strcpy (p->name, *namep);
1422             }
1423           else
1424             p->name = "";
1425           p->bind = ELF_ST_BIND (sym->st_info);
1426           p->abfd = abfd;
1427           p->shndx = sym->st_shndx;
1428         }
1429       else
1430         {
1431           if (p->bind == STB_WEAK
1432               && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
1433             {
1434               p->bind = STB_GLOBAL;
1435               p->abfd = abfd;
1436             }
1437         }
1438       *namep = NULL;
1439       return TRUE;
1440     }
1441   else if (*namep && **namep
1442            && info->hash->creator == abfd->xvec)
1443     {
1444       int i;
1445       struct sparc64_elf_app_reg *p;
1446
1447       p = sparc64_elf_hash_table(info)->app_regs;
1448       for (i = 0; i < 4; i++, p++)
1449         if (p->name != NULL && ! strcmp (p->name, *namep))
1450           {
1451             unsigned char type = ELF_ST_TYPE (sym->st_info);
1452
1453             if (type > STT_FUNC)
1454               type = 0;
1455             (*_bfd_error_handler)
1456               (_("Symbol `%s' has differing types: %s in %s, previously REGISTER in %s"),
1457                *namep, stt_types[type], bfd_archive_filename (abfd),
1458                bfd_archive_filename (p->abfd));
1459             return FALSE;
1460           }
1461     }
1462   return TRUE;
1463 }
1464
1465 /* This function takes care of emiting STT_REGISTER symbols
1466    which we cannot easily keep in the symbol hash table.  */
1467
1468 static bfd_boolean
1469 sparc64_elf_output_arch_syms (output_bfd, info, finfo, func)
1470      bfd *output_bfd ATTRIBUTE_UNUSED;
1471      struct bfd_link_info *info;
1472      PTR finfo;
1473      bfd_boolean (*func)
1474        PARAMS ((PTR, const char *, Elf_Internal_Sym *, asection *));
1475 {
1476   int reg;
1477   struct sparc64_elf_app_reg *app_regs =
1478     sparc64_elf_hash_table(info)->app_regs;
1479   Elf_Internal_Sym sym;
1480
1481   /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1482      at the end of the dynlocal list, so they came at the end of the local
1483      symbols in the symtab.  Except that they aren't STB_LOCAL, so we need
1484      to back up symtab->sh_info.  */
1485   if (elf_hash_table (info)->dynlocal)
1486     {
1487       bfd * dynobj = elf_hash_table (info)->dynobj;
1488       asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
1489       struct elf_link_local_dynamic_entry *e;
1490
1491       for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
1492         if (e->input_indx == -1)
1493           break;
1494       if (e)
1495         {
1496           elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
1497             = e->dynindx;
1498         }
1499     }
1500
1501   if (info->strip == strip_all)
1502     return TRUE;
1503
1504   for (reg = 0; reg < 4; reg++)
1505     if (app_regs [reg].name != NULL)
1506       {
1507         if (info->strip == strip_some
1508             && bfd_hash_lookup (info->keep_hash,
1509                                 app_regs [reg].name,
1510                                 FALSE, FALSE) == NULL)
1511           continue;
1512
1513         sym.st_value = reg < 2 ? reg + 2 : reg + 4;
1514         sym.st_size = 0;
1515         sym.st_other = 0;
1516         sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
1517         sym.st_shndx = app_regs [reg].shndx;
1518         if (! (*func) (finfo, app_regs [reg].name, &sym,
1519                        sym.st_shndx == SHN_ABS
1520                          ? bfd_abs_section_ptr : bfd_und_section_ptr))
1521           return FALSE;
1522       }
1523
1524   return TRUE;
1525 }
1526
1527 static int
1528 sparc64_elf_get_symbol_type (elf_sym, type)
1529      Elf_Internal_Sym * elf_sym;
1530      int type;
1531 {
1532   if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
1533     return STT_REGISTER;
1534   else
1535     return type;
1536 }
1537
1538 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1539    even in SHN_UNDEF section.  */
1540
1541 static void
1542 sparc64_elf_symbol_processing (abfd, asym)
1543      bfd *abfd ATTRIBUTE_UNUSED;
1544      asymbol *asym;
1545 {
1546   elf_symbol_type *elfsym;
1547
1548   elfsym = (elf_symbol_type *) asym;
1549   if (elfsym->internal_elf_sym.st_info
1550       == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
1551     {
1552       asym->flags |= BSF_GLOBAL;
1553     }
1554 }
1555
1556 /* Adjust a symbol defined by a dynamic object and referenced by a
1557    regular object.  The current definition is in some section of the
1558    dynamic object, but we're not including those sections.  We have to
1559    change the definition to something the rest of the link can
1560    understand.  */
1561
1562 static bfd_boolean
1563 sparc64_elf_adjust_dynamic_symbol (info, h)
1564      struct bfd_link_info *info;
1565      struct elf_link_hash_entry *h;
1566 {
1567   bfd *dynobj;
1568   asection *s;
1569   unsigned int power_of_two;
1570
1571   dynobj = elf_hash_table (info)->dynobj;
1572
1573   /* Make sure we know what is going on here.  */
1574   BFD_ASSERT (dynobj != NULL
1575               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1576                   || h->weakdef != NULL
1577                   || ((h->elf_link_hash_flags
1578                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1579                       && (h->elf_link_hash_flags
1580                           & ELF_LINK_HASH_REF_REGULAR) != 0
1581                       && (h->elf_link_hash_flags
1582                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1583
1584   /* If this is a function, put it in the procedure linkage table.  We
1585      will fill in the contents of the procedure linkage table later
1586      (although we could actually do it here).  The STT_NOTYPE
1587      condition is a hack specifically for the Oracle libraries
1588      delivered for Solaris; for some inexplicable reason, they define
1589      some of their functions as STT_NOTYPE when they really should be
1590      STT_FUNC.  */
1591   if (h->type == STT_FUNC
1592       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1593       || (h->type == STT_NOTYPE
1594           && (h->root.type == bfd_link_hash_defined
1595               || h->root.type == bfd_link_hash_defweak)
1596           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1597     {
1598       if (! elf_hash_table (info)->dynamic_sections_created)
1599         {
1600           /* This case can occur if we saw a WPLT30 reloc in an input
1601              file, but none of the input files were dynamic objects.
1602              In such a case, we don't actually need to build a
1603              procedure linkage table, and we can just do a WDISP30
1604              reloc instead.  */
1605           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
1606           return TRUE;
1607         }
1608
1609       s = bfd_get_section_by_name (dynobj, ".plt");
1610       BFD_ASSERT (s != NULL);
1611
1612       /* The first four bit in .plt is reserved.  */
1613       if (s->_raw_size == 0)
1614         s->_raw_size = PLT_HEADER_SIZE;
1615
1616       /* To simplify matters later, just store the plt index here.  */
1617       h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
1618
1619       /* If this symbol is not defined in a regular file, and we are
1620          not generating a shared library, then set the symbol to this
1621          location in the .plt.  This is required to make function
1622          pointers compare as equal between the normal executable and
1623          the shared library.  */
1624       if (! info->shared
1625           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1626         {
1627           h->root.u.def.section = s;
1628           h->root.u.def.value = sparc64_elf_plt_entry_offset (h->plt.offset);
1629         }
1630
1631       /* Make room for this entry.  */
1632       s->_raw_size += PLT_ENTRY_SIZE;
1633
1634       /* We also need to make an entry in the .rela.plt section.  */
1635
1636       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1637       BFD_ASSERT (s != NULL);
1638
1639       s->_raw_size += sizeof (Elf64_External_Rela);
1640
1641       /* The procedure linkage table size is bounded by the magnitude
1642          of the offset we can describe in the entry.  */
1643       if (s->_raw_size >= (bfd_vma)1 << 32)
1644         {
1645           bfd_set_error (bfd_error_bad_value);
1646           return FALSE;
1647         }
1648
1649       return TRUE;
1650     }
1651
1652   /* If this is a weak symbol, and there is a real definition, the
1653      processor independent code will have arranged for us to see the
1654      real definition first, and we can just use the same value.  */
1655   if (h->weakdef != NULL)
1656     {
1657       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1658                   || h->weakdef->root.type == bfd_link_hash_defweak);
1659       h->root.u.def.section = h->weakdef->root.u.def.section;
1660       h->root.u.def.value = h->weakdef->root.u.def.value;
1661       return TRUE;
1662     }
1663
1664   /* This is a reference to a symbol defined by a dynamic object which
1665      is not a function.  */
1666
1667   /* If we are creating a shared library, we must presume that the
1668      only references to the symbol are via the global offset table.
1669      For such cases we need not do anything here; the relocations will
1670      be handled correctly by relocate_section.  */
1671   if (info->shared)
1672     return TRUE;
1673
1674   /* We must allocate the symbol in our .dynbss section, which will
1675      become part of the .bss section of the executable.  There will be
1676      an entry for this symbol in the .dynsym section.  The dynamic
1677      object will contain position independent code, so all references
1678      from the dynamic object to this symbol will go through the global
1679      offset table.  The dynamic linker will use the .dynsym entry to
1680      determine the address it must put in the global offset table, so
1681      both the dynamic object and the regular object will refer to the
1682      same memory location for the variable.  */
1683
1684   s = bfd_get_section_by_name (dynobj, ".dynbss");
1685   BFD_ASSERT (s != NULL);
1686
1687   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1688      to copy the initial value out of the dynamic object and into the
1689      runtime process image.  We need to remember the offset into the
1690      .rel.bss section we are going to use.  */
1691   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1692     {
1693       asection *srel;
1694
1695       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1696       BFD_ASSERT (srel != NULL);
1697       srel->_raw_size += sizeof (Elf64_External_Rela);
1698       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1699     }
1700
1701   /* We need to figure out the alignment required for this symbol.  I
1702      have no idea how ELF linkers handle this.  16-bytes is the size
1703      of the largest type that requires hard alignment -- long double.  */
1704   power_of_two = bfd_log2 (h->size);
1705   if (power_of_two > 4)
1706     power_of_two = 4;
1707
1708   /* Apply the required alignment.  */
1709   s->_raw_size = BFD_ALIGN (s->_raw_size,
1710                             (bfd_size_type) (1 << power_of_two));
1711   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1712     {
1713       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1714         return FALSE;
1715     }
1716
1717   /* Define the symbol as being at this point in the section.  */
1718   h->root.u.def.section = s;
1719   h->root.u.def.value = s->_raw_size;
1720
1721   /* Increment the section size to make room for the symbol.  */
1722   s->_raw_size += h->size;
1723
1724   return TRUE;
1725 }
1726
1727 /* Set the sizes of the dynamic sections.  */
1728
1729 static bfd_boolean
1730 sparc64_elf_size_dynamic_sections (output_bfd, info)
1731      bfd *output_bfd;
1732      struct bfd_link_info *info;
1733 {
1734   bfd *dynobj;
1735   asection *s;
1736   bfd_boolean relplt;
1737
1738   dynobj = elf_hash_table (info)->dynobj;
1739   BFD_ASSERT (dynobj != NULL);
1740
1741   if (elf_hash_table (info)->dynamic_sections_created)
1742     {
1743       /* Set the contents of the .interp section to the interpreter.  */
1744       if (! info->shared)
1745         {
1746           s = bfd_get_section_by_name (dynobj, ".interp");
1747           BFD_ASSERT (s != NULL);
1748           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1749           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1750         }
1751     }
1752   else
1753     {
1754       /* We may have created entries in the .rela.got section.
1755          However, if we are not creating the dynamic sections, we will
1756          not actually use these entries.  Reset the size of .rela.got,
1757          which will cause it to get stripped from the output file
1758          below.  */
1759       s = bfd_get_section_by_name (dynobj, ".rela.got");
1760       if (s != NULL)
1761         s->_raw_size = 0;
1762     }
1763
1764   /* The check_relocs and adjust_dynamic_symbol entry points have
1765      determined the sizes of the various dynamic sections.  Allocate
1766      memory for them.  */
1767   relplt = FALSE;
1768   for (s = dynobj->sections; s != NULL; s = s->next)
1769     {
1770       const char *name;
1771       bfd_boolean strip;
1772
1773       if ((s->flags & SEC_LINKER_CREATED) == 0)
1774         continue;
1775
1776       /* It's OK to base decisions on the section name, because none
1777          of the dynobj section names depend upon the input files.  */
1778       name = bfd_get_section_name (dynobj, s);
1779
1780       strip = FALSE;
1781
1782       if (strncmp (name, ".rela", 5) == 0)
1783         {
1784           if (s->_raw_size == 0)
1785             {
1786               /* If we don't need this section, strip it from the
1787                  output file.  This is to handle .rela.bss and
1788                  .rel.plt.  We must create it in
1789                  create_dynamic_sections, because it must be created
1790                  before the linker maps input sections to output
1791                  sections.  The linker does that before
1792                  adjust_dynamic_symbol is called, and it is that
1793                  function which decides whether anything needs to go
1794                  into these sections.  */
1795               strip = TRUE;
1796             }
1797           else
1798             {
1799               if (strcmp (name, ".rela.plt") == 0)
1800                 relplt = TRUE;
1801
1802               /* We use the reloc_count field as a counter if we need
1803                  to copy relocs into the output file.  */
1804               s->reloc_count = 0;
1805             }
1806         }
1807       else if (strcmp (name, ".plt") != 0
1808                && strncmp (name, ".got", 4) != 0)
1809         {
1810           /* It's not one of our sections, so don't allocate space.  */
1811           continue;
1812         }
1813
1814       if (strip)
1815         {
1816           _bfd_strip_section_from_output (info, s);
1817           continue;
1818         }
1819
1820       /* Allocate memory for the section contents.  Zero the memory
1821          for the benefit of .rela.plt, which has 4 unused entries
1822          at the beginning, and we don't want garbage.  */
1823       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1824       if (s->contents == NULL && s->_raw_size != 0)
1825         return FALSE;
1826     }
1827
1828   if (elf_hash_table (info)->dynamic_sections_created)
1829     {
1830       /* Add some entries to the .dynamic section.  We fill in the
1831          values later, in sparc64_elf_finish_dynamic_sections, but we
1832          must add the entries now so that we get the correct size for
1833          the .dynamic section.  The DT_DEBUG entry is filled in by the
1834          dynamic linker and used by the debugger.  */
1835 #define add_dynamic_entry(TAG, VAL) \
1836   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1837
1838       int reg;
1839       struct sparc64_elf_app_reg * app_regs;
1840       struct elf_strtab_hash *dynstr;
1841       struct elf_link_hash_table *eht = elf_hash_table (info);
1842
1843       if (!info->shared)
1844         {
1845           if (!add_dynamic_entry (DT_DEBUG, 0))
1846             return FALSE;
1847         }
1848
1849       if (relplt)
1850         {
1851           if (!add_dynamic_entry (DT_PLTGOT, 0)
1852               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1853               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1854               || !add_dynamic_entry (DT_JMPREL, 0))
1855             return FALSE;
1856         }
1857
1858       if (!add_dynamic_entry (DT_RELA, 0)
1859           || !add_dynamic_entry (DT_RELASZ, 0)
1860           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1861         return FALSE;
1862
1863       if (info->flags & DF_TEXTREL)
1864         {
1865           if (!add_dynamic_entry (DT_TEXTREL, 0))
1866             return FALSE;
1867         }
1868
1869       /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1870          entries if needed.  */
1871       app_regs = sparc64_elf_hash_table (info)->app_regs;
1872       dynstr = eht->dynstr;
1873
1874       for (reg = 0; reg < 4; reg++)
1875         if (app_regs [reg].name != NULL)
1876           {
1877             struct elf_link_local_dynamic_entry *entry, *e;
1878
1879             if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
1880               return FALSE;
1881
1882             entry = (struct elf_link_local_dynamic_entry *)
1883               bfd_hash_allocate (&info->hash->table, sizeof (*entry));
1884             if (entry == NULL)
1885               return FALSE;
1886
1887             /* We cheat here a little bit: the symbol will not be local, so we
1888                put it at the end of the dynlocal linked list.  We will fix it
1889                later on, as we have to fix other fields anyway.  */
1890             entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
1891             entry->isym.st_size = 0;
1892             if (*app_regs [reg].name != '\0')
1893               entry->isym.st_name
1894                 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
1895             else
1896               entry->isym.st_name = 0;
1897             entry->isym.st_other = 0;
1898             entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
1899                                                STT_REGISTER);
1900             entry->isym.st_shndx = app_regs [reg].shndx;
1901             entry->next = NULL;
1902             entry->input_bfd = output_bfd;
1903             entry->input_indx = -1;
1904
1905             if (eht->dynlocal == NULL)
1906               eht->dynlocal = entry;
1907             else
1908               {
1909                 for (e = eht->dynlocal; e->next; e = e->next)
1910                   ;
1911                 e->next = entry;
1912               }
1913             eht->dynsymcount++;
1914           }
1915     }
1916 #undef add_dynamic_entry
1917
1918   return TRUE;
1919 }
1920 \f
1921 struct sparc64_elf_section_data
1922 {
1923   struct bfd_elf_section_data elf;
1924   unsigned int do_relax;
1925 };
1926
1927 #define sec_do_relax(sec) \
1928   ((struct sparc64_elf_section_data *) elf_section_data (sec))->do_relax
1929
1930 static bfd_boolean
1931 sparc64_elf_new_section_hook (abfd, sec)
1932      bfd *abfd;
1933      asection *sec;
1934 {
1935   struct sparc64_elf_section_data *sdata;
1936   bfd_size_type amt = sizeof (*sdata);
1937
1938   sdata = (struct sparc64_elf_section_data *) bfd_zalloc (abfd, amt);
1939   if (sdata == NULL)
1940     return FALSE;
1941   sec->used_by_bfd = (PTR) sdata;
1942
1943   return _bfd_elf_new_section_hook (abfd, sec);
1944 }
1945
1946 static bfd_boolean
1947 sparc64_elf_relax_section (abfd, section, link_info, again)
1948      bfd *abfd ATTRIBUTE_UNUSED;
1949      asection *section ATTRIBUTE_UNUSED;
1950      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1951      bfd_boolean *again;
1952 {
1953   *again = FALSE;
1954   sec_do_relax (section) = 1;
1955   return TRUE;
1956 }
1957 \f
1958 /* This is the condition under which finish_dynamic_symbol will be called
1959    from elflink.h.  If elflink.h doesn't call our finish_dynamic_symbol
1960    routine, we'll need to do something about initializing any .plt and
1961    .got entries in relocate_section.  */
1962 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H)                   \
1963   ((DYN)                                                                \
1964    && ((INFO)->shared                                                   \
1965        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1966    && ((H)->dynindx != -1                                               \
1967        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1968
1969 /* Relocate a SPARC64 ELF section.  */
1970
1971 static bfd_boolean
1972 sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1973                               contents, relocs, local_syms, local_sections)
1974      bfd *output_bfd;
1975      struct bfd_link_info *info;
1976      bfd *input_bfd;
1977      asection *input_section;
1978      bfd_byte *contents;
1979      Elf_Internal_Rela *relocs;
1980      Elf_Internal_Sym *local_syms;
1981      asection **local_sections;
1982 {
1983   bfd *dynobj;
1984   Elf_Internal_Shdr *symtab_hdr;
1985   struct elf_link_hash_entry **sym_hashes;
1986   bfd_vma *local_got_offsets;
1987   bfd_vma got_base;
1988   asection *sgot;
1989   asection *splt;
1990   asection *sreloc;
1991   Elf_Internal_Rela *rel;
1992   Elf_Internal_Rela *relend;
1993
1994   if (info->relocateable)
1995     return TRUE;
1996
1997   dynobj = elf_hash_table (info)->dynobj;
1998   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1999   sym_hashes = elf_sym_hashes (input_bfd);
2000   local_got_offsets = elf_local_got_offsets (input_bfd);
2001
2002   if (elf_hash_table(info)->hgot == NULL)
2003     got_base = 0;
2004   else
2005     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2006
2007   sgot = splt = sreloc = NULL;
2008
2009   rel = relocs;
2010   relend = relocs + NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2011   for (; rel < relend; rel++)
2012     {
2013       int r_type;
2014       reloc_howto_type *howto;
2015       unsigned long r_symndx;
2016       struct elf_link_hash_entry *h;
2017       Elf_Internal_Sym *sym;
2018       asection *sec;
2019       bfd_vma relocation, off;
2020       bfd_reloc_status_type r;
2021       bfd_boolean is_plt = FALSE;
2022       bfd_boolean unresolved_reloc;
2023
2024       r_type = ELF64_R_TYPE_ID (rel->r_info);
2025       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2026         {
2027           bfd_set_error (bfd_error_bad_value);
2028           return FALSE;
2029         }
2030       howto = sparc64_elf_howto_table + r_type;
2031
2032       /* This is a final link.  */
2033       r_symndx = ELF64_R_SYM (rel->r_info);
2034       h = NULL;
2035       sym = NULL;
2036       sec = NULL;
2037       unresolved_reloc = FALSE;
2038       if (r_symndx < symtab_hdr->sh_info)
2039         {
2040           sym = local_syms + r_symndx;
2041           sec = local_sections[r_symndx];
2042           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2043         }
2044       else
2045         {
2046           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2047           while (h->root.type == bfd_link_hash_indirect
2048                  || h->root.type == bfd_link_hash_warning)
2049             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2050
2051           relocation = 0;
2052           if (h->root.type == bfd_link_hash_defined
2053               || h->root.type == bfd_link_hash_defweak)
2054             {
2055               sec = h->root.u.def.section;
2056               if (sec->output_section == NULL)
2057                 /* Set a flag that will be cleared later if we find a
2058                    relocation value for this symbol.  output_section
2059                    is typically NULL for symbols satisfied by a shared
2060                    library.  */
2061                 unresolved_reloc = TRUE;
2062               else
2063                 relocation = (h->root.u.def.value
2064                               + sec->output_section->vma
2065                               + sec->output_offset);
2066             }
2067           else if (h->root.type == bfd_link_hash_undefweak)
2068             ;
2069           else if (info->shared
2070                    && !info->no_undefined
2071                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2072             ;
2073           else
2074             {
2075               if (! ((*info->callbacks->undefined_symbol)
2076                      (info, h->root.root.string, input_bfd,
2077                       input_section, rel->r_offset,
2078                       (!info->shared || info->no_undefined
2079                        || ELF_ST_VISIBILITY (h->other)))))
2080                 return FALSE;
2081
2082               /* To avoid generating warning messages about truncated
2083                  relocations, set the relocation's address to be the same as
2084                  the start of this section.  */
2085               if (input_section->output_section != NULL)
2086                 relocation = input_section->output_section->vma;
2087               else
2088                 relocation = 0;
2089             }
2090         }
2091
2092  do_dynreloc:
2093       /* When generating a shared object, these relocations are copied
2094          into the output file to be resolved at run time.  */
2095       if (info->shared && r_symndx != 0 && (input_section->flags & SEC_ALLOC))
2096         {
2097           switch (r_type)
2098             {
2099             case R_SPARC_PC10:
2100             case R_SPARC_PC22:
2101             case R_SPARC_PC_HH22:
2102             case R_SPARC_PC_HM10:
2103             case R_SPARC_PC_LM22:
2104               if (h != NULL
2105                   && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2106                 break;
2107               /* Fall through.  */
2108             case R_SPARC_DISP8:
2109             case R_SPARC_DISP16:
2110             case R_SPARC_DISP32:
2111             case R_SPARC_DISP64:
2112             case R_SPARC_WDISP30:
2113             case R_SPARC_WDISP22:
2114             case R_SPARC_WDISP19:
2115             case R_SPARC_WDISP16:
2116               if (h == NULL)
2117                 break;
2118               /* Fall through.  */
2119             case R_SPARC_8:
2120             case R_SPARC_16:
2121             case R_SPARC_32:
2122             case R_SPARC_HI22:
2123             case R_SPARC_22:
2124             case R_SPARC_13:
2125             case R_SPARC_LO10:
2126             case R_SPARC_UA32:
2127             case R_SPARC_10:
2128             case R_SPARC_11:
2129             case R_SPARC_64:
2130             case R_SPARC_OLO10:
2131             case R_SPARC_HH22:
2132             case R_SPARC_HM10:
2133             case R_SPARC_LM22:
2134             case R_SPARC_7:
2135             case R_SPARC_5:
2136             case R_SPARC_6:
2137             case R_SPARC_HIX22:
2138             case R_SPARC_LOX10:
2139             case R_SPARC_H44:
2140             case R_SPARC_M44:
2141             case R_SPARC_L44:
2142             case R_SPARC_UA64:
2143             case R_SPARC_UA16:
2144               {
2145                 Elf_Internal_Rela outrel;
2146                 bfd_byte *loc;
2147                 bfd_boolean skip, relocate;
2148
2149                 if (sreloc == NULL)
2150                   {
2151                     const char *name =
2152                       (bfd_elf_string_from_elf_section
2153                        (input_bfd,
2154                         elf_elfheader (input_bfd)->e_shstrndx,
2155                         elf_section_data (input_section)->rel_hdr.sh_name));
2156
2157                     if (name == NULL)
2158                       return FALSE;
2159
2160                     BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2161                                 && strcmp (bfd_get_section_name(input_bfd,
2162                                                                 input_section),
2163                                            name + 5) == 0);
2164
2165                     sreloc = bfd_get_section_by_name (dynobj, name);
2166                     BFD_ASSERT (sreloc != NULL);
2167                   }
2168
2169                 skip = FALSE;
2170                 relocate = FALSE;
2171
2172                 outrel.r_offset =
2173                   _bfd_elf_section_offset (output_bfd, info, input_section,
2174                                            rel->r_offset);
2175                 if (outrel.r_offset == (bfd_vma) -1)
2176                   skip = TRUE;
2177                 else if (outrel.r_offset == (bfd_vma) -2)
2178                   skip = TRUE, relocate = TRUE;
2179
2180                 outrel.r_offset += (input_section->output_section->vma
2181                                     + input_section->output_offset);
2182
2183                 /* Optimize unaligned reloc usage now that we know where
2184                    it finally resides.  */
2185                 switch (r_type)
2186                   {
2187                   case R_SPARC_16:
2188                     if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2189                     break;
2190                   case R_SPARC_UA16:
2191                     if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2192                     break;
2193                   case R_SPARC_32:
2194                     if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2195                     break;
2196                   case R_SPARC_UA32:
2197                     if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2198                     break;
2199                   case R_SPARC_64:
2200                     if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2201                     break;
2202                   case R_SPARC_UA64:
2203                     if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2204                     break;
2205                   case R_SPARC_DISP8:
2206                   case R_SPARC_DISP16:
2207                   case R_SPARC_DISP32:
2208                   case R_SPARC_DISP64:
2209                     /* If the symbol is not dynamic, we should not keep
2210                        a dynamic relocation.  But an .rela.* slot has been
2211                        allocated for it, output R_SPARC_NONE.
2212                        FIXME: Add code tracking needed dynamic relocs as
2213                        e.g. i386 has.  */
2214                     if (h->dynindx == -1)
2215                       skip = TRUE, relocate = TRUE;
2216                     break;
2217                   }
2218
2219                 if (skip)
2220                   memset (&outrel, 0, sizeof outrel);
2221                 /* h->dynindx may be -1 if the symbol was marked to
2222                    become local.  */
2223                 else if (h != NULL && ! is_plt
2224                          && ((! info->symbolic && h->dynindx != -1)
2225                              || (h->elf_link_hash_flags
2226                                  & ELF_LINK_HASH_DEF_REGULAR) == 0))
2227                   {
2228                     BFD_ASSERT (h->dynindx != -1);
2229                     outrel.r_info
2230                       = ELF64_R_INFO (h->dynindx,
2231                                       ELF64_R_TYPE_INFO (
2232                                         ELF64_R_TYPE_DATA (rel->r_info),
2233                                                            r_type));
2234                     outrel.r_addend = rel->r_addend;
2235                   }
2236                 else
2237                   {
2238                     outrel.r_addend = relocation + rel->r_addend;
2239                     if (r_type == R_SPARC_64)
2240                       outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2241                     else
2242                       {
2243                         long indx;
2244
2245                         if (is_plt)
2246                           sec = splt;
2247                         else if (h == NULL)
2248                           sec = local_sections[r_symndx];
2249                         else
2250                           {
2251                             BFD_ASSERT (h->root.type == bfd_link_hash_defined
2252                                         || (h->root.type
2253                                             == bfd_link_hash_defweak));
2254                             sec = h->root.u.def.section;
2255                           }
2256                         if (sec != NULL && bfd_is_abs_section (sec))
2257                           indx = 0;
2258                         else if (sec == NULL || sec->owner == NULL)
2259                           {
2260                             bfd_set_error (bfd_error_bad_value);
2261                             return FALSE;
2262                           }
2263                         else
2264                           {
2265                             asection *osec;
2266
2267                             osec = sec->output_section;
2268                             indx = elf_section_data (osec)->dynindx;
2269
2270                             /* We are turning this relocation into one
2271                                against a section symbol, so subtract out
2272                                the output section's address but not the
2273                                offset of the input section in the output
2274                                section.  */
2275                             outrel.r_addend -= osec->vma;
2276
2277                             /* FIXME: we really should be able to link non-pic
2278                                shared libraries.  */
2279                             if (indx == 0)
2280                               {
2281                                 BFD_FAIL ();
2282                                 (*_bfd_error_handler)
2283                                   (_("%s: probably compiled without -fPIC?"),
2284                                    bfd_archive_filename (input_bfd));
2285                                 bfd_set_error (bfd_error_bad_value);
2286                                 return FALSE;
2287                               }
2288                           }
2289
2290                         outrel.r_info
2291                           = ELF64_R_INFO (indx,
2292                                           ELF64_R_TYPE_INFO (
2293                                             ELF64_R_TYPE_DATA (rel->r_info),
2294                                                                r_type));
2295                       }
2296                   }
2297
2298                 loc = sreloc->contents;
2299                 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2300                 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2301
2302                 /* This reloc will be computed at runtime, so there's no
2303                    need to do anything now.  */
2304                 if (! relocate)
2305                   continue;
2306               }
2307             break;
2308             }
2309         }
2310
2311       switch (r_type)
2312         {
2313         case R_SPARC_GOT10:
2314         case R_SPARC_GOT13:
2315         case R_SPARC_GOT22:
2316           /* Relocation is to the entry for this symbol in the global
2317              offset table.  */
2318           if (sgot == NULL)
2319             {
2320               sgot = bfd_get_section_by_name (dynobj, ".got");
2321               BFD_ASSERT (sgot != NULL);
2322             }
2323
2324           if (h != NULL)
2325             {
2326               bfd_boolean dyn;
2327
2328               off = h->got.offset;
2329               BFD_ASSERT (off != (bfd_vma) -1);
2330               dyn = elf_hash_table (info)->dynamic_sections_created;
2331
2332               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2333                   || (info->shared
2334                       && (info->symbolic
2335                           || h->dynindx == -1
2336                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2337                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2338                 {
2339                   /* This is actually a static link, or it is a -Bsymbolic
2340                      link and the symbol is defined locally, or the symbol
2341                      was forced to be local because of a version file.  We
2342                      must initialize this entry in the global offset table.
2343                      Since the offset must always be a multiple of 8, we
2344                      use the least significant bit to record whether we
2345                      have initialized it already.
2346
2347                      When doing a dynamic link, we create a .rela.got
2348                      relocation entry to initialize the value.  This is
2349                      done in the finish_dynamic_symbol routine.  */
2350
2351                   if ((off & 1) != 0)
2352                     off &= ~1;
2353                   else
2354                     {
2355                       bfd_put_64 (output_bfd, relocation,
2356                                   sgot->contents + off);
2357                       h->got.offset |= 1;
2358                     }
2359                 }
2360               else
2361                 unresolved_reloc = FALSE;
2362             }
2363           else
2364             {
2365               BFD_ASSERT (local_got_offsets != NULL);
2366               off = local_got_offsets[r_symndx];
2367               BFD_ASSERT (off != (bfd_vma) -1);
2368
2369               /* The offset must always be a multiple of 8.  We use
2370                  the least significant bit to record whether we have
2371                  already processed this entry.  */
2372               if ((off & 1) != 0)
2373                 off &= ~1;
2374               else
2375                 {
2376                   local_got_offsets[r_symndx] |= 1;
2377
2378                   if (info->shared)
2379                     {
2380                       asection *s;
2381                       Elf_Internal_Rela outrel;
2382                       bfd_byte *loc;
2383
2384                       /* The Solaris 2.7 64-bit linker adds the contents
2385                          of the location to the value of the reloc.
2386                          Note this is different behaviour to the
2387                          32-bit linker, which both adds the contents
2388                          and ignores the addend.  So clear the location.  */
2389                       bfd_put_64 (output_bfd, (bfd_vma) 0,
2390                                   sgot->contents + off);
2391
2392                       /* We need to generate a R_SPARC_RELATIVE reloc
2393                          for the dynamic linker.  */
2394                       s = bfd_get_section_by_name(dynobj, ".rela.got");
2395                       BFD_ASSERT (s != NULL);
2396
2397                       outrel.r_offset = (sgot->output_section->vma
2398                                          + sgot->output_offset
2399                                          + off);
2400                       outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2401                       outrel.r_addend = relocation;
2402                       loc = s->contents;
2403                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2404                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2405                     }
2406                   else
2407                     bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2408                 }
2409             }
2410           relocation = sgot->output_offset + off - got_base;
2411           goto do_default;
2412
2413         case R_SPARC_WPLT30:
2414         case R_SPARC_PLT32:
2415         case R_SPARC_HIPLT22:
2416         case R_SPARC_LOPLT10:
2417         case R_SPARC_PCPLT32:
2418         case R_SPARC_PCPLT22:
2419         case R_SPARC_PCPLT10:
2420         case R_SPARC_PLT64:
2421           /* Relocation is to the entry for this symbol in the
2422              procedure linkage table.  */
2423           BFD_ASSERT (h != NULL);
2424
2425           if (h->plt.offset == (bfd_vma) -1)
2426             {
2427               /* We didn't make a PLT entry for this symbol.  This
2428                  happens when statically linking PIC code, or when
2429                  using -Bsymbolic.  */
2430               goto do_default;
2431             }
2432
2433           if (splt == NULL)
2434             {
2435               splt = bfd_get_section_by_name (dynobj, ".plt");
2436               BFD_ASSERT (splt != NULL);
2437             }
2438
2439           relocation = (splt->output_section->vma
2440                         + splt->output_offset
2441                         + sparc64_elf_plt_entry_offset (h->plt.offset));
2442           unresolved_reloc = FALSE;
2443           if (r_type == R_SPARC_WPLT30)
2444             goto do_wplt30;
2445           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2446             {
2447               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2448               is_plt = TRUE;
2449               goto do_dynreloc;
2450             }
2451           goto do_default;
2452
2453         case R_SPARC_OLO10:
2454           {
2455             bfd_vma x;
2456
2457             relocation += rel->r_addend;
2458             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2459
2460             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2461             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
2462             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2463
2464             r = bfd_check_overflow (howto->complain_on_overflow,
2465                                     howto->bitsize, howto->rightshift,
2466                                     bfd_arch_bits_per_address (input_bfd),
2467                                     relocation);
2468           }
2469           break;
2470
2471         case R_SPARC_WDISP16:
2472           {
2473             bfd_vma x;
2474
2475             relocation += rel->r_addend;
2476             /* Adjust for pc-relative-ness.  */
2477             relocation -= (input_section->output_section->vma
2478                            + input_section->output_offset);
2479             relocation -= rel->r_offset;
2480
2481             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2482             x &= ~(bfd_vma) 0x303fff;
2483             x |= ((((relocation >> 2) & 0xc000) << 6)
2484                   | ((relocation >> 2) & 0x3fff));
2485             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2486
2487             r = bfd_check_overflow (howto->complain_on_overflow,
2488                                     howto->bitsize, howto->rightshift,
2489                                     bfd_arch_bits_per_address (input_bfd),
2490                                     relocation);
2491           }
2492           break;
2493
2494         case R_SPARC_HIX22:
2495           {
2496             bfd_vma x;
2497
2498             relocation += rel->r_addend;
2499             relocation = relocation ^ MINUS_ONE;
2500
2501             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2502             x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2503             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2504
2505             r = bfd_check_overflow (howto->complain_on_overflow,
2506                                     howto->bitsize, howto->rightshift,
2507                                     bfd_arch_bits_per_address (input_bfd),
2508                                     relocation);
2509           }
2510           break;
2511
2512         case R_SPARC_LOX10:
2513           {
2514             bfd_vma x;
2515
2516             relocation += rel->r_addend;
2517             relocation = (relocation & 0x3ff) | 0x1c00;
2518
2519             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2520             x = (x & ~(bfd_vma) 0x1fff) | relocation;
2521             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2522
2523             r = bfd_reloc_ok;
2524           }
2525           break;
2526
2527         case R_SPARC_WDISP30:
2528         do_wplt30:
2529           if (sec_do_relax (input_section)
2530               && rel->r_offset + 4 < input_section->_raw_size)
2531             {
2532 #define G0              0
2533 #define O7              15
2534 #define XCC             (2 << 20)
2535 #define COND(x)         (((x)&0xf)<<25)
2536 #define CONDA           COND(0x8)
2537 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
2538 #define INSN_BA         (F2(0,2) | CONDA)
2539 #define INSN_OR         F3(2, 0x2, 0)
2540 #define INSN_NOP        F2(0,4)
2541
2542               bfd_vma x, y;
2543
2544               /* If the instruction is a call with either:
2545                  restore
2546                  arithmetic instruction with rd == %o7
2547                  where rs1 != %o7 and rs2 if it is register != %o7
2548                  then we can optimize if the call destination is near
2549                  by changing the call into a branch always.  */
2550               x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2551               y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2552               if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2553                 {
2554                   if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2555                        || ((y & OP3(0x28)) == 0 /* arithmetic */
2556                            && (y & RD(~0)) == RD(O7)))
2557                       && (y & RS1(~0)) != RS1(O7)
2558                       && ((y & F3I(~0))
2559                           || (y & RS2(~0)) != RS2(O7)))
2560                     {
2561                       bfd_vma reloc;
2562
2563                       reloc = relocation + rel->r_addend - rel->r_offset;
2564                       reloc -= (input_section->output_section->vma
2565                                 + input_section->output_offset);
2566                       if (reloc & 3)
2567                         goto do_default;
2568
2569                       /* Ensure the branch fits into simm22.  */
2570                       if ((reloc & ~(bfd_vma)0x7fffff)
2571                            && ((reloc | 0x7fffff) != MINUS_ONE))
2572                         goto do_default;
2573                       reloc >>= 2;
2574
2575                       /* Check whether it fits into simm19.  */
2576                       if ((reloc & 0x3c0000) == 0
2577                           || (reloc & 0x3c0000) == 0x3c0000)
2578                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2579                       else
2580                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
2581                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2582                       r = bfd_reloc_ok;
2583                       if (rel->r_offset >= 4
2584                           && (y & (0xffffffff ^ RS1(~0)))
2585                              == (INSN_OR | RD(O7) | RS2(G0)))
2586                         {
2587                           bfd_vma z;
2588                           unsigned int reg;
2589
2590                           z = bfd_get_32 (input_bfd,
2591                                           contents + rel->r_offset - 4);
2592                           if ((z & (0xffffffff ^ RD(~0)))
2593                               != (INSN_OR | RS1(O7) | RS2(G0)))
2594                             break;
2595
2596                           /* The sequence was
2597                              or %o7, %g0, %rN
2598                              call foo
2599                              or %rN, %g0, %o7
2600
2601                              If call foo was replaced with ba, replace
2602                              or %rN, %g0, %o7 with nop.  */
2603
2604                           reg = (y & RS1(~0)) >> 14;
2605                           if (reg != ((z & RD(~0)) >> 25)
2606                               || reg == G0 || reg == O7)
2607                             break;
2608
2609                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
2610                                       contents + rel->r_offset + 4);
2611                         }
2612                       break;
2613                     }
2614                 }
2615             }
2616           /* Fall through.  */
2617
2618         default:
2619         do_default:
2620           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2621                                         contents, rel->r_offset,
2622                                         relocation, rel->r_addend);
2623           break;
2624         }
2625
2626       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2627          because such sections are not SEC_ALLOC and thus ld.so will
2628          not process them.  */
2629       if (unresolved_reloc
2630           && !((input_section->flags & SEC_DEBUGGING) != 0
2631                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2632         (*_bfd_error_handler)
2633           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2634            bfd_archive_filename (input_bfd),
2635            bfd_get_section_name (input_bfd, input_section),
2636            (long) rel->r_offset,
2637            h->root.root.string);
2638
2639       switch (r)
2640         {
2641         case bfd_reloc_ok:
2642           break;
2643
2644         default:
2645         case bfd_reloc_outofrange:
2646           abort ();
2647
2648         case bfd_reloc_overflow:
2649           {
2650             const char *name;
2651
2652             /* The Solaris native linker silently disregards
2653                overflows.  We don't, but this breaks stabs debugging
2654                info, whose relocations are only 32-bits wide.  Ignore
2655                overflows for discarded entries.  */
2656             if (r_type == R_SPARC_32
2657                 && _bfd_elf_section_offset (output_bfd, info, input_section,
2658                                             rel->r_offset) == (bfd_vma) -1)
2659               break;
2660
2661             if (h != NULL)
2662               {
2663                 if (h->root.type == bfd_link_hash_undefweak
2664                     && howto->pc_relative)
2665                   {
2666                     /* Assume this is a call protected by other code that
2667                        detect the symbol is undefined.  If this is the case,
2668                        we can safely ignore the overflow.  If not, the
2669                        program is hosed anyway, and a little warning isn't
2670                        going to help.  */
2671                     break;
2672                   }
2673
2674                 name = h->root.root.string;
2675               }
2676             else
2677               {
2678                 name = (bfd_elf_string_from_elf_section
2679                         (input_bfd,
2680                          symtab_hdr->sh_link,
2681                          sym->st_name));
2682                 if (name == NULL)
2683                   return FALSE;
2684                 if (*name == '\0')
2685                   name = bfd_section_name (input_bfd, sec);
2686               }
2687             if (! ((*info->callbacks->reloc_overflow)
2688                    (info, name, howto->name, (bfd_vma) 0,
2689                     input_bfd, input_section, rel->r_offset)))
2690               return FALSE;
2691           }
2692         break;
2693         }
2694     }
2695
2696   return TRUE;
2697 }
2698
2699 /* Finish up dynamic symbol handling.  We set the contents of various
2700    dynamic sections here.  */
2701
2702 static bfd_boolean
2703 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2704      bfd *output_bfd;
2705      struct bfd_link_info *info;
2706      struct elf_link_hash_entry *h;
2707      Elf_Internal_Sym *sym;
2708 {
2709   bfd *dynobj;
2710
2711   dynobj = elf_hash_table (info)->dynobj;
2712
2713   if (h->plt.offset != (bfd_vma) -1)
2714     {
2715       asection *splt;
2716       asection *srela;
2717       Elf_Internal_Rela rela;
2718       bfd_byte *loc;
2719
2720       /* This symbol has an entry in the PLT.  Set it up.  */
2721
2722       BFD_ASSERT (h->dynindx != -1);
2723
2724       splt = bfd_get_section_by_name (dynobj, ".plt");
2725       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2726       BFD_ASSERT (splt != NULL && srela != NULL);
2727
2728       /* Fill in the entry in the .rela.plt section.  */
2729
2730       if (h->plt.offset < LARGE_PLT_THRESHOLD)
2731         {
2732           rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2733           rela.r_addend = 0;
2734         }
2735       else
2736         {
2737           bfd_vma max = splt->_raw_size / PLT_ENTRY_SIZE;
2738           rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
2739           rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2740                           -(splt->output_section->vma + splt->output_offset);
2741         }
2742       rela.r_offset += (splt->output_section->vma + splt->output_offset);
2743       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2744
2745       /* Adjust for the first 4 reserved elements in the .plt section
2746          when setting the offset in the .rela.plt section.
2747          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2748          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
2749
2750       loc = srela->contents;
2751       loc += (h->plt.offset - 4) * sizeof (Elf64_External_Rela);
2752       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2753
2754       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2755         {
2756           /* Mark the symbol as undefined, rather than as defined in
2757              the .plt section.  Leave the value alone.  */
2758           sym->st_shndx = SHN_UNDEF;
2759           /* If the symbol is weak, we do need to clear the value.
2760              Otherwise, the PLT entry would provide a definition for
2761              the symbol even if the symbol wasn't defined anywhere,
2762              and so the symbol would never be NULL.  */
2763           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2764               == 0)
2765             sym->st_value = 0;
2766         }
2767     }
2768
2769   if (h->got.offset != (bfd_vma) -1)
2770     {
2771       asection *sgot;
2772       asection *srela;
2773       Elf_Internal_Rela rela;
2774       bfd_byte *loc;
2775
2776       /* This symbol has an entry in the GOT.  Set it up.  */
2777
2778       sgot = bfd_get_section_by_name (dynobj, ".got");
2779       srela = bfd_get_section_by_name (dynobj, ".rela.got");
2780       BFD_ASSERT (sgot != NULL && srela != NULL);
2781
2782       rela.r_offset = (sgot->output_section->vma
2783                        + sgot->output_offset
2784                        + (h->got.offset &~ (bfd_vma) 1));
2785
2786       /* If this is a -Bsymbolic link, and the symbol is defined
2787          locally, we just want to emit a RELATIVE reloc.  Likewise if
2788          the symbol was forced to be local because of a version file.
2789          The entry in the global offset table will already have been
2790          initialized in the relocate_section function.  */
2791       if (info->shared
2792           && (info->symbolic || h->dynindx == -1)
2793           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2794         {
2795           asection *sec = h->root.u.def.section;
2796           rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2797           rela.r_addend = (h->root.u.def.value
2798                            + sec->output_section->vma
2799                            + sec->output_offset);
2800         }
2801       else
2802         {
2803           rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2804           rela.r_addend = 0;
2805         }
2806
2807       bfd_put_64 (output_bfd, (bfd_vma) 0,
2808                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2809       loc = srela->contents;
2810       loc += srela->reloc_count++ * sizeof (Elf64_External_Rela);
2811       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2812     }
2813
2814   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2815     {
2816       asection *s;
2817       Elf_Internal_Rela rela;
2818       bfd_byte *loc;
2819
2820       /* This symbols needs a copy reloc.  Set it up.  */
2821       BFD_ASSERT (h->dynindx != -1);
2822
2823       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2824                                    ".rela.bss");
2825       BFD_ASSERT (s != NULL);
2826
2827       rela.r_offset = (h->root.u.def.value
2828                        + h->root.u.def.section->output_section->vma
2829                        + h->root.u.def.section->output_offset);
2830       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2831       rela.r_addend = 0;
2832       loc = s->contents + s->reloc_count++ * sizeof (Elf64_External_Rela);
2833       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2834     }
2835
2836   /* Mark some specially defined symbols as absolute.  */
2837   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2838       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2839       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2840     sym->st_shndx = SHN_ABS;
2841
2842   return TRUE;
2843 }
2844
2845 /* Finish up the dynamic sections.  */
2846
2847 static bfd_boolean
2848 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2849      bfd *output_bfd;
2850      struct bfd_link_info *info;
2851 {
2852   bfd *dynobj;
2853   int stt_regidx = -1;
2854   asection *sdyn;
2855   asection *sgot;
2856
2857   dynobj = elf_hash_table (info)->dynobj;
2858
2859   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2860
2861   if (elf_hash_table (info)->dynamic_sections_created)
2862     {
2863       asection *splt;
2864       Elf64_External_Dyn *dyncon, *dynconend;
2865
2866       splt = bfd_get_section_by_name (dynobj, ".plt");
2867       BFD_ASSERT (splt != NULL && sdyn != NULL);
2868
2869       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2870       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2871       for (; dyncon < dynconend; dyncon++)
2872         {
2873           Elf_Internal_Dyn dyn;
2874           const char *name;
2875           bfd_boolean size;
2876
2877           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2878
2879           switch (dyn.d_tag)
2880             {
2881             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
2882             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
2883             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
2884             case DT_SPARC_REGISTER:
2885               if (stt_regidx == -1)
2886                 {
2887                   stt_regidx =
2888                     _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2889                   if (stt_regidx == -1)
2890                     return FALSE;
2891                 }
2892               dyn.d_un.d_val = stt_regidx++;
2893               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2894               /* fallthrough */
2895             default:          name = NULL; size = FALSE; break;
2896             }
2897
2898           if (name != NULL)
2899             {
2900               asection *s;
2901
2902               s = bfd_get_section_by_name (output_bfd, name);
2903               if (s == NULL)
2904                 dyn.d_un.d_val = 0;
2905               else
2906                 {
2907                   if (! size)
2908                     dyn.d_un.d_ptr = s->vma;
2909                   else
2910                     {
2911                       if (s->_cooked_size != 0)
2912                         dyn.d_un.d_val = s->_cooked_size;
2913                       else
2914                         dyn.d_un.d_val = s->_raw_size;
2915                     }
2916                 }
2917               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2918             }
2919         }
2920
2921       /* Initialize the contents of the .plt section.  */
2922       if (splt->_raw_size > 0)
2923         sparc64_elf_build_plt (output_bfd, splt->contents,
2924                                (int) (splt->_raw_size / PLT_ENTRY_SIZE));
2925
2926       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2927         PLT_ENTRY_SIZE;
2928     }
2929
2930   /* Set the first entry in the global offset table to the address of
2931      the dynamic section.  */
2932   sgot = bfd_get_section_by_name (dynobj, ".got");
2933   BFD_ASSERT (sgot != NULL);
2934   if (sgot->_raw_size > 0)
2935     {
2936       if (sdyn == NULL)
2937         bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2938       else
2939         bfd_put_64 (output_bfd,
2940                     sdyn->output_section->vma + sdyn->output_offset,
2941                     sgot->contents);
2942     }
2943
2944   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2945
2946   return TRUE;
2947 }
2948
2949 static enum elf_reloc_type_class
2950 sparc64_elf_reloc_type_class (rela)
2951      const Elf_Internal_Rela *rela;
2952 {
2953   switch ((int) ELF64_R_TYPE (rela->r_info))
2954     {
2955     case R_SPARC_RELATIVE:
2956       return reloc_class_relative;
2957     case R_SPARC_JMP_SLOT:
2958       return reloc_class_plt;
2959     case R_SPARC_COPY:
2960       return reloc_class_copy;
2961     default:
2962       return reloc_class_normal;
2963     }
2964 }
2965 \f
2966 /* Functions for dealing with the e_flags field.  */
2967
2968 /* Merge backend specific data from an object file to the output
2969    object file when linking.  */
2970
2971 static bfd_boolean
2972 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2973      bfd *ibfd;
2974      bfd *obfd;
2975 {
2976   bfd_boolean error;
2977   flagword new_flags, old_flags;
2978   int new_mm, old_mm;
2979
2980   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2981       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2982     return TRUE;
2983
2984   new_flags = elf_elfheader (ibfd)->e_flags;
2985   old_flags = elf_elfheader (obfd)->e_flags;
2986
2987   if (!elf_flags_init (obfd))   /* First call, no flags set */
2988     {
2989       elf_flags_init (obfd) = TRUE;
2990       elf_elfheader (obfd)->e_flags = new_flags;
2991     }
2992
2993   else if (new_flags == old_flags)      /* Compatible flags are ok */
2994     ;
2995
2996   else                                  /* Incompatible flags */
2997     {
2998       error = FALSE;
2999
3000 #define EF_SPARC_ISA_EXTENSIONS \
3001   (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
3002
3003       if ((ibfd->flags & DYNAMIC) != 0)
3004         {
3005           /* We don't want dynamic objects memory ordering and
3006              architecture to have any role. That's what dynamic linker
3007              should do.  */
3008           new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
3009           new_flags |= (old_flags
3010                         & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
3011         }
3012       else
3013         {
3014           /* Choose the highest architecture requirements.  */
3015           old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
3016           new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
3017           if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
3018               && (old_flags & EF_SPARC_HAL_R1))
3019             {
3020               error = TRUE;
3021               (*_bfd_error_handler)
3022                 (_("%s: linking UltraSPARC specific with HAL specific code"),
3023                  bfd_archive_filename (ibfd));
3024             }
3025           /* Choose the most restrictive memory ordering.  */
3026           old_mm = (old_flags & EF_SPARCV9_MM);
3027           new_mm = (new_flags & EF_SPARCV9_MM);
3028           old_flags &= ~EF_SPARCV9_MM;
3029           new_flags &= ~EF_SPARCV9_MM;
3030           if (new_mm < old_mm)
3031             old_mm = new_mm;
3032           old_flags |= old_mm;
3033           new_flags |= old_mm;
3034         }
3035
3036       /* Warn about any other mismatches */
3037       if (new_flags != old_flags)
3038         {
3039           error = TRUE;
3040           (*_bfd_error_handler)
3041             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3042              bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
3043         }
3044
3045       elf_elfheader (obfd)->e_flags = old_flags;
3046
3047       if (error)
3048         {
3049           bfd_set_error (bfd_error_bad_value);
3050           return FALSE;
3051         }
3052     }
3053   return TRUE;
3054 }
3055
3056 /* MARCO: Set the correct entry size for the .stab section.  */
3057
3058 static bfd_boolean
3059 sparc64_elf_fake_sections (abfd, hdr, sec)
3060      bfd *abfd ATTRIBUTE_UNUSED;
3061      Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
3062      asection *sec;
3063 {
3064   const char *name;
3065
3066   name = bfd_get_section_name (abfd, sec);
3067
3068   if (strcmp (name, ".stab") == 0)
3069     {
3070       /* Even in the 64bit case the stab entries are only 12 bytes long.  */
3071       elf_section_data (sec)->this_hdr.sh_entsize = 12;
3072     }
3073
3074   return TRUE;
3075 }
3076 \f
3077 /* Print a STT_REGISTER symbol to file FILE.  */
3078
3079 static const char *
3080 sparc64_elf_print_symbol_all (abfd, filep, symbol)
3081      bfd *abfd ATTRIBUTE_UNUSED;
3082      PTR filep;
3083      asymbol *symbol;
3084 {
3085   FILE *file = (FILE *) filep;
3086   int reg, type;
3087
3088   if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
3089       != STT_REGISTER)
3090     return NULL;
3091
3092   reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
3093   type = symbol->flags;
3094   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
3095                  ((type & BSF_LOCAL)
3096                   ? (type & BSF_GLOBAL) ? '!' : 'l'
3097                   : (type & BSF_GLOBAL) ? 'g' : ' '),
3098                  (type & BSF_WEAK) ? 'w' : ' ');
3099   if (symbol->name == NULL || symbol->name [0] == '\0')
3100     return "#scratch";
3101   else
3102     return symbol->name;
3103 }
3104 \f
3105 /* Set the right machine number for a SPARC64 ELF file.  */
3106
3107 static bfd_boolean
3108 sparc64_elf_object_p (abfd)
3109      bfd *abfd;
3110 {
3111   unsigned long mach = bfd_mach_sparc_v9;
3112
3113   if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3114     mach = bfd_mach_sparc_v9b;
3115   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3116     mach = bfd_mach_sparc_v9a;
3117   return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3118 }
3119
3120 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3121    standard ELF, because R_SPARC_OLO10 has secondary addend in
3122    ELF64_R_TYPE_DATA field.  This structure is used to redirect the
3123    relocation handling routines.  */
3124
3125 const struct elf_size_info sparc64_elf_size_info =
3126 {
3127   sizeof (Elf64_External_Ehdr),
3128   sizeof (Elf64_External_Phdr),
3129   sizeof (Elf64_External_Shdr),
3130   sizeof (Elf64_External_Rel),
3131   sizeof (Elf64_External_Rela),
3132   sizeof (Elf64_External_Sym),
3133   sizeof (Elf64_External_Dyn),
3134   sizeof (Elf_External_Note),
3135   4,            /* hash-table entry size.  */
3136   /* Internal relocations per external relocations.
3137      For link purposes we use just 1 internal per
3138      1 external, for assembly and slurp symbol table
3139      we use 2.  */
3140   1,
3141   64,           /* arch_size.  */
3142   8,            /* file_align.  */
3143   ELFCLASS64,
3144   EV_CURRENT,
3145   bfd_elf64_write_out_phdrs,
3146   bfd_elf64_write_shdrs_and_ehdr,
3147   sparc64_elf_write_relocs,
3148   bfd_elf64_swap_symbol_in,
3149   bfd_elf64_swap_symbol_out,
3150   sparc64_elf_slurp_reloc_table,
3151   bfd_elf64_slurp_symbol_table,
3152   bfd_elf64_swap_dyn_in,
3153   bfd_elf64_swap_dyn_out,
3154   bfd_elf64_swap_reloc_in,
3155   bfd_elf64_swap_reloc_out,
3156   bfd_elf64_swap_reloca_in,
3157   bfd_elf64_swap_reloca_out
3158 };
3159
3160 #define TARGET_BIG_SYM  bfd_elf64_sparc_vec
3161 #define TARGET_BIG_NAME "elf64-sparc"
3162 #define ELF_ARCH        bfd_arch_sparc
3163 #define ELF_MAXPAGESIZE 0x100000
3164
3165 /* This is the official ABI value.  */
3166 #define ELF_MACHINE_CODE EM_SPARCV9
3167
3168 /* This is the value that we used before the ABI was released.  */
3169 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3170
3171 #define bfd_elf64_bfd_link_hash_table_create \
3172   sparc64_elf_bfd_link_hash_table_create
3173
3174 #define elf_info_to_howto \
3175   sparc64_elf_info_to_howto
3176 #define bfd_elf64_get_reloc_upper_bound \
3177   sparc64_elf_get_reloc_upper_bound
3178 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3179   sparc64_elf_get_dynamic_reloc_upper_bound
3180 #define bfd_elf64_canonicalize_dynamic_reloc \
3181   sparc64_elf_canonicalize_dynamic_reloc
3182 #define bfd_elf64_bfd_reloc_type_lookup \
3183   sparc64_elf_reloc_type_lookup
3184 #define bfd_elf64_bfd_relax_section \
3185   sparc64_elf_relax_section
3186 #define bfd_elf64_new_section_hook \
3187   sparc64_elf_new_section_hook
3188
3189 #define elf_backend_create_dynamic_sections \
3190   _bfd_elf_create_dynamic_sections
3191 #define elf_backend_add_symbol_hook \
3192   sparc64_elf_add_symbol_hook
3193 #define elf_backend_get_symbol_type \
3194   sparc64_elf_get_symbol_type
3195 #define elf_backend_symbol_processing \
3196   sparc64_elf_symbol_processing
3197 #define elf_backend_check_relocs \
3198   sparc64_elf_check_relocs
3199 #define elf_backend_adjust_dynamic_symbol \
3200   sparc64_elf_adjust_dynamic_symbol
3201 #define elf_backend_size_dynamic_sections \
3202   sparc64_elf_size_dynamic_sections
3203 #define elf_backend_relocate_section \
3204   sparc64_elf_relocate_section
3205 #define elf_backend_finish_dynamic_symbol \
3206   sparc64_elf_finish_dynamic_symbol
3207 #define elf_backend_finish_dynamic_sections \
3208   sparc64_elf_finish_dynamic_sections
3209 #define elf_backend_print_symbol_all \
3210   sparc64_elf_print_symbol_all
3211 #define elf_backend_output_arch_syms \
3212   sparc64_elf_output_arch_syms
3213 #define bfd_elf64_bfd_merge_private_bfd_data \
3214   sparc64_elf_merge_private_bfd_data
3215 #define elf_backend_fake_sections \
3216   sparc64_elf_fake_sections
3217
3218 #define elf_backend_size_info \
3219   sparc64_elf_size_info
3220 #define elf_backend_object_p \
3221   sparc64_elf_object_p
3222 #define elf_backend_reloc_type_class \
3223   sparc64_elf_reloc_type_class
3224
3225 #define elf_backend_want_got_plt 0
3226 #define elf_backend_plt_readonly 0
3227 #define elf_backend_want_plt_sym 1
3228 #define elf_backend_rela_normal 1
3229
3230 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
3231 #define elf_backend_plt_alignment 8
3232
3233 #define elf_backend_got_header_size 8
3234 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3235
3236 #include "elf64-target.h"