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, previously %s in %s"),
1335              (int) sym->st_value,
1336              **namep ? *namep : "#scratch", bfd_archive_filename (abfd),
1337              *p->name ? p->name : "#scratch", bfd_archive_filename (p->abfd));
1338           return false;
1339         }
1340
1341       if (p->name == NULL)
1342         {
1343           if (**namep)
1344             {
1345               struct elf_link_hash_entry *h;
1346
1347               h = (struct elf_link_hash_entry *)
1348                 bfd_link_hash_lookup (info->hash, *namep, false, false, false);
1349
1350               if (h != NULL)
1351                 {
1352                   unsigned char type = h->type;
1353
1354                   if (type > STT_FUNC)
1355                     type = 0;
1356                   (*_bfd_error_handler)
1357                     (_("Symbol `%s' has differing types: REGISTER in %s, previously %s in %s"),
1358                      *namep, bfd_archive_filename (abfd),
1359                      stt_types[type], bfd_archive_filename (p->abfd));
1360                   return false;
1361                 }
1362
1363               p->name = bfd_hash_allocate (&info->hash->table,
1364                                            strlen (*namep) + 1);
1365               if (!p->name)
1366                 return false;
1367
1368               strcpy (p->name, *namep);
1369             }
1370           else
1371             p->name = "";
1372           p->bind = ELF_ST_BIND (sym->st_info);
1373           p->abfd = abfd;
1374           p->shndx = sym->st_shndx;
1375         }
1376       else
1377         {
1378           if (p->bind == STB_WEAK
1379               && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
1380             {
1381               p->bind = STB_GLOBAL;
1382               p->abfd = abfd;
1383             }
1384         }
1385       *namep = NULL;
1386       return true;
1387     }
1388   else if (! *namep || ! **namep)
1389     return true;
1390   else
1391     {
1392       int i;
1393       struct sparc64_elf_app_reg *p;
1394
1395       p = sparc64_elf_hash_table(info)->app_regs;
1396       for (i = 0; i < 4; i++, p++)
1397         if (p->name != NULL && ! strcmp (p->name, *namep))
1398           {
1399             unsigned char type = ELF_ST_TYPE (sym->st_info);
1400
1401             if (type > STT_FUNC)
1402               type = 0;
1403             (*_bfd_error_handler)
1404               (_("Symbol `%s' has differing types: %s in %s, previously REGISTER in %s"),
1405                *namep, stt_types[type], bfd_archive_filename (abfd),
1406                bfd_archive_filename (p->abfd));
1407             return false;
1408           }
1409     }
1410   return true;
1411 }
1412
1413 /* This function takes care of emiting STT_REGISTER symbols
1414    which we cannot easily keep in the symbol hash table.  */
1415
1416 static boolean
1417 sparc64_elf_output_arch_syms (output_bfd, info, finfo, func)
1418      bfd *output_bfd ATTRIBUTE_UNUSED;
1419      struct bfd_link_info *info;
1420      PTR finfo;
1421      boolean (*func) PARAMS ((PTR, const char *,
1422                               Elf_Internal_Sym *, asection *));
1423 {
1424   int reg;
1425   struct sparc64_elf_app_reg *app_regs =
1426     sparc64_elf_hash_table(info)->app_regs;
1427   Elf_Internal_Sym sym;
1428
1429   /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1430      at the end of the dynlocal list, so they came at the end of the local
1431      symbols in the symtab.  Except that they aren't STB_LOCAL, so we need
1432      to back up symtab->sh_info.  */
1433   if (elf_hash_table (info)->dynlocal)
1434     {
1435       bfd * dynobj = elf_hash_table (info)->dynobj;
1436       asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
1437       struct elf_link_local_dynamic_entry *e;
1438
1439       for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
1440         if (e->input_indx == -1)
1441           break;
1442       if (e)
1443         {
1444           elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
1445             = e->dynindx;
1446         }
1447     }
1448
1449   if (info->strip == strip_all)
1450     return true;
1451
1452   for (reg = 0; reg < 4; reg++)
1453     if (app_regs [reg].name != NULL)
1454       {
1455         if (info->strip == strip_some
1456             && bfd_hash_lookup (info->keep_hash,
1457                                 app_regs [reg].name,
1458                                 false, false) == NULL)
1459           continue;
1460
1461         sym.st_value = reg < 2 ? reg + 2 : reg + 4;
1462         sym.st_size = 0;
1463         sym.st_other = 0;
1464         sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
1465         sym.st_shndx = app_regs [reg].shndx;
1466         if (! (*func) (finfo, app_regs [reg].name, &sym,
1467                        sym.st_shndx == SHN_ABS
1468                          ? bfd_abs_section_ptr : bfd_und_section_ptr))
1469           return false;
1470       }
1471
1472   return true;
1473 }
1474
1475 static int
1476 sparc64_elf_get_symbol_type (elf_sym, type)
1477      Elf_Internal_Sym * elf_sym;
1478      int type;
1479 {
1480   if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
1481     return STT_REGISTER;
1482   else
1483     return type;
1484 }
1485
1486 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1487    even in SHN_UNDEF section.  */
1488
1489 static void
1490 sparc64_elf_symbol_processing (abfd, asym)
1491      bfd *abfd ATTRIBUTE_UNUSED;
1492      asymbol *asym;
1493 {
1494   elf_symbol_type *elfsym;
1495
1496   elfsym = (elf_symbol_type *) asym;
1497   if (elfsym->internal_elf_sym.st_info
1498       == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
1499     {
1500       asym->flags |= BSF_GLOBAL;
1501     }
1502 }
1503
1504 /* Adjust a symbol defined by a dynamic object and referenced by a
1505    regular object.  The current definition is in some section of the
1506    dynamic object, but we're not including those sections.  We have to
1507    change the definition to something the rest of the link can
1508    understand.  */
1509
1510 static boolean
1511 sparc64_elf_adjust_dynamic_symbol (info, h)
1512      struct bfd_link_info *info;
1513      struct elf_link_hash_entry *h;
1514 {
1515   bfd *dynobj;
1516   asection *s;
1517   unsigned int power_of_two;
1518
1519   dynobj = elf_hash_table (info)->dynobj;
1520
1521   /* Make sure we know what is going on here.  */
1522   BFD_ASSERT (dynobj != NULL
1523               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1524                   || h->weakdef != NULL
1525                   || ((h->elf_link_hash_flags
1526                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1527                       && (h->elf_link_hash_flags
1528                           & ELF_LINK_HASH_REF_REGULAR) != 0
1529                       && (h->elf_link_hash_flags
1530                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1531
1532   /* If this is a function, put it in the procedure linkage table.  We
1533      will fill in the contents of the procedure linkage table later
1534      (although we could actually do it here).  The STT_NOTYPE
1535      condition is a hack specifically for the Oracle libraries
1536      delivered for Solaris; for some inexplicable reason, they define
1537      some of their functions as STT_NOTYPE when they really should be
1538      STT_FUNC.  */
1539   if (h->type == STT_FUNC
1540       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1541       || (h->type == STT_NOTYPE
1542           && (h->root.type == bfd_link_hash_defined
1543               || h->root.type == bfd_link_hash_defweak)
1544           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1545     {
1546       if (! elf_hash_table (info)->dynamic_sections_created)
1547         {
1548           /* This case can occur if we saw a WPLT30 reloc in an input
1549              file, but none of the input files were dynamic objects.
1550              In such a case, we don't actually need to build a
1551              procedure linkage table, and we can just do a WDISP30
1552              reloc instead.  */
1553           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
1554           return true;
1555         }
1556
1557       s = bfd_get_section_by_name (dynobj, ".plt");
1558       BFD_ASSERT (s != NULL);
1559
1560       /* The first four bit in .plt is reserved.  */
1561       if (s->_raw_size == 0)
1562         s->_raw_size = PLT_HEADER_SIZE;
1563
1564       /* If this symbol is not defined in a regular file, and we are
1565          not generating a shared library, then set the symbol to this
1566          location in the .plt.  This is required to make function
1567          pointers compare as equal between the normal executable and
1568          the shared library.  */
1569       if (! info->shared
1570           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1571         {
1572           h->root.u.def.section = s;
1573           h->root.u.def.value = s->_raw_size;
1574         }
1575
1576       /* To simplify matters later, just store the plt index here.  */
1577       h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
1578
1579       /* Make room for this entry.  */
1580       s->_raw_size += PLT_ENTRY_SIZE;
1581
1582       /* We also need to make an entry in the .rela.plt section.  */
1583
1584       s = bfd_get_section_by_name (dynobj, ".rela.plt");
1585       BFD_ASSERT (s != NULL);
1586
1587       s->_raw_size += sizeof (Elf64_External_Rela);
1588
1589       /* The procedure linkage table size is bounded by the magnitude
1590          of the offset we can describe in the entry.  */
1591       if (s->_raw_size >= (bfd_vma)1 << 32)
1592         {
1593           bfd_set_error (bfd_error_bad_value);
1594           return false;
1595         }
1596
1597       return true;
1598     }
1599
1600   /* If this is a weak symbol, and there is a real definition, the
1601      processor independent code will have arranged for us to see the
1602      real definition first, and we can just use the same value.  */
1603   if (h->weakdef != NULL)
1604     {
1605       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1606                   || h->weakdef->root.type == bfd_link_hash_defweak);
1607       h->root.u.def.section = h->weakdef->root.u.def.section;
1608       h->root.u.def.value = h->weakdef->root.u.def.value;
1609       return true;
1610     }
1611
1612   /* This is a reference to a symbol defined by a dynamic object which
1613      is not a function.  */
1614
1615   /* If we are creating a shared library, we must presume that the
1616      only references to the symbol are via the global offset table.
1617      For such cases we need not do anything here; the relocations will
1618      be handled correctly by relocate_section.  */
1619   if (info->shared)
1620     return true;
1621
1622   /* We must allocate the symbol in our .dynbss section, which will
1623      become part of the .bss section of the executable.  There will be
1624      an entry for this symbol in the .dynsym section.  The dynamic
1625      object will contain position independent code, so all references
1626      from the dynamic object to this symbol will go through the global
1627      offset table.  The dynamic linker will use the .dynsym entry to
1628      determine the address it must put in the global offset table, so
1629      both the dynamic object and the regular object will refer to the
1630      same memory location for the variable.  */
1631
1632   s = bfd_get_section_by_name (dynobj, ".dynbss");
1633   BFD_ASSERT (s != NULL);
1634
1635   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1636      to copy the initial value out of the dynamic object and into the
1637      runtime process image.  We need to remember the offset into the
1638      .rel.bss section we are going to use.  */
1639   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1640     {
1641       asection *srel;
1642
1643       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1644       BFD_ASSERT (srel != NULL);
1645       srel->_raw_size += sizeof (Elf64_External_Rela);
1646       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1647     }
1648
1649   /* We need to figure out the alignment required for this symbol.  I
1650      have no idea how ELF linkers handle this.  16-bytes is the size
1651      of the largest type that requires hard alignment -- long double.  */
1652   power_of_two = bfd_log2 (h->size);
1653   if (power_of_two > 4)
1654     power_of_two = 4;
1655
1656   /* Apply the required alignment.  */
1657   s->_raw_size = BFD_ALIGN (s->_raw_size,
1658                             (bfd_size_type) (1 << power_of_two));
1659   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1660     {
1661       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1662         return false;
1663     }
1664
1665   /* Define the symbol as being at this point in the section.  */
1666   h->root.u.def.section = s;
1667   h->root.u.def.value = s->_raw_size;
1668
1669   /* Increment the section size to make room for the symbol.  */
1670   s->_raw_size += h->size;
1671
1672   return true;
1673 }
1674
1675 /* Set the sizes of the dynamic sections.  */
1676
1677 static boolean
1678 sparc64_elf_size_dynamic_sections (output_bfd, info)
1679      bfd *output_bfd;
1680      struct bfd_link_info *info;
1681 {
1682   bfd *dynobj;
1683   asection *s;
1684   boolean relplt;
1685
1686   dynobj = elf_hash_table (info)->dynobj;
1687   BFD_ASSERT (dynobj != NULL);
1688
1689   if (elf_hash_table (info)->dynamic_sections_created)
1690     {
1691       /* Set the contents of the .interp section to the interpreter.  */
1692       if (! info->shared)
1693         {
1694           s = bfd_get_section_by_name (dynobj, ".interp");
1695           BFD_ASSERT (s != NULL);
1696           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1697           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1698         }
1699     }
1700   else
1701     {
1702       /* We may have created entries in the .rela.got section.
1703          However, if we are not creating the dynamic sections, we will
1704          not actually use these entries.  Reset the size of .rela.got,
1705          which will cause it to get stripped from the output file
1706          below.  */
1707       s = bfd_get_section_by_name (dynobj, ".rela.got");
1708       if (s != NULL)
1709         s->_raw_size = 0;
1710     }
1711
1712   /* The check_relocs and adjust_dynamic_symbol entry points have
1713      determined the sizes of the various dynamic sections.  Allocate
1714      memory for them.  */
1715   relplt = false;
1716   for (s = dynobj->sections; s != NULL; s = s->next)
1717     {
1718       const char *name;
1719       boolean strip;
1720
1721       if ((s->flags & SEC_LINKER_CREATED) == 0)
1722         continue;
1723
1724       /* It's OK to base decisions on the section name, because none
1725          of the dynobj section names depend upon the input files.  */
1726       name = bfd_get_section_name (dynobj, s);
1727
1728       strip = false;
1729
1730       if (strncmp (name, ".rela", 5) == 0)
1731         {
1732           if (s->_raw_size == 0)
1733             {
1734               /* If we don't need this section, strip it from the
1735                  output file.  This is to handle .rela.bss and
1736                  .rel.plt.  We must create it in
1737                  create_dynamic_sections, because it must be created
1738                  before the linker maps input sections to output
1739                  sections.  The linker does that before
1740                  adjust_dynamic_symbol is called, and it is that
1741                  function which decides whether anything needs to go
1742                  into these sections.  */
1743               strip = true;
1744             }
1745           else
1746             {
1747               if (strcmp (name, ".rela.plt") == 0)
1748                 relplt = true;
1749
1750               /* We use the reloc_count field as a counter if we need
1751                  to copy relocs into the output file.  */
1752               s->reloc_count = 0;
1753             }
1754         }
1755       else if (strcmp (name, ".plt") != 0
1756                && strncmp (name, ".got", 4) != 0)
1757         {
1758           /* It's not one of our sections, so don't allocate space.  */
1759           continue;
1760         }
1761
1762       if (strip)
1763         {
1764           _bfd_strip_section_from_output (info, s);
1765           continue;
1766         }
1767
1768       /* Allocate memory for the section contents.  Zero the memory
1769          for the benefit of .rela.plt, which has 4 unused entries
1770          at the beginning, and we don't want garbage.  */
1771       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1772       if (s->contents == NULL && s->_raw_size != 0)
1773         return false;
1774     }
1775
1776   if (elf_hash_table (info)->dynamic_sections_created)
1777     {
1778       /* Add some entries to the .dynamic section.  We fill in the
1779          values later, in sparc64_elf_finish_dynamic_sections, but we
1780          must add the entries now so that we get the correct size for
1781          the .dynamic section.  The DT_DEBUG entry is filled in by the
1782          dynamic linker and used by the debugger.  */
1783 #define add_dynamic_entry(TAG, VAL) \
1784   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1785
1786       int reg;
1787       struct sparc64_elf_app_reg * app_regs;
1788       struct elf_strtab_hash *dynstr;
1789       struct elf_link_hash_table *eht = elf_hash_table (info);
1790
1791       if (!info->shared)
1792         {
1793           if (!add_dynamic_entry (DT_DEBUG, 0))
1794             return false;
1795         }
1796
1797       if (relplt)
1798         {
1799           if (!add_dynamic_entry (DT_PLTGOT, 0)
1800               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1801               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1802               || !add_dynamic_entry (DT_JMPREL, 0))
1803             return false;
1804         }
1805
1806       if (!add_dynamic_entry (DT_RELA, 0)
1807           || !add_dynamic_entry (DT_RELASZ, 0)
1808           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1809         return false;
1810
1811       if (info->flags & DF_TEXTREL)
1812         {
1813           if (!add_dynamic_entry (DT_TEXTREL, 0))
1814             return false;
1815         }
1816
1817       /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1818          entries if needed.  */
1819       app_regs = sparc64_elf_hash_table (info)->app_regs;
1820       dynstr = eht->dynstr;
1821
1822       for (reg = 0; reg < 4; reg++)
1823         if (app_regs [reg].name != NULL)
1824           {
1825             struct elf_link_local_dynamic_entry *entry, *e;
1826
1827             if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
1828               return false;
1829
1830             entry = (struct elf_link_local_dynamic_entry *)
1831               bfd_hash_allocate (&info->hash->table, sizeof (*entry));
1832             if (entry == NULL)
1833               return false;
1834
1835             /* We cheat here a little bit: the symbol will not be local, so we
1836                put it at the end of the dynlocal linked list.  We will fix it
1837                later on, as we have to fix other fields anyway.  */
1838             entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
1839             entry->isym.st_size = 0;
1840             if (*app_regs [reg].name != '\0')
1841               entry->isym.st_name
1842                 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, false);
1843             else
1844               entry->isym.st_name = 0;
1845             entry->isym.st_other = 0;
1846             entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
1847                                                STT_REGISTER);
1848             entry->isym.st_shndx = app_regs [reg].shndx;
1849             entry->next = NULL;
1850             entry->input_bfd = output_bfd;
1851             entry->input_indx = -1;
1852
1853             if (eht->dynlocal == NULL)
1854               eht->dynlocal = entry;
1855             else
1856               {
1857                 for (e = eht->dynlocal; e->next; e = e->next)
1858                   ;
1859                 e->next = entry;
1860               }
1861             eht->dynsymcount++;
1862           }
1863     }
1864 #undef add_dynamic_entry
1865
1866   return true;
1867 }
1868 \f
1869 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1870 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1871
1872 static boolean
1873 sparc64_elf_relax_section (abfd, section, link_info, again)
1874      bfd *abfd ATTRIBUTE_UNUSED;
1875      asection *section ATTRIBUTE_UNUSED;
1876      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1877      boolean *again;
1878 {
1879   *again = false;
1880   SET_SEC_DO_RELAX (section);
1881   return true;
1882 }
1883 \f
1884 /* Relocate a SPARC64 ELF section.  */
1885
1886 static boolean
1887 sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1888                               contents, relocs, local_syms, local_sections)
1889      bfd *output_bfd;
1890      struct bfd_link_info *info;
1891      bfd *input_bfd;
1892      asection *input_section;
1893      bfd_byte *contents;
1894      Elf_Internal_Rela *relocs;
1895      Elf_Internal_Sym *local_syms;
1896      asection **local_sections;
1897 {
1898   bfd *dynobj;
1899   Elf_Internal_Shdr *symtab_hdr;
1900   struct elf_link_hash_entry **sym_hashes;
1901   bfd_vma *local_got_offsets;
1902   bfd_vma got_base;
1903   asection *sgot;
1904   asection *splt;
1905   asection *sreloc;
1906   Elf_Internal_Rela *rel;
1907   Elf_Internal_Rela *relend;
1908
1909   dynobj = elf_hash_table (info)->dynobj;
1910   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1911   sym_hashes = elf_sym_hashes (input_bfd);
1912   local_got_offsets = elf_local_got_offsets (input_bfd);
1913
1914   if (elf_hash_table(info)->hgot == NULL)
1915     got_base = 0;
1916   else
1917     got_base = elf_hash_table (info)->hgot->root.u.def.value;
1918
1919   sgot = splt = sreloc = NULL;
1920
1921   rel = relocs;
1922   relend = relocs + NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
1923   for (; rel < relend; rel++)
1924     {
1925       int r_type;
1926       reloc_howto_type *howto;
1927       unsigned long r_symndx;
1928       struct elf_link_hash_entry *h;
1929       Elf_Internal_Sym *sym;
1930       asection *sec;
1931       bfd_vma relocation;
1932       bfd_reloc_status_type r;
1933       boolean is_plt = false;
1934
1935       r_type = ELF64_R_TYPE_ID (rel->r_info);
1936       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1937         {
1938           bfd_set_error (bfd_error_bad_value);
1939           return false;
1940         }
1941       howto = sparc64_elf_howto_table + r_type;
1942
1943       r_symndx = ELF64_R_SYM (rel->r_info);
1944
1945       if (info->relocateable)
1946         {
1947           /* This is a relocateable link.  We don't have to change
1948              anything, unless the reloc is against a section symbol,
1949              in which case we have to adjust according to where the
1950              section symbol winds up in the output section.  */
1951           if (r_symndx < symtab_hdr->sh_info)
1952             {
1953               sym = local_syms + r_symndx;
1954               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1955                 {
1956                   sec = local_sections[r_symndx];
1957                   rel->r_addend += sec->output_offset + sym->st_value;
1958                 }
1959             }
1960
1961           continue;
1962         }
1963
1964       /* This is a final link.  */
1965       h = NULL;
1966       sym = NULL;
1967       sec = NULL;
1968       if (r_symndx < symtab_hdr->sh_info)
1969         {
1970           sym = local_syms + r_symndx;
1971           sec = local_sections[r_symndx];
1972           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1973         }
1974       else
1975         {
1976           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1977           while (h->root.type == bfd_link_hash_indirect
1978                  || h->root.type == bfd_link_hash_warning)
1979             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1980           if (h->root.type == bfd_link_hash_defined
1981               || h->root.type == bfd_link_hash_defweak)
1982             {
1983               boolean skip_it = false;
1984               sec = h->root.u.def.section;
1985
1986               switch (r_type)
1987                 {
1988                 case R_SPARC_WPLT30:
1989                 case R_SPARC_PLT32:
1990                 case R_SPARC_HIPLT22:
1991                 case R_SPARC_LOPLT10:
1992                 case R_SPARC_PCPLT32:
1993                 case R_SPARC_PCPLT22:
1994                 case R_SPARC_PCPLT10:
1995                 case R_SPARC_PLT64:
1996                   if (h->plt.offset != (bfd_vma) -1)
1997                     skip_it = true;
1998                   break;
1999
2000                 case R_SPARC_GOT10:
2001                 case R_SPARC_GOT13:
2002                 case R_SPARC_GOT22:
2003                   if (elf_hash_table(info)->dynamic_sections_created
2004                       && (!info->shared
2005                           || (!info->symbolic && h->dynindx != -1)
2006                           || !(h->elf_link_hash_flags
2007                                & ELF_LINK_HASH_DEF_REGULAR)))
2008                     skip_it = true;
2009                   break;
2010
2011                 case R_SPARC_PC10:
2012                 case R_SPARC_PC22:
2013                 case R_SPARC_PC_HH22:
2014                 case R_SPARC_PC_HM10:
2015                 case R_SPARC_PC_LM22:
2016                   if (!strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2017                     break;
2018                   /* FALLTHRU */
2019
2020                 case R_SPARC_8:
2021                 case R_SPARC_16:
2022                 case R_SPARC_32:
2023                 case R_SPARC_DISP8:
2024                 case R_SPARC_DISP16:
2025                 case R_SPARC_DISP32:
2026                 case R_SPARC_WDISP30:
2027                 case R_SPARC_WDISP22:
2028                 case R_SPARC_HI22:
2029                 case R_SPARC_22:
2030                 case R_SPARC_13:
2031                 case R_SPARC_LO10:
2032                 case R_SPARC_UA32:
2033                 case R_SPARC_10:
2034                 case R_SPARC_11:
2035                 case R_SPARC_64:
2036                 case R_SPARC_OLO10:
2037                 case R_SPARC_HH22:
2038                 case R_SPARC_HM10:
2039                 case R_SPARC_LM22:
2040                 case R_SPARC_WDISP19:
2041                 case R_SPARC_WDISP16:
2042                 case R_SPARC_7:
2043                 case R_SPARC_5:
2044                 case R_SPARC_6:
2045                 case R_SPARC_DISP64:
2046                 case R_SPARC_HIX22:
2047                 case R_SPARC_LOX10:
2048                 case R_SPARC_H44:
2049                 case R_SPARC_M44:
2050                 case R_SPARC_L44:
2051                 case R_SPARC_UA64:
2052                 case R_SPARC_UA16:
2053                   if (info->shared
2054                       && ((!info->symbolic && h->dynindx != -1)
2055                           || !(h->elf_link_hash_flags
2056                                & ELF_LINK_HASH_DEF_REGULAR))
2057                       && ((input_section->flags & SEC_ALLOC) != 0
2058                           /* DWARF will emit R_SPARC_{32,64} relocations in
2059                              its sections against symbols defined externally
2060                              in shared libraries.  We can't do anything
2061                              with them here.  */
2062                           || ((input_section->flags & SEC_DEBUGGING) != 0
2063                               && (h->elf_link_hash_flags
2064                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0)))
2065                     skip_it = true;
2066                   break;
2067                 }
2068
2069               if (skip_it)
2070                 {
2071                   /* In these cases, we don't need the relocation
2072                      value.  We check specially because in some
2073                      obscure cases sec->output_section will be NULL.  */
2074                   relocation = 0;
2075                 }
2076               else
2077                 {
2078                   relocation = (h->root.u.def.value
2079                                 + sec->output_section->vma
2080                                 + sec->output_offset);
2081                 }
2082             }
2083           else if (h->root.type == bfd_link_hash_undefweak)
2084             relocation = 0;
2085           else if (info->shared
2086                    && (!info->symbolic || info->allow_shlib_undefined)
2087                    && !info->no_undefined
2088                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2089             relocation = 0;
2090           else
2091             {
2092               if (! ((*info->callbacks->undefined_symbol)
2093                      (info, h->root.root.string, input_bfd,
2094                       input_section, rel->r_offset,
2095                       (!info->shared || info->no_undefined
2096                        || ELF_ST_VISIBILITY (h->other)))))
2097                 return false;
2098
2099               /* To avoid generating warning messages about truncated
2100                  relocations, set the relocation's address to be the same as
2101                  the start of this section.  */
2102
2103               if (input_section->output_section != NULL)
2104                 relocation = input_section->output_section->vma;
2105               else
2106                 relocation = 0;
2107             }
2108         }
2109
2110 do_dynreloc:
2111       /* When generating a shared object, these relocations are copied
2112          into the output file to be resolved at run time.  */
2113       if (info->shared && r_symndx != 0 && (input_section->flags & SEC_ALLOC))
2114         {
2115           switch (r_type)
2116             {
2117             case R_SPARC_PC10:
2118             case R_SPARC_PC22:
2119             case R_SPARC_PC_HH22:
2120             case R_SPARC_PC_HM10:
2121             case R_SPARC_PC_LM22:
2122               if (h != NULL
2123                   && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2124                 break;
2125               /* Fall through.  */
2126             case R_SPARC_DISP8:
2127             case R_SPARC_DISP16:
2128             case R_SPARC_DISP32:
2129             case R_SPARC_WDISP30:
2130             case R_SPARC_WDISP22:
2131             case R_SPARC_WDISP19:
2132             case R_SPARC_WDISP16:
2133             case R_SPARC_DISP64:
2134               if (h == NULL)
2135                 break;
2136               /* Fall through.  */
2137             case R_SPARC_8:
2138             case R_SPARC_16:
2139             case R_SPARC_32:
2140             case R_SPARC_HI22:
2141             case R_SPARC_22:
2142             case R_SPARC_13:
2143             case R_SPARC_LO10:
2144             case R_SPARC_UA32:
2145             case R_SPARC_10:
2146             case R_SPARC_11:
2147             case R_SPARC_64:
2148             case R_SPARC_OLO10:
2149             case R_SPARC_HH22:
2150             case R_SPARC_HM10:
2151             case R_SPARC_LM22:
2152             case R_SPARC_7:
2153             case R_SPARC_5:
2154             case R_SPARC_6:
2155             case R_SPARC_HIX22:
2156             case R_SPARC_LOX10:
2157             case R_SPARC_H44:
2158             case R_SPARC_M44:
2159             case R_SPARC_L44:
2160             case R_SPARC_UA64:
2161             case R_SPARC_UA16:
2162               {
2163                 Elf_Internal_Rela outrel;
2164                 boolean skip;
2165
2166                 if (sreloc == NULL)
2167                   {
2168                     const char *name =
2169                       (bfd_elf_string_from_elf_section
2170                        (input_bfd,
2171                         elf_elfheader (input_bfd)->e_shstrndx,
2172                         elf_section_data (input_section)->rel_hdr.sh_name));
2173
2174                     if (name == NULL)
2175                       return false;
2176
2177                     BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2178                                 && strcmp (bfd_get_section_name(input_bfd,
2179                                                                 input_section),
2180                                            name + 5) == 0);
2181
2182                     sreloc = bfd_get_section_by_name (dynobj, name);
2183                     BFD_ASSERT (sreloc != NULL);
2184                   }
2185
2186                 skip = false;
2187
2188                 outrel.r_offset =
2189                   _bfd_elf_section_offset (output_bfd, info, input_section,
2190                                            rel->r_offset);
2191                 if (outrel.r_offset == (bfd_vma) -1)
2192                   skip = true;
2193
2194                 outrel.r_offset += (input_section->output_section->vma
2195                                     + input_section->output_offset);
2196
2197                 /* Optimize unaligned reloc usage now that we know where
2198                    it finally resides.  */
2199                 switch (r_type)
2200                   {
2201                   case R_SPARC_16:
2202                     if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2203                     break;
2204                   case R_SPARC_UA16:
2205                     if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2206                     break;
2207                   case R_SPARC_32:
2208                     if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2209                     break;
2210                   case R_SPARC_UA32:
2211                     if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2212                     break;
2213                   case R_SPARC_64:
2214                     if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2215                     break;
2216                   case R_SPARC_UA64:
2217                     if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2218                     break;
2219                   }
2220
2221                 if (skip)
2222                   memset (&outrel, 0, sizeof outrel);
2223                 /* h->dynindx may be -1 if the symbol was marked to
2224                    become local.  */
2225                 else if (h != NULL && ! is_plt
2226                          && ((! info->symbolic && h->dynindx != -1)
2227                              || (h->elf_link_hash_flags
2228                                  & ELF_LINK_HASH_DEF_REGULAR) == 0))
2229                   {
2230                     BFD_ASSERT (h->dynindx != -1);
2231                     outrel.r_info
2232                       = ELF64_R_INFO (h->dynindx,
2233                                       ELF64_R_TYPE_INFO (
2234                                         ELF64_R_TYPE_DATA (rel->r_info),
2235                                                            r_type));
2236                     outrel.r_addend = rel->r_addend;
2237                   }
2238                 else
2239                   {
2240                     if (r_type == R_SPARC_64)
2241                       {
2242                         outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2243                         outrel.r_addend = relocation + rel->r_addend;
2244                       }
2245                     else
2246                       {
2247                         long indx;
2248
2249                         if (is_plt)
2250                           sec = splt;
2251                         else if (h == NULL)
2252                           sec = local_sections[r_symndx];
2253                         else
2254                           {
2255                             BFD_ASSERT (h->root.type == bfd_link_hash_defined
2256                                         || (h->root.type
2257                                             == bfd_link_hash_defweak));
2258                             sec = h->root.u.def.section;
2259                           }
2260                         if (sec != NULL && bfd_is_abs_section (sec))
2261                           indx = 0;
2262                         else if (sec == NULL || sec->owner == NULL)
2263                           {
2264                             bfd_set_error (bfd_error_bad_value);
2265                             return false;
2266                           }
2267                         else
2268                           {
2269                             asection *osec;
2270
2271                             osec = sec->output_section;
2272                             indx = elf_section_data (osec)->dynindx;
2273
2274                             /* FIXME: we really should be able to link non-pic
2275                                shared libraries.  */
2276                             if (indx == 0)
2277                               {
2278                                 BFD_FAIL ();
2279                                 (*_bfd_error_handler)
2280                                   (_("%s: probably compiled without -fPIC?"),
2281                                    bfd_archive_filename (input_bfd));
2282                                 bfd_set_error (bfd_error_bad_value);
2283                                 return false;
2284                               }
2285                           }
2286
2287                         outrel.r_info
2288                           = ELF64_R_INFO (indx,
2289                                           ELF64_R_TYPE_INFO (
2290                                             ELF64_R_TYPE_DATA (rel->r_info),
2291                                                                r_type));
2292                         outrel.r_addend = relocation + rel->r_addend;
2293                       }
2294                   }
2295
2296                 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2297                                            (((Elf64_External_Rela *)
2298                                              sreloc->contents)
2299                                             + sreloc->reloc_count));
2300                 ++sreloc->reloc_count;
2301
2302                 /* This reloc will be computed at runtime, so there's no
2303                    need to do anything now.  */
2304                 continue;
2305               }
2306             break;
2307             }
2308         }
2309
2310       switch (r_type)
2311         {
2312         case R_SPARC_GOT10:
2313         case R_SPARC_GOT13:
2314         case R_SPARC_GOT22:
2315           /* Relocation is to the entry for this symbol in the global
2316              offset table.  */
2317           if (sgot == NULL)
2318             {
2319               sgot = bfd_get_section_by_name (dynobj, ".got");
2320               BFD_ASSERT (sgot != NULL);
2321             }
2322
2323           if (h != NULL)
2324             {
2325               bfd_vma off = h->got.offset;
2326               BFD_ASSERT (off != (bfd_vma) -1);
2327
2328               if (! elf_hash_table (info)->dynamic_sections_created
2329                   || (info->shared
2330                       && (info->symbolic || h->dynindx == -1)
2331                       && (h->elf_link_hash_flags
2332                           & ELF_LINK_HASH_DEF_REGULAR)))
2333                 {
2334                   /* This is actually a static link, or it is a -Bsymbolic
2335                      link and the symbol is defined locally, or the symbol
2336                      was forced to be local because of a version file.  We
2337                      must initialize this entry in the global offset table.
2338                      Since the offset must always be a multiple of 8, we
2339                      use the least significant bit to record whether we
2340                      have initialized it already.
2341
2342                      When doing a dynamic link, we create a .rela.got
2343                      relocation entry to initialize the value.  This is
2344                      done in the finish_dynamic_symbol routine.  */
2345
2346                   if ((off & 1) != 0)
2347                     off &= ~1;
2348                   else
2349                     {
2350                       bfd_put_64 (output_bfd, relocation,
2351                                   sgot->contents + off);
2352                       h->got.offset |= 1;
2353                     }
2354                 }
2355               relocation = sgot->output_offset + off - got_base;
2356             }
2357           else
2358             {
2359               bfd_vma off;
2360
2361               BFD_ASSERT (local_got_offsets != NULL);
2362               off = local_got_offsets[r_symndx];
2363               BFD_ASSERT (off != (bfd_vma) -1);
2364
2365               /* The offset must always be a multiple of 8.  We use
2366                  the least significant bit to record whether we have
2367                  already processed this entry.  */
2368               if ((off & 1) != 0)
2369                 off &= ~1;
2370               else
2371                 {
2372                   local_got_offsets[r_symndx] |= 1;
2373
2374                   if (info->shared)
2375                     {
2376                       asection *srelgot;
2377                       Elf_Internal_Rela outrel;
2378
2379                       /* The Solaris 2.7 64-bit linker adds the contents
2380                          of the location to the value of the reloc.
2381                          Note this is different behaviour to the
2382                          32-bit linker, which both adds the contents
2383                          and ignores the addend.  So clear the location.  */
2384                       bfd_put_64 (output_bfd, (bfd_vma) 0,
2385                                   sgot->contents + off);
2386
2387                       /* We need to generate a R_SPARC_RELATIVE reloc
2388                          for the dynamic linker.  */
2389                       srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
2390                       BFD_ASSERT (srelgot != NULL);
2391
2392                       outrel.r_offset = (sgot->output_section->vma
2393                                          + sgot->output_offset
2394                                          + off);
2395                       outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2396                       outrel.r_addend = relocation;
2397                       bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2398                                                  (((Elf64_External_Rela *)
2399                                                    srelgot->contents)
2400                                                   + srelgot->reloc_count));
2401                       ++srelgot->reloc_count;
2402                     }
2403                   else
2404                     bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2405                 }
2406               relocation = sgot->output_offset + off - got_base;
2407             }
2408           goto do_default;
2409
2410         case R_SPARC_WPLT30:
2411         case R_SPARC_PLT32:
2412         case R_SPARC_HIPLT22:
2413         case R_SPARC_LOPLT10:
2414         case R_SPARC_PCPLT32:
2415         case R_SPARC_PCPLT22:
2416         case R_SPARC_PCPLT10:
2417         case R_SPARC_PLT64:
2418           /* Relocation is to the entry for this symbol in the
2419              procedure linkage table.  */
2420           BFD_ASSERT (h != NULL);
2421
2422           if (h->plt.offset == (bfd_vma) -1)
2423             {
2424               /* We didn't make a PLT entry for this symbol.  This
2425                  happens when statically linking PIC code, or when
2426                  using -Bsymbolic.  */
2427               goto do_default;
2428             }
2429
2430           if (splt == NULL)
2431             {
2432               splt = bfd_get_section_by_name (dynobj, ".plt");
2433               BFD_ASSERT (splt != NULL);
2434             }
2435
2436           relocation = (splt->output_section->vma
2437                         + splt->output_offset
2438                         + sparc64_elf_plt_entry_offset (h->plt.offset));
2439           if (r_type == R_SPARC_WPLT30)
2440             goto do_wplt30;
2441           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2442             {
2443               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2444               is_plt = true;
2445               goto do_dynreloc;
2446             }
2447           goto do_default;
2448
2449         case R_SPARC_OLO10:
2450           {
2451             bfd_vma x;
2452
2453             relocation += rel->r_addend;
2454             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2455
2456             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2457             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
2458             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2459
2460             r = bfd_check_overflow (howto->complain_on_overflow,
2461                                     howto->bitsize, howto->rightshift,
2462                                     bfd_arch_bits_per_address (input_bfd),
2463                                     relocation);
2464           }
2465           break;
2466
2467         case R_SPARC_WDISP16:
2468           {
2469             bfd_vma x;
2470
2471             relocation += rel->r_addend;
2472             /* Adjust for pc-relative-ness.  */
2473             relocation -= (input_section->output_section->vma
2474                            + input_section->output_offset);
2475             relocation -= rel->r_offset;
2476
2477             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2478             x &= ~(bfd_vma) 0x303fff;
2479             x |= ((((relocation >> 2) & 0xc000) << 6)
2480                   | ((relocation >> 2) & 0x3fff));
2481             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2482
2483             r = bfd_check_overflow (howto->complain_on_overflow,
2484                                     howto->bitsize, howto->rightshift,
2485                                     bfd_arch_bits_per_address (input_bfd),
2486                                     relocation);
2487           }
2488           break;
2489
2490         case R_SPARC_HIX22:
2491           {
2492             bfd_vma x;
2493
2494             relocation += rel->r_addend;
2495             relocation = relocation ^ MINUS_ONE;
2496
2497             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2498             x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2499             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2500
2501             r = bfd_check_overflow (howto->complain_on_overflow,
2502                                     howto->bitsize, howto->rightshift,
2503                                     bfd_arch_bits_per_address (input_bfd),
2504                                     relocation);
2505           }
2506           break;
2507
2508         case R_SPARC_LOX10:
2509           {
2510             bfd_vma x;
2511
2512             relocation += rel->r_addend;
2513             relocation = (relocation & 0x3ff) | 0x1c00;
2514
2515             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2516             x = (x & ~(bfd_vma) 0x1fff) | relocation;
2517             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2518
2519             r = bfd_reloc_ok;
2520           }
2521           break;
2522
2523         case R_SPARC_WDISP30:
2524         do_wplt30:
2525           if (SEC_DO_RELAX (input_section)
2526               && rel->r_offset + 4 < input_section->_raw_size)
2527             {
2528 #define G0              0
2529 #define O7              15
2530 #define XCC             (2 << 20)
2531 #define COND(x)         (((x)&0xf)<<25)
2532 #define CONDA           COND(0x8)
2533 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
2534 #define INSN_BA         (F2(0,2) | CONDA)
2535 #define INSN_OR         F3(2, 0x2, 0)
2536 #define INSN_NOP        F2(0,4)
2537
2538               bfd_vma x, y;
2539
2540               /* If the instruction is a call with either:
2541                  restore
2542                  arithmetic instruction with rd == %o7
2543                  where rs1 != %o7 and rs2 if it is register != %o7
2544                  then we can optimize if the call destination is near
2545                  by changing the call into a branch always.  */
2546               x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2547               y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2548               if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2549                 {
2550                   if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2551                        || ((y & OP3(0x28)) == 0 /* arithmetic */
2552                            && (y & RD(~0)) == RD(O7)))
2553                       && (y & RS1(~0)) != RS1(O7)
2554                       && ((y & F3I(~0))
2555                           || (y & RS2(~0)) != RS2(O7)))
2556                     {
2557                       bfd_vma reloc;
2558
2559                       reloc = relocation + rel->r_addend - rel->r_offset;
2560                       reloc -= (input_section->output_section->vma
2561                                 + input_section->output_offset);
2562                       if (reloc & 3)
2563                         goto do_default;
2564
2565                       /* Ensure the branch fits into simm22.  */
2566                       if ((reloc & ~(bfd_vma)0x7fffff)
2567                            && ((reloc | 0x7fffff) != MINUS_ONE))
2568                         goto do_default;
2569                       reloc >>= 2;
2570
2571                       /* Check whether it fits into simm19.  */
2572                       if ((reloc & 0x3c0000) == 0
2573                           || (reloc & 0x3c0000) == 0x3c0000)
2574                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2575                       else
2576                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
2577                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2578                       r = bfd_reloc_ok;
2579                       if (rel->r_offset >= 4
2580                           && (y & (0xffffffff ^ RS1(~0)))
2581                              == (INSN_OR | RD(O7) | RS2(G0)))
2582                         {
2583                           bfd_vma z;
2584                           unsigned int reg;
2585
2586                           z = bfd_get_32 (input_bfd,
2587                                           contents + rel->r_offset - 4);
2588                           if ((z & (0xffffffff ^ RD(~0)))
2589                               != (INSN_OR | RS1(O7) | RS2(G0)))
2590                             break;
2591
2592                           /* The sequence was
2593                              or %o7, %g0, %rN
2594                              call foo
2595                              or %rN, %g0, %o7
2596
2597                              If call foo was replaced with ba, replace
2598                              or %rN, %g0, %o7 with nop.  */
2599
2600                           reg = (y & RS1(~0)) >> 14;
2601                           if (reg != ((z & RD(~0)) >> 25)
2602                               || reg == G0 || reg == O7)
2603                             break;
2604
2605                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
2606                                       contents + rel->r_offset + 4);
2607                         }
2608                       break;
2609                     }
2610                 }
2611             }
2612           /* FALLTHROUGH */
2613
2614         default:
2615         do_default:
2616           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2617                                         contents, rel->r_offset,
2618                                         relocation, rel->r_addend);
2619           break;
2620         }
2621
2622       switch (r)
2623         {
2624         case bfd_reloc_ok:
2625           break;
2626
2627         default:
2628         case bfd_reloc_outofrange:
2629           abort ();
2630
2631         case bfd_reloc_overflow:
2632           {
2633             const char *name;
2634
2635             /* The Solaris native linker silently disregards
2636                overflows.  We don't, but this breaks stabs debugging
2637                info, whose relocations are only 32-bits wide.  Ignore
2638                overflows in this case.  */
2639             if (r_type == R_SPARC_32
2640                 && (input_section->flags & SEC_DEBUGGING) != 0
2641                 && strcmp (bfd_section_name (input_bfd, input_section),
2642                            ".stab") == 0)
2643               break;
2644
2645             if (h != NULL)
2646               {
2647                 if (h->root.type == bfd_link_hash_undefweak
2648                     && howto->pc_relative)
2649                   {
2650                     /* Assume this is a call protected by other code that
2651                        detect the symbol is undefined.  If this is the case,
2652                        we can safely ignore the overflow.  If not, the
2653                        program is hosed anyway, and a little warning isn't
2654                        going to help.  */
2655                     break;
2656                   }
2657
2658                 name = h->root.root.string;
2659               }
2660             else
2661               {
2662                 name = (bfd_elf_string_from_elf_section
2663                         (input_bfd,
2664                          symtab_hdr->sh_link,
2665                          sym->st_name));
2666                 if (name == NULL)
2667                   return false;
2668                 if (*name == '\0')
2669                   name = bfd_section_name (input_bfd, sec);
2670               }
2671             if (! ((*info->callbacks->reloc_overflow)
2672                    (info, name, howto->name, (bfd_vma) 0,
2673                     input_bfd, input_section, rel->r_offset)))
2674               return false;
2675           }
2676         break;
2677         }
2678     }
2679
2680   return true;
2681 }
2682
2683 /* Finish up dynamic symbol handling.  We set the contents of various
2684    dynamic sections here.  */
2685
2686 static boolean
2687 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2688      bfd *output_bfd;
2689      struct bfd_link_info *info;
2690      struct elf_link_hash_entry *h;
2691      Elf_Internal_Sym *sym;
2692 {
2693   bfd *dynobj;
2694
2695   dynobj = elf_hash_table (info)->dynobj;
2696
2697   if (h->plt.offset != (bfd_vma) -1)
2698     {
2699       asection *splt;
2700       asection *srela;
2701       Elf_Internal_Rela rela;
2702
2703       /* This symbol has an entry in the PLT.  Set it up.  */
2704
2705       BFD_ASSERT (h->dynindx != -1);
2706
2707       splt = bfd_get_section_by_name (dynobj, ".plt");
2708       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2709       BFD_ASSERT (splt != NULL && srela != NULL);
2710
2711       /* Fill in the entry in the .rela.plt section.  */
2712
2713       if (h->plt.offset < LARGE_PLT_THRESHOLD)
2714         {
2715           rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2716           rela.r_addend = 0;
2717         }
2718       else
2719         {
2720           bfd_vma max = splt->_raw_size / PLT_ENTRY_SIZE;
2721           rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
2722           rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2723                           -(splt->output_section->vma + splt->output_offset);
2724         }
2725       rela.r_offset += (splt->output_section->vma + splt->output_offset);
2726       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2727
2728       /* Adjust for the first 4 reserved elements in the .plt section
2729          when setting the offset in the .rela.plt section.
2730          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2731          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
2732
2733       bfd_elf64_swap_reloca_out (output_bfd, &rela,
2734                                  ((Elf64_External_Rela *) srela->contents
2735                                   + (h->plt.offset - 4)));
2736
2737       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2738         {
2739           /* Mark the symbol as undefined, rather than as defined in
2740              the .plt section.  Leave the value alone.  */
2741           sym->st_shndx = SHN_UNDEF;
2742           /* If the symbol is weak, we do need to clear the value.
2743              Otherwise, the PLT entry would provide a definition for
2744              the symbol even if the symbol wasn't defined anywhere,
2745              and so the symbol would never be NULL.  */
2746           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2747               == 0)
2748             sym->st_value = 0;
2749         }
2750     }
2751
2752   if (h->got.offset != (bfd_vma) -1)
2753     {
2754       asection *sgot;
2755       asection *srela;
2756       Elf_Internal_Rela rela;
2757
2758       /* This symbol has an entry in the GOT.  Set it up.  */
2759
2760       sgot = bfd_get_section_by_name (dynobj, ".got");
2761       srela = bfd_get_section_by_name (dynobj, ".rela.got");
2762       BFD_ASSERT (sgot != NULL && srela != NULL);
2763
2764       rela.r_offset = (sgot->output_section->vma
2765                        + sgot->output_offset
2766                        + (h->got.offset &~ (bfd_vma) 1));
2767
2768       /* If this is a -Bsymbolic link, and the symbol is defined
2769          locally, we just want to emit a RELATIVE reloc.  Likewise if
2770          the symbol was forced to be local because of a version file.
2771          The entry in the global offset table will already have been
2772          initialized in the relocate_section function.  */
2773       if (info->shared
2774           && (info->symbolic || h->dynindx == -1)
2775           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2776         {
2777           asection *sec = h->root.u.def.section;
2778           rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2779           rela.r_addend = (h->root.u.def.value
2780                            + sec->output_section->vma
2781                            + sec->output_offset);
2782         }
2783       else
2784         {
2785           bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2786           rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2787           rela.r_addend = 0;
2788         }
2789
2790       bfd_elf64_swap_reloca_out (output_bfd, &rela,
2791                                  ((Elf64_External_Rela *) srela->contents
2792                                   + srela->reloc_count));
2793       ++srela->reloc_count;
2794     }
2795
2796   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2797     {
2798       asection *s;
2799       Elf_Internal_Rela rela;
2800
2801       /* This symbols needs a copy reloc.  Set it up.  */
2802
2803       BFD_ASSERT (h->dynindx != -1);
2804
2805       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2806                                    ".rela.bss");
2807       BFD_ASSERT (s != NULL);
2808
2809       rela.r_offset = (h->root.u.def.value
2810                        + h->root.u.def.section->output_section->vma
2811                        + h->root.u.def.section->output_offset);
2812       rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2813       rela.r_addend = 0;
2814       bfd_elf64_swap_reloca_out (output_bfd, &rela,
2815                                  ((Elf64_External_Rela *) s->contents
2816                                   + s->reloc_count));
2817       ++s->reloc_count;
2818     }
2819
2820   /* Mark some specially defined symbols as absolute.  */
2821   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2822       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2823       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2824     sym->st_shndx = SHN_ABS;
2825
2826   return true;
2827 }
2828
2829 /* Finish up the dynamic sections.  */
2830
2831 static boolean
2832 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2833      bfd *output_bfd;
2834      struct bfd_link_info *info;
2835 {
2836   bfd *dynobj;
2837   int stt_regidx = -1;
2838   asection *sdyn;
2839   asection *sgot;
2840
2841   dynobj = elf_hash_table (info)->dynobj;
2842
2843   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2844
2845   if (elf_hash_table (info)->dynamic_sections_created)
2846     {
2847       asection *splt;
2848       Elf64_External_Dyn *dyncon, *dynconend;
2849
2850       splt = bfd_get_section_by_name (dynobj, ".plt");
2851       BFD_ASSERT (splt != NULL && sdyn != NULL);
2852
2853       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2854       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2855       for (; dyncon < dynconend; dyncon++)
2856         {
2857           Elf_Internal_Dyn dyn;
2858           const char *name;
2859           boolean size;
2860
2861           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2862
2863           switch (dyn.d_tag)
2864             {
2865             case DT_PLTGOT:   name = ".plt"; size = false; break;
2866             case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2867             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
2868             case DT_SPARC_REGISTER:
2869               if (stt_regidx == -1)
2870                 {
2871                   stt_regidx =
2872                     _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2873                   if (stt_regidx == -1)
2874                     return false;
2875                 }
2876               dyn.d_un.d_val = stt_regidx++;
2877               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2878               /* fallthrough */
2879             default:          name = NULL; size = false; break;
2880             }
2881
2882           if (name != NULL)
2883             {
2884               asection *s;
2885
2886               s = bfd_get_section_by_name (output_bfd, name);
2887               if (s == NULL)
2888                 dyn.d_un.d_val = 0;
2889               else
2890                 {
2891                   if (! size)
2892                     dyn.d_un.d_ptr = s->vma;
2893                   else
2894                     {
2895                       if (s->_cooked_size != 0)
2896                         dyn.d_un.d_val = s->_cooked_size;
2897                       else
2898                         dyn.d_un.d_val = s->_raw_size;
2899                     }
2900                 }
2901               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2902             }
2903         }
2904
2905       /* Initialize the contents of the .plt section.  */
2906       if (splt->_raw_size > 0)
2907         {
2908           sparc64_elf_build_plt (output_bfd, splt->contents,
2909                                  (int) (splt->_raw_size / PLT_ENTRY_SIZE));
2910         }
2911
2912       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2913         PLT_ENTRY_SIZE;
2914     }
2915
2916   /* Set the first entry in the global offset table to the address of
2917      the dynamic section.  */
2918   sgot = bfd_get_section_by_name (dynobj, ".got");
2919   BFD_ASSERT (sgot != NULL);
2920   if (sgot->_raw_size > 0)
2921     {
2922       if (sdyn == NULL)
2923         bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2924       else
2925         bfd_put_64 (output_bfd,
2926                     sdyn->output_section->vma + sdyn->output_offset,
2927                     sgot->contents);
2928     }
2929
2930   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2931
2932   return true;
2933 }
2934
2935 static enum elf_reloc_type_class
2936 sparc64_elf_reloc_type_class (rela)
2937      const Elf_Internal_Rela *rela;
2938 {
2939   switch ((int) ELF64_R_TYPE (rela->r_info))
2940     {
2941     case R_SPARC_RELATIVE:
2942       return reloc_class_relative;
2943     case R_SPARC_JMP_SLOT:
2944       return reloc_class_plt;
2945     case R_SPARC_COPY:
2946       return reloc_class_copy;
2947     default:
2948       return reloc_class_normal;
2949     }
2950 }
2951 \f
2952 /* Functions for dealing with the e_flags field.  */
2953
2954 /* Merge backend specific data from an object file to the output
2955    object file when linking.  */
2956
2957 static boolean
2958 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2959      bfd *ibfd;
2960      bfd *obfd;
2961 {
2962   boolean error;
2963   flagword new_flags, old_flags;
2964   int new_mm, old_mm;
2965
2966   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2967       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2968     return true;
2969
2970   new_flags = elf_elfheader (ibfd)->e_flags;
2971   old_flags = elf_elfheader (obfd)->e_flags;
2972
2973   if (!elf_flags_init (obfd))   /* First call, no flags set */
2974     {
2975       elf_flags_init (obfd) = true;
2976       elf_elfheader (obfd)->e_flags = new_flags;
2977     }
2978
2979   else if (new_flags == old_flags)      /* Compatible flags are ok */
2980     ;
2981
2982   else                                  /* Incompatible flags */
2983     {
2984       error = false;
2985
2986 #define EF_SPARC_ISA_EXTENSIONS \
2987   (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
2988
2989       if ((ibfd->flags & DYNAMIC) != 0)
2990         {
2991           /* We don't want dynamic objects memory ordering and
2992              architecture to have any role. That's what dynamic linker
2993              should do.  */
2994           new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
2995           new_flags |= (old_flags
2996                         & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
2997         }
2998       else
2999         {
3000           /* Choose the highest architecture requirements.  */
3001           old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
3002           new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
3003           if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
3004               && (old_flags & EF_SPARC_HAL_R1))
3005             {
3006               error = true;
3007               (*_bfd_error_handler)
3008                 (_("%s: linking UltraSPARC specific with HAL specific code"),
3009                  bfd_archive_filename (ibfd));
3010             }
3011           /* Choose the most restrictive memory ordering.  */
3012           old_mm = (old_flags & EF_SPARCV9_MM);
3013           new_mm = (new_flags & EF_SPARCV9_MM);
3014           old_flags &= ~EF_SPARCV9_MM;
3015           new_flags &= ~EF_SPARCV9_MM;
3016           if (new_mm < old_mm)
3017             old_mm = new_mm;
3018           old_flags |= old_mm;
3019           new_flags |= old_mm;
3020         }
3021
3022       /* Warn about any other mismatches */
3023       if (new_flags != old_flags)
3024         {
3025           error = true;
3026           (*_bfd_error_handler)
3027             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3028              bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
3029         }
3030
3031       elf_elfheader (obfd)->e_flags = old_flags;
3032
3033       if (error)
3034         {
3035           bfd_set_error (bfd_error_bad_value);
3036           return false;
3037         }
3038     }
3039   return true;
3040 }
3041 \f
3042 /* Print a STT_REGISTER symbol to file FILE.  */
3043
3044 static const char *
3045 sparc64_elf_print_symbol_all (abfd, filep, symbol)
3046      bfd *abfd ATTRIBUTE_UNUSED;
3047      PTR filep;
3048      asymbol *symbol;
3049 {
3050   FILE *file = (FILE *) filep;
3051   int reg, type;
3052
3053   if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
3054       != STT_REGISTER)
3055     return NULL;
3056
3057   reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
3058   type = symbol->flags;
3059   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
3060                  ((type & BSF_LOCAL)
3061                   ? (type & BSF_GLOBAL) ? '!' : 'l'
3062                   : (type & BSF_GLOBAL) ? 'g' : ' '),
3063                  (type & BSF_WEAK) ? 'w' : ' ');
3064   if (symbol->name == NULL || symbol->name [0] == '\0')
3065     return "#scratch";
3066   else
3067     return symbol->name;
3068 }
3069 \f
3070 /* Set the right machine number for a SPARC64 ELF file.  */
3071
3072 static boolean
3073 sparc64_elf_object_p (abfd)
3074      bfd *abfd;
3075 {
3076   unsigned long mach = bfd_mach_sparc_v9;
3077
3078   if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3079     mach = bfd_mach_sparc_v9b;
3080   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3081     mach = bfd_mach_sparc_v9a;
3082   return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3083 }
3084
3085 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3086    standard ELF, because R_SPARC_OLO10 has secondary addend in
3087    ELF64_R_TYPE_DATA field.  This structure is used to redirect the
3088    relocation handling routines.  */
3089
3090 const struct elf_size_info sparc64_elf_size_info =
3091 {
3092   sizeof (Elf64_External_Ehdr),
3093   sizeof (Elf64_External_Phdr),
3094   sizeof (Elf64_External_Shdr),
3095   sizeof (Elf64_External_Rel),
3096   sizeof (Elf64_External_Rela),
3097   sizeof (Elf64_External_Sym),
3098   sizeof (Elf64_External_Dyn),
3099   sizeof (Elf_External_Note),
3100   4,            /* hash-table entry size */
3101   /* internal relocations per external relocations.
3102      For link purposes we use just 1 internal per
3103      1 external, for assembly and slurp symbol table
3104      we use 2.  */
3105   1,
3106   64,           /* arch_size */
3107   8,            /* file_align */
3108   ELFCLASS64,
3109   EV_CURRENT,
3110   bfd_elf64_write_out_phdrs,
3111   bfd_elf64_write_shdrs_and_ehdr,
3112   sparc64_elf_write_relocs,
3113   bfd_elf64_swap_symbol_out,
3114   sparc64_elf_slurp_reloc_table,
3115   bfd_elf64_slurp_symbol_table,
3116   bfd_elf64_swap_dyn_in,
3117   bfd_elf64_swap_dyn_out,
3118   NULL,
3119   NULL,
3120   NULL,
3121   NULL
3122 };
3123
3124 #define TARGET_BIG_SYM  bfd_elf64_sparc_vec
3125 #define TARGET_BIG_NAME "elf64-sparc"
3126 #define ELF_ARCH        bfd_arch_sparc
3127 #define ELF_MAXPAGESIZE 0x100000
3128
3129 /* This is the official ABI value.  */
3130 #define ELF_MACHINE_CODE EM_SPARCV9
3131
3132 /* This is the value that we used before the ABI was released.  */
3133 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3134
3135 #define bfd_elf64_bfd_link_hash_table_create \
3136   sparc64_elf_bfd_link_hash_table_create
3137
3138 #define elf_info_to_howto \
3139   sparc64_elf_info_to_howto
3140 #define bfd_elf64_get_reloc_upper_bound \
3141   sparc64_elf_get_reloc_upper_bound
3142 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3143   sparc64_elf_get_dynamic_reloc_upper_bound
3144 #define bfd_elf64_canonicalize_dynamic_reloc \
3145   sparc64_elf_canonicalize_dynamic_reloc
3146 #define bfd_elf64_bfd_reloc_type_lookup \
3147   sparc64_elf_reloc_type_lookup
3148 #define bfd_elf64_bfd_relax_section \
3149   sparc64_elf_relax_section
3150
3151 #define elf_backend_create_dynamic_sections \
3152   _bfd_elf_create_dynamic_sections
3153 #define elf_backend_add_symbol_hook \
3154   sparc64_elf_add_symbol_hook
3155 #define elf_backend_get_symbol_type \
3156   sparc64_elf_get_symbol_type
3157 #define elf_backend_symbol_processing \
3158   sparc64_elf_symbol_processing
3159 #define elf_backend_check_relocs \
3160   sparc64_elf_check_relocs
3161 #define elf_backend_adjust_dynamic_symbol \
3162   sparc64_elf_adjust_dynamic_symbol
3163 #define elf_backend_size_dynamic_sections \
3164   sparc64_elf_size_dynamic_sections
3165 #define elf_backend_relocate_section \
3166   sparc64_elf_relocate_section
3167 #define elf_backend_finish_dynamic_symbol \
3168   sparc64_elf_finish_dynamic_symbol
3169 #define elf_backend_finish_dynamic_sections \
3170   sparc64_elf_finish_dynamic_sections
3171 #define elf_backend_print_symbol_all \
3172   sparc64_elf_print_symbol_all
3173 #define elf_backend_output_arch_syms \
3174   sparc64_elf_output_arch_syms
3175 #define bfd_elf64_bfd_merge_private_bfd_data \
3176   sparc64_elf_merge_private_bfd_data
3177
3178 #define elf_backend_size_info \
3179   sparc64_elf_size_info
3180 #define elf_backend_object_p \
3181   sparc64_elf_object_p
3182 #define elf_backend_reloc_type_class \
3183   sparc64_elf_reloc_type_class
3184
3185 #define elf_backend_want_got_plt 0
3186 #define elf_backend_plt_readonly 0
3187 #define elf_backend_want_plt_sym 1
3188
3189 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
3190 #define elf_backend_plt_alignment 8
3191
3192 #define elf_backend_got_header_size 8
3193 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3194
3195 #include "elf64-target.h"