bfd/elf32-sparc.c

   1 /* SPARC-specific support for 32-bit ELF
   2    Copyright (C) 1993, 94, 95, 96, 97, 98, 99, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/sparc.h"
  27 #include "opcode/sparc.h"
  28
  29 static reloc_howto_type *elf32_sparc_reloc_type_lookup
  30   PARAMS ((bfd *, bfd_reloc_code_real_type));
  31 static void elf32_sparc_info_to_howto
  32   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  33 static boolean elf32_sparc_check_relocs
  34   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  35            const Elf_Internal_Rela *));
  36 static boolean elf32_sparc_adjust_dynamic_symbol
  37   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  38 static boolean elf32_sparc_size_dynamic_sections
  39   PARAMS ((bfd *, struct bfd_link_info *));
  40 static boolean elf32_sparc_relax_section
  41   PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
  42 static boolean elf32_sparc_relocate_section
  43   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  44            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  45 static boolean elf32_sparc_finish_dynamic_symbol
  46   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  47            Elf_Internal_Sym *));
  48 static boolean elf32_sparc_finish_dynamic_sections
  49   PARAMS ((bfd *, struct bfd_link_info *));
  50 static boolean elf32_sparc_merge_private_bfd_data PARAMS ((bfd *, bfd *));
  51 static boolean elf32_sparc_object_p
  52   PARAMS ((bfd *));
  53 static void elf32_sparc_final_write_processing
  54   PARAMS ((bfd *, boolean));
  55 \f
  56 /* The relocation "howto" table.  */
  57
  58 static bfd_reloc_status_type sparc_elf_notsupported_reloc
  59   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  60 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
  61   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  62
  63 reloc_howto_type _bfd_sparc_elf_howto_table[] =
  64 {
  65   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
  66   HOWTO(R_SPARC_8,         0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_8",       false,0,0x000000ff,true),
  67   HOWTO(R_SPARC_16,        0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_16",      false,0,0x0000ffff,true),
  68   HOWTO(R_SPARC_32,        0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_32",      false,0,0xffffffff,true),
  69   HOWTO(R_SPARC_DISP8,     0,0, 8,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP8",   false,0,0x000000ff,true),
  70   HOWTO(R_SPARC_DISP16,    0,1,16,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP16",  false,0,0x0000ffff,true),
  71   HOWTO(R_SPARC_DISP32,    0,2,32,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP32",  false,0,0x00ffffff,true),
  72   HOWTO(R_SPARC_WDISP30,   2,2,30,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP30", false,0,0x3fffffff,true),
  73   HOWTO(R_SPARC_WDISP22,   2,2,22,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP22", false,0,0x003fffff,true),
  74   HOWTO(R_SPARC_HI22,     10,2,22,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HI22",    false,0,0x003fffff,true),
  75   HOWTO(R_SPARC_22,        0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_22",      false,0,0x003fffff,true),
  76   HOWTO(R_SPARC_13,        0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_13",      false,0,0x00001fff,true),
  77   HOWTO(R_SPARC_LO10,      0,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LO10",    false,0,0x000003ff,true),
  78   HOWTO(R_SPARC_GOT10,     0,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT10",   false,0,0x000003ff,true),
  79   HOWTO(R_SPARC_GOT13,     0,2,13,false,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_GOT13",   false,0,0x00001fff,true),
  80   HOWTO(R_SPARC_GOT22,    10,2,22,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT22",   false,0,0x003fffff,true),
  81   HOWTO(R_SPARC_PC10,      0,2,10,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC10",    false,0,0x000003ff,true),
  82   HOWTO(R_SPARC_PC22,     10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PC22",    false,0,0x003fffff,true),
  83   HOWTO(R_SPARC_WPLT30,    2,2,30,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WPLT30",  false,0,0x3fffffff,true),
  84   HOWTO(R_SPARC_COPY,      0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_COPY",    false,0,0x00000000,true),
  85   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),
  86   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),
  87   HOWTO(R_SPARC_RELATIVE,  0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_RELATIVE",false,0,0x00000000,true),
  88   HOWTO(R_SPARC_UA32,      0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA32",    false,0,0xffffffff,true),
  89   HOWTO(R_SPARC_PLT32,     0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PLT32",    false,0,0x00000000,true),
  90   HOWTO(R_SPARC_HIPLT22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HIPLT22",  false,0,0x00000000,true),
  91   HOWTO(R_SPARC_LOPLT10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LOPLT10",  false,0,0x00000000,true),
  92   HOWTO(R_SPARC_PCPLT32,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT32",  false,0,0x00000000,true),
  93   HOWTO(R_SPARC_PCPLT22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT22",  false,0,0x00000000,true),
  94   HOWTO(R_SPARC_PCPLT10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT10",  false,0,0x00000000,true),
  95   HOWTO(R_SPARC_10,        0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      false,0,0x000003ff,true),
  96   HOWTO(R_SPARC_11,        0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      false,0,0x000007ff,true),
  97   /* These are for sparc64 in a 64 bit environment.
  98      Values need to be here because the table is indexed by reloc number.  */
  99   HOWTO(R_SPARC_64,        0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_64",      false,0,0x00000000,true),
 100   HOWTO(R_SPARC_OLO10,     0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_OLO10",   false,0,0x00000000,true),
 101   HOWTO(R_SPARC_HH22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HH22",    false,0,0x00000000,true),
 102   HOWTO(R_SPARC_HM10,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HM10",    false,0,0x00000000,true),
 103   HOWTO(R_SPARC_LM22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LM22",    false,0,0x00000000,true),
 104   HOWTO(R_SPARC_PC_HH22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_HH22", false,0,0x00000000,true),
 105   HOWTO(R_SPARC_PC_HM10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_HM10", false,0,0x00000000,true),
 106   HOWTO(R_SPARC_PC_LM22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_LM22", false,0,0x00000000,true),
 107   /* End sparc64 in 64 bit environment values.
 108      The following are for sparc64 in a 32 bit environment.  */
 109   HOWTO(R_SPARC_WDISP16,   2,2,16,true, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
 110   HOWTO(R_SPARC_WDISP19,   2,2,19,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", false,0,0x0007ffff,true),
 111   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),
 112   HOWTO(R_SPARC_7,         0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       false,0,0x0000007f,true),
 113   HOWTO(R_SPARC_5,         0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       false,0,0x0000001f,true),
 114   HOWTO(R_SPARC_6,         0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       false,0,0x0000003f,true),
 115   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 116   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 117   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 118   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 119   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 120   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 121   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 122   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 123   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 124   HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
 125   HOWTO(R_SPARC_REV32,      0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_REV32",      false,0,0xffffffff,true),
 126 };
 127 static reloc_howto_type elf32_sparc_vtinherit_howto =
 128   HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", false,0, 0, false);
 129 static reloc_howto_type elf32_sparc_vtentry_howto =
 130   HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", false,0,0, false);
 131
 132 struct elf_reloc_map {
 133   bfd_reloc_code_real_type bfd_reloc_val;
 134   unsigned char elf_reloc_val;
 135 };
 136
 137 static CONST struct elf_reloc_map sparc_reloc_map[] =
 138 {
 139   { BFD_RELOC_NONE, R_SPARC_NONE, },
 140   { BFD_RELOC_16, R_SPARC_16, },
 141   { BFD_RELOC_8, R_SPARC_8 },
 142   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
 143   { BFD_RELOC_CTOR, R_SPARC_32 },
 144   { BFD_RELOC_32, R_SPARC_32 },
 145   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
 146   { BFD_RELOC_HI22, R_SPARC_HI22 },
 147   { BFD_RELOC_LO10, R_SPARC_LO10, },
 148   { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
 149   { BFD_RELOC_SPARC22, R_SPARC_22 },
 150   { BFD_RELOC_SPARC13, R_SPARC_13 },
 151   { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
 152   { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
 153   { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
 154   { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
 155   { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
 156   { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
 157   { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
 158   { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
 159   { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
 160   { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
 161   { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
 162   /* ??? Doesn't dwarf use this?  */
 163 /*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
 164   {BFD_RELOC_SPARC_10, R_SPARC_10},
 165   {BFD_RELOC_SPARC_11, R_SPARC_11},
 166   {BFD_RELOC_SPARC_64, R_SPARC_64},
 167   {BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10},
 168   {BFD_RELOC_SPARC_HH22, R_SPARC_HH22},
 169   {BFD_RELOC_SPARC_HM10, R_SPARC_HM10},
 170   {BFD_RELOC_SPARC_LM22, R_SPARC_LM22},
 171   {BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22},
 172   {BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10},
 173   {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
 174   {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
 175   {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
 176   {BFD_RELOC_SPARC_7, R_SPARC_7},
 177   {BFD_RELOC_SPARC_5, R_SPARC_5},
 178   {BFD_RELOC_SPARC_6, R_SPARC_6},
 179   {BFD_RELOC_SPARC_REV32, R_SPARC_REV32 },
 180   {BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT},
 181   {BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY},
 182 };
 183
 184 static reloc_howto_type *
 185 elf32_sparc_reloc_type_lookup (abfd, code)
 186      bfd *abfd ATTRIBUTE_UNUSED;
 187      bfd_reloc_code_real_type code;
 188 {
 189   unsigned int i;
 190
 191   switch (code)
 192     {
 193     case BFD_RELOC_VTABLE_INHERIT:
 194       return &elf32_sparc_vtinherit_howto;
 195
 196     case BFD_RELOC_VTABLE_ENTRY:
 197       return &elf32_sparc_vtentry_howto;
 198
 199     default:
 200       for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
 201         {
 202           if (sparc_reloc_map[i].bfd_reloc_val == code)
 203             return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
 204         }
 205     }
 206     bfd_set_error (bfd_error_bad_value);
 207     return NULL;
 208 }
 209
 210 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
 211    and elf64-sparc.c has its own copy.  */
 212
 213 static void
 214 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
 215      bfd *abfd ATTRIBUTE_UNUSED;
 216      arelent *cache_ptr;
 217      Elf_Internal_Rela *dst;
 218 {
 219   switch (ELF32_R_TYPE(dst->r_info))
 220     {
 221     case R_SPARC_GNU_VTINHERIT:
 222       cache_ptr->howto = &elf32_sparc_vtinherit_howto;
 223       break;
 224
 225     case R_SPARC_GNU_VTENTRY:
 226       cache_ptr->howto = &elf32_sparc_vtentry_howto;
 227       break;
 228
 229     default:
 230       BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
 231       cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
 232     }
 233 }
 234 \f
 235 /* For unsupported relocs.  */
 236
 237 static bfd_reloc_status_type
 238 sparc_elf_notsupported_reloc (abfd,
 239                              reloc_entry,
 240                              symbol,
 241                              data,
 242                              input_section,
 243                              output_bfd,
 244                              error_message)
 245      bfd *abfd ATTRIBUTE_UNUSED;
 246      arelent *reloc_entry ATTRIBUTE_UNUSED;
 247      asymbol *symbol ATTRIBUTE_UNUSED;
 248      PTR data ATTRIBUTE_UNUSED;
 249      asection *input_section ATTRIBUTE_UNUSED;
 250      bfd *output_bfd ATTRIBUTE_UNUSED;
 251      char **error_message ATTRIBUTE_UNUSED;
 252 {
 253   return bfd_reloc_notsupported;
 254 }
 255
 256 /* Handle the WDISP16 reloc.  */
 257
 258 static bfd_reloc_status_type
 259 sparc_elf_wdisp16_reloc (abfd,
 260                          reloc_entry,
 261                          symbol,
 262                          data,
 263                          input_section,
 264                          output_bfd,
 265                          error_message)
 266      bfd *abfd;
 267      arelent *reloc_entry;
 268      asymbol *symbol;
 269      PTR data;
 270      asection *input_section;
 271      bfd *output_bfd;
 272      char **error_message ATTRIBUTE_UNUSED;
 273 {
 274   bfd_vma relocation;
 275   bfd_vma x;
 276
 277   if (output_bfd != (bfd *) NULL
 278       && (symbol->flags & BSF_SECTION_SYM) == 0
 279       && (! reloc_entry->howto->partial_inplace
 280           || reloc_entry->addend == 0))
 281     {
 282       reloc_entry->address += input_section->output_offset;
 283       return bfd_reloc_ok;
 284     }
 285
 286   if (output_bfd != NULL)
 287     return bfd_reloc_continue;
 288
 289   if (reloc_entry->address > input_section->_cooked_size)
 290     return bfd_reloc_outofrange;
 291
 292   relocation = (symbol->value
 293                 + symbol->section->output_section->vma
 294                 + symbol->section->output_offset);
 295   relocation += reloc_entry->addend;
 296   relocation -= (input_section->output_section->vma
 297                  + input_section->output_offset);
 298   relocation -= reloc_entry->address;
 299
 300   x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 301   x |= ((((relocation >> 2) & 0xc000) << 6)
 302         | ((relocation >> 2) & 0x3fff));
 303   bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
 304
 305   if ((bfd_signed_vma) relocation < - 0x40000
 306       || (bfd_signed_vma) relocation > 0x3ffff)
 307     return bfd_reloc_overflow;
 308   else
 309     return bfd_reloc_ok;
 310 }
 311 \f
 312 /* Functions for the SPARC ELF linker.  */
 313
 314 /* The name of the dynamic interpreter.  This is put in the .interp
 315    section.  */
 316
 317 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 318
 319 /* The nop opcode we use.  */
 320
 321 #define SPARC_NOP 0x01000000
 322
 323 /* The size in bytes of an entry in the procedure linkage table.  */
 324
 325 #define PLT_ENTRY_SIZE 12
 326
 327 /* The first four entries in a procedure linkage table are reserved,
 328    and the initial contents are unimportant (we zero them out).
 329    Subsequent entries look like this.  See the SVR4 ABI SPARC
 330    supplement to see how this works.  */
 331
 332 /* sethi %hi(.-.plt0),%g1.  We fill in the address later.  */
 333 #define PLT_ENTRY_WORD0 0x03000000
 334 /* b,a .plt0.  We fill in the offset later.  */
 335 #define PLT_ENTRY_WORD1 0x30800000
 336 /* nop.  */
 337 #define PLT_ENTRY_WORD2 SPARC_NOP
 338
 339 /* Look through the relocs for a section during the first phase, and
 340    allocate space in the global offset table or procedure linkage
 341    table.  */
 342
 343 static boolean
 344 elf32_sparc_check_relocs (abfd, info, sec, relocs)
 345      bfd *abfd;
 346      struct bfd_link_info *info;
 347      asection *sec;
 348      const Elf_Internal_Rela *relocs;
 349 {
 350   bfd *dynobj;
 351   Elf_Internal_Shdr *symtab_hdr;
 352   struct elf_link_hash_entry **sym_hashes;
 353   bfd_vma *local_got_offsets;
 354   const Elf_Internal_Rela *rel;
 355   const Elf_Internal_Rela *rel_end;
 356   asection *sgot;
 357   asection *srelgot;
 358   asection *sreloc;
 359
 360   if (info->relocateable)
 361     return true;
 362
 363   dynobj = elf_hash_table (info)->dynobj;
 364   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 365   sym_hashes = elf_sym_hashes (abfd);
 366   local_got_offsets = elf_local_got_offsets (abfd);
 367
 368   sgot = NULL;
 369   srelgot = NULL;
 370   sreloc = NULL;
 371
 372   rel_end = relocs + sec->reloc_count;
 373   for (rel = relocs; rel < rel_end; rel++)
 374     {
 375       unsigned long r_symndx;
 376       struct elf_link_hash_entry *h;
 377
 378       r_symndx = ELF32_R_SYM (rel->r_info);
 379       if (r_symndx < symtab_hdr->sh_info)
 380         h = NULL;
 381       else
 382         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 383
 384       switch (ELF32_R_TYPE (rel->r_info))
 385         {
 386         case R_SPARC_GOT10:
 387         case R_SPARC_GOT13:
 388         case R_SPARC_GOT22:
 389           /* This symbol requires a global offset table entry.  */
 390
 391           if (dynobj == NULL)
 392             {
 393               /* Create the .got section.  */
 394               elf_hash_table (info)->dynobj = dynobj = abfd;
 395               if (! _bfd_elf_create_got_section (dynobj, info))
 396                 return false;
 397             }
 398
 399           if (sgot == NULL)
 400             {
 401               sgot = bfd_get_section_by_name (dynobj, ".got");
 402               BFD_ASSERT (sgot != NULL);
 403             }
 404
 405           if (srelgot == NULL
 406               && (h != NULL || info->shared))
 407             {
 408               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 409               if (srelgot == NULL)
 410                 {
 411                   srelgot = bfd_make_section (dynobj, ".rela.got");
 412                   if (srelgot == NULL
 413                       || ! bfd_set_section_flags (dynobj, srelgot,
 414                                                   (SEC_ALLOC
 415                                                    | SEC_LOAD
 416                                                    | SEC_HAS_CONTENTS
 417                                                    | SEC_IN_MEMORY
 418                                                    | SEC_LINKER_CREATED
 419                                                    | SEC_READONLY))
 420                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 421                     return false;
 422                 }
 423             }
 424
 425           if (h != NULL)
 426             {
 427               if (h->got.offset != (bfd_vma) -1)
 428                 {
 429                   /* We have already allocated space in the .got.  */
 430                   break;
 431                 }
 432               h->got.offset = sgot->_raw_size;
 433
 434               /* Make sure this symbol is output as a dynamic symbol.  */
 435               if (h->dynindx == -1)
 436                 {
 437                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 438                     return false;
 439                 }
 440
 441               srelgot->_raw_size += sizeof (Elf32_External_Rela);
 442             }
 443           else
 444             {
 445               /* This is a global offset table entry for a local
 446                  symbol.  */
 447               if (local_got_offsets == NULL)
 448                 {
 449                   size_t size;
 450                   register unsigned int i;
 451
 452                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 453                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 454                   if (local_got_offsets == NULL)
 455                     return false;
 456                   elf_local_got_offsets (abfd) = local_got_offsets;
 457                   for (i = 0; i < symtab_hdr->sh_info; i++)
 458                     local_got_offsets[i] = (bfd_vma) -1;
 459                 }
 460               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 461                 {
 462                   /* We have already allocated space in the .got.  */
 463                   break;
 464                 }
 465               local_got_offsets[r_symndx] = sgot->_raw_size;
 466
 467               if (info->shared)
 468                 {
 469                   /* If we are generating a shared object, we need to
 470                      output a R_SPARC_RELATIVE reloc so that the
 471                      dynamic linker can adjust this GOT entry.  */
 472                   srelgot->_raw_size += sizeof (Elf32_External_Rela);
 473                 }
 474             }
 475
 476           sgot->_raw_size += 4;
 477
 478           /* If the .got section is more than 0x1000 bytes, we add
 479              0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
 480              bit relocations have a greater chance of working.  */
 481           if (sgot->_raw_size >= 0x1000
 482               && elf_hash_table (info)->hgot->root.u.def.value == 0)
 483             elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
 484
 485           break;
 486
 487         case R_SPARC_WPLT30:
 488           /* This symbol requires a procedure linkage table entry.  We
 489              actually build the entry in adjust_dynamic_symbol,
 490              because this might be a case of linking PIC code without
 491              linking in any dynamic objects, in which case we don't
 492              need to generate a procedure linkage table after all.  */
 493
 494           if (h == NULL)
 495             {
 496               /* The Solaris native assembler will generate a WPLT30
 497                  reloc for a local symbol if you assemble a call from
 498                  one section to another when using -K pic.  We treat
 499                  it as WDISP30.  */
 500               break;
 501             }
 502
 503           /* Make sure this symbol is output as a dynamic symbol.  */
 504           if (h->dynindx == -1)
 505             {
 506               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 507                 return false;
 508             }
 509
 510           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 511
 512           break;
 513
 514         case R_SPARC_PC10:
 515         case R_SPARC_PC22:
 516           if (h != NULL)
 517             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 518
 519           if (h != NULL
 520               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
 521             break;
 522           /* Fall through.  */
 523         case R_SPARC_DISP8:
 524         case R_SPARC_DISP16:
 525         case R_SPARC_DISP32:
 526         case R_SPARC_WDISP30:
 527         case R_SPARC_WDISP22:
 528         case R_SPARC_WDISP19:
 529         case R_SPARC_WDISP16:
 530           if (h != NULL)
 531             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 532
 533           /* If we are linking with -Bsymbolic, we do not need to copy
 534              a PC relative reloc against a global symbol which is
 535              defined in an object we are including in the link (i.e.,
 536              DEF_REGULAR is set).  FIXME: At this point we have not
 537              seen all the input files, so it is possible that
 538              DEF_REGULAR is not set now but will be set later (it is
 539              never cleared).  This needs to be handled as in
 540              elf32-i386.c.  */
 541           if (h == NULL
 542               || (info->symbolic
 543                   && (h->elf_link_hash_flags
 544                       & ELF_LINK_HASH_DEF_REGULAR) != 0))
 545             break;
 546           /* Fall through.  */
 547         case R_SPARC_8:
 548         case R_SPARC_16:
 549         case R_SPARC_32:
 550         case R_SPARC_HI22:
 551         case R_SPARC_22:
 552         case R_SPARC_13:
 553         case R_SPARC_LO10:
 554         case R_SPARC_UA32:
 555           if (h != NULL)
 556             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 557
 558           if (info->shared)
 559             {
 560               /* When creating a shared object, we must copy these
 561                  relocs into the output file.  We create a reloc
 562                  section in dynobj and make room for the reloc.  */
 563               if (sreloc == NULL)
 564                 {
 565                   const char *name;
 566
 567                   name = (bfd_elf_string_from_elf_section
 568                           (abfd,
 569                            elf_elfheader (abfd)->e_shstrndx,
 570                            elf_section_data (sec)->rel_hdr.sh_name));
 571                   if (name == NULL)
 572                     return false;
 573
 574                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
 575                               && strcmp (bfd_get_section_name (abfd, sec),
 576                                          name + 5) == 0);
 577
 578                   sreloc = bfd_get_section_by_name (dynobj, name);
 579                   if (sreloc == NULL)
 580                     {
 581                       flagword flags;
 582
 583                       sreloc = bfd_make_section (dynobj, name);
 584                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 585                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 586                       if ((sec->flags & SEC_ALLOC) != 0)
 587                         flags |= SEC_ALLOC | SEC_LOAD;
 588                       if (sreloc == NULL
 589                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 590                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 591                         return false;
 592                     }
 593                 }
 594
 595               sreloc->_raw_size += sizeof (Elf32_External_Rela);
 596             }
 597
 598           break;
 599
 600         case R_SPARC_GNU_VTINHERIT:
 601           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 602             return false;
 603           break;
 604
 605         case R_SPARC_GNU_VTENTRY:
 606           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 607             return false;
 608           break;
 609
 610         default:
 611           break;
 612         }
 613     }
 614
 615   return true;
 616 }
 617
 618 static asection *
 619 elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym)
 620        bfd *abfd;
 621        struct bfd_link_info *info ATTRIBUTE_UNUSED;
 622        Elf_Internal_Rela *rel;
 623        struct elf_link_hash_entry *h;
 624        Elf_Internal_Sym *sym;
 625 {
 626
 627   if (h != NULL)
 628     {
 629       switch (ELF32_R_TYPE (rel->r_info))
 630       {
 631       case R_SPARC_GNU_VTINHERIT:
 632       case R_SPARC_GNU_VTENTRY:
 633         break;
 634
 635       default:
 636         switch (h->root.type)
 637           {
 638           case bfd_link_hash_defined:
 639           case bfd_link_hash_defweak:
 640             return h->root.u.def.section;
 641
 642           case bfd_link_hash_common:
 643             return h->root.u.c.p->section;
 644
 645           default:
 646             break;
 647           }
 648        }
 649      }
 650    else
 651      {
 652        if (!(elf_bad_symtab (abfd)
 653            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 654          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 655                 && sym->st_shndx != SHN_COMMON))
 656           {
 657             return bfd_section_from_elf_index (abfd, sym->st_shndx);
 658           }
 659       }
 660
 661   return NULL;
 662 }
 663
 664 /* Update the got entry reference counts for the section being removed.  */
 665 static boolean
 666 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
 667      bfd *abfd;
 668      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 669      asection *sec;
 670      const Elf_Internal_Rela *relocs;
 671 {
 672
 673   Elf_Internal_Shdr *symtab_hdr;
 674   struct elf_link_hash_entry **sym_hashes;
 675   bfd_signed_vma *local_got_refcounts;
 676   const Elf_Internal_Rela *rel, *relend;
 677   unsigned long r_symndx;
 678   struct elf_link_hash_entry *h;
 679
 680   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 681   sym_hashes = elf_sym_hashes (abfd);
 682   local_got_refcounts = elf_local_got_refcounts (abfd);
 683
 684   relend = relocs + sec->reloc_count;
 685   for (rel = relocs; rel < relend; rel++)
 686     switch (ELF32_R_TYPE (rel->r_info))
 687       {
 688       case R_SPARC_GOT10:
 689       case R_SPARC_GOT13:
 690       case R_SPARC_GOT22:
 691         r_symndx = ELF32_R_SYM (rel->r_info);
 692         if (r_symndx >= symtab_hdr->sh_info)
 693           {
 694             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 695             if (h->got.refcount > 0)
 696               h->got.refcount--;
 697           }
 698         else
 699           {
 700             if (local_got_refcounts[r_symndx] > 0)
 701               local_got_refcounts[r_symndx]--;
 702           }
 703         break;
 704
 705       case R_SPARC_PLT32:
 706       case R_SPARC_HIPLT22:
 707       case R_SPARC_LOPLT10:
 708       case R_SPARC_PCPLT32:
 709       case R_SPARC_PCPLT10:
 710         r_symndx = ELF32_R_SYM (rel->r_info);
 711         if (r_symndx >= symtab_hdr->sh_info)
 712           {
 713             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 714             if (h->plt.refcount > 0)
 715               h->plt.refcount--;
 716           }
 717         break;
 718
 719       default:
 720         break;
 721       }
 722
 723   return true;
 724 }
 725
 726 /* Adjust a symbol defined by a dynamic object and referenced by a
 727    regular object.  The current definition is in some section of the
 728    dynamic object, but we're not including those sections.  We have to
 729    change the definition to something the rest of the link can
 730    understand.  */
 731
 732 static boolean
 733 elf32_sparc_adjust_dynamic_symbol (info, h)
 734      struct bfd_link_info *info;
 735      struct elf_link_hash_entry *h;
 736 {
 737   bfd *dynobj;
 738   asection *s;
 739   unsigned int power_of_two;
 740
 741   dynobj = elf_hash_table (info)->dynobj;
 742
 743   /* Make sure we know what is going on here.  */
 744   BFD_ASSERT (dynobj != NULL
 745               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 746                   || h->weakdef != NULL
 747                   || ((h->elf_link_hash_flags
 748                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 749                       && (h->elf_link_hash_flags
 750                           & ELF_LINK_HASH_REF_REGULAR) != 0
 751                       && (h->elf_link_hash_flags
 752                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 753
 754   /* If this is a function, put it in the procedure linkage table.  We
 755      will fill in the contents of the procedure linkage table later
 756      (although we could actually do it here).  The STT_NOTYPE
 757      condition is a hack specifically for the Oracle libraries
 758      delivered for Solaris; for some inexplicable reason, they define
 759      some of their functions as STT_NOTYPE when they really should be
 760      STT_FUNC.  */
 761   if (h->type == STT_FUNC
 762       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
 763       || (h->type == STT_NOTYPE
 764           && (h->root.type == bfd_link_hash_defined
 765               || h->root.type == bfd_link_hash_defweak)
 766           && (h->root.u.def.section->flags & SEC_CODE) != 0))
 767     {
 768       if (! elf_hash_table (info)->dynamic_sections_created
 769           || ((!info->shared || info->symbolic || h->dynindx == -1)
 770               && (h->elf_link_hash_flags
 771                   & ELF_LINK_HASH_DEF_REGULAR) != 0))
 772         {
 773           /* This case can occur if we saw a WPLT30 reloc in an input
 774              file, but none of the input files were dynamic objects.
 775              Or, when linking the main application or a -Bsymbolic
 776              shared library against PIC code.  Or when a global symbol
 777              has been made private, e.g. via versioning.
 778
 779              In these cases we know what value the symbol will resolve
 780              to, so we don't actually need to build a procedure linkage
 781              table, and we can just do a WDISP30 reloc instead.  */
 782
 783           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 784           return true;
 785         }
 786
 787       s = bfd_get_section_by_name (dynobj, ".plt");
 788       BFD_ASSERT (s != NULL);
 789
 790       /* The first four entries in .plt are reserved.  */
 791       if (s->_raw_size == 0)
 792         s->_raw_size = 4 * PLT_ENTRY_SIZE;
 793
 794       /* The procedure linkage table has a maximum size.  */
 795       if (s->_raw_size >= 0x400000)
 796         {
 797           bfd_set_error (bfd_error_bad_value);
 798           return false;
 799         }
 800
 801      /* If this symbol is not defined in a regular file, and we are
 802        not generating a shared library, then set the symbol to this
 803        location in the .plt.  This is required to make function
 804        pointers compare as equal between the normal executable and
 805        the shared library.  */
 806      if (! info->shared
 807         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 808       {
 809         h->root.u.def.section = s;
 810         h->root.u.def.value = s->_raw_size;
 811       }
 812
 813       h->plt.offset = s->_raw_size;
 814
 815       /* Make room for this entry.  */
 816       s->_raw_size += PLT_ENTRY_SIZE;
 817
 818       /* We also need to make an entry in the .rela.plt section.  */
 819
 820       s = bfd_get_section_by_name (dynobj, ".rela.plt");
 821       BFD_ASSERT (s != NULL);
 822       s->_raw_size += sizeof (Elf32_External_Rela);
 823
 824       return true;
 825     }
 826
 827   /* If this is a weak symbol, and there is a real definition, the
 828      processor independent code will have arranged for us to see the
 829      real definition first, and we can just use the same value.  */
 830   if (h->weakdef != NULL)
 831     {
 832       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
 833                   || h->weakdef->root.type == bfd_link_hash_defweak);
 834       h->root.u.def.section = h->weakdef->root.u.def.section;
 835       h->root.u.def.value = h->weakdef->root.u.def.value;
 836       return true;
 837     }
 838
 839   /* This is a reference to a symbol defined by a dynamic object which
 840      is not a function.  */
 841
 842   /* If we are creating a shared library, we must presume that the
 843      only references to the symbol are via the global offset table.
 844      For such cases we need not do anything here; the relocations will
 845      be handled correctly by relocate_section.  */
 846   if (info->shared)
 847     return true;
 848
 849   /* If there are no references to this symbol that do not use the
 850      GOT, we don't need to generate a copy reloc.  */
 851   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
 852     return true;
 853
 854   /* We must allocate the symbol in our .dynbss section, which will
 855      become part of the .bss section of the executable.  There will be
 856      an entry for this symbol in the .dynsym section.  The dynamic
 857      object will contain position independent code, so all references
 858      from the dynamic object to this symbol will go through the global
 859      offset table.  The dynamic linker will use the .dynsym entry to
 860      determine the address it must put in the global offset table, so
 861      both the dynamic object and the regular object will refer to the
 862      same memory location for the variable.  */
 863
 864   s = bfd_get_section_by_name (dynobj, ".dynbss");
 865   BFD_ASSERT (s != NULL);
 866
 867   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
 868      to copy the initial value out of the dynamic object and into the
 869      runtime process image.  We need to remember the offset into the
 870      .rel.bss section we are going to use.  */
 871   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
 872     {
 873       asection *srel;
 874
 875       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
 876       BFD_ASSERT (srel != NULL);
 877       srel->_raw_size += sizeof (Elf32_External_Rela);
 878       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
 879     }
 880
 881   /* We need to figure out the alignment required for this symbol.  I
 882      have no idea how ELF linkers handle this.  */
 883   power_of_two = bfd_log2 (h->size);
 884   if (power_of_two > 3)
 885     power_of_two = 3;
 886
 887   /* Apply the required alignment.  */
 888   s->_raw_size = BFD_ALIGN (s->_raw_size,
 889                             (bfd_size_type) (1 << power_of_two));
 890   if (power_of_two > bfd_get_section_alignment (dynobj, s))
 891     {
 892       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
 893         return false;
 894     }
 895
 896   /* Define the symbol as being at this point in the section.  */
 897   h->root.u.def.section = s;
 898   h->root.u.def.value = s->_raw_size;
 899
 900   /* Increment the section size to make room for the symbol.  */
 901   s->_raw_size += h->size;
 902
 903   return true;
 904 }
 905
 906 /* Set the sizes of the dynamic sections.  */
 907
 908 static boolean
 909 elf32_sparc_size_dynamic_sections (output_bfd, info)
 910      bfd *output_bfd;
 911      struct bfd_link_info *info;
 912 {
 913   bfd *dynobj;
 914   asection *s;
 915   boolean reltext;
 916   boolean relplt;
 917
 918   dynobj = elf_hash_table (info)->dynobj;
 919   BFD_ASSERT (dynobj != NULL);
 920
 921   if (elf_hash_table (info)->dynamic_sections_created)
 922     {
 923       /* Set the contents of the .interp section to the interpreter.  */
 924       if (! info->shared)
 925         {
 926           s = bfd_get_section_by_name (dynobj, ".interp");
 927           BFD_ASSERT (s != NULL);
 928           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 929           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 930         }
 931
 932       /* Make space for the trailing nop in .plt.  */
 933       s = bfd_get_section_by_name (dynobj, ".plt");
 934       BFD_ASSERT (s != NULL);
 935       if (s->_raw_size > 0)
 936         s->_raw_size += 4;
 937     }
 938   else
 939     {
 940       /* We may have created entries in the .rela.got section.
 941          However, if we are not creating the dynamic sections, we will
 942          not actually use these entries.  Reset the size of .rela.got,
 943          which will cause it to get stripped from the output file
 944          below.  */
 945       s = bfd_get_section_by_name (dynobj, ".rela.got");
 946       if (s != NULL)
 947         s->_raw_size = 0;
 948     }
 949
 950   /* The check_relocs and adjust_dynamic_symbol entry points have
 951      determined the sizes of the various dynamic sections.  Allocate
 952      memory for them.  */
 953   reltext = false;
 954   relplt = false;
 955   for (s = dynobj->sections; s != NULL; s = s->next)
 956     {
 957       const char *name;
 958       boolean strip;
 959
 960       if ((s->flags & SEC_LINKER_CREATED) == 0)
 961         continue;
 962
 963       /* It's OK to base decisions on the section name, because none
 964          of the dynobj section names depend upon the input files.  */
 965       name = bfd_get_section_name (dynobj, s);
 966
 967       strip = false;
 968
 969       if (strncmp (name, ".rela", 5) == 0)
 970         {
 971           if (s->_raw_size == 0)
 972             {
 973               /* If we don't need this section, strip it from the
 974                  output file.  This is to handle .rela.bss and
 975                  .rel.plt.  We must create it in
 976                  create_dynamic_sections, because it must be created
 977                  before the linker maps input sections to output
 978                  sections.  The linker does that before
 979                  adjust_dynamic_symbol is called, and it is that
 980                  function which decides whether anything needs to go
 981                  into these sections.  */
 982               strip = true;
 983             }
 984           else
 985             {
 986               const char *outname;
 987               asection *target;
 988
 989               /* If this relocation section applies to a read only
 990                  section, then we probably need a DT_TEXTREL entry.  */
 991               outname = bfd_get_section_name (output_bfd,
 992                                               s->output_section);
 993               target = bfd_get_section_by_name (output_bfd, outname + 5);
 994               if (target != NULL
 995                   && (target->flags & SEC_READONLY) != 0
 996                   && (target->flags & SEC_ALLOC) != 0)
 997                 reltext = true;
 998
 999               if (strcmp (name, ".rela.plt") == 0)
1000                 relplt = true;
1001
1002               /* We use the reloc_count field as a counter if we need
1003                  to copy relocs into the output file.  */
1004               s->reloc_count = 0;
1005             }
1006         }
1007       else if (strcmp (name, ".plt") != 0
1008                && strcmp (name, ".got") != 0)
1009         {
1010           /* It's not one of our sections, so don't allocate space.  */
1011           continue;
1012         }
1013
1014       if (strip)
1015         {
1016           _bfd_strip_section_from_output (info, s);
1017           continue;
1018         }
1019
1020       /* Allocate memory for the section contents.  */
1021       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1022          Unused entries should be reclaimed before the section's contents
1023          are written out, but at the moment this does not happen.  Thus in
1024          order to prevent writing out garbage, we initialise the section's
1025          contents to zero.  */
1026       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1027       if (s->contents == NULL && s->_raw_size != 0)
1028         return false;
1029     }
1030
1031   if (elf_hash_table (info)->dynamic_sections_created)
1032     {
1033       /* Add some entries to the .dynamic section.  We fill in the
1034          values later, in elf32_sparc_finish_dynamic_sections, but we
1035          must add the entries now so that we get the correct size for
1036          the .dynamic section.  The DT_DEBUG entry is filled in by the
1037          dynamic linker and used by the debugger.  */
1038       if (! info->shared)
1039         {
1040           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1041             return false;
1042         }
1043
1044       if (relplt)
1045         {
1046           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1047               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1048               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1049               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1050             return false;
1051         }
1052
1053       if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
1054           || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
1055           || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
1056                                             sizeof (Elf32_External_Rela)))
1057         return false;
1058
1059       if (reltext)
1060         {
1061           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1062             return false;
1063           info->flags |= DF_TEXTREL;
1064         }
1065     }
1066
1067   return true;
1068 }
1069
1070 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1071 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1072
1073 static boolean
1074 elf32_sparc_relax_section (abfd, section, link_info, again)
1075      bfd *abfd ATTRIBUTE_UNUSED;
1076      asection *section ATTRIBUTE_UNUSED;
1077      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1078      boolean *again;
1079 {
1080   *again = false;
1081   SET_SEC_DO_RELAX (section);
1082   return true;
1083 }
1084
1085 /* Relocate a SPARC ELF section.  */
1086
1087 static boolean
1088 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
1089                               contents, relocs, local_syms, local_sections)
1090      bfd *output_bfd;
1091      struct bfd_link_info *info;
1092      bfd *input_bfd;
1093      asection *input_section;
1094      bfd_byte *contents;
1095      Elf_Internal_Rela *relocs;
1096      Elf_Internal_Sym *local_syms;
1097      asection **local_sections;
1098 {
1099   bfd *dynobj;
1100   Elf_Internal_Shdr *symtab_hdr;
1101   struct elf_link_hash_entry **sym_hashes;
1102   bfd_vma *local_got_offsets;
1103   bfd_vma got_base;
1104   asection *sgot;
1105   asection *splt;
1106   asection *sreloc;
1107   Elf_Internal_Rela *rel;
1108   Elf_Internal_Rela *relend;
1109
1110   dynobj = elf_hash_table (info)->dynobj;
1111   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1112   sym_hashes = elf_sym_hashes (input_bfd);
1113   local_got_offsets = elf_local_got_offsets (input_bfd);
1114
1115   if (elf_hash_table (info)->hgot == NULL)
1116     got_base = 0;
1117   else
1118     got_base = elf_hash_table (info)->hgot->root.u.def.value;
1119
1120   sgot = NULL;
1121   splt = NULL;
1122   sreloc = NULL;
1123
1124   rel = relocs;
1125   relend = relocs + input_section->reloc_count;
1126   for (; rel < relend; rel++)
1127     {
1128       int r_type;
1129       reloc_howto_type *howto;
1130       unsigned long r_symndx;
1131       struct elf_link_hash_entry *h;
1132       Elf_Internal_Sym *sym;
1133       asection *sec;
1134       bfd_vma relocation;
1135       bfd_reloc_status_type r;
1136
1137       r_type = ELF32_R_TYPE (rel->r_info);
1138
1139       if (r_type == R_SPARC_GNU_VTINHERIT
1140           || r_type == R_SPARC_GNU_VTENTRY)
1141         continue;
1142
1143       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1144         {
1145           bfd_set_error (bfd_error_bad_value);
1146           return false;
1147         }
1148       howto = _bfd_sparc_elf_howto_table + r_type;
1149
1150       r_symndx = ELF32_R_SYM (rel->r_info);
1151
1152       if (info->relocateable)
1153         {
1154           /* This is a relocateable link.  We don't have to change
1155              anything, unless the reloc is against a section symbol,
1156              in which case we have to adjust according to where the
1157              section symbol winds up in the output section.  */
1158           if (r_symndx < symtab_hdr->sh_info)
1159             {
1160               sym = local_syms + r_symndx;
1161               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1162                 {
1163                   sec = local_sections[r_symndx];
1164                   rel->r_addend += sec->output_offset + sym->st_value;
1165                 }
1166             }
1167
1168           continue;
1169         }
1170
1171       /* This is a final link.  */
1172       h = NULL;
1173       sym = NULL;
1174       sec = NULL;
1175       if (r_symndx < symtab_hdr->sh_info)
1176         {
1177           sym = local_syms + r_symndx;
1178           sec = local_sections[r_symndx];
1179           relocation = (sec->output_section->vma
1180                         + sec->output_offset
1181                         + sym->st_value);
1182         }
1183       else
1184         {
1185           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1186           while (h->root.type == bfd_link_hash_indirect
1187                  || h->root.type == bfd_link_hash_warning)
1188             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1189           if (h->root.type == bfd_link_hash_defined
1190               || h->root.type == bfd_link_hash_defweak)
1191             {
1192               sec = h->root.u.def.section;
1193               if ((r_type == R_SPARC_WPLT30
1194                    && h->plt.offset != (bfd_vma) -1)
1195                   || ((r_type == R_SPARC_GOT10
1196                        || r_type == R_SPARC_GOT13
1197                        || r_type == R_SPARC_GOT22)
1198                       && elf_hash_table (info)->dynamic_sections_created
1199                       && (! info->shared
1200                           || (! info->symbolic && h->dynindx != -1)
1201                           || (h->elf_link_hash_flags
1202                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1203                   || (info->shared
1204                       && ((! info->symbolic && h->dynindx != -1)
1205                           || (h->elf_link_hash_flags
1206                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1207                       && (r_type == R_SPARC_8
1208                           || r_type == R_SPARC_16
1209                           || r_type == R_SPARC_32
1210                           || r_type == R_SPARC_DISP8
1211                           || r_type == R_SPARC_DISP16
1212                           || r_type == R_SPARC_DISP32
1213                           || r_type == R_SPARC_WDISP30
1214                           || r_type == R_SPARC_WDISP22
1215                           || r_type == R_SPARC_WDISP19
1216                           || r_type == R_SPARC_WDISP16
1217                           || r_type == R_SPARC_HI22
1218                           || r_type == R_SPARC_22
1219                           || r_type == R_SPARC_13
1220                           || r_type == R_SPARC_LO10
1221                           || r_type == R_SPARC_UA32
1222                           || ((r_type == R_SPARC_PC10
1223                                || r_type == R_SPARC_PC22)
1224                               && strcmp (h->root.root.string,
1225                                          "_GLOBAL_OFFSET_TABLE_") != 0))))
1226                 {
1227                   /* In these cases, we don't need the relocation
1228                      value.  We check specially because in some
1229                      obscure cases sec->output_section will be NULL.  */
1230                   relocation = 0;
1231                 }
1232               else
1233                 relocation = (h->root.u.def.value
1234                               + sec->output_section->vma
1235                               + sec->output_offset);
1236             }
1237           else if (h->root.type == bfd_link_hash_undefweak)
1238             relocation = 0;
1239           else if (info->shared && !info->symbolic
1240                    && !info->no_undefined
1241                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1242             relocation = 0;
1243           else
1244             {
1245               if (! ((*info->callbacks->undefined_symbol)
1246                      (info, h->root.root.string, input_bfd,
1247                       input_section, rel->r_offset,
1248                       (!info->shared || info->no_undefined
1249                        || ELF_ST_VISIBILITY (h->other)))))
1250                 return false;
1251               relocation = 0;
1252             }
1253         }
1254
1255       switch (r_type)
1256         {
1257         case R_SPARC_GOT10:
1258         case R_SPARC_GOT13:
1259         case R_SPARC_GOT22:
1260           /* Relocation is to the entry for this symbol in the global
1261              offset table.  */
1262           if (sgot == NULL)
1263             {
1264               sgot = bfd_get_section_by_name (dynobj, ".got");
1265               BFD_ASSERT (sgot != NULL);
1266             }
1267
1268           if (h != NULL)
1269             {
1270               bfd_vma off;
1271
1272               off = h->got.offset;
1273               BFD_ASSERT (off != (bfd_vma) -1);
1274
1275               if (! elf_hash_table (info)->dynamic_sections_created
1276                   || (info->shared
1277                       && (info->symbolic || h->dynindx == -1)
1278                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1279                 {
1280                   /* This is actually a static link, or it is a
1281                      -Bsymbolic link and the symbol is defined
1282                      locally, or the symbol was forced to be local
1283                      because of a version file.  We must initialize
1284                      this entry in the global offset table.  Since the
1285                      offset must always be a multiple of 4, we use the
1286                      least significant bit to record whether we have
1287                      initialized it already.
1288
1289                      When doing a dynamic link, we create a .rela.got
1290                      relocation entry to initialize the value.  This
1291                      is done in the finish_dynamic_symbol routine.  */
1292                   if ((off & 1) != 0)
1293                     off &= ~1;
1294                   else
1295                     {
1296                       bfd_put_32 (output_bfd, relocation,
1297                                   sgot->contents + off);
1298                       h->got.offset |= 1;
1299                     }
1300                 }
1301
1302               relocation = sgot->output_offset + off - got_base;
1303             }
1304           else
1305             {
1306               bfd_vma off;
1307
1308               BFD_ASSERT (local_got_offsets != NULL
1309                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
1310
1311               off = local_got_offsets[r_symndx];
1312
1313               /* The offset must always be a multiple of 4.  We use
1314                  the least significant bit to record whether we have
1315                  already processed this entry.  */
1316               if ((off & 1) != 0)
1317                 off &= ~1;
1318               else
1319                 {
1320                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1321
1322                   if (info->shared)
1323                     {
1324                       asection *srelgot;
1325                       Elf_Internal_Rela outrel;
1326
1327                       /* We need to generate a R_SPARC_RELATIVE reloc
1328                          for the dynamic linker.  */
1329                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1330                       BFD_ASSERT (srelgot != NULL);
1331
1332                       outrel.r_offset = (sgot->output_section->vma
1333                                          + sgot->output_offset
1334                                          + off);
1335                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1336                       outrel.r_addend = 0;
1337                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1338                                                  (((Elf32_External_Rela *)
1339                                                    srelgot->contents)
1340                                                   + srelgot->reloc_count));
1341                       ++srelgot->reloc_count;
1342                     }
1343
1344                   local_got_offsets[r_symndx] |= 1;
1345                 }
1346
1347               relocation = sgot->output_offset + off - got_base;
1348             }
1349
1350           break;
1351
1352         case R_SPARC_WPLT30:
1353           /* Relocation is to the entry for this symbol in the
1354              procedure linkage table.  */
1355
1356           /* The Solaris native assembler will generate a WPLT30 reloc
1357              for a local symbol if you assemble a call from one
1358              section to another when using -K pic.  We treat it as
1359              WDISP30.  */
1360           if (h == NULL)
1361             break;
1362
1363           if (h->plt.offset == (bfd_vma) -1)
1364             {
1365               /* We didn't make a PLT entry for this symbol.  This
1366                  happens when statically linking PIC code, or when
1367                  using -Bsymbolic.  */
1368               break;
1369             }
1370
1371           if (splt == NULL)
1372             {
1373               splt = bfd_get_section_by_name (dynobj, ".plt");
1374               BFD_ASSERT (splt != NULL);
1375             }
1376
1377           relocation = (splt->output_section->vma
1378                         + splt->output_offset
1379                         + h->plt.offset);
1380           break;
1381
1382         case R_SPARC_PC10:
1383         case R_SPARC_PC22:
1384           if (h != NULL
1385               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1386             break;
1387           /* Fall through.  */
1388         case R_SPARC_DISP8:
1389         case R_SPARC_DISP16:
1390         case R_SPARC_DISP32:
1391         case R_SPARC_WDISP30:
1392         case R_SPARC_WDISP22:
1393         case R_SPARC_WDISP19:
1394         case R_SPARC_WDISP16:
1395           if (h == NULL
1396               || (info->symbolic
1397                   && (h->elf_link_hash_flags
1398                       & ELF_LINK_HASH_DEF_REGULAR) != 0))
1399             break;
1400           /* Fall through.  */
1401         case R_SPARC_8:
1402         case R_SPARC_16:
1403         case R_SPARC_32:
1404         case R_SPARC_HI22:
1405         case R_SPARC_22:
1406         case R_SPARC_13:
1407         case R_SPARC_LO10:
1408         case R_SPARC_UA32:
1409           if (info->shared)
1410             {
1411               Elf_Internal_Rela outrel;
1412               boolean skip;
1413
1414               /* When generating a shared object, these relocations
1415                  are copied into the output file to be resolved at run
1416                  time.  */
1417
1418               if (sreloc == NULL)
1419                 {
1420                   const char *name;
1421
1422                   name = (bfd_elf_string_from_elf_section
1423                           (input_bfd,
1424                            elf_elfheader (input_bfd)->e_shstrndx,
1425                            elf_section_data (input_section)->rel_hdr.sh_name));
1426                   if (name == NULL)
1427                     return false;
1428
1429                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1430                               && strcmp (bfd_get_section_name (input_bfd,
1431                                                                input_section),
1432                                          name + 5) == 0);
1433
1434                   sreloc = bfd_get_section_by_name (dynobj, name);
1435                   BFD_ASSERT (sreloc != NULL);
1436                 }
1437
1438               skip = false;
1439
1440               if (elf_section_data (input_section)->stab_info == NULL)
1441                 outrel.r_offset = rel->r_offset;
1442               else
1443                 {
1444                   bfd_vma off;
1445
1446                   off = (_bfd_stab_section_offset
1447                          (output_bfd, &elf_hash_table (info)->stab_info,
1448                           input_section,
1449                           &elf_section_data (input_section)->stab_info,
1450                           rel->r_offset));
1451                   if (off == (bfd_vma) -1)
1452                     skip = true;
1453                   outrel.r_offset = off;
1454                 }
1455
1456               outrel.r_offset += (input_section->output_section->vma
1457                                   + input_section->output_offset);
1458
1459               if (skip)
1460                 memset (&outrel, 0, sizeof outrel);
1461               /* h->dynindx may be -1 if the symbol was marked to
1462                  become local.  */
1463               else if (h != NULL
1464                        && ((! info->symbolic && h->dynindx != -1)
1465                            || (h->elf_link_hash_flags
1466                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1467                 {
1468                   BFD_ASSERT (h->dynindx != -1);
1469                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1470                   outrel.r_addend = rel->r_addend;
1471                 }
1472               else
1473                 {
1474                   if (r_type == R_SPARC_32)
1475                     {
1476                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1477                       outrel.r_addend = relocation + rel->r_addend;
1478                     }
1479                   else
1480                     {
1481                       long indx;
1482
1483                       if (h == NULL)
1484                         sec = local_sections[r_symndx];
1485                       else
1486                         {
1487                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1488                                       || (h->root.type
1489                                           == bfd_link_hash_defweak));
1490                           sec = h->root.u.def.section;
1491                         }
1492                       if (sec != NULL && bfd_is_abs_section (sec))
1493                         indx = 0;
1494                       else if (sec == NULL || sec->owner == NULL)
1495                         {
1496                           bfd_set_error (bfd_error_bad_value);
1497                           return false;
1498                         }
1499                       else
1500                         {
1501                           asection *osec;
1502
1503                           osec = sec->output_section;
1504                           indx = elf_section_data (osec)->dynindx;
1505
1506                           /* FIXME: we really should be able to link non-pic
1507                              shared libraries.  */
1508                           if (indx == 0)
1509                             {
1510                               BFD_FAIL ();
1511                               (*_bfd_error_handler)
1512                                 (_("%s: probably compiled without -fPIC?"),
1513                                  bfd_get_filename (input_bfd));
1514                               bfd_set_error (bfd_error_bad_value);
1515                               return false;
1516                             }
1517                         }
1518
1519                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1520                       outrel.r_addend = relocation + rel->r_addend;
1521                     }
1522                 }
1523
1524               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1525                                          (((Elf32_External_Rela *)
1526                                            sreloc->contents)
1527                                           + sreloc->reloc_count));
1528               ++sreloc->reloc_count;
1529
1530               /* This reloc will be computed at runtime, so there's no
1531                  need to do anything now, unless this is a RELATIVE
1532                  reloc in an unallocated section.  */
1533               if (skip
1534                   || (input_section->flags & SEC_ALLOC) != 0
1535                   || ELF32_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE)
1536                 continue;
1537             }
1538           break;
1539
1540         default:
1541           break;
1542         }
1543
1544       r = bfd_reloc_continue;
1545       if (r_type == R_SPARC_WDISP16)
1546         {
1547           bfd_vma x;
1548
1549           relocation += rel->r_addend;
1550           relocation -= (input_section->output_section->vma
1551                          + input_section->output_offset);
1552           relocation -= rel->r_offset;
1553
1554           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1555           x |= ((((relocation >> 2) & 0xc000) << 6)
1556                 | ((relocation >> 2) & 0x3fff));
1557           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1558
1559           if ((bfd_signed_vma) relocation < - 0x40000
1560               || (bfd_signed_vma) relocation > 0x3ffff)
1561             r = bfd_reloc_overflow;
1562           else
1563             r = bfd_reloc_ok;
1564         }
1565       else if (r_type == R_SPARC_REV32)
1566         {
1567           bfd_vma x;
1568
1569           relocation = relocation + rel->r_addend;
1570
1571           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1572           x = x + relocation;
1573           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
1574           r = bfd_reloc_ok;
1575         }
1576       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
1577                && SEC_DO_RELAX (input_section)
1578                && rel->r_offset + 4 < input_section->_raw_size)
1579         {
1580 #define G0              0
1581 #define O7              15
1582 #define XCC             (2 << 20)
1583 #define COND(x)         (((x)&0xf)<<25)
1584 #define CONDA           COND(0x8)
1585 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
1586 #define INSN_BA         (F2(0,2) | CONDA)
1587 #define INSN_OR         F3(2, 0x2, 0)
1588 #define INSN_NOP        F2(0,4)
1589
1590           bfd_vma x, y;
1591
1592           /* If the instruction is a call with either:
1593              restore
1594              arithmetic instruction with rd == %o7
1595              where rs1 != %o7 and rs2 if it is register != %o7
1596              then we can optimize if the call destination is near
1597              by changing the call into a branch always.  */
1598           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1599           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
1600           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
1601             {
1602               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
1603                    || ((y & OP3(0x28)) == 0 /* arithmetic */
1604                        && (y & RD(~0)) == RD(O7)))
1605                   && (y & RS1(~0)) != RS1(O7)
1606                   && ((y & F3I(~0))
1607                       || (y & RS2(~0)) != RS2(O7)))
1608                 {
1609                   bfd_vma reloc;
1610
1611                   reloc = relocation + rel->r_addend - rel->r_offset;
1612                   reloc -= (input_section->output_section->vma
1613                            + input_section->output_offset);
1614
1615                   /* Ensure the reloc fits into simm22.  */
1616                   if ((reloc & 3) == 0
1617                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
1618                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
1619                     {
1620                       reloc >>= 2;
1621
1622                       /* Check whether it fits into simm19 on v9.  */
1623                       if (((reloc & 0x3c0000) == 0
1624                            || (reloc & 0x3c0000) == 0x3c0000)
1625                           && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
1626                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
1627                       else
1628                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
1629                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1630                       r = bfd_reloc_ok;
1631                       if (rel->r_offset >= 4
1632                           && (y & (0xffffffff ^ RS1(~0)))
1633                               == (INSN_OR | RD(O7) | RS2(G0)))
1634                         {
1635                           bfd_vma z;
1636                           unsigned int reg;
1637
1638                           z = bfd_get_32 (input_bfd,
1639                                           contents + rel->r_offset - 4);
1640                           if ((z & (0xffffffff ^ RD(~0)))
1641                               != (INSN_OR | RS1(O7) | RS2(G0)))
1642                             break;
1643
1644                           /* The sequence was
1645                              or %o7, %g0, %rN
1646                              call foo
1647                              or %rN, %g0, %o7
1648
1649                              If call foo was replaced with ba, replace
1650                              or %rN, %g0, %o7 with nop.  */
1651
1652                           reg = (y & RS1(~0)) >> 14;
1653                           if (reg != ((z & RD(~0)) >> 25)
1654                               || reg == G0 || reg == O7)
1655                             break;
1656
1657                           bfd_put_32 (input_bfd, INSN_NOP,
1658                                       contents + rel->r_offset + 4);
1659                         }
1660
1661                     }
1662                 }
1663             }
1664         }
1665
1666       if (r == bfd_reloc_continue)
1667         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1668                                       contents, rel->r_offset,
1669                                       relocation, rel->r_addend);
1670
1671       if (r != bfd_reloc_ok)
1672         {
1673           switch (r)
1674             {
1675             default:
1676             case bfd_reloc_outofrange:
1677               abort ();
1678             case bfd_reloc_overflow:
1679               {
1680                 const char *name;
1681
1682                 if (h != NULL)
1683                   name = h->root.root.string;
1684                 else
1685                   {
1686                     name = bfd_elf_string_from_elf_section (input_bfd,
1687                                                             symtab_hdr->sh_link,
1688                                                             sym->st_name);
1689                     if (name == NULL)
1690                       return false;
1691                     if (*name == '\0')
1692                       name = bfd_section_name (input_bfd, sec);
1693                   }
1694                 if (! ((*info->callbacks->reloc_overflow)
1695                        (info, name, howto->name, (bfd_vma) 0,
1696                         input_bfd, input_section, rel->r_offset)))
1697                   return false;
1698               }
1699               break;
1700             }
1701         }
1702     }
1703
1704   return true;
1705 }
1706
1707 /* Finish up dynamic symbol handling.  We set the contents of various
1708    dynamic sections here.  */
1709
1710 static boolean
1711 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1712      bfd *output_bfd;
1713      struct bfd_link_info *info;
1714      struct elf_link_hash_entry *h;
1715      Elf_Internal_Sym *sym;
1716 {
1717   bfd *dynobj;
1718
1719   dynobj = elf_hash_table (info)->dynobj;
1720
1721   if (h->plt.offset != (bfd_vma) -1)
1722     {
1723       asection *splt;
1724       asection *srela;
1725       Elf_Internal_Rela rela;
1726
1727       /* This symbol has an entry in the procedure linkage table.  Set
1728          it up.  */
1729
1730       BFD_ASSERT (h->dynindx != -1);
1731
1732       splt = bfd_get_section_by_name (dynobj, ".plt");
1733       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1734       BFD_ASSERT (splt != NULL && srela != NULL);
1735
1736       /* Fill in the entry in the procedure linkage table.  */
1737       bfd_put_32 (output_bfd,
1738                   PLT_ENTRY_WORD0 + h->plt.offset,
1739                   splt->contents + h->plt.offset);
1740       bfd_put_32 (output_bfd,
1741                   (PLT_ENTRY_WORD1
1742                    + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
1743                   splt->contents + h->plt.offset + 4);
1744       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
1745                   splt->contents + h->plt.offset + 8);
1746
1747       /* Fill in the entry in the .rela.plt section.  */
1748       rela.r_offset = (splt->output_section->vma
1749                        + splt->output_offset
1750                        + h->plt.offset);
1751       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1752       rela.r_addend = 0;
1753       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1754                                  ((Elf32_External_Rela *) srela->contents
1755                                   + h->plt.offset / PLT_ENTRY_SIZE - 4));
1756
1757       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1758         {
1759           /* Mark the symbol as undefined, rather than as defined in
1760              the .plt section.  Leave the value alone.  */
1761           sym->st_shndx = SHN_UNDEF;
1762         }
1763     }
1764
1765   if (h->got.offset != (bfd_vma) -1)
1766     {
1767       asection *sgot;
1768       asection *srela;
1769       Elf_Internal_Rela rela;
1770
1771       /* This symbol has an entry in the global offset table.  Set it
1772          up.  */
1773
1774       sgot = bfd_get_section_by_name (dynobj, ".got");
1775       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1776       BFD_ASSERT (sgot != NULL && srela != NULL);
1777
1778       rela.r_offset = (sgot->output_section->vma
1779                        + sgot->output_offset
1780                        + (h->got.offset &~ 1));
1781
1782       /* If this is a -Bsymbolic link, and the symbol is defined
1783          locally, we just want to emit a RELATIVE reloc.  Likewise if
1784          the symbol was forced to be local because of a version file.
1785          The entry in the global offset table will already have been
1786          initialized in the relocate_section function.  */
1787       if (info->shared
1788           && (info->symbolic || h->dynindx == -1)
1789           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1790         rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1791       else
1792         {
1793           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1794           rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1795         }
1796
1797       rela.r_addend = 0;
1798       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1799                                  ((Elf32_External_Rela *) srela->contents
1800                                   + srela->reloc_count));
1801       ++srela->reloc_count;
1802     }
1803
1804   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1805     {
1806       asection *s;
1807       Elf_Internal_Rela rela;
1808
1809       /* This symbols needs a copy reloc.  Set it up.  */
1810
1811       BFD_ASSERT (h->dynindx != -1);
1812
1813       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1814                                    ".rela.bss");
1815       BFD_ASSERT (s != NULL);
1816
1817       rela.r_offset = (h->root.u.def.value
1818                        + h->root.u.def.section->output_section->vma
1819                        + h->root.u.def.section->output_offset);
1820       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1821       rela.r_addend = 0;
1822       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1823                                  ((Elf32_External_Rela *) s->contents
1824                                   + s->reloc_count));
1825       ++s->reloc_count;
1826     }
1827
1828   /* Mark some specially defined symbols as absolute.  */
1829   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1830       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1831       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1832     sym->st_shndx = SHN_ABS;
1833
1834   return true;
1835 }
1836
1837 /* Finish up the dynamic sections.  */
1838
1839 static boolean
1840 elf32_sparc_finish_dynamic_sections (output_bfd, info)
1841      bfd *output_bfd;
1842      struct bfd_link_info *info;
1843 {
1844   bfd *dynobj;
1845   asection *sdyn;
1846   asection *sgot;
1847
1848   dynobj = elf_hash_table (info)->dynobj;
1849
1850   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1851
1852   if (elf_hash_table (info)->dynamic_sections_created)
1853     {
1854       asection *splt;
1855       Elf32_External_Dyn *dyncon, *dynconend;
1856
1857       splt = bfd_get_section_by_name (dynobj, ".plt");
1858       BFD_ASSERT (splt != NULL && sdyn != NULL);
1859
1860       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1861       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1862       for (; dyncon < dynconend; dyncon++)
1863         {
1864           Elf_Internal_Dyn dyn;
1865           const char *name;
1866           boolean size;
1867
1868           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1869
1870           switch (dyn.d_tag)
1871             {
1872             case DT_PLTGOT:   name = ".plt"; size = false; break;
1873             case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1874             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
1875             default:      name = NULL; size = false; break;
1876             }
1877
1878           if (name != NULL)
1879             {
1880               asection *s;
1881
1882               s = bfd_get_section_by_name (output_bfd, name);
1883               if (s == NULL)
1884                 dyn.d_un.d_val = 0;
1885               else
1886                 {
1887                   if (! size)
1888                     dyn.d_un.d_ptr = s->vma;
1889                   else
1890                     {
1891                       if (s->_cooked_size != 0)
1892                         dyn.d_un.d_val = s->_cooked_size;
1893                       else
1894                         dyn.d_un.d_val = s->_raw_size;
1895                     }
1896                 }
1897               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1898             }
1899         }
1900
1901       /* Clear the first four entries in the procedure linkage table,
1902          and put a nop in the last four bytes.  */
1903       if (splt->_raw_size > 0)
1904         {
1905           memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1906           bfd_put_32 (output_bfd, SPARC_NOP,
1907                       splt->contents + splt->_raw_size - 4);
1908         }
1909
1910       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1911         PLT_ENTRY_SIZE;
1912     }
1913
1914   /* Set the first entry in the global offset table to the address of
1915      the dynamic section.  */
1916   sgot = bfd_get_section_by_name (dynobj, ".got");
1917   BFD_ASSERT (sgot != NULL);
1918   if (sgot->_raw_size > 0)
1919     {
1920       if (sdyn == NULL)
1921         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1922       else
1923         bfd_put_32 (output_bfd,
1924                     sdyn->output_section->vma + sdyn->output_offset,
1925                     sgot->contents);
1926     }
1927
1928   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1929
1930   return true;
1931 }
1932 \f
1933 /* Functions for dealing with the e_flags field.
1934
1935    We don't define set_private_flags or copy_private_bfd_data because
1936    the only currently defined values are based on the bfd mach number,
1937    so we use the latter instead and defer setting e_flags until the
1938    file is written out.  */
1939
1940 /* Merge backend specific data from an object file to the output
1941    object file when linking.  */
1942
1943 static boolean
1944 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1945      bfd *ibfd;
1946      bfd *obfd;
1947 {
1948   boolean error;
1949   /* FIXME: This should not be static.  */
1950   static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
1951
1952   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1953       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1954     return true;
1955
1956   error = false;
1957
1958   if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1959     {
1960       error = true;
1961       (*_bfd_error_handler)
1962         (_("%s: compiled for a 64 bit system and target is 32 bit"),
1963          bfd_get_filename (ibfd));
1964     }
1965   else if ((ibfd->flags & DYNAMIC) == 0)
1966     {
1967       if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1968         bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1969     }
1970
1971   if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
1972        != previous_ibfd_e_flags)
1973       && previous_ibfd_e_flags != (unsigned long) -1)
1974     {
1975       (*_bfd_error_handler)
1976         (_("%s: linking little endian files with big endian files"),
1977          bfd_get_filename (ibfd));
1978       error = true;
1979     }
1980   previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
1981
1982   if (error)
1983     {
1984       bfd_set_error (bfd_error_bad_value);
1985       return false;
1986     }
1987
1988   return true;
1989 }
1990 \f
1991 /* Set the right machine number.  */
1992
1993 static boolean
1994 elf32_sparc_object_p (abfd)
1995      bfd *abfd;
1996 {
1997   if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
1998     {
1999       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
2000         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2001                                           bfd_mach_sparc_v8plusb);
2002       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2003         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2004                                           bfd_mach_sparc_v8plusa);
2005       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
2006         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2007                                           bfd_mach_sparc_v8plus);
2008       else
2009         return false;
2010     }
2011   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
2012     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2013                                       bfd_mach_sparc_sparclite_le);
2014   else
2015     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
2016 }
2017
2018 /* The final processing done just before writing out the object file.
2019    We need to set the e_machine field appropriately.  */
2020
2021 static void
2022 elf32_sparc_final_write_processing (abfd, linker)
2023      bfd *abfd;
2024      boolean linker ATTRIBUTE_UNUSED;
2025 {
2026   switch (bfd_get_mach (abfd))
2027     {
2028     case bfd_mach_sparc :
2029       break; /* nothing to do */
2030     case bfd_mach_sparc_v8plus :
2031       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2032       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2033       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
2034       break;
2035     case bfd_mach_sparc_v8plusa :
2036       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2037       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2038       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
2039       break;
2040     case bfd_mach_sparc_v8plusb :
2041       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2042       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2043       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
2044                                        | EF_SPARC_SUN_US3;
2045       break;
2046     case bfd_mach_sparc_sparclite_le :
2047       elf_elfheader (abfd)->e_machine = EM_SPARC;
2048       elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
2049       break;
2050     default :
2051       abort ();
2052       break;
2053     }
2054 }
2055 \f
2056 #define TARGET_BIG_SYM  bfd_elf32_sparc_vec
2057 #define TARGET_BIG_NAME "elf32-sparc"
2058 #define ELF_ARCH        bfd_arch_sparc
2059 #define ELF_MACHINE_CODE EM_SPARC
2060 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2061 #define ELF_MAXPAGESIZE 0x10000
2062
2063 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2064 #define bfd_elf32_bfd_relax_section     elf32_sparc_relax_section
2065 #define elf_info_to_howto               elf32_sparc_info_to_howto
2066 #define elf_backend_create_dynamic_sections \
2067                                         _bfd_elf_create_dynamic_sections
2068 #define elf_backend_check_relocs        elf32_sparc_check_relocs
2069 #define elf_backend_adjust_dynamic_symbol \
2070                                         elf32_sparc_adjust_dynamic_symbol
2071 #define elf_backend_size_dynamic_sections \
2072                                         elf32_sparc_size_dynamic_sections
2073 #define elf_backend_relocate_section    elf32_sparc_relocate_section
2074 #define elf_backend_finish_dynamic_symbol \
2075                                         elf32_sparc_finish_dynamic_symbol
2076 #define elf_backend_finish_dynamic_sections \
2077                                         elf32_sparc_finish_dynamic_sections
2078 #define bfd_elf32_bfd_merge_private_bfd_data \
2079                                         elf32_sparc_merge_private_bfd_data
2080 #define elf_backend_object_p            elf32_sparc_object_p
2081 #define elf_backend_final_write_processing \
2082                                         elf32_sparc_final_write_processing
2083 #define elf_backend_gc_mark_hook        elf32_sparc_gc_mark_hook
2084 #define elf_backend_gc_sweep_hook       elf32_sparc_gc_sweep_hook
2085
2086 #define elf_backend_can_gc_sections 1
2087 #define elf_backend_want_got_plt 0
2088 #define elf_backend_plt_readonly 0
2089 #define elf_backend_want_plt_sym 1
2090 #define elf_backend_got_header_size 4
2091 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2092
2093 #include "elf32-target.h"