contrib/binutils/bfd/elf64-sparc.c

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