bfd/elf64-sparc.c

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