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