bfd/elf32-sparc.c

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