contrib/binutils/bfd/elf64-sparc.c

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