bfd/elf32-sparc.c

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