bfd/elf32-sparc.c

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