bfd/elf32-sparc.c

   1 /* SPARC-specific support for 32-bit ELF
   2    Copyright (C) 1993, 1994, 1995, 1996 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 elf_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_DAT",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 elf_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_READONLY))
 398                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 399                     return false;
 400                 }
 401             }
 402
 403           if (h != NULL)
 404             {
 405               if (h->got_offset != (bfd_vma) -1)
 406                 {
 407                   /* We have already allocated space in the .got.  */
 408                   break;
 409                 }
 410               h->got_offset = sgot->_raw_size;
 411
 412               /* Make sure this symbol is output as a dynamic symbol.  */
 413               if (h->dynindx == -1)
 414                 {
 415                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 416                     return false;
 417                 }
 418
 419               srelgot->_raw_size += sizeof (Elf32_External_Rela);
 420             }
 421           else
 422             {
 423               /* This is a global offset table entry for a local
 424                  symbol.  */
 425               if (local_got_offsets == NULL)
 426                 {
 427                   size_t size;
 428                   register unsigned int i;
 429
 430                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 431                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 432                   if (local_got_offsets == NULL)
 433                     return false;
 434                   elf_local_got_offsets (abfd) = local_got_offsets;
 435                   for (i = 0; i < symtab_hdr->sh_info; i++)
 436                     local_got_offsets[i] = (bfd_vma) -1;
 437                 }
 438               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 439                 {
 440                   /* We have already allocated space in the .got.  */
 441                   break;
 442                 }
 443               local_got_offsets[r_symndx] = sgot->_raw_size;
 444
 445               if (info->shared)
 446                 {
 447                   /* If we are generating a shared object, we need to
 448                      output a R_SPARC_RELATIVE reloc so that the
 449                      dynamic linker can adjust this GOT entry.  */
 450                   srelgot->_raw_size += sizeof (Elf32_External_Rela);
 451                 }
 452             }
 453
 454           sgot->_raw_size += 4;
 455
 456           /* If the .got section is more than 0x1000 bytes, we add
 457              0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
 458              bit relocations have a greater chance of working.  */
 459           if (sgot->_raw_size >= 0x1000
 460               && elf_hash_table (info)->hgot->root.u.def.value == 0)
 461             elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
 462
 463           break;
 464
 465         case R_SPARC_WPLT30:
 466           /* This symbol requires a procedure linkage table entry.  We
 467              actually build the entry in adjust_dynamic_symbol,
 468              because this might be a case of linking PIC code without
 469              linking in any dynamic objects, in which case we don't
 470              need to generate a procedure linkage table after all.  */
 471
 472           if (h == NULL)
 473             {
 474               /* It does not make sense to have a procedure linkage
 475                  table entry for a local symbol.  */
 476               bfd_set_error (bfd_error_bad_value);
 477               return false;
 478             }
 479
 480           /* Make sure this symbol is output as a dynamic symbol.  */
 481           if (h->dynindx == -1)
 482             {
 483               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 484                 return false;
 485             }
 486
 487           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 488
 489           break;
 490
 491         case R_SPARC_PC10:
 492         case R_SPARC_PC22:
 493           if (h != NULL
 494               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
 495             break;
 496           /* Fall through.  */
 497         case R_SPARC_DISP8:
 498         case R_SPARC_DISP16:
 499         case R_SPARC_DISP32:
 500         case R_SPARC_WDISP30:
 501         case R_SPARC_WDISP22:
 502         case R_SPARC_WDISP19:
 503         case R_SPARC_WDISP16:
 504           if (h == NULL)
 505             break;
 506           /* Fall through.  */
 507         case R_SPARC_8:
 508         case R_SPARC_16:
 509         case R_SPARC_32:
 510         case R_SPARC_HI22:
 511         case R_SPARC_22:
 512         case R_SPARC_13:
 513         case R_SPARC_LO10:
 514         case R_SPARC_UA32:
 515           if (info->shared
 516               && (sec->flags & SEC_ALLOC) != 0)
 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                       sreloc = bfd_make_section (dynobj, name);
 540                       if (sreloc == NULL
 541                           || ! bfd_set_section_flags (dynobj, sreloc,
 542                                                       (SEC_ALLOC
 543                                                        | SEC_LOAD
 544                                                        | SEC_HAS_CONTENTS
 545                                                        | SEC_IN_MEMORY
 546                                                        | SEC_READONLY))
 547                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 548                         return false;
 549                     }
 550                 }
 551
 552               sreloc->_raw_size += sizeof (Elf32_External_Rela);
 553             }
 554
 555           break;
 556
 557         default:
 558           break;
 559         }
 560     }
 561
 562   return true;
 563 }
 564
 565 /* Adjust a symbol defined by a dynamic object and referenced by a
 566    regular object.  The current definition is in some section of the
 567    dynamic object, but we're not including those sections.  We have to
 568    change the definition to something the rest of the link can
 569    understand.  */
 570
 571 static boolean
 572 elf32_sparc_adjust_dynamic_symbol (info, h)
 573      struct bfd_link_info *info;
 574      struct elf_link_hash_entry *h;
 575 {
 576   bfd *dynobj;
 577   asection *s;
 578   unsigned int power_of_two;
 579
 580   dynobj = elf_hash_table (info)->dynobj;
 581
 582   /* Make sure we know what is going on here.  */
 583   BFD_ASSERT (dynobj != NULL
 584               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 585                   || h->weakdef != NULL
 586                   || ((h->elf_link_hash_flags
 587                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 588                       && (h->elf_link_hash_flags
 589                           & ELF_LINK_HASH_REF_REGULAR) != 0
 590                       && (h->elf_link_hash_flags
 591                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 592
 593   /* If this is a function, put it in the procedure linkage table.  We
 594      will fill in the contents of the procedure linkage table later
 595      (although we could actually do it here).  */
 596   if (h->type == STT_FUNC
 597       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 598     {
 599       if (! elf_hash_table (info)->dynamic_sections_created)
 600         {
 601           /* This case can occur if we saw a WPLT30 reloc in an input
 602              file, but none of the input files were dynamic objects.
 603              In such a case, we don't actually need to build a
 604              procedure linkage table, and we can just do a WDISP30
 605              reloc instead.  */
 606           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
 607           return true;
 608         }
 609
 610       s = bfd_get_section_by_name (dynobj, ".plt");
 611       BFD_ASSERT (s != NULL);
 612
 613       /* The first four entries in .plt are reserved.  */
 614       if (s->_raw_size == 0)
 615         s->_raw_size = 4 * PLT_ENTRY_SIZE;
 616
 617       /* The procedure linkage table has a maximum size.  */
 618       if (s->_raw_size >= 0x400000)
 619         {
 620           bfd_set_error (bfd_error_bad_value);
 621           return false;
 622         }
 623
 624       /* If this symbol is not defined in a regular file, and we are
 625          not generating a shared library, then set the symbol to this
 626          location in the .plt.  This is required to make function
 627          pointers compare as equal between the normal executable and
 628          the shared library.  */
 629       if (! info->shared
 630           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 631         {
 632           h->root.u.def.section = s;
 633           h->root.u.def.value = s->_raw_size;
 634         }
 635
 636       h->plt_offset = s->_raw_size;
 637
 638       /* Make room for this entry.  */
 639       s->_raw_size += PLT_ENTRY_SIZE;
 640
 641       /* We also need to make an entry in the .rela.plt section.  */
 642
 643       s = bfd_get_section_by_name (dynobj, ".rela.plt");
 644       BFD_ASSERT (s != NULL);
 645       s->_raw_size += sizeof (Elf32_External_Rela);
 646
 647       return true;
 648     }
 649
 650   /* If this is a weak symbol, and there is a real definition, the
 651      processor independent code will have arranged for us to see the
 652      real definition first, and we can just use the same value.  */
 653   if (h->weakdef != NULL)
 654     {
 655       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
 656                   || h->weakdef->root.type == bfd_link_hash_defweak);
 657       h->root.u.def.section = h->weakdef->root.u.def.section;
 658       h->root.u.def.value = h->weakdef->root.u.def.value;
 659       return true;
 660     }
 661
 662   /* This is a reference to a symbol defined by a dynamic object which
 663      is not a function.  */
 664
 665   /* If we are creating a shared library, we must presume that the
 666      only references to the symbol are via the global offset table.
 667      For such cases we need not do anything here; the relocations will
 668      be handled correctly by relocate_section.  */
 669   if (info->shared)
 670     return true;
 671
 672   /* We must allocate the symbol in our .dynbss section, which will
 673      become part of the .bss section of the executable.  There will be
 674      an entry for this symbol in the .dynsym section.  The dynamic
 675      object will contain position independent code, so all references
 676      from the dynamic object to this symbol will go through the global
 677      offset table.  The dynamic linker will use the .dynsym entry to
 678      determine the address it must put in the global offset table, so
 679      both the dynamic object and the regular object will refer to the
 680      same memory location for the variable.  */
 681
 682   s = bfd_get_section_by_name (dynobj, ".dynbss");
 683   BFD_ASSERT (s != NULL);
 684
 685   /* If the symbol is currently defined in the .bss section of the
 686      dynamic object, then it is OK to simply initialize it to zero.
 687      If the symbol is in some other section, we must generate a
 688      R_SPARC_COPY reloc to tell the dynamic linker to copy the initial
 689      value out of the dynamic object and into the runtime process
 690      image.  We need to remember the offset into the .rel.bss section
 691      we are going to use.  */
 692   if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
 693     {
 694       asection *srel;
 695
 696       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
 697       BFD_ASSERT (srel != NULL);
 698       srel->_raw_size += sizeof (Elf32_External_Rela);
 699       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
 700     }
 701
 702   /* We need to figure out the alignment required for this symbol.  I
 703      have no idea how ELF linkers handle this.  */
 704   power_of_two = bfd_log2 (h->size);
 705   if (power_of_two > 3)
 706     power_of_two = 3;
 707
 708   /* Apply the required alignment.  */
 709   s->_raw_size = BFD_ALIGN (s->_raw_size,
 710                             (bfd_size_type) (1 << power_of_two));
 711   if (power_of_two > bfd_get_section_alignment (dynobj, s))
 712     {
 713       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
 714         return false;
 715     }
 716
 717   /* Define the symbol as being at this point in the section.  */
 718   h->root.u.def.section = s;
 719   h->root.u.def.value = s->_raw_size;
 720
 721   /* Increment the section size to make room for the symbol.  */
 722   s->_raw_size += h->size;
 723
 724   return true;
 725 }
 726
 727 /* Set the sizes of the dynamic sections.  */
 728
 729 static boolean
 730 elf32_sparc_size_dynamic_sections (output_bfd, info)
 731      bfd *output_bfd;
 732      struct bfd_link_info *info;
 733 {
 734   bfd *dynobj;
 735   asection *s;
 736   boolean reltext;
 737   boolean relplt;
 738
 739   dynobj = elf_hash_table (info)->dynobj;
 740   BFD_ASSERT (dynobj != NULL);
 741
 742   if (elf_hash_table (info)->dynamic_sections_created)
 743     {
 744       /* Set the contents of the .interp section to the interpreter.  */
 745       if (! info->shared)
 746         {
 747           s = bfd_get_section_by_name (dynobj, ".interp");
 748           BFD_ASSERT (s != NULL);
 749           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 750           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 751         }
 752
 753       /* Make space for the trailing nop in .plt.  */
 754       s = bfd_get_section_by_name (dynobj, ".plt");
 755       BFD_ASSERT (s != NULL);
 756       if (s->_raw_size > 0)
 757         s->_raw_size += 4;
 758     }
 759   else
 760     {
 761       /* We may have created entries in the .rela.got section.
 762          However, if we are not creating the dynamic sections, we will
 763          not actually use these entries.  Reset the size of .rela.got,
 764          which will cause it to get stripped from the output file
 765          below.  */
 766       s = bfd_get_section_by_name (dynobj, ".rela.got");
 767       if (s != NULL)
 768         s->_raw_size = 0;
 769     }
 770
 771   /* The check_relocs and adjust_dynamic_symbol entry points have
 772      determined the sizes of the various dynamic sections.  Allocate
 773      memory for them.  */
 774   reltext = false;
 775   relplt = false;
 776   for (s = dynobj->sections; s != NULL; s = s->next)
 777     {
 778       const char *name;
 779       boolean strip;
 780
 781       if ((s->flags & SEC_IN_MEMORY) == 0)
 782         continue;
 783
 784       /* It's OK to base decisions on the section name, because none
 785          of the dynobj section names depend upon the input files.  */
 786       name = bfd_get_section_name (dynobj, s);
 787
 788       strip = false;
 789
 790       if (strncmp (name, ".rela", 5) == 0)
 791         {
 792           if (s->_raw_size == 0)
 793             {
 794               /* If we don't need this section, strip it from the
 795                  output file.  This is to handle .rela.bss and
 796                  .rel.plt.  We must create it in
 797                  create_dynamic_sections, because it must be created
 798                  before the linker maps input sections to output
 799                  sections.  The linker does that before
 800                  adjust_dynamic_symbol is called, and it is that
 801                  function which decides whether anything needs to go
 802                  into these sections.  */
 803               strip = true;
 804             }
 805           else
 806             {
 807               asection *target;
 808
 809               /* If this relocation section applies to a read only
 810                  section, then we probably need a DT_TEXTREL entry.  */
 811               target = bfd_get_section_by_name (output_bfd, name + 5);
 812               if (target != NULL
 813                   && (target->flags & SEC_READONLY) != 0)
 814                 reltext = true;
 815
 816               if (strcmp (name, ".rela.plt") == 0)
 817                 relplt = true;
 818
 819               /* We use the reloc_count field as a counter if we need
 820                  to copy relocs into the output file.  */
 821               s->reloc_count = 0;
 822             }
 823         }
 824       else if (strcmp (name, ".plt") != 0
 825                && strcmp (name, ".got") != 0)
 826         {
 827           /* It's not one of our sections, so don't allocate space.  */
 828           continue;
 829         }
 830
 831       if (strip)
 832         {
 833           asection **spp;
 834
 835           for (spp = &s->output_section->owner->sections;
 836                *spp != s->output_section;
 837                spp = &(*spp)->next)
 838             ;
 839           *spp = s->output_section->next;
 840           --s->output_section->owner->section_count;
 841
 842           continue;
 843         }
 844
 845       /* Allocate memory for the section contents.  */
 846       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
 847       if (s->contents == NULL && s->_raw_size != 0)
 848         return false;
 849     }
 850
 851   if (elf_hash_table (info)->dynamic_sections_created)
 852     {
 853       /* Add some entries to the .dynamic section.  We fill in the
 854          values later, in elf32_sparc_finish_dynamic_sections, but we
 855          must add the entries now so that we get the correct size for
 856          the .dynamic section.  The DT_DEBUG entry is filled in by the
 857          dynamic linker and used by the debugger.  */
 858       if (! info->shared)
 859         {
 860           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
 861             return false;
 862         }
 863
 864       if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
 865         return false;
 866
 867       if (relplt)
 868         {
 869           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
 870               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
 871               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
 872             return false;
 873         }
 874
 875       if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
 876           || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
 877           || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
 878                                             sizeof (Elf32_External_Rela)))
 879         return false;
 880
 881       if (reltext)
 882         {
 883           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
 884             return false;
 885         }
 886     }
 887
 888   /* If we are generating a shared library, we generate a section
 889      symbol for each output section.  These are local symbols, which
 890      means that they must come first in the dynamic symbol table.
 891      That means we must increment the dynamic symbol index of every
 892      other dynamic symbol.  */
 893   if (info->shared)
 894     {
 895       int c, i;
 896
 897       c = bfd_count_sections (output_bfd);
 898       elf_link_hash_traverse (elf_hash_table (info),
 899                               elf32_sparc_adjust_dynindx,
 900                               (PTR) &c);
 901       elf_hash_table (info)->dynsymcount += c;
 902
 903       for (i = 1, s = output_bfd->sections; s != NULL; s = s->next, i++)
 904         {
 905           elf_section_data (s)->dynindx = i;
 906           /* These symbols will have no names, so we don't need to
 907              fiddle with dynstr_index.  */
 908         }
 909     }
 910
 911   return true;
 912 }
 913
 914 /* Increment the index of a dynamic symbol by a given amount.  Called
 915    via elf_link_hash_traverse.  */
 916
 917 static boolean
 918 elf32_sparc_adjust_dynindx (h, cparg)
 919      struct elf_link_hash_entry *h;
 920      PTR cparg;
 921 {
 922   int *cp = (int *) cparg;
 923
 924   if (h->dynindx != -1)
 925     h->dynindx += *cp;
 926   return true;
 927 }
 928
 929 /* Relocate a SPARC ELF section.  */
 930
 931 static boolean
 932 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 933                               contents, relocs, local_syms, local_sections)
 934      bfd *output_bfd;
 935      struct bfd_link_info *info;
 936      bfd *input_bfd;
 937      asection *input_section;
 938      bfd_byte *contents;
 939      Elf_Internal_Rela *relocs;
 940      Elf_Internal_Sym *local_syms;
 941      asection **local_sections;
 942 {
 943   bfd *dynobj;
 944   Elf_Internal_Shdr *symtab_hdr;
 945   struct elf_link_hash_entry **sym_hashes;
 946   bfd_vma *local_got_offsets;
 947   bfd_vma got_base;
 948   asection *sgot;
 949   asection *splt;
 950   asection *sreloc;
 951   Elf_Internal_Rela *rel;
 952   Elf_Internal_Rela *relend;
 953
 954   dynobj = elf_hash_table (info)->dynobj;
 955   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 956   sym_hashes = elf_sym_hashes (input_bfd);
 957   local_got_offsets = elf_local_got_offsets (input_bfd);
 958
 959   if (elf_hash_table (info)->hgot == NULL)
 960     got_base = 0;
 961   else
 962     got_base = elf_hash_table (info)->hgot->root.u.def.value;
 963
 964   sgot = NULL;
 965   splt = NULL;
 966   sreloc = NULL;
 967
 968   rel = relocs;
 969   relend = relocs + input_section->reloc_count;
 970   for (; rel < relend; rel++)
 971     {
 972       int r_type;
 973       reloc_howto_type *howto;
 974       unsigned long r_symndx;
 975       struct elf_link_hash_entry *h;
 976       Elf_Internal_Sym *sym;
 977       asection *sec;
 978       bfd_vma relocation;
 979       bfd_reloc_status_type r;
 980
 981       r_type = ELF32_R_TYPE (rel->r_info);
 982       if (r_type < 0 || r_type >= (int) R_SPARC_max)
 983         {
 984           bfd_set_error (bfd_error_bad_value);
 985           return false;
 986         }
 987       howto = _bfd_sparc_elf_howto_table + r_type;
 988
 989       r_symndx = ELF32_R_SYM (rel->r_info);
 990
 991       if (info->relocateable)
 992         {
 993           /* This is a relocateable link.  We don't have to change
 994              anything, unless the reloc is against a section symbol,
 995              in which case we have to adjust according to where the
 996              section symbol winds up in the output section.  */
 997           if (r_symndx < symtab_hdr->sh_info)
 998             {
 999               sym = local_syms + r_symndx;
1000               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1001                 {
1002                   sec = local_sections[r_symndx];
1003                   rel->r_addend += sec->output_offset + sym->st_value;
1004                 }
1005             }
1006
1007           continue;
1008         }
1009
1010       /* This is a final link.  */
1011       h = NULL;
1012       sym = NULL;
1013       sec = NULL;
1014       if (r_symndx < symtab_hdr->sh_info)
1015         {
1016           sym = local_syms + r_symndx;
1017           sec = local_sections[r_symndx];
1018           relocation = (sec->output_section->vma
1019                         + sec->output_offset
1020                         + sym->st_value);
1021         }
1022       else
1023         {
1024           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1025           while (h->root.type == bfd_link_hash_indirect
1026                  || h->root.type == bfd_link_hash_warning)
1027             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1028           if (h->root.type == bfd_link_hash_defined
1029               || h->root.type == bfd_link_hash_defweak)
1030             {
1031               sec = h->root.u.def.section;
1032               if ((r_type == R_SPARC_WPLT30
1033                    && h->plt_offset != (bfd_vma) -1)
1034                   || ((r_type == R_SPARC_GOT10
1035                        || r_type == R_SPARC_GOT13
1036                        || r_type == R_SPARC_GOT22)
1037                       && elf_hash_table (info)->dynamic_sections_created
1038                       && (! info->shared
1039                           || ! info->symbolic
1040                           || (h->elf_link_hash_flags
1041                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1042                   || (info->shared
1043                       && (! info->symbolic
1044                           || (h->elf_link_hash_flags
1045                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1046                       && (input_section->flags & SEC_ALLOC) != 0
1047                       && (r_type == R_SPARC_8
1048                           || r_type == R_SPARC_16
1049                           || r_type == R_SPARC_32
1050                           || r_type == R_SPARC_DISP8
1051                           || r_type == R_SPARC_DISP16
1052                           || r_type == R_SPARC_DISP32
1053                           || r_type == R_SPARC_WDISP30
1054                           || r_type == R_SPARC_WDISP22
1055                           || r_type == R_SPARC_WDISP19
1056                           || r_type == R_SPARC_WDISP16
1057                           || r_type == R_SPARC_HI22
1058                           || r_type == R_SPARC_22
1059                           || r_type == R_SPARC_13
1060                           || r_type == R_SPARC_LO10
1061                           || r_type == R_SPARC_UA32
1062                           || ((r_type == R_SPARC_PC10
1063                                || r_type == R_SPARC_PC22)
1064                               && strcmp (h->root.root.string,
1065                                          "_GLOBAL_OFFSET_TABLE_") != 0))))
1066                 {
1067                   /* In these cases, we don't need the relocation
1068                      value.  We check specially because in some
1069                      obscure cases sec->output_section will be NULL.  */
1070                   relocation = 0;
1071                 }
1072               else
1073                 relocation = (h->root.u.def.value
1074                               + sec->output_section->vma
1075                               + sec->output_offset);
1076             }
1077           else if (h->root.type == bfd_link_hash_undefweak)
1078             relocation = 0;
1079           else if (info->shared && !info->symbolic)
1080             relocation = 0;
1081           else
1082             {
1083               if (! ((*info->callbacks->undefined_symbol)
1084                      (info, h->root.root.string, input_bfd,
1085                       input_section, rel->r_offset)))
1086                 return false;
1087               relocation = 0;
1088             }
1089         }
1090
1091       switch (r_type)
1092         {
1093         case R_SPARC_GOT10:
1094         case R_SPARC_GOT13:
1095         case R_SPARC_GOT22:
1096           /* Relocation is to the entry for this symbol in the global
1097              offset table.  */
1098           if (sgot == NULL)
1099             {
1100               sgot = bfd_get_section_by_name (dynobj, ".got");
1101               BFD_ASSERT (sgot != NULL);
1102             }
1103
1104           if (h != NULL)
1105             {
1106               bfd_vma off;
1107
1108               off = h->got_offset;
1109               BFD_ASSERT (off != (bfd_vma) -1);
1110
1111               if (! elf_hash_table (info)->dynamic_sections_created
1112                   || (info->shared
1113                       && info->symbolic
1114                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1115                 {
1116                   /* This is actually a static link, or it is a
1117                      -Bsymbolic link and the symbol is defined
1118                      locally.  We must initialize this entry in the
1119                      global offset table.  Since the offset must
1120                      always be a multiple of 4, we use the least
1121                      significant bit to record whether we have
1122                      initialized it already.
1123
1124                      When doing a dynamic link, we create a .rela.got
1125                      relocation entry to initialize the value.  This
1126                      is done in the finish_dynamic_symbol routine.  */
1127                   if ((off & 1) != 0)
1128                     off &= ~1;
1129                   else
1130                     {
1131                       bfd_put_32 (output_bfd, relocation,
1132                                   sgot->contents + off);
1133                       h->got_offset |= 1;
1134                     }
1135                 }
1136
1137               relocation = sgot->output_offset + off - got_base;
1138             }
1139           else
1140             {
1141               bfd_vma off;
1142
1143               BFD_ASSERT (local_got_offsets != NULL
1144                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
1145
1146               off = local_got_offsets[r_symndx];
1147
1148               /* The offset must always be a multiple of 4.  We use
1149                  the least significant bit to record whether we have
1150                  already processed this entry.  */
1151               if ((off & 1) != 0)
1152                 off &= ~1;
1153               else
1154                 {
1155                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1156
1157                   if (info->shared)
1158                     {
1159                       asection *srelgot;
1160                       Elf_Internal_Rela outrel;
1161
1162                       /* We need to generate a R_SPARC_RELATIVE reloc
1163                          for the dynamic linker.  */
1164                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1165                       BFD_ASSERT (srelgot != NULL);
1166
1167                       outrel.r_offset = (sgot->output_section->vma
1168                                          + sgot->output_offset
1169                                          + off);
1170                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1171                       outrel.r_addend = 0;
1172                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1173                                                  (((Elf32_External_Rela *)
1174                                                    srelgot->contents)
1175                                                   + srelgot->reloc_count));
1176                       ++srelgot->reloc_count;
1177                     }
1178
1179                   local_got_offsets[r_symndx] |= 1;
1180                 }
1181
1182               relocation = sgot->output_offset + off - got_base;
1183             }
1184
1185           break;
1186
1187         case R_SPARC_WPLT30:
1188           /* Relocation is to the entry for this symbol in the
1189              procedure linkage table.  */
1190           BFD_ASSERT (h != NULL);
1191
1192           if (h->plt_offset == (bfd_vma) -1)
1193             {
1194               /* We didn't make a PLT entry for this symbol.  This
1195                  happens when statically linking PIC code, or when
1196                  using -Bsymbolic.  */
1197               break;
1198             }
1199
1200           if (splt == NULL)
1201             {
1202               splt = bfd_get_section_by_name (dynobj, ".plt");
1203               BFD_ASSERT (splt != NULL);
1204             }
1205
1206           relocation = (splt->output_section->vma
1207                         + splt->output_offset
1208                         + h->plt_offset);
1209           break;
1210
1211         case R_SPARC_PC10:
1212         case R_SPARC_PC22:
1213           if (h != NULL
1214               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1215             break;
1216           /* Fall through.  */
1217         case R_SPARC_DISP8:
1218         case R_SPARC_DISP16:
1219         case R_SPARC_DISP32:
1220         case R_SPARC_WDISP30:
1221         case R_SPARC_WDISP22:
1222         case R_SPARC_WDISP19:
1223         case R_SPARC_WDISP16:
1224           if (h == NULL)
1225             break;
1226           /* Fall through.  */
1227         case R_SPARC_8:
1228         case R_SPARC_16:
1229         case R_SPARC_32:
1230         case R_SPARC_HI22:
1231         case R_SPARC_22:
1232         case R_SPARC_13:
1233         case R_SPARC_LO10:
1234         case R_SPARC_UA32:
1235           if (info->shared
1236               && (input_section->flags & SEC_ALLOC) != 0)
1237             {
1238               Elf_Internal_Rela outrel;
1239
1240               /* When generating a shared object, these relocations
1241                  are copied into the output file to be resolved at run
1242                  time.  */
1243
1244               if (sreloc == NULL)
1245                 {
1246                   const char *name;
1247
1248                   name = (bfd_elf_string_from_elf_section
1249                           (input_bfd,
1250                            elf_elfheader (input_bfd)->e_shstrndx,
1251                            elf_section_data (input_section)->rel_hdr.sh_name));
1252                   if (name == NULL)
1253                     return false;
1254
1255                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1256                               && strcmp (bfd_get_section_name (input_bfd,
1257                                                                input_section),
1258                                          name + 5) == 0);
1259
1260                   sreloc = bfd_get_section_by_name (dynobj, name);
1261                   BFD_ASSERT (sreloc != NULL);
1262                 }
1263
1264               outrel.r_offset = (rel->r_offset
1265                                  + input_section->output_section->vma
1266                                  + input_section->output_offset);
1267               if (h != NULL
1268                   && (! info->symbolic
1269                       || (h->elf_link_hash_flags
1270                           & ELF_LINK_HASH_DEF_REGULAR) == 0))
1271                 {
1272                   BFD_ASSERT (h->dynindx != -1);
1273                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1274                   outrel.r_addend = rel->r_addend;
1275                 }
1276               else
1277                 {
1278                   if (r_type == R_SPARC_32)
1279                     {
1280                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1281                       outrel.r_addend = relocation + rel->r_addend;
1282                     }
1283                   else
1284                     {
1285                       long indx;
1286
1287                       if (h == NULL)
1288                         sec = local_sections[r_symndx];
1289                       else
1290                         {
1291                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1292                                       || (h->root.type
1293                                           == bfd_link_hash_defweak));
1294                           sec = h->root.u.def.section;
1295                         }
1296                       if (sec != NULL && bfd_is_abs_section (sec))
1297                         indx = 0;
1298                       else if (sec == NULL || sec->owner == NULL)
1299                         {
1300                           bfd_set_error (bfd_error_bad_value);
1301                           return false;
1302                         }
1303                       else
1304                         {
1305                           asection *osec;
1306
1307                           osec = sec->output_section;
1308                           indx = elf_section_data (osec)->dynindx;
1309                           if (indx == 0)
1310                             abort ();
1311                         }
1312
1313                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1314                       outrel.r_addend = relocation + rel->r_addend;
1315                     }
1316                 }
1317
1318               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1319                                          (((Elf32_External_Rela *)
1320                                            sreloc->contents)
1321                                           + sreloc->reloc_count));
1322               ++sreloc->reloc_count;
1323
1324               /* This reloc will be computed at runtime, so there's no
1325                  need to do anything now.  */
1326               continue;
1327             }
1328
1329         default:
1330           break;
1331         }
1332
1333       if (r_type != R_SPARC_WDISP16)
1334         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1335                                       contents, rel->r_offset,
1336                                       relocation, rel->r_addend);
1337       else
1338         {
1339           bfd_vma x;
1340
1341           relocation += rel->r_addend;
1342           relocation -= (input_section->output_section->vma
1343                          + input_section->output_offset);
1344           relocation -= rel->r_offset;
1345
1346           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1347           x |= ((((relocation >> 2) & 0xc000) << 6)
1348                 | ((relocation >> 2) & 0x3fff));
1349           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1350
1351           if ((bfd_signed_vma) relocation < - 0x40000
1352               || (bfd_signed_vma) relocation > 0x3ffff)
1353             r = bfd_reloc_overflow;
1354           else
1355             r = bfd_reloc_ok;
1356         }
1357
1358       if (r != bfd_reloc_ok)
1359         {
1360           switch (r)
1361             {
1362             default:
1363             case bfd_reloc_outofrange:
1364               abort ();
1365             case bfd_reloc_overflow:
1366               {
1367                 const char *name;
1368
1369                 if (h != NULL)
1370                   name = h->root.root.string;
1371                 else
1372                   {
1373                     name = bfd_elf_string_from_elf_section (input_bfd,
1374                                                             symtab_hdr->sh_link,
1375                                                             sym->st_name);
1376                     if (name == NULL)
1377                       return false;
1378                     if (*name == '\0')
1379                       name = bfd_section_name (input_bfd, sec);
1380                   }
1381                 if (! ((*info->callbacks->reloc_overflow)
1382                        (info, name, howto->name, (bfd_vma) 0,
1383                         input_bfd, input_section, rel->r_offset)))
1384                   return false;
1385               }
1386               break;
1387             }
1388         }
1389     }
1390
1391   return true;
1392 }
1393
1394 /* Finish up dynamic symbol handling.  We set the contents of various
1395    dynamic sections here.  */
1396
1397 static boolean
1398 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1399      bfd *output_bfd;
1400      struct bfd_link_info *info;
1401      struct elf_link_hash_entry *h;
1402      Elf_Internal_Sym *sym;
1403 {
1404   bfd *dynobj;
1405
1406   dynobj = elf_hash_table (info)->dynobj;
1407
1408   if (h->plt_offset != (bfd_vma) -1)
1409     {
1410       asection *splt;
1411       asection *srela;
1412       Elf_Internal_Rela rela;
1413
1414       /* This symbol has an entry in the procedure linkage table.  Set
1415          it up.  */
1416
1417       BFD_ASSERT (h->dynindx != -1);
1418
1419       splt = bfd_get_section_by_name (dynobj, ".plt");
1420       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1421       BFD_ASSERT (splt != NULL && srela != NULL);
1422
1423       /* Fill in the entry in the procedure linkage table.  */
1424       bfd_put_32 (output_bfd,
1425                   PLT_ENTRY_WORD0 + h->plt_offset,
1426                   splt->contents + h->plt_offset);
1427       bfd_put_32 (output_bfd,
1428                   (PLT_ENTRY_WORD1
1429                    + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
1430                   splt->contents + h->plt_offset + 4);
1431       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
1432                   splt->contents + h->plt_offset + 8);
1433
1434       /* Fill in the entry in the .rela.plt section.  */
1435       rela.r_offset = (splt->output_section->vma
1436                        + splt->output_offset
1437                        + h->plt_offset);
1438       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1439       rela.r_addend = 0;
1440       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1441                                  ((Elf32_External_Rela *) srela->contents
1442                                   + h->plt_offset / PLT_ENTRY_SIZE - 4));
1443
1444       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1445         {
1446           /* Mark the symbol as undefined, rather than as defined in
1447              the .plt section.  Leave the value alone.  */
1448           sym->st_shndx = SHN_UNDEF;
1449         }
1450     }
1451
1452   if (h->got_offset != (bfd_vma) -1)
1453     {
1454       asection *sgot;
1455       asection *srela;
1456       Elf_Internal_Rela rela;
1457
1458       /* This symbol has an entry in the global offset table.  Set it
1459          up.  */
1460
1461       BFD_ASSERT (h->dynindx != -1);
1462
1463       sgot = bfd_get_section_by_name (dynobj, ".got");
1464       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1465       BFD_ASSERT (sgot != NULL && srela != NULL);
1466
1467       rela.r_offset = (sgot->output_section->vma
1468                        + sgot->output_offset
1469                        + (h->got_offset &~ 1));
1470
1471       /* If this is a -Bsymbolic link, and the symbol is defined
1472          locally, we just want to emit a RELATIVE reloc.  The entry in
1473          the global offset table will already have been initialized in
1474          the relocate_section function.  */
1475       if (info->shared
1476           && info->symbolic
1477           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1478         rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1479       else
1480         {
1481           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1482           rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1483         }
1484
1485       rela.r_addend = 0;
1486       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1487                                  ((Elf32_External_Rela *) srela->contents
1488                                   + srela->reloc_count));
1489       ++srela->reloc_count;
1490     }
1491
1492   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1493     {
1494       asection *s;
1495       Elf_Internal_Rela rela;
1496
1497       /* This symbols needs a copy reloc.  Set it up.  */
1498
1499       BFD_ASSERT (h->dynindx != -1);
1500
1501       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1502                                    ".rela.bss");
1503       BFD_ASSERT (s != NULL);
1504
1505       rela.r_offset = (h->root.u.def.value
1506                        + h->root.u.def.section->output_section->vma
1507                        + h->root.u.def.section->output_offset);
1508       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1509       rela.r_addend = 0;
1510       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1511                                  ((Elf32_External_Rela *) s->contents
1512                                   + s->reloc_count));
1513       ++s->reloc_count;
1514     }
1515
1516   /* Mark some specially defined symbols as absolute.  */
1517   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1518       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1519       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1520     sym->st_shndx = SHN_ABS;
1521
1522   return true;
1523 }
1524
1525 /* Finish up the dynamic sections.  */
1526
1527 static boolean
1528 elf32_sparc_finish_dynamic_sections (output_bfd, info)
1529      bfd *output_bfd;
1530      struct bfd_link_info *info;
1531 {
1532   bfd *dynobj;
1533   asection *sdyn;
1534   asection *sgot;
1535
1536   dynobj = elf_hash_table (info)->dynobj;
1537
1538   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1539
1540   if (elf_hash_table (info)->dynamic_sections_created)
1541     {
1542       asection *splt;
1543       Elf32_External_Dyn *dyncon, *dynconend;
1544
1545       splt = bfd_get_section_by_name (dynobj, ".plt");
1546       BFD_ASSERT (splt != NULL && sdyn != NULL);
1547
1548       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1549       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1550       for (; dyncon < dynconend; dyncon++)
1551         {
1552           Elf_Internal_Dyn dyn;
1553           const char *name;
1554           boolean size;
1555
1556           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1557
1558           switch (dyn.d_tag)
1559             {
1560             case DT_PLTGOT:   name = ".plt"; size = false; break;
1561             case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1562             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
1563             default:      name = NULL; size = false; break;
1564             }
1565
1566           if (name != NULL)
1567             {
1568               asection *s;
1569
1570               s = bfd_get_section_by_name (output_bfd, name);
1571               if (s == NULL)
1572                 dyn.d_un.d_val = 0;
1573               else
1574                 {
1575                   if (! size)
1576                     dyn.d_un.d_ptr = s->vma;
1577                   else
1578                     {
1579                       if (s->_cooked_size != 0)
1580                         dyn.d_un.d_val = s->_cooked_size;
1581                       else
1582                         dyn.d_un.d_val = s->_raw_size;
1583                     }
1584                 }
1585               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1586             }
1587         }
1588
1589       /* Clear the first four entries in the procedure linkage table,
1590          and put a nop in the last four bytes.  */
1591       if (splt->_raw_size > 0)
1592         {
1593           memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1594           bfd_put_32 (output_bfd, SPARC_NOP,
1595                       splt->contents + splt->_raw_size - 4);
1596         }
1597
1598       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1599         PLT_ENTRY_SIZE;
1600     }
1601
1602   /* Set the first entry in the global offset table to the address of
1603      the dynamic section.  */
1604   sgot = bfd_get_section_by_name (dynobj, ".got");
1605   BFD_ASSERT (sgot != NULL);
1606   if (sgot->_raw_size > 0)
1607     {
1608       if (sdyn == NULL)
1609         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1610       else
1611         bfd_put_32 (output_bfd,
1612                     sdyn->output_section->vma + sdyn->output_offset,
1613                     sgot->contents);
1614     }
1615
1616   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1617
1618   if (info->shared)
1619     {
1620       asection *sdynsym;
1621       asection *s;
1622       Elf_Internal_Sym sym;
1623
1624       /* Set up the section symbols for the output sections.  */
1625
1626       sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1627       BFD_ASSERT (sdynsym != NULL);
1628
1629       sym.st_size = 0;
1630       sym.st_name = 0;
1631       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1632       sym.st_other = 0;
1633
1634       for (s = output_bfd->sections; s != NULL; s = s->next)
1635         {
1636           int indx;
1637
1638           sym.st_value = s->vma;
1639
1640           indx = elf_section_data (s)->this_idx;
1641           BFD_ASSERT (indx > 0);
1642           sym.st_shndx = indx;
1643
1644           bfd_elf32_swap_symbol_out (output_bfd, &sym,
1645                                      (PTR) (((Elf32_External_Sym *)
1646                                              sdynsym->contents)
1647                                             + elf_section_data (s)->dynindx));
1648         }
1649
1650       /* Set the sh_info field of the output .dynsym section to the
1651          index of the first global symbol.  */
1652       elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1653         bfd_count_sections (output_bfd) + 1;
1654     }
1655
1656   return true;
1657 }
1658 \f
1659 /* Functions for dealing with the e_flags field.
1660
1661    We don't define set_private_flags or copy_private_bfd_data because
1662    the only currently defined values are based on the bfd mach number,
1663    so we use the latter instead and defer setting e_flags until the
1664    file is written out.  */
1665
1666 /* Merge backend specific data from an object file to the output
1667    object file when linking.  */
1668
1669 static boolean
1670 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1671      bfd *ibfd;
1672      bfd *obfd;
1673 {
1674   boolean error;
1675
1676   /* This function is selected based on the input vector.  We only
1677      want to copy information over if the output BFD also uses Elf
1678      format.  */
1679   if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1680     return true;
1681
1682   error = false;
1683
1684 #if 0
1685   /* ??? The native linker doesn't do this so we can't (otherwise gcc would
1686      have to know which linker is being used).  Instead, the native linker
1687      bumps up the architecture level when it has to.  However, I still think
1688      warnings like these are good, so it would be nice to have them turned on
1689      by some option.  */
1690
1691   /* If the output machine is normal sparc, we can't allow v9 input files.  */
1692   if (bfd_get_mach (obfd) == bfd_mach_sparc
1693       && (bfd_get_mach (ibfd) == bfd_mach_sparc_v8plus
1694           || bfd_get_mach (ibfd) == bfd_mach_sparc_v8plusa))
1695     {
1696       error = true;
1697       (*_bfd_error_handler)
1698         ("%s: compiled for a v8plus system and target is v8",
1699          bfd_get_filename (ibfd));
1700     }
1701   /* If the output machine is v9, we can't allow v9+vis input files.  */
1702   if (bfd_get_mach (obfd) == bfd_mach_sparc_v8plus
1703       && bfd_get_mach (ibfd) == bfd_mach_sparc_v8plusa)
1704     {
1705       error = true;
1706       (*_bfd_error_handler)
1707         ("%s: compiled for a v8plusa system and target is v8plus",
1708          bfd_get_filename (ibfd));
1709     }
1710 #else
1711   if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1712     {
1713       error = true;
1714       (*_bfd_error_handler)
1715         ("%s: compiled for a 64 bit system and target is 32 bit",
1716          bfd_get_filename (ibfd));
1717     }
1718   else if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1719     bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1720 #endif
1721
1722   if (error)
1723     {
1724       bfd_set_error (bfd_error_bad_value);
1725       return false;
1726     }
1727
1728   return true;
1729 }
1730 \f
1731 /* Set the right machine number.  */
1732
1733 static boolean
1734 elf32_sparc_object_p (abfd)
1735      bfd *abfd;
1736 {
1737   if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
1738     {
1739       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
1740         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
1741                                           bfd_mach_sparc_v8plusa);
1742       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
1743         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
1744                                           bfd_mach_sparc_v8plus);
1745       else
1746         return false;
1747     }
1748   else
1749     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
1750 }
1751
1752 /* The final processing done just before writing out the object file.
1753    We need to set the e_machine field appropriately.  */
1754
1755 static void
1756 elf32_sparc_final_write_processing (abfd, linker)
1757      bfd *abfd;
1758      boolean linker;
1759 {
1760   switch (bfd_get_mach (abfd))
1761     {
1762     case bfd_mach_sparc :
1763       break; /* nothing to do */
1764     case bfd_mach_sparc_v8plus :
1765       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
1766       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
1767       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
1768       break;
1769     case bfd_mach_sparc_v8plusa :
1770       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
1771       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
1772       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
1773       break;
1774     default :
1775       abort ();
1776     }
1777 }
1778 \f
1779 #define TARGET_BIG_SYM  bfd_elf32_sparc_vec
1780 #define TARGET_BIG_NAME "elf32-sparc"
1781 #define ELF_ARCH        bfd_arch_sparc
1782 #define ELF_MACHINE_CODE EM_SPARC
1783 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
1784 #define ELF_MAXPAGESIZE 0x10000
1785
1786 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
1787 #define elf_backend_create_dynamic_sections \
1788                                         _bfd_elf_create_dynamic_sections
1789 #define elf_backend_check_relocs        elf32_sparc_check_relocs
1790 #define elf_backend_adjust_dynamic_symbol \
1791                                         elf32_sparc_adjust_dynamic_symbol
1792 #define elf_backend_size_dynamic_sections \
1793                                         elf32_sparc_size_dynamic_sections
1794 #define elf_backend_relocate_section    elf32_sparc_relocate_section
1795 #define elf_backend_finish_dynamic_symbol \
1796                                         elf32_sparc_finish_dynamic_symbol
1797 #define elf_backend_finish_dynamic_sections \
1798                                         elf32_sparc_finish_dynamic_sections
1799 #define bfd_elf32_bfd_merge_private_bfd_data \
1800                                         elf32_sparc_merge_private_bfd_data
1801 #define elf_backend_object_p            elf32_sparc_object_p
1802 #define elf_backend_final_write_processing \
1803                                         elf32_sparc_final_write_processing
1804 #define elf_backend_want_got_plt 0
1805 #define elf_backend_plt_readonly 0
1806 #define elf_backend_want_plt_sym 1
1807
1808 #include "elf32-target.h"