bfd/elf32-sparc.c

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