bfd/elf32-sparc.c

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