bfd/elf64-sparc.c

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