bfd/elf64-sparc.c

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