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,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA64",    false,0,(~ (bfd_vma)0), 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         case R_SPARC_UA64:
 558           if (h != NULL)
 559             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 560
 561           if (info->shared)
 562             {
 563               /* When creating a shared object, we must copy these
 564                  relocs into the output file.  We create a reloc
 565                  section in dynobj and make room for the reloc.  */
 566               if (sreloc == NULL)
 567                 {
 568                   const char *name;
 569
 570                   name = (bfd_elf_string_from_elf_section
 571                           (abfd,
 572                            elf_elfheader (abfd)->e_shstrndx,
 573                            elf_section_data (sec)->rel_hdr.sh_name));
 574                   if (name == NULL)
 575                     return false;
 576
 577                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
 578                               && strcmp (bfd_get_section_name (abfd, sec),
 579                                          name + 5) == 0);
 580
 581                   sreloc = bfd_get_section_by_name (dynobj, name);
 582                   if (sreloc == NULL)
 583                     {
 584                       flagword flags;
 585
 586                       sreloc = bfd_make_section (dynobj, name);
 587                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 588                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 589                       if ((sec->flags & SEC_ALLOC) != 0)
 590                         flags |= SEC_ALLOC | SEC_LOAD;
 591                       if (sreloc == NULL
 592                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 593                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 594                         return false;
 595                     }
 596                 }
 597
 598               sreloc->_raw_size += sizeof (Elf32_External_Rela);
 599             }
 600
 601           break;
 602
 603         case R_SPARC_GNU_VTINHERIT:
 604           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 605             return false;
 606           break;
 607
 608         case R_SPARC_GNU_VTENTRY:
 609           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 610             return false;
 611           break;
 612
 613         default:
 614           break;
 615         }
 616     }
 617
 618   return true;
 619 }
 620
 621 static asection *
 622 elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym)
 623        bfd *abfd;
 624        struct bfd_link_info *info ATTRIBUTE_UNUSED;
 625        Elf_Internal_Rela *rel;
 626        struct elf_link_hash_entry *h;
 627        Elf_Internal_Sym *sym;
 628 {
 629
 630   if (h != NULL)
 631     {
 632       switch (ELF32_R_TYPE (rel->r_info))
 633       {
 634       case R_SPARC_GNU_VTINHERIT:
 635       case R_SPARC_GNU_VTENTRY:
 636         break;
 637
 638       default:
 639         switch (h->root.type)
 640           {
 641           case bfd_link_hash_defined:
 642           case bfd_link_hash_defweak:
 643             return h->root.u.def.section;
 644
 645           case bfd_link_hash_common:
 646             return h->root.u.c.p->section;
 647
 648           default:
 649             break;
 650           }
 651        }
 652      }
 653    else
 654      {
 655        if (!(elf_bad_symtab (abfd)
 656            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 657          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 658                 && sym->st_shndx != SHN_COMMON))
 659           {
 660             return bfd_section_from_elf_index (abfd, sym->st_shndx);
 661           }
 662       }
 663
 664   return NULL;
 665 }
 666
 667 /* Update the got entry reference counts for the section being removed.  */
 668 static boolean
 669 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
 670      bfd *abfd;
 671      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 672      asection *sec;
 673      const Elf_Internal_Rela *relocs;
 674 {
 675
 676   Elf_Internal_Shdr *symtab_hdr;
 677   struct elf_link_hash_entry **sym_hashes;
 678   bfd_signed_vma *local_got_refcounts;
 679   const Elf_Internal_Rela *rel, *relend;
 680   unsigned long r_symndx;
 681   struct elf_link_hash_entry *h;
 682
 683   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 684   sym_hashes = elf_sym_hashes (abfd);
 685   local_got_refcounts = elf_local_got_refcounts (abfd);
 686
 687   relend = relocs + sec->reloc_count;
 688   for (rel = relocs; rel < relend; rel++)
 689     switch (ELF32_R_TYPE (rel->r_info))
 690       {
 691       case R_SPARC_GOT10:
 692       case R_SPARC_GOT13:
 693       case R_SPARC_GOT22:
 694         r_symndx = ELF32_R_SYM (rel->r_info);
 695         if (r_symndx >= symtab_hdr->sh_info)
 696           {
 697             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 698             if (h->got.refcount > 0)
 699               h->got.refcount--;
 700           }
 701         else
 702           {
 703             if (local_got_refcounts[r_symndx] > 0)
 704               local_got_refcounts[r_symndx]--;
 705           }
 706         break;
 707
 708       case R_SPARC_PLT32:
 709       case R_SPARC_HIPLT22:
 710       case R_SPARC_LOPLT10:
 711       case R_SPARC_PCPLT32:
 712       case R_SPARC_PCPLT10:
 713         r_symndx = ELF32_R_SYM (rel->r_info);
 714         if (r_symndx >= symtab_hdr->sh_info)
 715           {
 716             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 717             if (h->plt.refcount > 0)
 718               h->plt.refcount--;
 719           }
 720         break;
 721
 722       default:
 723         break;
 724       }
 725
 726   return true;
 727 }
 728
 729 /* Adjust a symbol defined by a dynamic object and referenced by a
 730    regular object.  The current definition is in some section of the
 731    dynamic object, but we're not including those sections.  We have to
 732    change the definition to something the rest of the link can
 733    understand.  */
 734
 735 static boolean
 736 elf32_sparc_adjust_dynamic_symbol (info, h)
 737      struct bfd_link_info *info;
 738      struct elf_link_hash_entry *h;
 739 {
 740   bfd *dynobj;
 741   asection *s;
 742   unsigned int power_of_two;
 743
 744   dynobj = elf_hash_table (info)->dynobj;
 745
 746   /* Make sure we know what is going on here.  */
 747   BFD_ASSERT (dynobj != NULL
 748               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 749                   || h->weakdef != NULL
 750                   || ((h->elf_link_hash_flags
 751                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 752                       && (h->elf_link_hash_flags
 753                           & ELF_LINK_HASH_REF_REGULAR) != 0
 754                       && (h->elf_link_hash_flags
 755                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 756
 757   /* If this is a function, put it in the procedure linkage table.  We
 758      will fill in the contents of the procedure linkage table later
 759      (although we could actually do it here).  The STT_NOTYPE
 760      condition is a hack specifically for the Oracle libraries
 761      delivered for Solaris; for some inexplicable reason, they define
 762      some of their functions as STT_NOTYPE when they really should be
 763      STT_FUNC.  */
 764   if (h->type == STT_FUNC
 765       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
 766       || (h->type == STT_NOTYPE
 767           && (h->root.type == bfd_link_hash_defined
 768               || h->root.type == bfd_link_hash_defweak)
 769           && (h->root.u.def.section->flags & SEC_CODE) != 0))
 770     {
 771       if (! elf_hash_table (info)->dynamic_sections_created
 772           || ((!info->shared || info->symbolic || h->dynindx == -1)
 773               && (h->elf_link_hash_flags
 774                   & ELF_LINK_HASH_DEF_REGULAR) != 0))
 775         {
 776           /* This case can occur if we saw a WPLT30 reloc in an input
 777              file, but none of the input files were dynamic objects.
 778              Or, when linking the main application or a -Bsymbolic
 779              shared library against PIC code.  Or when a global symbol
 780              has been made private, e.g. via versioning.
 781
 782              In these cases we know what value the symbol will resolve
 783              to, so we don't actually need to build a procedure linkage
 784              table, and we can just do a WDISP30 reloc instead.  */
 785
 786           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 787           return true;
 788         }
 789
 790       s = bfd_get_section_by_name (dynobj, ".plt");
 791       BFD_ASSERT (s != NULL);
 792
 793       /* The first four entries in .plt are reserved.  */
 794       if (s->_raw_size == 0)
 795         s->_raw_size = 4 * PLT_ENTRY_SIZE;
 796
 797       /* The procedure linkage table has a maximum size.  */
 798       if (s->_raw_size >= 0x400000)
 799         {
 800           bfd_set_error (bfd_error_bad_value);
 801           return false;
 802         }
 803
 804      /* If this symbol is not defined in a regular file, and we are
 805        not generating a shared library, then set the symbol to this
 806        location in the .plt.  This is required to make function
 807        pointers compare as equal between the normal executable and
 808        the shared library.  */
 809      if (! info->shared
 810         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 811       {
 812         h->root.u.def.section = s;
 813         h->root.u.def.value = s->_raw_size;
 814       }
 815
 816       h->plt.offset = s->_raw_size;
 817
 818       /* Make room for this entry.  */
 819       s->_raw_size += PLT_ENTRY_SIZE;
 820
 821       /* We also need to make an entry in the .rela.plt section.  */
 822
 823       s = bfd_get_section_by_name (dynobj, ".rela.plt");
 824       BFD_ASSERT (s != NULL);
 825       s->_raw_size += sizeof (Elf32_External_Rela);
 826
 827       return true;
 828     }
 829
 830   /* If this is a weak symbol, and there is a real definition, the
 831      processor independent code will have arranged for us to see the
 832      real definition first, and we can just use the same value.  */
 833   if (h->weakdef != NULL)
 834     {
 835       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
 836                   || h->weakdef->root.type == bfd_link_hash_defweak);
 837       h->root.u.def.section = h->weakdef->root.u.def.section;
 838       h->root.u.def.value = h->weakdef->root.u.def.value;
 839       return true;
 840     }
 841
 842   /* This is a reference to a symbol defined by a dynamic object which
 843      is not a function.  */
 844
 845   /* If we are creating a shared library, we must presume that the
 846      only references to the symbol are via the global offset table.
 847      For such cases we need not do anything here; the relocations will
 848      be handled correctly by relocate_section.  */
 849   if (info->shared)
 850     return true;
 851
 852   /* If there are no references to this symbol that do not use the
 853      GOT, we don't need to generate a copy reloc.  */
 854   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
 855     return true;
 856
 857   /* We must allocate the symbol in our .dynbss section, which will
 858      become part of the .bss section of the executable.  There will be
 859      an entry for this symbol in the .dynsym section.  The dynamic
 860      object will contain position independent code, so all references
 861      from the dynamic object to this symbol will go through the global
 862      offset table.  The dynamic linker will use the .dynsym entry to
 863      determine the address it must put in the global offset table, so
 864      both the dynamic object and the regular object will refer to the
 865      same memory location for the variable.  */
 866
 867   s = bfd_get_section_by_name (dynobj, ".dynbss");
 868   BFD_ASSERT (s != NULL);
 869
 870   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
 871      to copy the initial value out of the dynamic object and into the
 872      runtime process image.  We need to remember the offset into the
 873      .rel.bss section we are going to use.  */
 874   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
 875     {
 876       asection *srel;
 877
 878       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
 879       BFD_ASSERT (srel != NULL);
 880       srel->_raw_size += sizeof (Elf32_External_Rela);
 881       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
 882     }
 883
 884   /* We need to figure out the alignment required for this symbol.  I
 885      have no idea how ELF linkers handle this.  */
 886   power_of_two = bfd_log2 (h->size);
 887   if (power_of_two > 3)
 888     power_of_two = 3;
 889
 890   /* Apply the required alignment.  */
 891   s->_raw_size = BFD_ALIGN (s->_raw_size,
 892                             (bfd_size_type) (1 << power_of_two));
 893   if (power_of_two > bfd_get_section_alignment (dynobj, s))
 894     {
 895       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
 896         return false;
 897     }
 898
 899   /* Define the symbol as being at this point in the section.  */
 900   h->root.u.def.section = s;
 901   h->root.u.def.value = s->_raw_size;
 902
 903   /* Increment the section size to make room for the symbol.  */
 904   s->_raw_size += h->size;
 905
 906   return true;
 907 }
 908
 909 /* Set the sizes of the dynamic sections.  */
 910
 911 static boolean
 912 elf32_sparc_size_dynamic_sections (output_bfd, info)
 913      bfd *output_bfd;
 914      struct bfd_link_info *info;
 915 {
 916   bfd *dynobj;
 917   asection *s;
 918   boolean reltext;
 919   boolean relplt;
 920
 921   dynobj = elf_hash_table (info)->dynobj;
 922   BFD_ASSERT (dynobj != NULL);
 923
 924   if (elf_hash_table (info)->dynamic_sections_created)
 925     {
 926       /* Set the contents of the .interp section to the interpreter.  */
 927       if (! info->shared)
 928         {
 929           s = bfd_get_section_by_name (dynobj, ".interp");
 930           BFD_ASSERT (s != NULL);
 931           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 932           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 933         }
 934
 935       /* Make space for the trailing nop in .plt.  */
 936       s = bfd_get_section_by_name (dynobj, ".plt");
 937       BFD_ASSERT (s != NULL);
 938       if (s->_raw_size > 0)
 939         s->_raw_size += 4;
 940     }
 941   else
 942     {
 943       /* We may have created entries in the .rela.got section.
 944          However, if we are not creating the dynamic sections, we will
 945          not actually use these entries.  Reset the size of .rela.got,
 946          which will cause it to get stripped from the output file
 947          below.  */
 948       s = bfd_get_section_by_name (dynobj, ".rela.got");
 949       if (s != NULL)
 950         s->_raw_size = 0;
 951     }
 952
 953   /* The check_relocs and adjust_dynamic_symbol entry points have
 954      determined the sizes of the various dynamic sections.  Allocate
 955      memory for them.  */
 956   reltext = false;
 957   relplt = false;
 958   for (s = dynobj->sections; s != NULL; s = s->next)
 959     {
 960       const char *name;
 961       boolean strip;
 962
 963       if ((s->flags & SEC_LINKER_CREATED) == 0)
 964         continue;
 965
 966       /* It's OK to base decisions on the section name, because none
 967          of the dynobj section names depend upon the input files.  */
 968       name = bfd_get_section_name (dynobj, s);
 969
 970       strip = false;
 971
 972       if (strncmp (name, ".rela", 5) == 0)
 973         {
 974           if (s->_raw_size == 0)
 975             {
 976               /* If we don't need this section, strip it from the
 977                  output file.  This is to handle .rela.bss and
 978                  .rel.plt.  We must create it in
 979                  create_dynamic_sections, because it must be created
 980                  before the linker maps input sections to output
 981                  sections.  The linker does that before
 982                  adjust_dynamic_symbol is called, and it is that
 983                  function which decides whether anything needs to go
 984                  into these sections.  */
 985               strip = true;
 986             }
 987           else
 988             {
 989               const char *outname;
 990               asection *target;
 991
 992               /* If this relocation section applies to a read only
 993                  section, then we probably need a DT_TEXTREL entry.  */
 994               outname = bfd_get_section_name (output_bfd,
 995                                               s->output_section);
 996               target = bfd_get_section_by_name (output_bfd, outname + 5);
 997               if (target != NULL
 998                   && (target->flags & SEC_READONLY) != 0
 999                   && (target->flags & SEC_ALLOC) != 0)
1000                 reltext = true;
1001
1002               if (strcmp (name, ".rela.plt") == 0)
1003                 relplt = true;
1004
1005               /* We use the reloc_count field as a counter if we need
1006                  to copy relocs into the output file.  */
1007               s->reloc_count = 0;
1008             }
1009         }
1010       else if (strcmp (name, ".plt") != 0
1011                && strcmp (name, ".got") != 0)
1012         {
1013           /* It's not one of our sections, so don't allocate space.  */
1014           continue;
1015         }
1016
1017       if (strip)
1018         {
1019           _bfd_strip_section_from_output (info, s);
1020           continue;
1021         }
1022
1023       /* Allocate memory for the section contents.  */
1024       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1025          Unused entries should be reclaimed before the section's contents
1026          are written out, but at the moment this does not happen.  Thus in
1027          order to prevent writing out garbage, we initialise the section's
1028          contents to zero.  */
1029       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1030       if (s->contents == NULL && s->_raw_size != 0)
1031         return false;
1032     }
1033
1034   if (elf_hash_table (info)->dynamic_sections_created)
1035     {
1036       /* Add some entries to the .dynamic section.  We fill in the
1037          values later, in elf32_sparc_finish_dynamic_sections, but we
1038          must add the entries now so that we get the correct size for
1039          the .dynamic section.  The DT_DEBUG entry is filled in by the
1040          dynamic linker and used by the debugger.  */
1041       if (! info->shared)
1042         {
1043           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1044             return false;
1045         }
1046
1047       if (relplt)
1048         {
1049           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1050               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1051               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1052               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1053             return false;
1054         }
1055
1056       if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
1057           || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
1058           || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
1059                                             sizeof (Elf32_External_Rela)))
1060         return false;
1061
1062       if (reltext)
1063         {
1064           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1065             return false;
1066           info->flags |= DF_TEXTREL;
1067         }
1068     }
1069
1070   return true;
1071 }
1072
1073 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1074 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1075
1076 static boolean
1077 elf32_sparc_relax_section (abfd, section, link_info, again)
1078      bfd *abfd ATTRIBUTE_UNUSED;
1079      asection *section ATTRIBUTE_UNUSED;
1080      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1081      boolean *again;
1082 {
1083   *again = false;
1084   SET_SEC_DO_RELAX (section);
1085   return true;
1086 }
1087
1088 /* Relocate a SPARC ELF section.  */
1089
1090 static boolean
1091 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
1092                               contents, relocs, local_syms, local_sections)
1093      bfd *output_bfd;
1094      struct bfd_link_info *info;
1095      bfd *input_bfd;
1096      asection *input_section;
1097      bfd_byte *contents;
1098      Elf_Internal_Rela *relocs;
1099      Elf_Internal_Sym *local_syms;
1100      asection **local_sections;
1101 {
1102   bfd *dynobj;
1103   Elf_Internal_Shdr *symtab_hdr;
1104   struct elf_link_hash_entry **sym_hashes;
1105   bfd_vma *local_got_offsets;
1106   bfd_vma got_base;
1107   asection *sgot;
1108   asection *splt;
1109   asection *sreloc;
1110   Elf_Internal_Rela *rel;
1111   Elf_Internal_Rela *relend;
1112
1113   dynobj = elf_hash_table (info)->dynobj;
1114   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1115   sym_hashes = elf_sym_hashes (input_bfd);
1116   local_got_offsets = elf_local_got_offsets (input_bfd);
1117
1118   if (elf_hash_table (info)->hgot == NULL)
1119     got_base = 0;
1120   else
1121     got_base = elf_hash_table (info)->hgot->root.u.def.value;
1122
1123   sgot = NULL;
1124   splt = NULL;
1125   sreloc = NULL;
1126
1127   rel = relocs;
1128   relend = relocs + input_section->reloc_count;
1129   for (; rel < relend; rel++)
1130     {
1131       int r_type;
1132       reloc_howto_type *howto;
1133       unsigned long r_symndx;
1134       struct elf_link_hash_entry *h;
1135       Elf_Internal_Sym *sym;
1136       asection *sec;
1137       bfd_vma relocation;
1138       bfd_reloc_status_type r;
1139
1140       r_type = ELF32_R_TYPE (rel->r_info);
1141
1142       if (r_type == R_SPARC_GNU_VTINHERIT
1143           || r_type == R_SPARC_GNU_VTENTRY)
1144         continue;
1145
1146       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1147         {
1148           bfd_set_error (bfd_error_bad_value);
1149           return false;
1150         }
1151       howto = _bfd_sparc_elf_howto_table + r_type;
1152
1153       r_symndx = ELF32_R_SYM (rel->r_info);
1154
1155       if (info->relocateable)
1156         {
1157           /* This is a relocateable link.  We don't have to change
1158              anything, unless the reloc is against a section symbol,
1159              in which case we have to adjust according to where the
1160              section symbol winds up in the output section.  */
1161           if (r_symndx < symtab_hdr->sh_info)
1162             {
1163               sym = local_syms + r_symndx;
1164               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1165                 {
1166                   sec = local_sections[r_symndx];
1167                   rel->r_addend += sec->output_offset + sym->st_value;
1168                 }
1169             }
1170
1171           continue;
1172         }
1173
1174       /* This is a final link.  */
1175       h = NULL;
1176       sym = NULL;
1177       sec = NULL;
1178       if (r_symndx < symtab_hdr->sh_info)
1179         {
1180           sym = local_syms + r_symndx;
1181           sec = local_sections[r_symndx];
1182           relocation = (sec->output_section->vma
1183                         + sec->output_offset
1184                         + sym->st_value);
1185         }
1186       else
1187         {
1188           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1189           while (h->root.type == bfd_link_hash_indirect
1190                  || h->root.type == bfd_link_hash_warning)
1191             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1192           if (h->root.type == bfd_link_hash_defined
1193               || h->root.type == bfd_link_hash_defweak)
1194             {
1195               sec = h->root.u.def.section;
1196               if ((r_type == R_SPARC_WPLT30
1197                    && h->plt.offset != (bfd_vma) -1)
1198                   || ((r_type == R_SPARC_GOT10
1199                        || r_type == R_SPARC_GOT13
1200                        || r_type == R_SPARC_GOT22)
1201                       && elf_hash_table (info)->dynamic_sections_created
1202                       && (! info->shared
1203                           || (! info->symbolic && h->dynindx != -1)
1204                           || (h->elf_link_hash_flags
1205                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1206                   || (info->shared
1207                       && ((! info->symbolic && h->dynindx != -1)
1208                           || (h->elf_link_hash_flags
1209                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1210                       && (r_type == R_SPARC_8
1211                           || r_type == R_SPARC_16
1212                           || r_type == R_SPARC_32
1213                           || r_type == R_SPARC_DISP8
1214                           || r_type == R_SPARC_DISP16
1215                           || r_type == R_SPARC_DISP32
1216                           || r_type == R_SPARC_WDISP30
1217                           || r_type == R_SPARC_WDISP22
1218                           || r_type == R_SPARC_WDISP19
1219                           || r_type == R_SPARC_WDISP16
1220                           || r_type == R_SPARC_HI22
1221                           || r_type == R_SPARC_22
1222                           || r_type == R_SPARC_13
1223                           || r_type == R_SPARC_LO10
1224                           || r_type == R_SPARC_UA16
1225                           || r_type == R_SPARC_UA32
1226                           || r_type == R_SPARC_UA64
1227                           || ((r_type == R_SPARC_PC10
1228                                || r_type == R_SPARC_PC22)
1229                               && strcmp (h->root.root.string,
1230                                          "_GLOBAL_OFFSET_TABLE_") != 0))))
1231                 {
1232                   /* In these cases, we don't need the relocation
1233                      value.  We check specially because in some
1234                      obscure cases sec->output_section will be NULL.  */
1235                   relocation = 0;
1236                 }
1237               else
1238                 relocation = (h->root.u.def.value
1239                               + sec->output_section->vma
1240                               + sec->output_offset);
1241             }
1242           else if (h->root.type == bfd_link_hash_undefweak)
1243             relocation = 0;
1244           else if (info->shared && !info->symbolic
1245                    && !info->no_undefined
1246                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1247             relocation = 0;
1248           else
1249             {
1250               if (! ((*info->callbacks->undefined_symbol)
1251                      (info, h->root.root.string, input_bfd,
1252                       input_section, rel->r_offset,
1253                       (!info->shared || info->no_undefined
1254                        || ELF_ST_VISIBILITY (h->other)))))
1255                 return false;
1256               relocation = 0;
1257             }
1258         }
1259
1260       switch (r_type)
1261         {
1262         case R_SPARC_GOT10:
1263         case R_SPARC_GOT13:
1264         case R_SPARC_GOT22:
1265           /* Relocation is to the entry for this symbol in the global
1266              offset table.  */
1267           if (sgot == NULL)
1268             {
1269               sgot = bfd_get_section_by_name (dynobj, ".got");
1270               BFD_ASSERT (sgot != NULL);
1271             }
1272
1273           if (h != NULL)
1274             {
1275               bfd_vma off;
1276
1277               off = h->got.offset;
1278               BFD_ASSERT (off != (bfd_vma) -1);
1279
1280               if (! elf_hash_table (info)->dynamic_sections_created
1281                   || (info->shared
1282                       && (info->symbolic || h->dynindx == -1)
1283                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1284                 {
1285                   /* This is actually a static link, or it is a
1286                      -Bsymbolic link and the symbol is defined
1287                      locally, or the symbol was forced to be local
1288                      because of a version file.  We must initialize
1289                      this entry in the global offset table.  Since the
1290                      offset must always be a multiple of 4, we use the
1291                      least significant bit to record whether we have
1292                      initialized it already.
1293
1294                      When doing a dynamic link, we create a .rela.got
1295                      relocation entry to initialize the value.  This
1296                      is done in the finish_dynamic_symbol routine.  */
1297                   if ((off & 1) != 0)
1298                     off &= ~1;
1299                   else
1300                     {
1301                       bfd_put_32 (output_bfd, relocation,
1302                                   sgot->contents + off);
1303                       h->got.offset |= 1;
1304                     }
1305                 }
1306
1307               relocation = sgot->output_offset + off - got_base;
1308             }
1309           else
1310             {
1311               bfd_vma off;
1312
1313               BFD_ASSERT (local_got_offsets != NULL
1314                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
1315
1316               off = local_got_offsets[r_symndx];
1317
1318               /* The offset must always be a multiple of 4.  We use
1319                  the least significant bit to record whether we have
1320                  already processed this entry.  */
1321               if ((off & 1) != 0)
1322                 off &= ~1;
1323               else
1324                 {
1325                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1326
1327                   if (info->shared)
1328                     {
1329                       asection *srelgot;
1330                       Elf_Internal_Rela outrel;
1331
1332                       /* We need to generate a R_SPARC_RELATIVE reloc
1333                          for the dynamic linker.  */
1334                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1335                       BFD_ASSERT (srelgot != NULL);
1336
1337                       outrel.r_offset = (sgot->output_section->vma
1338                                          + sgot->output_offset
1339                                          + off);
1340                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1341                       outrel.r_addend = 0;
1342                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1343                                                  (((Elf32_External_Rela *)
1344                                                    srelgot->contents)
1345                                                   + srelgot->reloc_count));
1346                       ++srelgot->reloc_count;
1347                     }
1348
1349                   local_got_offsets[r_symndx] |= 1;
1350                 }
1351
1352               relocation = sgot->output_offset + off - got_base;
1353             }
1354
1355           break;
1356
1357         case R_SPARC_WPLT30:
1358           /* Relocation is to the entry for this symbol in the
1359              procedure linkage table.  */
1360
1361           /* The Solaris native assembler will generate a WPLT30 reloc
1362              for a local symbol if you assemble a call from one
1363              section to another when using -K pic.  We treat it as
1364              WDISP30.  */
1365           if (h == NULL)
1366             break;
1367
1368           if (h->plt.offset == (bfd_vma) -1)
1369             {
1370               /* We didn't make a PLT entry for this symbol.  This
1371                  happens when statically linking PIC code, or when
1372                  using -Bsymbolic.  */
1373               break;
1374             }
1375
1376           if (splt == NULL)
1377             {
1378               splt = bfd_get_section_by_name (dynobj, ".plt");
1379               BFD_ASSERT (splt != NULL);
1380             }
1381
1382           relocation = (splt->output_section->vma
1383                         + splt->output_offset
1384                         + h->plt.offset);
1385           break;
1386
1387         case R_SPARC_PC10:
1388         case R_SPARC_PC22:
1389           if (h != NULL
1390               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1391             break;
1392           /* Fall through.  */
1393         case R_SPARC_DISP8:
1394         case R_SPARC_DISP16:
1395         case R_SPARC_DISP32:
1396         case R_SPARC_WDISP30:
1397         case R_SPARC_WDISP22:
1398         case R_SPARC_WDISP19:
1399         case R_SPARC_WDISP16:
1400           if (h == NULL
1401               || (info->symbolic
1402                   && (h->elf_link_hash_flags
1403                       & ELF_LINK_HASH_DEF_REGULAR) != 0))
1404             break;
1405           /* Fall through.  */
1406         case R_SPARC_8:
1407         case R_SPARC_16:
1408         case R_SPARC_32:
1409         case R_SPARC_HI22:
1410         case R_SPARC_22:
1411         case R_SPARC_13:
1412         case R_SPARC_LO10:
1413         case R_SPARC_UA16:
1414         case R_SPARC_UA32:
1415         case R_SPARC_UA64:
1416           if (info->shared)
1417             {
1418               Elf_Internal_Rela outrel;
1419               boolean skip;
1420
1421               /* When generating a shared object, these relocations
1422                  are copied into the output file to be resolved at run
1423                  time.  */
1424
1425               if (sreloc == NULL)
1426                 {
1427                   const char *name;
1428
1429                   name = (bfd_elf_string_from_elf_section
1430                           (input_bfd,
1431                            elf_elfheader (input_bfd)->e_shstrndx,
1432                            elf_section_data (input_section)->rel_hdr.sh_name));
1433                   if (name == NULL)
1434                     return false;
1435
1436                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1437                               && strcmp (bfd_get_section_name (input_bfd,
1438                                                                input_section),
1439                                          name + 5) == 0);
1440
1441                   sreloc = bfd_get_section_by_name (dynobj, name);
1442                   BFD_ASSERT (sreloc != NULL);
1443                 }
1444
1445               skip = false;
1446
1447               if (elf_section_data (input_section)->stab_info == NULL)
1448                 outrel.r_offset = rel->r_offset;
1449               else
1450                 {
1451                   bfd_vma off;
1452
1453                   off = (_bfd_stab_section_offset
1454                          (output_bfd, &elf_hash_table (info)->stab_info,
1455                           input_section,
1456                           &elf_section_data (input_section)->stab_info,
1457                           rel->r_offset));
1458                   if (off == (bfd_vma) -1)
1459                     skip = true;
1460                   outrel.r_offset = off;
1461                 }
1462
1463               outrel.r_offset += (input_section->output_section->vma
1464                                   + input_section->output_offset);
1465
1466               if (skip)
1467                 memset (&outrel, 0, sizeof outrel);
1468               /* h->dynindx may be -1 if the symbol was marked to
1469                  become local.  */
1470               else if (h != NULL
1471                        && ((! info->symbolic && h->dynindx != -1)
1472                            || (h->elf_link_hash_flags
1473                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1474                 {
1475                   BFD_ASSERT (h->dynindx != -1);
1476                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1477                   outrel.r_addend = rel->r_addend;
1478                 }
1479               else
1480                 {
1481                   if (r_type == R_SPARC_32)
1482                     {
1483                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1484                       outrel.r_addend = relocation + rel->r_addend;
1485                     }
1486                   else
1487                     {
1488                       long indx;
1489
1490                       if (h == NULL)
1491                         sec = local_sections[r_symndx];
1492                       else
1493                         {
1494                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1495                                       || (h->root.type
1496                                           == bfd_link_hash_defweak));
1497                           sec = h->root.u.def.section;
1498                         }
1499                       if (sec != NULL && bfd_is_abs_section (sec))
1500                         indx = 0;
1501                       else if (sec == NULL || sec->owner == NULL)
1502                         {
1503                           bfd_set_error (bfd_error_bad_value);
1504                           return false;
1505                         }
1506                       else
1507                         {
1508                           asection *osec;
1509
1510                           osec = sec->output_section;
1511                           indx = elf_section_data (osec)->dynindx;
1512
1513                           /* FIXME: we really should be able to link non-pic
1514                              shared libraries.  */
1515                           if (indx == 0)
1516                             {
1517                               BFD_FAIL ();
1518                               (*_bfd_error_handler)
1519                                 (_("%s: probably compiled without -fPIC?"),
1520                                  bfd_get_filename (input_bfd));
1521                               bfd_set_error (bfd_error_bad_value);
1522                               return false;
1523                             }
1524                         }
1525
1526                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1527                       outrel.r_addend = relocation + rel->r_addend;
1528                     }
1529                 }
1530
1531               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1532                                          (((Elf32_External_Rela *)
1533                                            sreloc->contents)
1534                                           + sreloc->reloc_count));
1535               ++sreloc->reloc_count;
1536
1537               /* This reloc will be computed at runtime, so there's no
1538                  need to do anything now, unless this is a RELATIVE
1539                  reloc in an unallocated section.  */
1540               if (skip
1541                   || (input_section->flags & SEC_ALLOC) != 0
1542                   || ELF32_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE)
1543                 continue;
1544             }
1545           break;
1546
1547         default:
1548           break;
1549         }
1550
1551       r = bfd_reloc_continue;
1552       if (r_type == R_SPARC_WDISP16)
1553         {
1554           bfd_vma x;
1555
1556           relocation += rel->r_addend;
1557           relocation -= (input_section->output_section->vma
1558                          + input_section->output_offset);
1559           relocation -= rel->r_offset;
1560
1561           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1562           x |= ((((relocation >> 2) & 0xc000) << 6)
1563                 | ((relocation >> 2) & 0x3fff));
1564           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1565
1566           if ((bfd_signed_vma) relocation < - 0x40000
1567               || (bfd_signed_vma) relocation > 0x3ffff)
1568             r = bfd_reloc_overflow;
1569           else
1570             r = bfd_reloc_ok;
1571         }
1572       else if (r_type == R_SPARC_REV32)
1573         {
1574           bfd_vma x;
1575
1576           relocation = relocation + rel->r_addend;
1577
1578           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1579           x = x + relocation;
1580           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
1581           r = bfd_reloc_ok;
1582         }
1583       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
1584                && SEC_DO_RELAX (input_section)
1585                && rel->r_offset + 4 < input_section->_raw_size)
1586         {
1587 #define G0              0
1588 #define O7              15
1589 #define XCC             (2 << 20)
1590 #define COND(x)         (((x)&0xf)<<25)
1591 #define CONDA           COND(0x8)
1592 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
1593 #define INSN_BA         (F2(0,2) | CONDA)
1594 #define INSN_OR         F3(2, 0x2, 0)
1595 #define INSN_NOP        F2(0,4)
1596
1597           bfd_vma x, y;
1598
1599           /* If the instruction is a call with either:
1600              restore
1601              arithmetic instruction with rd == %o7
1602              where rs1 != %o7 and rs2 if it is register != %o7
1603              then we can optimize if the call destination is near
1604              by changing the call into a branch always.  */
1605           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1606           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
1607           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
1608             {
1609               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
1610                    || ((y & OP3(0x28)) == 0 /* arithmetic */
1611                        && (y & RD(~0)) == RD(O7)))
1612                   && (y & RS1(~0)) != RS1(O7)
1613                   && ((y & F3I(~0))
1614                       || (y & RS2(~0)) != RS2(O7)))
1615                 {
1616                   bfd_vma reloc;
1617
1618                   reloc = relocation + rel->r_addend - rel->r_offset;
1619                   reloc -= (input_section->output_section->vma
1620                            + input_section->output_offset);
1621
1622                   /* Ensure the reloc fits into simm22.  */
1623                   if ((reloc & 3) == 0
1624                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
1625                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
1626                     {
1627                       reloc >>= 2;
1628
1629                       /* Check whether it fits into simm19 on v9.  */
1630                       if (((reloc & 0x3c0000) == 0
1631                            || (reloc & 0x3c0000) == 0x3c0000)
1632                           && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
1633                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
1634                       else
1635                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
1636                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1637                       r = bfd_reloc_ok;
1638                       if (rel->r_offset >= 4
1639                           && (y & (0xffffffff ^ RS1(~0)))
1640                               == (INSN_OR | RD(O7) | RS2(G0)))
1641                         {
1642                           bfd_vma z;
1643                           unsigned int reg;
1644
1645                           z = bfd_get_32 (input_bfd,
1646                                           contents + rel->r_offset - 4);
1647                           if ((z & (0xffffffff ^ RD(~0)))
1648                               != (INSN_OR | RS1(O7) | RS2(G0)))
1649                             break;
1650
1651                           /* The sequence was
1652                              or %o7, %g0, %rN
1653                              call foo
1654                              or %rN, %g0, %o7
1655
1656                              If call foo was replaced with ba, replace
1657                              or %rN, %g0, %o7 with nop.  */
1658
1659                           reg = (y & RS1(~0)) >> 14;
1660                           if (reg != ((z & RD(~0)) >> 25)
1661                               || reg == G0 || reg == O7)
1662                             break;
1663
1664                           bfd_put_32 (input_bfd, INSN_NOP,
1665                                       contents + rel->r_offset + 4);
1666                         }
1667
1668                     }
1669                 }
1670             }
1671         }
1672
1673       if (r == bfd_reloc_continue)
1674         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1675                                       contents, rel->r_offset,
1676                                       relocation, rel->r_addend);
1677
1678       if (r != bfd_reloc_ok)
1679         {
1680           switch (r)
1681             {
1682             default:
1683             case bfd_reloc_outofrange:
1684               abort ();
1685             case bfd_reloc_overflow:
1686               {
1687                 const char *name;
1688
1689                 if (h != NULL)
1690                   name = h->root.root.string;
1691                 else
1692                   {
1693                     name = bfd_elf_string_from_elf_section (input_bfd,
1694                                                             symtab_hdr->sh_link,
1695                                                             sym->st_name);
1696                     if (name == NULL)
1697                       return false;
1698                     if (*name == '\0')
1699                       name = bfd_section_name (input_bfd, sec);
1700                   }
1701                 if (! ((*info->callbacks->reloc_overflow)
1702                        (info, name, howto->name, (bfd_vma) 0,
1703                         input_bfd, input_section, rel->r_offset)))
1704                   return false;
1705               }
1706               break;
1707             }
1708         }
1709     }
1710
1711   return true;
1712 }
1713
1714 /* Finish up dynamic symbol handling.  We set the contents of various
1715    dynamic sections here.  */
1716
1717 static boolean
1718 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1719      bfd *output_bfd;
1720      struct bfd_link_info *info;
1721      struct elf_link_hash_entry *h;
1722      Elf_Internal_Sym *sym;
1723 {
1724   bfd *dynobj;
1725
1726   dynobj = elf_hash_table (info)->dynobj;
1727
1728   if (h->plt.offset != (bfd_vma) -1)
1729     {
1730       asection *splt;
1731       asection *srela;
1732       Elf_Internal_Rela rela;
1733
1734       /* This symbol has an entry in the procedure linkage table.  Set
1735          it up.  */
1736
1737       BFD_ASSERT (h->dynindx != -1);
1738
1739       splt = bfd_get_section_by_name (dynobj, ".plt");
1740       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1741       BFD_ASSERT (splt != NULL && srela != NULL);
1742
1743       /* Fill in the entry in the procedure linkage table.  */
1744       bfd_put_32 (output_bfd,
1745                   PLT_ENTRY_WORD0 + h->plt.offset,
1746                   splt->contents + h->plt.offset);
1747       bfd_put_32 (output_bfd,
1748                   (PLT_ENTRY_WORD1
1749                    + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
1750                   splt->contents + h->plt.offset + 4);
1751       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
1752                   splt->contents + h->plt.offset + 8);
1753
1754       /* Fill in the entry in the .rela.plt section.  */
1755       rela.r_offset = (splt->output_section->vma
1756                        + splt->output_offset
1757                        + h->plt.offset);
1758       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1759       rela.r_addend = 0;
1760       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1761                                  ((Elf32_External_Rela *) srela->contents
1762                                   + h->plt.offset / PLT_ENTRY_SIZE - 4));
1763
1764       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1765         {
1766           /* Mark the symbol as undefined, rather than as defined in
1767              the .plt section.  Leave the value alone.  */
1768           sym->st_shndx = SHN_UNDEF;
1769           /* If the symbol is weak, we do need to clear the value.
1770              Otherwise, the PLT entry would provide a definition for
1771              the symbol even if the symbol wasn't defined anywhere,
1772              and so the symbol would never be NULL.  */
1773           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1774               == 0)
1775             sym->st_value = 0;
1776         }
1777     }
1778
1779   if (h->got.offset != (bfd_vma) -1)
1780     {
1781       asection *sgot;
1782       asection *srela;
1783       Elf_Internal_Rela rela;
1784
1785       /* This symbol has an entry in the global offset table.  Set it
1786          up.  */
1787
1788       sgot = bfd_get_section_by_name (dynobj, ".got");
1789       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1790       BFD_ASSERT (sgot != NULL && srela != NULL);
1791
1792       rela.r_offset = (sgot->output_section->vma
1793                        + sgot->output_offset
1794                        + (h->got.offset &~ 1));
1795
1796       /* If this is a -Bsymbolic link, and the symbol is defined
1797          locally, we just want to emit a RELATIVE reloc.  Likewise if
1798          the symbol was forced to be local because of a version file.
1799          The entry in the global offset table will already have been
1800          initialized in the relocate_section function.  */
1801       if (info->shared
1802           && (info->symbolic || h->dynindx == -1)
1803           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1804         rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1805       else
1806         {
1807           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1808           rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1809         }
1810
1811       rela.r_addend = 0;
1812       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1813                                  ((Elf32_External_Rela *) srela->contents
1814                                   + srela->reloc_count));
1815       ++srela->reloc_count;
1816     }
1817
1818   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1819     {
1820       asection *s;
1821       Elf_Internal_Rela rela;
1822
1823       /* This symbols needs a copy reloc.  Set it up.  */
1824
1825       BFD_ASSERT (h->dynindx != -1);
1826
1827       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1828                                    ".rela.bss");
1829       BFD_ASSERT (s != NULL);
1830
1831       rela.r_offset = (h->root.u.def.value
1832                        + h->root.u.def.section->output_section->vma
1833                        + h->root.u.def.section->output_offset);
1834       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1835       rela.r_addend = 0;
1836       bfd_elf32_swap_reloca_out (output_bfd, &rela,
1837                                  ((Elf32_External_Rela *) s->contents
1838                                   + s->reloc_count));
1839       ++s->reloc_count;
1840     }
1841
1842   /* Mark some specially defined symbols as absolute.  */
1843   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1844       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1845       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1846     sym->st_shndx = SHN_ABS;
1847
1848   return true;
1849 }
1850
1851 /* Finish up the dynamic sections.  */
1852
1853 static boolean
1854 elf32_sparc_finish_dynamic_sections (output_bfd, info)
1855      bfd *output_bfd;
1856      struct bfd_link_info *info;
1857 {
1858   bfd *dynobj;
1859   asection *sdyn;
1860   asection *sgot;
1861
1862   dynobj = elf_hash_table (info)->dynobj;
1863
1864   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1865
1866   if (elf_hash_table (info)->dynamic_sections_created)
1867     {
1868       asection *splt;
1869       Elf32_External_Dyn *dyncon, *dynconend;
1870
1871       splt = bfd_get_section_by_name (dynobj, ".plt");
1872       BFD_ASSERT (splt != NULL && sdyn != NULL);
1873
1874       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1875       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1876       for (; dyncon < dynconend; dyncon++)
1877         {
1878           Elf_Internal_Dyn dyn;
1879           const char *name;
1880           boolean size;
1881
1882           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1883
1884           switch (dyn.d_tag)
1885             {
1886             case DT_PLTGOT:   name = ".plt"; size = false; break;
1887             case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1888             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
1889             default:      name = NULL; size = false; break;
1890             }
1891
1892           if (name != NULL)
1893             {
1894               asection *s;
1895
1896               s = bfd_get_section_by_name (output_bfd, name);
1897               if (s == NULL)
1898                 dyn.d_un.d_val = 0;
1899               else
1900                 {
1901                   if (! size)
1902                     dyn.d_un.d_ptr = s->vma;
1903                   else
1904                     {
1905                       if (s->_cooked_size != 0)
1906                         dyn.d_un.d_val = s->_cooked_size;
1907                       else
1908                         dyn.d_un.d_val = s->_raw_size;
1909                     }
1910                 }
1911               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1912             }
1913         }
1914
1915       /* Clear the first four entries in the procedure linkage table,
1916          and put a nop in the last four bytes.  */
1917       if (splt->_raw_size > 0)
1918         {
1919           memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1920           bfd_put_32 (output_bfd, SPARC_NOP,
1921                       splt->contents + splt->_raw_size - 4);
1922         }
1923
1924       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1925         PLT_ENTRY_SIZE;
1926     }
1927
1928   /* Set the first entry in the global offset table to the address of
1929      the dynamic section.  */
1930   sgot = bfd_get_section_by_name (dynobj, ".got");
1931   BFD_ASSERT (sgot != NULL);
1932   if (sgot->_raw_size > 0)
1933     {
1934       if (sdyn == NULL)
1935         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1936       else
1937         bfd_put_32 (output_bfd,
1938                     sdyn->output_section->vma + sdyn->output_offset,
1939                     sgot->contents);
1940     }
1941
1942   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1943
1944   return true;
1945 }
1946 \f
1947 /* Functions for dealing with the e_flags field.
1948
1949    We don't define set_private_flags or copy_private_bfd_data because
1950    the only currently defined values are based on the bfd mach number,
1951    so we use the latter instead and defer setting e_flags until the
1952    file is written out.  */
1953
1954 /* Merge backend specific data from an object file to the output
1955    object file when linking.  */
1956
1957 static boolean
1958 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1959      bfd *ibfd;
1960      bfd *obfd;
1961 {
1962   boolean error;
1963   /* FIXME: This should not be static.  */
1964   static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
1965
1966   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1967       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1968     return true;
1969
1970   error = false;
1971
1972   if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1973     {
1974       error = true;
1975       (*_bfd_error_handler)
1976         (_("%s: compiled for a 64 bit system and target is 32 bit"),
1977          bfd_get_filename (ibfd));
1978     }
1979   else if ((ibfd->flags & DYNAMIC) == 0)
1980     {
1981       if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1982         bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1983     }
1984
1985   if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
1986        != previous_ibfd_e_flags)
1987       && previous_ibfd_e_flags != (unsigned long) -1)
1988     {
1989       (*_bfd_error_handler)
1990         (_("%s: linking little endian files with big endian files"),
1991          bfd_get_filename (ibfd));
1992       error = true;
1993     }
1994   previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
1995
1996   if (error)
1997     {
1998       bfd_set_error (bfd_error_bad_value);
1999       return false;
2000     }
2001
2002   return true;
2003 }
2004 \f
2005 /* Set the right machine number.  */
2006
2007 static boolean
2008 elf32_sparc_object_p (abfd)
2009      bfd *abfd;
2010 {
2011   if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
2012     {
2013       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
2014         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2015                                           bfd_mach_sparc_v8plusb);
2016       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2017         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2018                                           bfd_mach_sparc_v8plusa);
2019       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
2020         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2021                                           bfd_mach_sparc_v8plus);
2022       else
2023         return false;
2024     }
2025   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
2026     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2027                                       bfd_mach_sparc_sparclite_le);
2028   else
2029     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
2030 }
2031
2032 /* The final processing done just before writing out the object file.
2033    We need to set the e_machine field appropriately.  */
2034
2035 static void
2036 elf32_sparc_final_write_processing (abfd, linker)
2037      bfd *abfd;
2038      boolean linker ATTRIBUTE_UNUSED;
2039 {
2040   switch (bfd_get_mach (abfd))
2041     {
2042     case bfd_mach_sparc :
2043       break; /* nothing to do */
2044     case bfd_mach_sparc_v8plus :
2045       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2046       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2047       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
2048       break;
2049     case bfd_mach_sparc_v8plusa :
2050       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2051       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2052       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
2053       break;
2054     case bfd_mach_sparc_v8plusb :
2055       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2056       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2057       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
2058                                        | EF_SPARC_SUN_US3;
2059       break;
2060     case bfd_mach_sparc_sparclite_le :
2061       elf_elfheader (abfd)->e_machine = EM_SPARC;
2062       elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
2063       break;
2064     default :
2065       abort ();
2066       break;
2067     }
2068 }
2069 \f
2070 #define TARGET_BIG_SYM  bfd_elf32_sparc_vec
2071 #define TARGET_BIG_NAME "elf32-sparc"
2072 #define ELF_ARCH        bfd_arch_sparc
2073 #define ELF_MACHINE_CODE EM_SPARC
2074 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2075 #define ELF_MAXPAGESIZE 0x10000
2076
2077 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2078 #define bfd_elf32_bfd_relax_section     elf32_sparc_relax_section
2079 #define elf_info_to_howto               elf32_sparc_info_to_howto
2080 #define elf_backend_create_dynamic_sections \
2081                                         _bfd_elf_create_dynamic_sections
2082 #define elf_backend_check_relocs        elf32_sparc_check_relocs
2083 #define elf_backend_adjust_dynamic_symbol \
2084                                         elf32_sparc_adjust_dynamic_symbol
2085 #define elf_backend_size_dynamic_sections \
2086                                         elf32_sparc_size_dynamic_sections
2087 #define elf_backend_relocate_section    elf32_sparc_relocate_section
2088 #define elf_backend_finish_dynamic_symbol \
2089                                         elf32_sparc_finish_dynamic_symbol
2090 #define elf_backend_finish_dynamic_sections \
2091                                         elf32_sparc_finish_dynamic_sections
2092 #define bfd_elf32_bfd_merge_private_bfd_data \
2093                                         elf32_sparc_merge_private_bfd_data
2094 #define elf_backend_object_p            elf32_sparc_object_p
2095 #define elf_backend_final_write_processing \
2096                                         elf32_sparc_final_write_processing
2097 #define elf_backend_gc_mark_hook        elf32_sparc_gc_mark_hook
2098 #define elf_backend_gc_sweep_hook       elf32_sparc_gc_sweep_hook
2099
2100 #define elf_backend_can_gc_sections 1
2101 #define elf_backend_want_got_plt 0
2102 #define elf_backend_plt_readonly 0
2103 #define elf_backend_want_plt_sym 1
2104 #define elf_backend_got_header_size 4
2105 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2106
2107 #include "elf32-target.h"