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