bfd/elf32-sparc.c

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