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->symbolic || info->allow_shlib_undefined)
2071                    && !info->no_undefined
2072                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2073             ;
2074           else
2075             {
2076               if (! ((*info->callbacks->undefined_symbol)
2077                      (info, h->root.root.string, input_bfd,
2078                       input_section, rel->r_offset,
2079                       (!info->shared || info->no_undefined
2080                        || ELF_ST_VISIBILITY (h->other)))))
2081                 return FALSE;
2082
2083               /* To avoid generating warning messages about truncated
2084                  relocations, set the relocation's address to be the same as
2085                  the start of this section.  */
2086
2087               if (input_section->output_section != NULL)
2088                 relocation = input_section->output_section->vma;
2089               else
2090                 relocation = 0;
2091             }
2092         }
2093
2094  do_dynreloc:
2095       /* When generating a shared object, these relocations are copied
2096          into the output file to be resolved at run time.  */
2097       if (info->shared && r_symndx != 0 && (input_section->flags & SEC_ALLOC))
2098         {
2099           switch (r_type)
2100             {
2101             case R_SPARC_PC10:
2102             case R_SPARC_PC22:
2103             case R_SPARC_PC_HH22:
2104             case R_SPARC_PC_HM10:
2105             case R_SPARC_PC_LM22:
2106               if (h != NULL
2107                   && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2108                 break;
2109               /* Fall through.  */
2110             case R_SPARC_DISP8:
2111             case R_SPARC_DISP16:
2112             case R_SPARC_DISP32:
2113             case R_SPARC_DISP64:
2114             case R_SPARC_WDISP30:
2115             case R_SPARC_WDISP22:
2116             case R_SPARC_WDISP19:
2117             case R_SPARC_WDISP16:
2118               if (h == NULL)
2119                 break;
2120               /* Fall through.  */
2121             case R_SPARC_8:
2122             case R_SPARC_16:
2123             case R_SPARC_32:
2124             case R_SPARC_HI22:
2125             case R_SPARC_22:
2126             case R_SPARC_13:
2127             case R_SPARC_LO10:
2128             case R_SPARC_UA32:
2129             case R_SPARC_10:
2130             case R_SPARC_11:
2131             case R_SPARC_64:
2132             case R_SPARC_OLO10:
2133             case R_SPARC_HH22:
2134             case R_SPARC_HM10:
2135             case R_SPARC_LM22:
2136             case R_SPARC_7:
2137             case R_SPARC_5:
2138             case R_SPARC_6:
2139             case R_SPARC_HIX22:
2140             case R_SPARC_LOX10:
2141             case R_SPARC_H44:
2142             case R_SPARC_M44:
2143             case R_SPARC_L44:
2144             case R_SPARC_UA64:
2145             case R_SPARC_UA16:
2146               {
2147                 Elf_Internal_Rela outrel;
2148                 bfd_byte *loc;
2149                 bfd_boolean skip, relocate;
2150
2151                 if (sreloc == NULL)
2152                   {
2153                     const char *name =
2154                       (bfd_elf_string_from_elf_section
2155                        (input_bfd,
2156                         elf_elfheader (input_bfd)->e_shstrndx,
2157                         elf_section_data (input_section)->rel_hdr.sh_name));
2158
2159                     if (name == NULL)
2160                       return FALSE;
2161
2162                     BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2163                                 && strcmp (bfd_get_section_name(input_bfd,
2164                                                                 input_section),
2165                                            name + 5) == 0);
2166
2167                     sreloc = bfd_get_section_by_name (dynobj, name);
2168                     BFD_ASSERT (sreloc != NULL);
2169                   }
2170
2171                 skip = FALSE;
2172                 relocate = FALSE;
2173
2174                 outrel.r_offset =
2175                   _bfd_elf_section_offset (output_bfd, info, input_section,
2176                                            rel->r_offset);
2177                 if (outrel.r_offset == (bfd_vma) -1)
2178                   skip = TRUE;
2179                 else if (outrel.r_offset == (bfd_vma) -2)
2180                   skip = TRUE, relocate = TRUE;
2181
2182                 outrel.r_offset += (input_section->output_section->vma
2183                                     + input_section->output_offset);
2184
2185                 /* Optimize unaligned reloc usage now that we know where
2186                    it finally resides.  */
2187                 switch (r_type)
2188                   {
2189                   case R_SPARC_16:
2190                     if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2191                     break;
2192                   case R_SPARC_UA16:
2193                     if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2194                     break;
2195                   case R_SPARC_32:
2196                     if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2197                     break;
2198                   case R_SPARC_UA32:
2199                     if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2200                     break;
2201                   case R_SPARC_64:
2202                     if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2203                     break;
2204                   case R_SPARC_UA64:
2205                     if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2206                     break;
2207                   case R_SPARC_DISP8:
2208                   case R_SPARC_DISP16:
2209                   case R_SPARC_DISP32:
2210                   case R_SPARC_DISP64:
2211                     /* If the symbol is not dynamic, we should not keep
2212                        a dynamic relocation.  But an .rela.* slot has been
2213                        allocated for it, output R_SPARC_NONE.
2214                        FIXME: Add code tracking needed dynamic relocs as
2215                        e.g. i386 has.  */
2216                     if (h->dynindx == -1)
2217                       skip = TRUE, relocate = TRUE;
2218                     break;
2219                   }
2220
2221                 if (skip)
2222                   memset (&outrel, 0, sizeof outrel);
2223                 /* h->dynindx may be -1 if the symbol was marked to
2224                    become local.  */
2225                 else if (h != NULL && ! is_plt
2226                          && ((! info->symbolic && h->dynindx != -1)
2227                              || (h->elf_link_hash_flags
2228                                  & ELF_LINK_HASH_DEF_REGULAR) == 0))
2229                   {
2230                     BFD_ASSERT (h->dynindx != -1);
2231                     outrel.r_info
2232                       = ELF64_R_INFO (h->dynindx,
2233                                       ELF64_R_TYPE_INFO (
2234                                         ELF64_R_TYPE_DATA (rel->r_info),
2235                                                            r_type));
2236                     outrel.r_addend = rel->r_addend;
2237                   }
2238                 else
2239                   {
2240                     outrel.r_addend = relocation + rel->r_addend;
2241                     if (r_type == R_SPARC_64)
2242                       outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2243                     else
2244                       {
2245                         long indx;
2246
2247                         if (is_plt)
2248                           sec = splt;
2249                         else if (h == NULL)
2250                           sec = local_sections[r_symndx];
2251                         else
2252                           {
2253                             BFD_ASSERT (h->root.type == bfd_link_hash_defined
2254                                         || (h->root.type
2255                                             == bfd_link_hash_defweak));
2256                             sec = h->root.u.def.section;
2257                           }
2258                         if (sec != NULL && bfd_is_abs_section (sec))
2259                           indx = 0;
2260                         else if (sec == NULL || sec->owner == NULL)
2261                           {
2262                             bfd_set_error (bfd_error_bad_value);
2263                             return FALSE;
2264                           }
2265                         else
2266                           {
2267                             asection *osec;
2268
2269                             osec = sec->output_section;
2270                             indx = elf_section_data (osec)->dynindx;
2271
2272                             /* We are turning this relocation into one
2273                                against a section symbol, so subtract out
2274                                the output section's address but not the
2275                                offset of the input section in the output
2276                                section.  */
2277                             outrel.r_addend -= osec->vma;
2278
2279                             /* FIXME: we really should be able to link non-pic
2280                                shared libraries.  */
2281                             if (indx == 0)
2282                               {
2283                                 BFD_FAIL ();
2284                                 (*_bfd_error_handler)
2285                                   (_("%s: probably compiled without -fPIC?"),
2286                                    bfd_archive_filename (input_bfd));
2287                                 bfd_set_error (bfd_error_bad_value);
2288                                 return FALSE;
2289                               }
2290                           }
2291
2292                         outrel.r_info
2293                           = ELF64_R_INFO (indx,
2294                                           ELF64_R_TYPE_INFO (
2295                                             ELF64_R_TYPE_DATA (rel->r_info),
2296                                                                r_type));
2297                       }
2298                   }
2299
2300                 loc = sreloc->contents;
2301                 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2302                 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2303
2304                 /* This reloc will be computed at runtime, so there's no
2305                    need to do anything now.  */
2306                 if (! relocate)
2307                   continue;
2308               }
2309             break;
2310             }
2311         }
2312
2313       switch (r_type)
2314         {
2315         case R_SPARC_GOT10:
2316         case R_SPARC_GOT13:
2317         case R_SPARC_GOT22:
2318           /* Relocation is to the entry for this symbol in the global
2319              offset table.  */
2320           if (sgot == NULL)
2321             {
2322               sgot = bfd_get_section_by_name (dynobj, ".got");
2323               BFD_ASSERT (sgot != NULL);
2324             }
2325
2326           if (h != NULL)
2327             {
2328               bfd_boolean dyn;
2329
2330               off = h->got.offset;
2331               BFD_ASSERT (off != (bfd_vma) -1);
2332               dyn = elf_hash_table (info)->dynamic_sections_created;
2333
2334               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2335                   || (info->shared
2336                       && (info->symbolic
2337                           || h->dynindx == -1
2338                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2339                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2340                 {
2341                   /* This is actually a static link, or it is a -Bsymbolic
2342                      link and the symbol is defined locally, or the symbol
2343                      was forced to be local because of a version file.  We
2344                      must initialize this entry in the global offset table.
2345                      Since the offset must always be a multiple of 8, we
2346                      use the least significant bit to record whether we
2347                      have initialized it already.
2348
2349                      When doing a dynamic link, we create a .rela.got
2350                      relocation entry to initialize the value.  This is
2351                      done in the finish_dynamic_symbol routine.  */
2352
2353                   if ((off & 1) != 0)
2354                     off &= ~1;
2355                   else
2356                     {
2357                       bfd_put_64 (output_bfd, relocation,
2358                                   sgot->contents + off);
2359                       h->got.offset |= 1;
2360                     }
2361                 }
2362               else
2363                 unresolved_reloc = FALSE;
2364             }
2365           else
2366             {
2367               BFD_ASSERT (local_got_offsets != NULL);
2368               off = local_got_offsets[r_symndx];
2369               BFD_ASSERT (off != (bfd_vma) -1);
2370
2371               /* The offset must always be a multiple of 8.  We use
2372                  the least significant bit to record whether we have
2373                  already processed this entry.  */
2374               if ((off & 1) != 0)
2375                 off &= ~1;
2376               else
2377                 {
2378                   local_got_offsets[r_symndx] |= 1;
2379
2380                   if (info->shared)
2381                     {
2382                       asection *s;
2383                       Elf_Internal_Rela outrel;
2384                       bfd_byte *loc;
2385
2386                       /* The Solaris 2.7 64-bit linker adds the contents
2387                          of the location to the value of the reloc.
2388                          Note this is different behaviour to the
2389                          32-bit linker, which both adds the contents
2390                          and ignores the addend.  So clear the location.  */
2391                       bfd_put_64 (output_bfd, (bfd_vma) 0,
2392                                   sgot->contents + off);
2393
2394                       /* We need to generate a R_SPARC_RELATIVE reloc
2395                          for the dynamic linker.  */
2396                       s = bfd_get_section_by_name(dynobj, ".rela.got");
2397                       BFD_ASSERT (s != NULL);
2398
2399                       outrel.r_offset = (sgot->output_section->vma
2400                                          + sgot->output_offset
2401                                          + off);
2402                       outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2403                       outrel.r_addend = relocation;
2404                       loc = s->contents;
2405                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2406                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2407                     }
2408                   else
2409                     bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2410                 }
2411             }
2412           relocation = sgot->output_offset + off - got_base;
2413           goto do_default;
2414
2415         case R_SPARC_WPLT30:
2416         case R_SPARC_PLT32:
2417         case R_SPARC_HIPLT22:
2418         case R_SPARC_LOPLT10:
2419         case R_SPARC_PCPLT32:
2420         case R_SPARC_PCPLT22:
2421         case R_SPARC_PCPLT10:
2422         case R_SPARC_PLT64:
2423           /* Relocation is to the entry for this symbol in the
2424              procedure linkage table.  */
2425           BFD_ASSERT (h != NULL);
2426
2427           if (h->plt.offset == (bfd_vma) -1)
2428             {
2429               /* We didn't make a PLT entry for this symbol.  This
2430                  happens when statically linking PIC code, or when
2431                  using -Bsymbolic.  */
2432               goto do_default;
2433             }
2434
2435           if (splt == NULL)
2436             {
2437               splt = bfd_get_section_by_name (dynobj, ".plt");
2438               BFD_ASSERT (splt != NULL);
2439             }
2440
2441           relocation = (splt->output_section->vma
2442                         + splt->output_offset
2443                         + sparc64_elf_plt_entry_offset (h->plt.offset));
2444           unresolved_reloc = FALSE;
2445           if (r_type == R_SPARC_WPLT30)
2446             goto do_wplt30;
2447           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2448             {
2449               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2450               is_plt = TRUE;
2451               goto do_dynreloc;
2452             }
2453           goto do_default;
2454
2455         case R_SPARC_OLO10:
2456           {
2457             bfd_vma x;
2458
2459             relocation += rel->r_addend;
2460             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2461
2462             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2463             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
2464             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2465
2466             r = bfd_check_overflow (howto->complain_on_overflow,
2467                                     howto->bitsize, howto->rightshift,
2468                                     bfd_arch_bits_per_address (input_bfd),
2469                                     relocation);
2470           }
2471           break;
2472
2473         case R_SPARC_WDISP16:
2474           {
2475             bfd_vma x;
2476
2477             relocation += rel->r_addend;
2478             /* Adjust for pc-relative-ness.  */
2479             relocation -= (input_section->output_section->vma
2480                            + input_section->output_offset);
2481             relocation -= rel->r_offset;
2482
2483             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2484             x &= ~(bfd_vma) 0x303fff;
2485             x |= ((((relocation >> 2) & 0xc000) << 6)
2486                   | ((relocation >> 2) & 0x3fff));
2487             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2488
2489             r = bfd_check_overflow (howto->complain_on_overflow,
2490                                     howto->bitsize, howto->rightshift,
2491                                     bfd_arch_bits_per_address (input_bfd),
2492                                     relocation);
2493           }
2494           break;
2495
2496         case R_SPARC_HIX22:
2497           {
2498             bfd_vma x;
2499
2500             relocation += rel->r_addend;
2501             relocation = relocation ^ MINUS_ONE;
2502
2503             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2504             x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2505             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2506
2507             r = bfd_check_overflow (howto->complain_on_overflow,
2508                                     howto->bitsize, howto->rightshift,
2509                                     bfd_arch_bits_per_address (input_bfd),
2510                                     relocation);
2511           }
2512           break;
2513
2514         case R_SPARC_LOX10:
2515           {
2516             bfd_vma x;
2517
2518             relocation += rel->r_addend;
2519             relocation = (relocation & 0x3ff) | 0x1c00;
2520
2521             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2522             x = (x & ~(bfd_vma) 0x1fff) | relocation;
2523             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2524
2525             r = bfd_reloc_ok;
2526           }
2527           break;
2528
2529         case R_SPARC_WDISP30:
2530         do_wplt30:
2531           if (sec_do_relax (input_section)
2532               && rel->r_offset + 4 < input_section->_raw_size)
2533             {
2534 #define G0              0
2535 #define O7              15
2536 #define XCC             (2 << 20)
2537 #define COND(x)         (((x)&0xf)<<25)
2538 #define CONDA           COND(0x8)
2539 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
2540 #define INSN_BA         (F2(0,2) | CONDA)
2541 #define INSN_OR         F3(2, 0x2, 0)
2542 #define INSN_NOP        F2(0,4)
2543
2544               bfd_vma x, y;
2545
2546               /* If the instruction is a call with either:
2547                  restore
2548                  arithmetic instruction with rd == %o7
2549                  where rs1 != %o7 and rs2 if it is register != %o7
2550                  then we can optimize if the call destination is near
2551                  by changing the call into a branch always.  */
2552               x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2553               y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2554               if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2555                 {
2556                   if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2557                        || ((y & OP3(0x28)) == 0 /* arithmetic */
2558                            && (y & RD(~0)) == RD(O7)))
2559                       && (y & RS1(~0)) != RS1(O7)
2560                       && ((y & F3I(~0))
2561                           || (y & RS2(~0)) != RS2(O7)))
2562                     {
2563                       bfd_vma reloc;
2564
2565                       reloc = relocation + rel->r_addend - rel->r_offset;
2566                       reloc -= (input_section->output_section->vma
2567                                 + input_section->output_offset);
2568                       if (reloc & 3)
2569                         goto do_default;
2570
2571                       /* Ensure the branch fits into simm22.  */
2572                       if ((reloc & ~(bfd_vma)0x7fffff)
2573                            && ((reloc | 0x7fffff) != MINUS_ONE))
2574                         goto do_default;
2575                       reloc >>= 2;
2576
2577                       /* Check whether it fits into simm19.  */
2578                       if ((reloc & 0x3c0000) == 0
2579                           || (reloc & 0x3c0000) == 0x3c0000)
2580                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2581                       else
2582                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
2583                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2584                       r = bfd_reloc_ok;
2585                       if (rel->r_offset >= 4
2586                           && (y & (0xffffffff ^ RS1(~0)))
2587                              == (INSN_OR | RD(O7) | RS2(G0)))
2588                         {
2589                           bfd_vma z;
2590                           unsigned int reg;
2591
2592                           z = bfd_get_32 (input_bfd,
2593                                           contents + rel->r_offset - 4);
2594                           if ((z & (0xffffffff ^ RD(~0)))
2595                               != (INSN_OR | RS1(O7) | RS2(G0)))
2596                             break;
2597
2598                           /* The sequence was
2599                              or %o7, %g0, %rN
2600                              call foo
2601                              or %rN, %g0, %o7
2602
2603                              If call foo was replaced with ba, replace
2604                              or %rN, %g0, %o7 with nop.  */
2605
2606                           reg = (y & RS1(~0)) >> 14;
2607                           if (reg != ((z & RD(~0)) >> 25)
2608                               || reg == G0 || reg == O7)
2609                             break;
2610
2611                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
2612                                       contents + rel->r_offset + 4);
2613                         }
2614                       break;
2615                     }
2616                 }
2617             }
2618           /* FALLTHROUGH */
2619
2620         default:
2621         do_default:
2622           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2623                                         contents, rel->r_offset,
2624                                         relocation, rel->r_addend);
2625           break;
2626         }
2627
2628       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2629          because such sections are not SEC_ALLOC and thus ld.so will
2630          not process them.  */
2631       if (unresolved_reloc
2632           && !((input_section->flags & SEC_DEBUGGING) != 0
2633                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2634         (*_bfd_error_handler)
2635           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2636            bfd_archive_filename (input_bfd),
2637            bfd_get_section_name (input_bfd, input_section),
2638            (long) rel->r_offset,
2639            h->root.root.string);
2640
2641       switch (r)
2642         {
2643         case bfd_reloc_ok:
2644           break;
2645
2646         default:
2647         case bfd_reloc_outofrange:
2648           abort ();
2649
2650         case bfd_reloc_overflow:
2651           {
2652             const char *name;
2653
2654             /* The Solaris native linker silently disregards
2655                overflows.  We don't, but this breaks stabs debugging
2656                info, whose relocations are only 32-bits wide.  Ignore
2657                overflows for discarded entries.  */
2658             if (r_type == R_SPARC_32
2659                 && _bfd_elf_section_offset (output_bfd, info, input_section,
2660                                             rel->r_offset) == (bfd_vma) -1)
2661               break;
2662
2663             if (h != NULL)
2664               {
2665                 if (h->root.type == bfd_link_hash_undefweak
2666                     && howto->pc_relative)
2667                   {
2668                     /* Assume this is a call protected by other code that
2669                        detect the symbol is undefined.  If this is the case,
2670                        we can safely ignore the overflow.  If not, the
2671                        program is hosed anyway, and a little warning isn't
2672                        going to help.  */
2673                     break;
2674                   }
2675
2676                 name = h->root.root.string;
2677               }
2678             else
2679               {
2680                 name = (bfd_elf_string_from_elf_section
2681                         (input_bfd,
2682                          symtab_hdr->sh_link,
2683                          sym->st_name));
2684                 if (name == NULL)
2685                   return FALSE;
2686                 if (*name == '\0')
2687                   name = bfd_section_name (input_bfd, sec);
2688               }
2689             if (! ((*info->callbacks->reloc_overflow)
2690                    (info, name, howto->name, (bfd_vma) 0,
2691                     input_bfd, input_section, rel->r_offset)))
2692               return FALSE;
2693           }
2694         break;
2695         }
2696     }
2697
2698   return TRUE;
2699 }
2700
2701 /* Finish up dynamic symbol handling.  We set the contents of various
2702    dynamic sections here.  */
2703
2704 static bfd_boolean
2705 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2706      bfd *output_bfd;
2707      struct bfd_link_info *info;
2708      struct elf_link_hash_entry *h;
2709      Elf_Internal_Sym *sym;
2710 {
2711   bfd *dynobj;
2712
2713   dynobj = elf_hash_table (info)->dynobj;
2714
2715   if (h->plt.offset != (bfd_vma) -1)
2716     {
2717       asection *splt;
2718       asection *srela;
2719       Elf_Internal_Rela rela;
2720       bfd_byte *loc;
2721
2722       /* This symbol has an entry in the PLT.  Set it up.  */
2723
2724       BFD_ASSERT (h->dynindx != -1);
2725
2726       splt = bfd_get_section_by_name (dynobj, ".plt");
2727       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2728       BFD_ASSERT (splt != NULL && srela != NULL);
2729
2730       /* Fill in the entry in the .rela.plt section.  */
2731
2732       if (h->plt.offset < LARGE_PLT_THRESHOLD)
2733         {
2734           rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2735           rela.r_addend = 0;
2736         }
2737       else
2738         {
2739           bfd_vma max = splt->_raw_size / PLT_ENTRY_SIZE;
2740           rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
2741           rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2742                           -(splt->output_section->vma + splt->output_offset);
2743         }
2744       rela.r_offset += (splt->output_section->vma + splt->output_offset);
2745       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2746
2747       /* Adjust for the first 4 reserved elements in the .plt section
2748          when setting the offset in the .rela.plt section.
2749          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2750          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
2751
2752       loc = srela->contents;
2753       loc += (h->plt.offset - 4) * sizeof (Elf64_External_Rela);
2754       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2755
2756       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2757         {
2758           /* Mark the symbol as undefined, rather than as defined in
2759              the .plt section.  Leave the value alone.  */
2760           sym->st_shndx = SHN_UNDEF;
2761           /* If the symbol is weak, we do need to clear the value.
2762              Otherwise, the PLT entry would provide a definition for
2763              the symbol even if the symbol wasn't defined anywhere,
2764              and so the symbol would never be NULL.  */
2765           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2766               == 0)
2767             sym->st_value = 0;
2768         }
2769     }
2770
2771   if (h->got.offset != (bfd_vma) -1)
2772     {
2773       asection *sgot;
2774       asection *srela;
2775       Elf_Internal_Rela rela;
2776       bfd_byte *loc;
2777
2778       /* This symbol has an entry in the GOT.  Set it up.  */
2779
2780       sgot = bfd_get_section_by_name (dynobj, ".got");
2781       srela = bfd_get_section_by_name (dynobj, ".rela.got");
2782       BFD_ASSERT (sgot != NULL && srela != NULL);
2783
2784       rela.r_offset = (sgot->output_section->vma
2785                        + sgot->output_offset
2786                        + (h->got.offset &~ (bfd_vma) 1));
2787
2788       /* If this is a -Bsymbolic link, and the symbol is defined
2789          locally, we just want to emit a RELATIVE reloc.  Likewise if
2790          the symbol was forced to be local because of a version file.
2791          The entry in the global offset table will already have been
2792          initialized in the relocate_section function.  */
2793       if (info->shared
2794           && (info->symbolic || h->dynindx == -1)
2795           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2796         {
2797           asection *sec = h->root.u.def.section;
2798           rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2799           rela.r_addend = (h->root.u.def.value
2800                            + sec->output_section->vma
2801                            + sec->output_offset);
2802         }
2803       else
2804         {
2805           rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2806           rela.r_addend = 0;
2807         }
2808
2809       bfd_put_64 (output_bfd, (bfd_vma) 0,
2810                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2811       loc = srela->contents;
2812       loc += srela->reloc_count++ * sizeof (Elf64_External_Rela);
2813       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2814     }
2815
2816   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2817     {
2818       asection *s;
2819       Elf_Internal_Rela rela;
2820       bfd_byte *loc;
2821
2822       /* This symbols needs a copy reloc.  Set it up.  */
2823
2824       BFD_ASSERT (h->dynindx != -1);
2825
2826       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2827                                    ".rela.bss");
2828       BFD_ASSERT (s != NULL);
2829
2830       rela.r_offset = (h->root.u.def.value
2831                        + h->root.u.def.section->output_section->vma
2832                        + h->root.u.def.section->output_offset);
2833       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2834       rela.r_addend = 0;
2835       loc = s->contents + s->reloc_count++ * sizeof (Elf64_External_Rela);
2836       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2837     }
2838
2839   /* Mark some specially defined symbols as absolute.  */
2840   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2841       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2842       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2843     sym->st_shndx = SHN_ABS;
2844
2845   return TRUE;
2846 }
2847
2848 /* Finish up the dynamic sections.  */
2849
2850 static bfd_boolean
2851 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2852      bfd *output_bfd;
2853      struct bfd_link_info *info;
2854 {
2855   bfd *dynobj;
2856   int stt_regidx = -1;
2857   asection *sdyn;
2858   asection *sgot;
2859
2860   dynobj = elf_hash_table (info)->dynobj;
2861
2862   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2863
2864   if (elf_hash_table (info)->dynamic_sections_created)
2865     {
2866       asection *splt;
2867       Elf64_External_Dyn *dyncon, *dynconend;
2868
2869       splt = bfd_get_section_by_name (dynobj, ".plt");
2870       BFD_ASSERT (splt != NULL && sdyn != NULL);
2871
2872       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2873       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2874       for (; dyncon < dynconend; dyncon++)
2875         {
2876           Elf_Internal_Dyn dyn;
2877           const char *name;
2878           bfd_boolean size;
2879
2880           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2881
2882           switch (dyn.d_tag)
2883             {
2884             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
2885             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
2886             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
2887             case DT_SPARC_REGISTER:
2888               if (stt_regidx == -1)
2889                 {
2890                   stt_regidx =
2891                     _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2892                   if (stt_regidx == -1)
2893                     return FALSE;
2894                 }
2895               dyn.d_un.d_val = stt_regidx++;
2896               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2897               /* fallthrough */
2898             default:          name = NULL; size = FALSE; break;
2899             }
2900
2901           if (name != NULL)
2902             {
2903               asection *s;
2904
2905               s = bfd_get_section_by_name (output_bfd, name);
2906               if (s == NULL)
2907                 dyn.d_un.d_val = 0;
2908               else
2909                 {
2910                   if (! size)
2911                     dyn.d_un.d_ptr = s->vma;
2912                   else
2913                     {
2914                       if (s->_cooked_size != 0)
2915                         dyn.d_un.d_val = s->_cooked_size;
2916                       else
2917                         dyn.d_un.d_val = s->_raw_size;
2918                     }
2919                 }
2920               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2921             }
2922         }
2923
2924       /* Initialize the contents of the .plt section.  */
2925       if (splt->_raw_size > 0)
2926         {
2927           sparc64_elf_build_plt (output_bfd, splt->contents,
2928                                  (int) (splt->_raw_size / PLT_ENTRY_SIZE));
2929         }
2930
2931       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2932         PLT_ENTRY_SIZE;
2933     }
2934
2935   /* Set the first entry in the global offset table to the address of
2936      the dynamic section.  */
2937   sgot = bfd_get_section_by_name (dynobj, ".got");
2938   BFD_ASSERT (sgot != NULL);
2939   if (sgot->_raw_size > 0)
2940     {
2941       if (sdyn == NULL)
2942         bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2943       else
2944         bfd_put_64 (output_bfd,
2945                     sdyn->output_section->vma + sdyn->output_offset,
2946                     sgot->contents);
2947     }
2948
2949   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2950
2951   return TRUE;
2952 }
2953
2954 static enum elf_reloc_type_class
2955 sparc64_elf_reloc_type_class (rela)
2956      const Elf_Internal_Rela *rela;
2957 {
2958   switch ((int) ELF64_R_TYPE (rela->r_info))
2959     {
2960     case R_SPARC_RELATIVE:
2961       return reloc_class_relative;
2962     case R_SPARC_JMP_SLOT:
2963       return reloc_class_plt;
2964     case R_SPARC_COPY:
2965       return reloc_class_copy;
2966     default:
2967       return reloc_class_normal;
2968     }
2969 }
2970 \f
2971 /* Functions for dealing with the e_flags field.  */
2972
2973 /* Merge backend specific data from an object file to the output
2974    object file when linking.  */
2975
2976 static bfd_boolean
2977 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2978      bfd *ibfd;
2979      bfd *obfd;
2980 {
2981   bfd_boolean error;
2982   flagword new_flags, old_flags;
2983   int new_mm, old_mm;
2984
2985   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2986       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2987     return TRUE;
2988
2989   new_flags = elf_elfheader (ibfd)->e_flags;
2990   old_flags = elf_elfheader (obfd)->e_flags;
2991
2992   if (!elf_flags_init (obfd))   /* First call, no flags set */
2993     {
2994       elf_flags_init (obfd) = TRUE;
2995       elf_elfheader (obfd)->e_flags = new_flags;
2996     }
2997
2998   else if (new_flags == old_flags)      /* Compatible flags are ok */
2999     ;
3000
3001   else                                  /* Incompatible flags */
3002     {
3003       error = FALSE;
3004
3005 #define EF_SPARC_ISA_EXTENSIONS \
3006   (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
3007
3008       if ((ibfd->flags & DYNAMIC) != 0)
3009         {
3010           /* We don't want dynamic objects memory ordering and
3011              architecture to have any role. That's what dynamic linker
3012              should do.  */
3013           new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
3014           new_flags |= (old_flags
3015                         & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
3016         }
3017       else
3018         {
3019           /* Choose the highest architecture requirements.  */
3020           old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
3021           new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
3022           if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
3023               && (old_flags & EF_SPARC_HAL_R1))
3024             {
3025               error = TRUE;
3026               (*_bfd_error_handler)
3027                 (_("%s: linking UltraSPARC specific with HAL specific code"),
3028                  bfd_archive_filename (ibfd));
3029             }
3030           /* Choose the most restrictive memory ordering.  */
3031           old_mm = (old_flags & EF_SPARCV9_MM);
3032           new_mm = (new_flags & EF_SPARCV9_MM);
3033           old_flags &= ~EF_SPARCV9_MM;
3034           new_flags &= ~EF_SPARCV9_MM;
3035           if (new_mm < old_mm)
3036             old_mm = new_mm;
3037           old_flags |= old_mm;
3038           new_flags |= old_mm;
3039         }
3040
3041       /* Warn about any other mismatches */
3042       if (new_flags != old_flags)
3043         {
3044           error = TRUE;
3045           (*_bfd_error_handler)
3046             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3047              bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
3048         }
3049
3050       elf_elfheader (obfd)->e_flags = old_flags;
3051
3052       if (error)
3053         {
3054           bfd_set_error (bfd_error_bad_value);
3055           return FALSE;
3056         }
3057     }
3058   return TRUE;
3059 }
3060
3061 /* MARCO: Set the correct entry size for the .stab section.  */
3062
3063 static bfd_boolean
3064 sparc64_elf_fake_sections (abfd, hdr, sec)
3065      bfd *abfd ATTRIBUTE_UNUSED;
3066      Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
3067      asection *sec;
3068 {
3069   const char *name;
3070
3071   name = bfd_get_section_name (abfd, sec);
3072
3073   if (strcmp (name, ".stab") == 0)
3074     {
3075       /* Even in the 64bit case the stab entries are only 12 bytes long.  */
3076       elf_section_data (sec)->this_hdr.sh_entsize = 12;
3077     }
3078
3079   return TRUE;
3080 }
3081 \f
3082 /* Print a STT_REGISTER symbol to file FILE.  */
3083
3084 static const char *
3085 sparc64_elf_print_symbol_all (abfd, filep, symbol)
3086      bfd *abfd ATTRIBUTE_UNUSED;
3087      PTR filep;
3088      asymbol *symbol;
3089 {
3090   FILE *file = (FILE *) filep;
3091   int reg, type;
3092
3093   if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
3094       != STT_REGISTER)
3095     return NULL;
3096
3097   reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
3098   type = symbol->flags;
3099   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
3100                  ((type & BSF_LOCAL)
3101                   ? (type & BSF_GLOBAL) ? '!' : 'l'
3102                   : (type & BSF_GLOBAL) ? 'g' : ' '),
3103                  (type & BSF_WEAK) ? 'w' : ' ');
3104   if (symbol->name == NULL || symbol->name [0] == '\0')
3105     return "#scratch";
3106   else
3107     return symbol->name;
3108 }
3109 \f
3110 /* Set the right machine number for a SPARC64 ELF file.  */
3111
3112 static bfd_boolean
3113 sparc64_elf_object_p (abfd)
3114      bfd *abfd;
3115 {
3116   unsigned long mach = bfd_mach_sparc_v9;
3117
3118   if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3119     mach = bfd_mach_sparc_v9b;
3120   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3121     mach = bfd_mach_sparc_v9a;
3122   return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3123 }
3124
3125 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3126    standard ELF, because R_SPARC_OLO10 has secondary addend in
3127    ELF64_R_TYPE_DATA field.  This structure is used to redirect the
3128    relocation handling routines.  */
3129
3130 const struct elf_size_info sparc64_elf_size_info =
3131 {
3132   sizeof (Elf64_External_Ehdr),
3133   sizeof (Elf64_External_Phdr),
3134   sizeof (Elf64_External_Shdr),
3135   sizeof (Elf64_External_Rel),
3136   sizeof (Elf64_External_Rela),
3137   sizeof (Elf64_External_Sym),
3138   sizeof (Elf64_External_Dyn),
3139   sizeof (Elf_External_Note),
3140   4,            /* hash-table entry size */
3141   /* internal relocations per external relocations.
3142      For link purposes we use just 1 internal per
3143      1 external, for assembly and slurp symbol table
3144      we use 2.  */
3145   1,
3146   64,           /* arch_size */
3147   8,            /* file_align */
3148   ELFCLASS64,
3149   EV_CURRENT,
3150   bfd_elf64_write_out_phdrs,
3151   bfd_elf64_write_shdrs_and_ehdr,
3152   sparc64_elf_write_relocs,
3153   bfd_elf64_swap_symbol_in,
3154   bfd_elf64_swap_symbol_out,
3155   sparc64_elf_slurp_reloc_table,
3156   bfd_elf64_slurp_symbol_table,
3157   bfd_elf64_swap_dyn_in,
3158   bfd_elf64_swap_dyn_out,
3159   bfd_elf64_swap_reloc_in,
3160   bfd_elf64_swap_reloc_out,
3161   bfd_elf64_swap_reloca_in,
3162   bfd_elf64_swap_reloca_out
3163 };
3164
3165 #define TARGET_BIG_SYM  bfd_elf64_sparc_vec
3166 #define TARGET_BIG_NAME "elf64-sparc"
3167 #define ELF_ARCH        bfd_arch_sparc
3168 #define ELF_MAXPAGESIZE 0x100000
3169
3170 /* This is the official ABI value.  */
3171 #define ELF_MACHINE_CODE EM_SPARCV9
3172
3173 /* This is the value that we used before the ABI was released.  */
3174 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3175
3176 #define bfd_elf64_bfd_link_hash_table_create \
3177   sparc64_elf_bfd_link_hash_table_create
3178
3179 #define elf_info_to_howto \
3180   sparc64_elf_info_to_howto
3181 #define bfd_elf64_get_reloc_upper_bound \
3182   sparc64_elf_get_reloc_upper_bound
3183 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3184   sparc64_elf_get_dynamic_reloc_upper_bound
3185 #define bfd_elf64_canonicalize_dynamic_reloc \
3186   sparc64_elf_canonicalize_dynamic_reloc
3187 #define bfd_elf64_bfd_reloc_type_lookup \
3188   sparc64_elf_reloc_type_lookup
3189 #define bfd_elf64_bfd_relax_section \
3190   sparc64_elf_relax_section
3191 #define bfd_elf64_new_section_hook \
3192   sparc64_elf_new_section_hook
3193
3194 #define elf_backend_create_dynamic_sections \
3195   _bfd_elf_create_dynamic_sections
3196 #define elf_backend_add_symbol_hook \
3197   sparc64_elf_add_symbol_hook
3198 #define elf_backend_get_symbol_type \
3199   sparc64_elf_get_symbol_type
3200 #define elf_backend_symbol_processing \
3201   sparc64_elf_symbol_processing
3202 #define elf_backend_check_relocs \
3203   sparc64_elf_check_relocs
3204 #define elf_backend_adjust_dynamic_symbol \
3205   sparc64_elf_adjust_dynamic_symbol
3206 #define elf_backend_size_dynamic_sections \
3207   sparc64_elf_size_dynamic_sections
3208 #define elf_backend_relocate_section \
3209   sparc64_elf_relocate_section
3210 #define elf_backend_finish_dynamic_symbol \
3211   sparc64_elf_finish_dynamic_symbol
3212 #define elf_backend_finish_dynamic_sections \
3213   sparc64_elf_finish_dynamic_sections
3214 #define elf_backend_print_symbol_all \
3215   sparc64_elf_print_symbol_all
3216 #define elf_backend_output_arch_syms \
3217   sparc64_elf_output_arch_syms
3218 #define bfd_elf64_bfd_merge_private_bfd_data \
3219   sparc64_elf_merge_private_bfd_data
3220 #define elf_backend_fake_sections \
3221   sparc64_elf_fake_sections
3222
3223 #define elf_backend_size_info \
3224   sparc64_elf_size_info
3225 #define elf_backend_object_p \
3226   sparc64_elf_object_p
3227 #define elf_backend_reloc_type_class \
3228   sparc64_elf_reloc_type_class
3229
3230 #define elf_backend_want_got_plt 0
3231 #define elf_backend_plt_readonly 0
3232 #define elf_backend_want_plt_sym 1
3233 #define elf_backend_rela_normal 1
3234
3235 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
3236 #define elf_backend_plt_alignment 8
3237
3238 #define elf_backend_got_header_size 8
3239 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3240
3241 #include "elf64-target.h"