bfd/elf32-sparc.c

   1 /* SPARC-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004 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 bfd_boolean elf32_sparc_check_relocs
  34   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  35            const Elf_Internal_Rela *));
  36 static bfd_boolean elf32_sparc_adjust_dynamic_symbol
  37   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  38 static bfd_boolean allocate_dynrelocs
  39   PARAMS ((struct elf_link_hash_entry *, PTR));
  40 static bfd_boolean readonly_dynrelocs
  41   PARAMS ((struct elf_link_hash_entry *, PTR));
  42 static bfd_boolean elf32_sparc_size_dynamic_sections
  43   PARAMS ((bfd *, struct bfd_link_info *));
  44 static bfd_boolean elf32_sparc_new_section_hook
  45   PARAMS ((bfd *, asection *));
  46 static bfd_boolean elf32_sparc_relax_section
  47   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  48 static bfd_vma dtpoff_base
  49   PARAMS ((struct bfd_link_info *));
  50 static bfd_vma tpoff
  51   PARAMS ((struct bfd_link_info *, bfd_vma));
  52 static bfd_boolean elf32_sparc_relocate_section
  53   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  54            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  55 static bfd_boolean elf32_sparc_finish_dynamic_symbol
  56   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  57            Elf_Internal_Sym *));
  58 static bfd_boolean elf32_sparc_finish_dynamic_sections
  59   PARAMS ((bfd *, struct bfd_link_info *));
  60 static bfd_boolean elf32_sparc_merge_private_bfd_data
  61   PARAMS ((bfd *, bfd *));
  62 static struct bfd_hash_entry *link_hash_newfunc
  63   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  64 static struct bfd_link_hash_table *elf32_sparc_link_hash_table_create
  65   PARAMS ((bfd *));
  66 static bfd_boolean create_got_section
  67   PARAMS ((bfd *, struct bfd_link_info *));
  68 static bfd_boolean elf32_sparc_create_dynamic_sections
  69   PARAMS ((bfd *, struct bfd_link_info *));
  70 static void elf32_sparc_copy_indirect_symbol
  71   PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
  72           struct elf_link_hash_entry *));
  73 static int elf32_sparc_tls_transition
  74   PARAMS ((struct bfd_link_info *, bfd *, int, int));
  75
  76 static bfd_boolean elf32_sparc_mkobject
  77   PARAMS ((bfd *));
  78 static bfd_boolean elf32_sparc_object_p
  79   PARAMS ((bfd *));
  80 static void elf32_sparc_final_write_processing
  81   PARAMS ((bfd *, bfd_boolean));
  82 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
  83   PARAMS ((const Elf_Internal_Rela *));
  84 static asection * elf32_sparc_gc_mark_hook
  85   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  86            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  87 static bfd_boolean elf32_sparc_gc_sweep_hook
  88   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  89            const Elf_Internal_Rela *));
  90 \f
  91 /* The relocation "howto" table.  */
  92
  93 static bfd_reloc_status_type sparc_elf_notsupported_reloc
  94   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  95 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
  96   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  97 static bfd_reloc_status_type sparc_elf_hix22_reloc
  98   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  99 static bfd_reloc_status_type sparc_elf_lox10_reloc
 100   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 101
 102 reloc_howto_type _bfd_sparc_elf_howto_table[] =
 103 {
 104   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 105   HOWTO(R_SPARC_8,         0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_8",       FALSE,0,0x000000ff,TRUE),
 106   HOWTO(R_SPARC_16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_16",      FALSE,0,0x0000ffff,TRUE),
 107   HOWTO(R_SPARC_32,        0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_32",      FALSE,0,0xffffffff,TRUE),
 108   HOWTO(R_SPARC_DISP8,     0,0, 8,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP8",   FALSE,0,0x000000ff,TRUE),
 109   HOWTO(R_SPARC_DISP16,    0,1,16,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP16",  FALSE,0,0x0000ffff,TRUE),
 110   HOWTO(R_SPARC_DISP32,    0,2,32,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP32",  FALSE,0,0xffffffff,TRUE),
 111   HOWTO(R_SPARC_WDISP30,   2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
 112   HOWTO(R_SPARC_WDISP22,   2,2,22,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
 113   HOWTO(R_SPARC_HI22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HI22",    FALSE,0,0x003fffff,TRUE),
 114   HOWTO(R_SPARC_22,        0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_22",      FALSE,0,0x003fffff,TRUE),
 115   HOWTO(R_SPARC_13,        0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_13",      FALSE,0,0x00001fff,TRUE),
 116   HOWTO(R_SPARC_LO10,      0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LO10",    FALSE,0,0x000003ff,TRUE),
 117   HOWTO(R_SPARC_GOT10,     0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT10",   FALSE,0,0x000003ff,TRUE),
 118   HOWTO(R_SPARC_GOT13,     0,2,13,FALSE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_GOT13",   FALSE,0,0x00001fff,TRUE),
 119   HOWTO(R_SPARC_GOT22,    10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT22",   FALSE,0,0x003fffff,TRUE),
 120   HOWTO(R_SPARC_PC10,      0,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC10",    FALSE,0,0x000003ff,TRUE),
 121   HOWTO(R_SPARC_PC22,     10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PC22",    FALSE,0,0x003fffff,TRUE),
 122   HOWTO(R_SPARC_WPLT30,    2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WPLT30",  FALSE,0,0x3fffffff,TRUE),
 123   HOWTO(R_SPARC_COPY,      0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_COPY",    FALSE,0,0x00000000,TRUE),
 124   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),
 125   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),
 126   HOWTO(R_SPARC_RELATIVE,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
 127   HOWTO(R_SPARC_UA32,      0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA32",    FALSE,0,0xffffffff,TRUE),
 128   HOWTO(R_SPARC_PLT32,     0,0,00,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT32",   FALSE,0,0xffffffff,TRUE),
 129   HOWTO(R_SPARC_HIPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HIPLT22",  FALSE,0,0x00000000,TRUE),
 130   HOWTO(R_SPARC_LOPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LOPLT10",  FALSE,0,0x00000000,TRUE),
 131   HOWTO(R_SPARC_PCPLT32,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT32",  FALSE,0,0x00000000,TRUE),
 132   HOWTO(R_SPARC_PCPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT22",  FALSE,0,0x00000000,TRUE),
 133   HOWTO(R_SPARC_PCPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT10",  FALSE,0,0x00000000,TRUE),
 134   HOWTO(R_SPARC_10,        0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      FALSE,0,0x000003ff,TRUE),
 135   HOWTO(R_SPARC_11,        0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      FALSE,0,0x000007ff,TRUE),
 136   /* These are for sparc64 in a 64 bit environment.
 137      Values need to be here because the table is indexed by reloc number.  */
 138   HOWTO(R_SPARC_64,        0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_64",      FALSE,0,0x00000000,TRUE),
 139   HOWTO(R_SPARC_OLO10,     0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_OLO10",   FALSE,0,0x00000000,TRUE),
 140   HOWTO(R_SPARC_HH22,      0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HH22",    FALSE,0,0x00000000,TRUE),
 141   HOWTO(R_SPARC_HM10,      0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HM10",    FALSE,0,0x00000000,TRUE),
 142   HOWTO(R_SPARC_LM22,      0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LM22",    FALSE,0,0x00000000,TRUE),
 143   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),
 144   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),
 145   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),
 146   /* End sparc64 in 64 bit environment values.
 147      The following are for sparc64 in a 32 bit environment.  */
 148   HOWTO(R_SPARC_WDISP16,   2,2,16,TRUE, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
 149   HOWTO(R_SPARC_WDISP19,   2,2,19,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
 150   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),
 151   HOWTO(R_SPARC_7,         0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       FALSE,0,0x0000007f,TRUE),
 152   HOWTO(R_SPARC_5,         0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       FALSE,0,0x0000001f,TRUE),
 153   HOWTO(R_SPARC_6,         0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       FALSE,0,0x0000003f,TRUE),
 154   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 155   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 156   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 157   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 158   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 159   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 160   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 161   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 162   HOWTO(R_SPARC_UA64,      0,0, 0,FALSE,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_UA64",    FALSE,0,0x00000000,TRUE),
 163   HOWTO(R_SPARC_UA16,      0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA16",    FALSE,0,0x0000ffff,TRUE),
 164   HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
 165   HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
 166   HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
 167   HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
 168   HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
 169   HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
 170   HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
 171   HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
 172   HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
 173   HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont,  sparc_elf_lox10_reloc,  "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
 174   HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
 175   HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
 176   HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
 177   HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont,     bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
 178   HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
 179   HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
 180   HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
 181   HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont,   sparc_elf_lox10_reloc,  "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
 182   HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
 183   HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
 184   HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
 185   HOWTO(R_SPARC_TLS_DTPOFF64,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPOFF64",FALSE,0,0x00000000,TRUE),
 186   HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
 187   HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE)
 188 };
 189 static reloc_howto_type elf32_sparc_vtinherit_howto =
 190   HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
 191 static reloc_howto_type elf32_sparc_vtentry_howto =
 192   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);
 193 static reloc_howto_type elf32_sparc_rev32_howto =
 194   HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
 195
 196 struct elf_reloc_map {
 197   bfd_reloc_code_real_type bfd_reloc_val;
 198   unsigned char elf_reloc_val;
 199 };
 200
 201 static const struct elf_reloc_map sparc_reloc_map[] =
 202 {
 203   { BFD_RELOC_NONE, R_SPARC_NONE, },
 204   { BFD_RELOC_16, R_SPARC_16, },
 205   { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
 206   { BFD_RELOC_8, R_SPARC_8 },
 207   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
 208   { BFD_RELOC_CTOR, R_SPARC_32 },
 209   { BFD_RELOC_32, R_SPARC_32 },
 210   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
 211   { BFD_RELOC_HI22, R_SPARC_HI22 },
 212   { BFD_RELOC_LO10, R_SPARC_LO10, },
 213   { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
 214   { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
 215   { BFD_RELOC_SPARC22, R_SPARC_22 },
 216   { BFD_RELOC_SPARC13, R_SPARC_13 },
 217   { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
 218   { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
 219   { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
 220   { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
 221   { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
 222   { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
 223   { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
 224   { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
 225   { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
 226   { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
 227   { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
 228   { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
 229   { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
 230   { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
 231   { BFD_RELOC_SPARC_10, R_SPARC_10 },
 232   { BFD_RELOC_SPARC_11, R_SPARC_11 },
 233   { BFD_RELOC_SPARC_64, R_SPARC_64 },
 234   { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
 235   { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
 236   { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
 237   { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
 238   { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
 239   { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
 240   { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
 241   { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
 242   { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
 243   { BFD_RELOC_SPARC_7, R_SPARC_7 },
 244   { BFD_RELOC_SPARC_5, R_SPARC_5 },
 245   { BFD_RELOC_SPARC_6, R_SPARC_6 },
 246   { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
 247   { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
 248   { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
 249   { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
 250   { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
 251   { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
 252   { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
 253   { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
 254   { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
 255   { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
 256   { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
 257   { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
 258   { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
 259   { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
 260   { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
 261   { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
 262   { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
 263   { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
 264   { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
 265   { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
 266   { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
 267   { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
 268   { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
 269   { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
 270   { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
 271   { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
 272   { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }
 273 };
 274
 275 static reloc_howto_type *
 276 elf32_sparc_reloc_type_lookup (abfd, code)
 277      bfd *abfd ATTRIBUTE_UNUSED;
 278      bfd_reloc_code_real_type code;
 279 {
 280   unsigned int i;
 281
 282   switch (code)
 283     {
 284     case BFD_RELOC_VTABLE_INHERIT:
 285       return &elf32_sparc_vtinherit_howto;
 286
 287     case BFD_RELOC_VTABLE_ENTRY:
 288       return &elf32_sparc_vtentry_howto;
 289
 290     case BFD_RELOC_SPARC_REV32:
 291       return &elf32_sparc_rev32_howto;
 292
 293     default:
 294       for (i = 0;
 295            i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
 296            i++)
 297         {
 298           if (sparc_reloc_map[i].bfd_reloc_val == code)
 299             return (_bfd_sparc_elf_howto_table
 300                     + (int) sparc_reloc_map[i].elf_reloc_val);
 301         }
 302     }
 303     bfd_set_error (bfd_error_bad_value);
 304     return NULL;
 305 }
 306
 307 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
 308    and elf64-sparc.c has its own copy.  */
 309
 310 static void
 311 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
 312      bfd *abfd ATTRIBUTE_UNUSED;
 313      arelent *cache_ptr;
 314      Elf_Internal_Rela *dst;
 315 {
 316   switch (ELF32_R_TYPE(dst->r_info))
 317     {
 318     case R_SPARC_GNU_VTINHERIT:
 319       cache_ptr->howto = &elf32_sparc_vtinherit_howto;
 320       break;
 321
 322     case R_SPARC_GNU_VTENTRY:
 323       cache_ptr->howto = &elf32_sparc_vtentry_howto;
 324       break;
 325
 326     case R_SPARC_REV32:
 327       cache_ptr->howto = &elf32_sparc_rev32_howto;
 328       break;
 329
 330     default:
 331       BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
 332       cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
 333     }
 334 }
 335 \f
 336 /* For unsupported relocs.  */
 337
 338 static bfd_reloc_status_type
 339 sparc_elf_notsupported_reloc (abfd,
 340                              reloc_entry,
 341                              symbol,
 342                              data,
 343                              input_section,
 344                              output_bfd,
 345                              error_message)
 346      bfd *abfd ATTRIBUTE_UNUSED;
 347      arelent *reloc_entry ATTRIBUTE_UNUSED;
 348      asymbol *symbol ATTRIBUTE_UNUSED;
 349      PTR data ATTRIBUTE_UNUSED;
 350      asection *input_section ATTRIBUTE_UNUSED;
 351      bfd *output_bfd ATTRIBUTE_UNUSED;
 352      char **error_message ATTRIBUTE_UNUSED;
 353 {
 354   return bfd_reloc_notsupported;
 355 }
 356
 357 /* Handle the WDISP16 reloc.  */
 358
 359 static bfd_reloc_status_type
 360 sparc_elf_wdisp16_reloc (abfd,
 361                          reloc_entry,
 362                          symbol,
 363                          data,
 364                          input_section,
 365                          output_bfd,
 366                          error_message)
 367      bfd *abfd;
 368      arelent *reloc_entry;
 369      asymbol *symbol;
 370      PTR data;
 371      asection *input_section;
 372      bfd *output_bfd;
 373      char **error_message ATTRIBUTE_UNUSED;
 374 {
 375   bfd_vma relocation;
 376   bfd_vma x;
 377   bfd_size_type sz;
 378
 379   if (output_bfd != (bfd *) NULL
 380       && (symbol->flags & BSF_SECTION_SYM) == 0
 381       && (! reloc_entry->howto->partial_inplace
 382           || reloc_entry->addend == 0))
 383     {
 384       reloc_entry->address += input_section->output_offset;
 385       return bfd_reloc_ok;
 386     }
 387
 388   if (output_bfd != NULL)
 389     return bfd_reloc_continue;
 390
 391   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
 392   if (reloc_entry->address > sz)
 393     return bfd_reloc_outofrange;
 394
 395   relocation = (symbol->value
 396                 + symbol->section->output_section->vma
 397                 + symbol->section->output_offset);
 398   relocation += reloc_entry->addend;
 399   relocation -= (input_section->output_section->vma
 400                  + input_section->output_offset);
 401   relocation -= reloc_entry->address;
 402
 403   x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 404   x |= ((((relocation >> 2) & 0xc000) << 6)
 405         | ((relocation >> 2) & 0x3fff));
 406   bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
 407
 408   if ((bfd_signed_vma) relocation < - 0x40000
 409       || (bfd_signed_vma) relocation > 0x3ffff)
 410     return bfd_reloc_overflow;
 411   else
 412     return bfd_reloc_ok;
 413 }
 414
 415 /* Handle the HIX22 reloc.  */
 416
 417 static bfd_reloc_status_type
 418 sparc_elf_hix22_reloc (abfd,
 419                        reloc_entry,
 420                        symbol,
 421                        data,
 422                        input_section,
 423                        output_bfd,
 424                        error_message)
 425      bfd *abfd;
 426      arelent *reloc_entry;
 427      asymbol *symbol;
 428      PTR data;
 429      asection *input_section;
 430      bfd *output_bfd;
 431      char **error_message ATTRIBUTE_UNUSED;
 432 {
 433   bfd_vma relocation;
 434   bfd_vma insn;
 435   bfd_size_type sz;
 436
 437   if (output_bfd != (bfd *) NULL
 438       && (symbol->flags & BSF_SECTION_SYM) == 0)
 439     {
 440       reloc_entry->address += input_section->output_offset;
 441       return bfd_reloc_ok;
 442     }
 443
 444   if (output_bfd != NULL)
 445     return bfd_reloc_continue;
 446
 447   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
 448   if (reloc_entry->address > sz)
 449     return bfd_reloc_outofrange;
 450
 451   relocation = (symbol->value
 452                 + symbol->section->output_section->vma
 453                 + symbol->section->output_offset);
 454   relocation += reloc_entry->addend;
 455   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 456
 457   insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff);
 458   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 459
 460   return bfd_reloc_ok;
 461 }
 462
 463 /* Handle the LOX10 reloc.  */
 464
 465 static bfd_reloc_status_type
 466 sparc_elf_lox10_reloc (abfd,
 467                        reloc_entry,
 468                        symbol,
 469                        data,
 470                        input_section,
 471                        output_bfd,
 472                        error_message)
 473      bfd *abfd;
 474      arelent *reloc_entry;
 475      asymbol *symbol;
 476      PTR data;
 477      asection *input_section;
 478      bfd *output_bfd;
 479      char **error_message ATTRIBUTE_UNUSED;
 480 {
 481   bfd_vma relocation;
 482   bfd_vma insn;
 483   bfd_size_type sz;
 484
 485   if (output_bfd != (bfd *) NULL
 486       && (symbol->flags & BSF_SECTION_SYM) == 0)
 487     {
 488       reloc_entry->address += input_section->output_offset;
 489       return bfd_reloc_ok;
 490     }
 491
 492   if (output_bfd != NULL)
 493     return bfd_reloc_continue;
 494
 495   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
 496   if (reloc_entry->address > sz)
 497     return bfd_reloc_outofrange;
 498
 499   relocation = (symbol->value
 500                 + symbol->section->output_section->vma
 501                 + symbol->section->output_offset);
 502   relocation += reloc_entry->addend;
 503   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 504
 505   insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
 506   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 507
 508   return bfd_reloc_ok;
 509 }
 510 \f
 511 /* Support for core dump NOTE sections.  */
 512
 513 static bfd_boolean
 514 elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 515 {
 516   switch (note->descsz)
 517     {
 518     default:
 519       return FALSE;
 520
 521     case 260:                   /* Solaris prpsinfo_t.  */
 522       elf_tdata (abfd)->core_program
 523         = _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
 524       elf_tdata (abfd)->core_command
 525         = _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
 526       break;
 527
 528     case 336:                   /* Solaris psinfo_t.  */
 529       elf_tdata (abfd)->core_program
 530         = _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
 531       elf_tdata (abfd)->core_command
 532         = _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
 533       break;
 534     }
 535
 536   return TRUE;
 537 }
 538
 539 \f
 540 /* Functions for the SPARC ELF linker.  */
 541
 542 /* The name of the dynamic interpreter.  This is put in the .interp
 543    section.  */
 544
 545 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 546
 547 /* The nop opcode we use.  */
 548
 549 #define SPARC_NOP 0x01000000
 550
 551 /* The size in bytes of an entry in the procedure linkage table.  */
 552
 553 #define PLT_ENTRY_SIZE 12
 554
 555 /* The first four entries in a procedure linkage table are reserved,
 556    and the initial contents are unimportant (we zero them out).
 557    Subsequent entries look like this.  See the SVR4 ABI SPARC
 558    supplement to see how this works.  */
 559
 560 /* sethi %hi(.-.plt0),%g1.  We fill in the address later.  */
 561 #define PLT_ENTRY_WORD0 0x03000000
 562 /* b,a .plt0.  We fill in the offset later.  */
 563 #define PLT_ENTRY_WORD1 0x30800000
 564 /* nop.  */
 565 #define PLT_ENTRY_WORD2 SPARC_NOP
 566
 567 /* The SPARC linker needs to keep track of the number of relocs that it
 568    decides to copy as dynamic relocs in check_relocs for each symbol.
 569    This is so that it can later discard them if they are found to be
 570    unnecessary.  We store the information in a field extending the
 571    regular ELF linker hash table.  */
 572
 573 struct elf32_sparc_dyn_relocs
 574 {
 575   struct elf32_sparc_dyn_relocs *next;
 576
 577   /* The input section of the reloc.  */
 578   asection *sec;
 579
 580   /* Total number of relocs copied for the input section.  */
 581   bfd_size_type count;
 582
 583   /* Number of pc-relative relocs copied for the input section.  */
 584   bfd_size_type pc_count;
 585 };
 586
 587 /* SPARC ELF linker hash entry.  */
 588
 589 struct elf32_sparc_link_hash_entry
 590 {
 591   struct elf_link_hash_entry elf;
 592
 593   /* Track dynamic relocs copied for this symbol.  */
 594   struct elf32_sparc_dyn_relocs *dyn_relocs;
 595
 596 #define GOT_UNKNOWN     0
 597 #define GOT_NORMAL      1
 598 #define GOT_TLS_GD      2
 599 #define GOT_TLS_IE      3
 600   unsigned char tls_type;
 601 };
 602
 603 #define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
 604
 605 struct elf32_sparc_obj_tdata
 606 {
 607   struct elf_obj_tdata root;
 608
 609   /* tls_type for each local got entry.  */
 610   char *local_got_tls_type;
 611
 612   /* TRUE if TLS GD relocs has been seen for this object.  */
 613   bfd_boolean has_tlsgd;
 614 };
 615
 616 #define elf32_sparc_tdata(abfd) \
 617   ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
 618
 619 #define elf32_sparc_local_got_tls_type(abfd) \
 620   (elf32_sparc_tdata (abfd)->local_got_tls_type)
 621
 622 static bfd_boolean
 623 elf32_sparc_mkobject (abfd)
 624      bfd *abfd;
 625 {
 626   bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
 627   abfd->tdata.any = bfd_zalloc (abfd, amt);
 628   if (abfd->tdata.any == NULL)
 629     return FALSE;
 630   return TRUE;
 631 }
 632
 633 /* SPARC ELF linker hash table.  */
 634
 635 struct elf32_sparc_link_hash_table
 636 {
 637   struct elf_link_hash_table elf;
 638
 639   /* Short-cuts to get to dynamic linker sections.  */
 640   asection *sgot;
 641   asection *srelgot;
 642   asection *splt;
 643   asection *srelplt;
 644   asection *sdynbss;
 645   asection *srelbss;
 646
 647   union {
 648     bfd_signed_vma refcount;
 649     bfd_vma offset;
 650   } tls_ldm_got;
 651
 652   /* Small local sym to section mapping cache.  */
 653   struct sym_sec_cache sym_sec;
 654 };
 655
 656 /* Get the SPARC ELF linker hash table from a link_info structure.  */
 657
 658 #define elf32_sparc_hash_table(p) \
 659   ((struct elf32_sparc_link_hash_table *) ((p)->hash))
 660
 661 /* Create an entry in an i386 ELF linker hash table.  */
 662
 663 static struct bfd_hash_entry *
 664 link_hash_newfunc (entry, table, string)
 665      struct bfd_hash_entry *entry;
 666      struct bfd_hash_table *table;
 667      const char *string;
 668 {
 669   /* Allocate the structure if it has not already been allocated by a
 670      subclass.  */
 671   if (entry == NULL)
 672     {
 673       entry = bfd_hash_allocate (table,
 674                                  sizeof (struct elf32_sparc_link_hash_entry));
 675       if (entry == NULL)
 676         return entry;
 677     }
 678
 679   /* Call the allocation method of the superclass.  */
 680   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 681   if (entry != NULL)
 682     {
 683       struct elf32_sparc_link_hash_entry *eh;
 684
 685       eh = (struct elf32_sparc_link_hash_entry *) entry;
 686       eh->dyn_relocs = NULL;
 687       eh->tls_type = GOT_UNKNOWN;
 688     }
 689
 690   return entry;
 691 }
 692
 693 /* Create a SPARC ELF linker hash table.  */
 694
 695 static struct bfd_link_hash_table *
 696 elf32_sparc_link_hash_table_create (abfd)
 697      bfd *abfd;
 698 {
 699   struct elf32_sparc_link_hash_table *ret;
 700   bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table);
 701
 702   ret = (struct elf32_sparc_link_hash_table *) bfd_malloc (amt);
 703   if (ret == NULL)
 704     return NULL;
 705
 706   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 707     {
 708       free (ret);
 709       return NULL;
 710     }
 711
 712   ret->sgot = NULL;
 713   ret->srelgot = NULL;
 714   ret->splt = NULL;
 715   ret->srelplt = NULL;
 716   ret->sdynbss = NULL;
 717   ret->srelbss = NULL;
 718   ret->tls_ldm_got.refcount = 0;
 719   ret->sym_sec.abfd = NULL;
 720
 721   return &ret->elf.root;
 722 }
 723
 724 /* Create .got and .rela.got sections in DYNOBJ, and set up
 725    shortcuts to them in our hash table.  */
 726
 727 static bfd_boolean
 728 create_got_section (dynobj, info)
 729      bfd *dynobj;
 730      struct bfd_link_info *info;
 731 {
 732   struct elf32_sparc_link_hash_table *htab;
 733
 734   if (! _bfd_elf_create_got_section (dynobj, info))
 735     return FALSE;
 736
 737   htab = elf32_sparc_hash_table (info);
 738   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 739   if (!htab->sgot)
 740     abort ();
 741
 742   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
 743   if (htab->srelgot == NULL
 744       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 745                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 746                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 747                                    | SEC_READONLY))
 748       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 749     return FALSE;
 750   return TRUE;
 751 }
 752
 753 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
 754    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 755    hash table.  */
 756
 757 static bfd_boolean
 758 elf32_sparc_create_dynamic_sections (dynobj, info)
 759      bfd *dynobj;
 760      struct bfd_link_info *info;
 761 {
 762   struct elf32_sparc_link_hash_table *htab;
 763
 764   htab = elf32_sparc_hash_table (info);
 765   if (!htab->sgot && !create_got_section (dynobj, info))
 766     return FALSE;
 767
 768   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 769     return FALSE;
 770
 771   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 772   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 773   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 774   if (!info->shared)
 775     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 776
 777   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 778       || (!info->shared && !htab->srelbss))
 779     abort ();
 780
 781   return TRUE;
 782 }
 783
 784 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 785
 786 static void
 787 elf32_sparc_copy_indirect_symbol (bed, dir, ind)
 788      const struct elf_backend_data *bed;
 789      struct elf_link_hash_entry *dir, *ind;
 790 {
 791   struct elf32_sparc_link_hash_entry *edir, *eind;
 792
 793   edir = (struct elf32_sparc_link_hash_entry *) dir;
 794   eind = (struct elf32_sparc_link_hash_entry *) ind;
 795
 796   if (eind->dyn_relocs != NULL)
 797     {
 798       if (edir->dyn_relocs != NULL)
 799         {
 800           struct elf32_sparc_dyn_relocs **pp;
 801           struct elf32_sparc_dyn_relocs *p;
 802
 803           if (ind->root.type == bfd_link_hash_indirect)
 804             abort ();
 805
 806           /* Add reloc counts against the weak sym to the strong sym
 807              list.  Merge any entries against the same section.  */
 808           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 809             {
 810               struct elf32_sparc_dyn_relocs *q;
 811
 812               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 813                 if (q->sec == p->sec)
 814                   {
 815                     q->pc_count += p->pc_count;
 816                     q->count += p->count;
 817                     *pp = p->next;
 818                     break;
 819                   }
 820               if (q == NULL)
 821                 pp = &p->next;
 822             }
 823           *pp = edir->dyn_relocs;
 824         }
 825
 826       edir->dyn_relocs = eind->dyn_relocs;
 827       eind->dyn_relocs = NULL;
 828     }
 829
 830   if (ind->root.type == bfd_link_hash_indirect
 831       && dir->got.refcount <= 0)
 832     {
 833       edir->tls_type = eind->tls_type;
 834       eind->tls_type = GOT_UNKNOWN;
 835     }
 836   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 837 }
 838
 839 static int
 840 elf32_sparc_tls_transition (info, abfd, r_type, is_local)
 841      struct bfd_link_info *info;
 842      bfd *abfd;
 843      int r_type;
 844      int is_local;
 845 {
 846   if (r_type == R_SPARC_TLS_GD_HI22
 847       && ! elf32_sparc_tdata (abfd)->has_tlsgd)
 848     r_type = R_SPARC_REV32;
 849
 850   if (info->shared)
 851     return r_type;
 852
 853   switch (r_type)
 854     {
 855     case R_SPARC_TLS_GD_HI22:
 856       if (is_local)
 857         return R_SPARC_TLS_LE_HIX22;
 858       return R_SPARC_TLS_IE_HI22;
 859     case R_SPARC_TLS_GD_LO10:
 860       if (is_local)
 861         return R_SPARC_TLS_LE_LOX10;
 862       return R_SPARC_TLS_IE_LO10;
 863     case R_SPARC_TLS_IE_HI22:
 864       if (is_local)
 865         return R_SPARC_TLS_LE_HIX22;
 866       return r_type;
 867     case R_SPARC_TLS_IE_LO10:
 868       if (is_local)
 869         return R_SPARC_TLS_LE_LOX10;
 870       return r_type;
 871     case R_SPARC_TLS_LDM_HI22:
 872       return R_SPARC_TLS_LE_HIX22;
 873     case R_SPARC_TLS_LDM_LO10:
 874       return R_SPARC_TLS_LE_LOX10;
 875     }
 876
 877   return r_type;
 878 }
 879
 880 /* Look through the relocs for a section during the first phase, and
 881    allocate space in the global offset table or procedure linkage
 882    table.  */
 883
 884 static bfd_boolean
 885 elf32_sparc_check_relocs (abfd, info, sec, relocs)
 886      bfd *abfd;
 887      struct bfd_link_info *info;
 888      asection *sec;
 889      const Elf_Internal_Rela *relocs;
 890 {
 891   struct elf32_sparc_link_hash_table *htab;
 892   Elf_Internal_Shdr *symtab_hdr;
 893   struct elf_link_hash_entry **sym_hashes;
 894   bfd_vma *local_got_offsets;
 895   const Elf_Internal_Rela *rel;
 896   const Elf_Internal_Rela *rel_end;
 897   asection *sreloc;
 898   bfd_boolean checked_tlsgd = FALSE;
 899
 900   if (info->relocatable)
 901     return TRUE;
 902
 903   htab = elf32_sparc_hash_table (info);
 904   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 905   sym_hashes = elf_sym_hashes (abfd);
 906   local_got_offsets = elf_local_got_offsets (abfd);
 907
 908   sreloc = NULL;
 909
 910   rel_end = relocs + sec->reloc_count;
 911   for (rel = relocs; rel < rel_end; rel++)
 912     {
 913       unsigned int r_type;
 914       unsigned long r_symndx;
 915       struct elf_link_hash_entry *h;
 916
 917       r_symndx = ELF32_R_SYM (rel->r_info);
 918       r_type = ELF32_R_TYPE (rel->r_info);
 919
 920       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 921         {
 922           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 923                                  bfd_archive_filename (abfd),
 924                                  r_symndx);
 925           return FALSE;
 926         }
 927
 928       if (r_symndx < symtab_hdr->sh_info)
 929         h = NULL;
 930       else
 931         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 932
 933       /* Compatibility with old R_SPARC_REV32 reloc conflicting
 934          with R_SPARC_TLS_GD_HI22.  */
 935       if (! checked_tlsgd)
 936         switch (r_type)
 937           {
 938           case R_SPARC_TLS_GD_HI22:
 939             {
 940               const Elf_Internal_Rela *relt;
 941
 942               for (relt = rel + 1; relt < rel_end; relt++)
 943                 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
 944                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
 945                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
 946                   break;
 947               checked_tlsgd = TRUE;
 948               elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end;
 949             }
 950             break;
 951           case R_SPARC_TLS_GD_LO10:
 952           case R_SPARC_TLS_GD_ADD:
 953           case R_SPARC_TLS_GD_CALL:
 954             checked_tlsgd = TRUE;
 955             elf32_sparc_tdata (abfd)->has_tlsgd = TRUE;
 956             break;
 957           }
 958
 959       r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL);
 960       switch (r_type)
 961         {
 962         case R_SPARC_TLS_LDM_HI22:
 963         case R_SPARC_TLS_LDM_LO10:
 964           htab->tls_ldm_got.refcount += 1;
 965           break;
 966
 967         case R_SPARC_TLS_LE_HIX22:
 968         case R_SPARC_TLS_LE_LOX10:
 969           if (info->shared)
 970             goto r_sparc_plt32;
 971           break;
 972
 973         case R_SPARC_TLS_IE_HI22:
 974         case R_SPARC_TLS_IE_LO10:
 975           if (info->shared)
 976             info->flags |= DF_STATIC_TLS;
 977           /* Fall through */
 978
 979         case R_SPARC_GOT10:
 980         case R_SPARC_GOT13:
 981         case R_SPARC_GOT22:
 982         case R_SPARC_TLS_GD_HI22:
 983         case R_SPARC_TLS_GD_LO10:
 984           /* This symbol requires a global offset table entry.  */
 985           {
 986             int tls_type, old_tls_type;
 987
 988             switch (r_type)
 989               {
 990               default:
 991               case R_SPARC_GOT10:
 992               case R_SPARC_GOT13:
 993               case R_SPARC_GOT22:
 994                 tls_type = GOT_NORMAL;
 995                 break;
 996               case R_SPARC_TLS_GD_HI22:
 997               case R_SPARC_TLS_GD_LO10:
 998                 tls_type = GOT_TLS_GD;
 999                 break;
1000               case R_SPARC_TLS_IE_HI22:
1001               case R_SPARC_TLS_IE_LO10:
1002                 tls_type = GOT_TLS_IE;
1003                 break;
1004               }
1005
1006             if (h != NULL)
1007               {
1008                 h->got.refcount += 1;
1009                 old_tls_type = elf32_sparc_hash_entry(h)->tls_type;
1010               }
1011             else
1012               {
1013                 bfd_signed_vma *local_got_refcounts;
1014
1015                 /* This is a global offset table entry for a local symbol.  */
1016                 local_got_refcounts = elf_local_got_refcounts (abfd);
1017                 if (local_got_refcounts == NULL)
1018                   {
1019                     bfd_size_type size;
1020
1021                     size = symtab_hdr->sh_info;
1022                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
1023                     local_got_refcounts = ((bfd_signed_vma *)
1024                                            bfd_zalloc (abfd, size));
1025                     if (local_got_refcounts == NULL)
1026                       return FALSE;
1027                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1028                     elf32_sparc_local_got_tls_type (abfd)
1029                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1030                   }
1031                 local_got_refcounts[r_symndx] += 1;
1032                 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx];
1033               }
1034
1035             /* If a TLS symbol is accessed using IE at least once,
1036                there is no point to use dynamic model for it.  */
1037             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1038                 && (old_tls_type != GOT_TLS_GD
1039                     || tls_type != GOT_TLS_IE))
1040               {
1041                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1042                   tls_type = old_tls_type;
1043                 else
1044                   {
1045                     (*_bfd_error_handler)
1046                       (_("%s: `%s' accessed both as normal and thread local symbol"),
1047                        bfd_archive_filename (abfd),
1048                        h ? h->root.root.string : "<local>");
1049                     return FALSE;
1050                   }
1051               }
1052
1053             if (old_tls_type != tls_type)
1054               {
1055                 if (h != NULL)
1056                   elf32_sparc_hash_entry (h)->tls_type = tls_type;
1057                 else
1058                   elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type;
1059               }
1060           }
1061
1062           if (htab->sgot == NULL)
1063             {
1064               if (htab->elf.dynobj == NULL)
1065                 htab->elf.dynobj = abfd;
1066               if (!create_got_section (htab->elf.dynobj, info))
1067                 return FALSE;
1068             }
1069           break;
1070
1071         case R_SPARC_TLS_GD_CALL:
1072         case R_SPARC_TLS_LDM_CALL:
1073           if (info->shared)
1074             {
1075               /* These are basically R_SPARC_TLS_WPLT30 relocs against
1076                  __tls_get_addr.  */
1077               struct bfd_link_hash_entry *bh = NULL;
1078               if (! _bfd_generic_link_add_one_symbol (info, abfd,
1079                                                       "__tls_get_addr", 0,
1080                                                       bfd_und_section_ptr, 0,
1081                                                       NULL, FALSE, FALSE,
1082                                                       &bh))
1083                 return FALSE;
1084               h = (struct elf_link_hash_entry *) bh;
1085             }
1086           else
1087             break;
1088           /* Fall through */
1089
1090         case R_SPARC_PLT32:
1091         case R_SPARC_WPLT30:
1092           /* This symbol requires a procedure linkage table entry.  We
1093              actually build the entry in adjust_dynamic_symbol,
1094              because this might be a case of linking PIC code without
1095              linking in any dynamic objects, in which case we don't
1096              need to generate a procedure linkage table after all.  */
1097
1098           if (h == NULL)
1099             {
1100               /* The Solaris native assembler will generate a WPLT30
1101                  reloc for a local symbol if you assemble a call from
1102                  one section to another when using -K pic.  We treat
1103                  it as WDISP30.  */
1104               if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1105                 goto r_sparc_plt32;
1106               break;
1107             }
1108
1109           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1110
1111           if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1112             goto r_sparc_plt32;
1113           h->plt.refcount += 1;
1114           break;
1115
1116         case R_SPARC_PC10:
1117         case R_SPARC_PC22:
1118           if (h != NULL)
1119             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1120
1121           if (h != NULL
1122               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1123             break;
1124           /* Fall through.  */
1125
1126         case R_SPARC_DISP8:
1127         case R_SPARC_DISP16:
1128         case R_SPARC_DISP32:
1129         case R_SPARC_WDISP30:
1130         case R_SPARC_WDISP22:
1131         case R_SPARC_WDISP19:
1132         case R_SPARC_WDISP16:
1133         case R_SPARC_8:
1134         case R_SPARC_16:
1135         case R_SPARC_32:
1136         case R_SPARC_HI22:
1137         case R_SPARC_22:
1138         case R_SPARC_13:
1139         case R_SPARC_LO10:
1140         case R_SPARC_UA16:
1141         case R_SPARC_UA32:
1142           if (h != NULL)
1143             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1144
1145         r_sparc_plt32:
1146           if (h != NULL && !info->shared)
1147             {
1148               /* We may need a .plt entry if the function this reloc
1149                  refers to is in a shared lib.  */
1150               h->plt.refcount += 1;
1151             }
1152
1153           /* If we are creating a shared library, and this is a reloc
1154              against a global symbol, or a non PC relative reloc
1155              against a local symbol, then we need to copy the reloc
1156              into the shared library.  However, if we are linking with
1157              -Bsymbolic, we do not need to copy a reloc against a
1158              global symbol which is defined in an object we are
1159              including in the link (i.e., DEF_REGULAR is set).  At
1160              this point we have not seen all the input files, so it is
1161              possible that DEF_REGULAR is not set now but will be set
1162              later (it is never cleared).  In case of a weak definition,
1163              DEF_REGULAR may be cleared later by a strong definition in
1164              a shared library.  We account for that possibility below by
1165              storing information in the relocs_copied field of the hash
1166              table entry.  A similar situation occurs when creating
1167              shared libraries and symbol visibility changes render the
1168              symbol local.
1169
1170              If on the other hand, we are creating an executable, we
1171              may need to keep relocations for symbols satisfied by a
1172              dynamic library if we manage to avoid copy relocs for the
1173              symbol.  */
1174           if ((info->shared
1175                && (sec->flags & SEC_ALLOC) != 0
1176                && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1177                    || (h != NULL
1178                        && (! info->symbolic
1179                            || h->root.type == bfd_link_hash_defweak
1180                            || (h->elf_link_hash_flags
1181                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1182               || (!info->shared
1183                   && (sec->flags & SEC_ALLOC) != 0
1184                   && h != NULL
1185                   && (h->root.type == bfd_link_hash_defweak
1186                       || (h->elf_link_hash_flags
1187                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1188             {
1189               struct elf32_sparc_dyn_relocs *p;
1190               struct elf32_sparc_dyn_relocs **head;
1191
1192               /* When creating a shared object, we must copy these
1193                  relocs into the output file.  We create a reloc
1194                  section in dynobj and make room for the reloc.  */
1195               if (sreloc == NULL)
1196                 {
1197                   const char *name;
1198                   bfd *dynobj;
1199
1200                   name = (bfd_elf_string_from_elf_section
1201                           (abfd,
1202                            elf_elfheader (abfd)->e_shstrndx,
1203                            elf_section_data (sec)->rel_hdr.sh_name));
1204                   if (name == NULL)
1205                     return FALSE;
1206
1207                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1208                               && strcmp (bfd_get_section_name (abfd, sec),
1209                                          name + 5) == 0);
1210
1211                   if (htab->elf.dynobj == NULL)
1212                     htab->elf.dynobj = abfd;
1213                   dynobj = htab->elf.dynobj;
1214
1215                   sreloc = bfd_get_section_by_name (dynobj, name);
1216                   if (sreloc == NULL)
1217                     {
1218                       flagword flags;
1219
1220                       sreloc = bfd_make_section (dynobj, name);
1221                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1222                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1223                       if ((sec->flags & SEC_ALLOC) != 0)
1224                         flags |= SEC_ALLOC | SEC_LOAD;
1225                       if (sreloc == NULL
1226                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
1227                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1228                         return FALSE;
1229                     }
1230                   elf_section_data (sec)->sreloc = sreloc;
1231                 }
1232
1233               /* If this is a global symbol, we count the number of
1234                  relocations we need for this symbol.  */
1235               if (h != NULL)
1236                 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs;
1237               else
1238                 {
1239                   /* Track dynamic relocs needed for local syms too.
1240                      We really need local syms available to do this
1241                      easily.  Oh well.  */
1242
1243                   asection *s;
1244                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1245                                                  sec, r_symndx);
1246                   if (s == NULL)
1247                     return FALSE;
1248
1249                   head = ((struct elf32_sparc_dyn_relocs **)
1250                           &elf_section_data (s)->local_dynrel);
1251                 }
1252
1253               p = *head;
1254               if (p == NULL || p->sec != sec)
1255                 {
1256                   bfd_size_type amt = sizeof *p;
1257                   p = ((struct elf32_sparc_dyn_relocs *)
1258                        bfd_alloc (htab->elf.dynobj, amt));
1259                   if (p == NULL)
1260                     return FALSE;
1261                   p->next = *head;
1262                   *head = p;
1263                   p->sec = sec;
1264                   p->count = 0;
1265                   p->pc_count = 0;
1266                 }
1267
1268               p->count += 1;
1269               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1270                 p->pc_count += 1;
1271             }
1272
1273           break;
1274
1275         case R_SPARC_GNU_VTINHERIT:
1276           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1277             return FALSE;
1278           break;
1279
1280         case R_SPARC_GNU_VTENTRY:
1281           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1282             return FALSE;
1283           break;
1284
1285         default:
1286           break;
1287         }
1288     }
1289
1290   return TRUE;
1291 }
1292
1293 static asection *
1294 elf32_sparc_gc_mark_hook (sec, info, rel, h, sym)
1295        asection *sec;
1296        struct bfd_link_info *info ATTRIBUTE_UNUSED;
1297        Elf_Internal_Rela *rel;
1298        struct elf_link_hash_entry *h;
1299        Elf_Internal_Sym *sym;
1300 {
1301   if (h != NULL)
1302     {
1303       switch (ELF32_R_TYPE (rel->r_info))
1304       {
1305       case R_SPARC_GNU_VTINHERIT:
1306       case R_SPARC_GNU_VTENTRY:
1307         break;
1308
1309       default:
1310         switch (h->root.type)
1311           {
1312           case bfd_link_hash_defined:
1313           case bfd_link_hash_defweak:
1314             return h->root.u.def.section;
1315
1316           case bfd_link_hash_common:
1317             return h->root.u.c.p->section;
1318
1319           default:
1320             break;
1321           }
1322        }
1323      }
1324    else
1325      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1326
1327   return NULL;
1328 }
1329
1330 /* Update the got entry reference counts for the section being removed.  */
1331 static bfd_boolean
1332 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
1333      bfd *abfd;
1334      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1335      asection *sec;
1336      const Elf_Internal_Rela *relocs;
1337 {
1338   Elf_Internal_Shdr *symtab_hdr;
1339   struct elf_link_hash_entry **sym_hashes;
1340   bfd_signed_vma *local_got_refcounts;
1341   const Elf_Internal_Rela *rel, *relend;
1342
1343   elf_section_data (sec)->local_dynrel = NULL;
1344
1345   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1346   sym_hashes = elf_sym_hashes (abfd);
1347   local_got_refcounts = elf_local_got_refcounts (abfd);
1348
1349   relend = relocs + sec->reloc_count;
1350   for (rel = relocs; rel < relend; rel++)
1351     {
1352       unsigned long r_symndx;
1353       unsigned int r_type;
1354       struct elf_link_hash_entry *h = NULL;
1355
1356       r_symndx = ELF32_R_SYM (rel->r_info);
1357       if (r_symndx >= symtab_hdr->sh_info)
1358         {
1359           struct elf32_sparc_link_hash_entry *eh;
1360           struct elf32_sparc_dyn_relocs **pp;
1361           struct elf32_sparc_dyn_relocs *p;
1362
1363           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1364           eh = (struct elf32_sparc_link_hash_entry *) h;
1365           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1366             if (p->sec == sec)
1367               {
1368                 /* Everything must go for SEC.  */
1369                 *pp = p->next;
1370                 break;
1371               }
1372         }
1373
1374       r_type = ELF32_R_TYPE (rel->r_info);
1375       r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL);
1376       switch (r_type)
1377         {
1378         case R_SPARC_TLS_LDM_HI22:
1379         case R_SPARC_TLS_LDM_LO10:
1380           if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0)
1381             elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1;
1382           break;
1383
1384         case R_SPARC_TLS_GD_HI22:
1385         case R_SPARC_TLS_GD_LO10:
1386         case R_SPARC_TLS_IE_HI22:
1387         case R_SPARC_TLS_IE_LO10:
1388         case R_SPARC_GOT10:
1389         case R_SPARC_GOT13:
1390         case R_SPARC_GOT22:
1391           if (h != NULL)
1392             {
1393               if (h->got.refcount > 0)
1394                 h->got.refcount--;
1395             }
1396           else
1397             {
1398               if (local_got_refcounts[r_symndx] > 0)
1399                 local_got_refcounts[r_symndx]--;
1400             }
1401           break;
1402
1403         case R_SPARC_PC10:
1404         case R_SPARC_PC22:
1405           if (h != NULL
1406               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1407             break;
1408           /* Fall through.  */
1409
1410         case R_SPARC_DISP8:
1411         case R_SPARC_DISP16:
1412         case R_SPARC_DISP32:
1413         case R_SPARC_WDISP30:
1414         case R_SPARC_WDISP22:
1415         case R_SPARC_WDISP19:
1416         case R_SPARC_WDISP16:
1417         case R_SPARC_8:
1418         case R_SPARC_16:
1419         case R_SPARC_32:
1420         case R_SPARC_HI22:
1421         case R_SPARC_22:
1422         case R_SPARC_13:
1423         case R_SPARC_LO10:
1424         case R_SPARC_UA16:
1425         case R_SPARC_UA32:
1426         case R_SPARC_PLT32:
1427           if (info->shared)
1428             break;
1429           /* Fall through.  */
1430
1431         case R_SPARC_WPLT30:
1432           if (h != NULL)
1433             {
1434               if (h->plt.refcount > 0)
1435                 h->plt.refcount--;
1436             }
1437           break;
1438
1439         default:
1440           break;
1441         }
1442     }
1443
1444   return TRUE;
1445 }
1446
1447 /* Adjust a symbol defined by a dynamic object and referenced by a
1448    regular object.  The current definition is in some section of the
1449    dynamic object, but we're not including those sections.  We have to
1450    change the definition to something the rest of the link can
1451    understand.  */
1452
1453 static bfd_boolean
1454 elf32_sparc_adjust_dynamic_symbol (info, h)
1455      struct bfd_link_info *info;
1456      struct elf_link_hash_entry *h;
1457 {
1458   struct elf32_sparc_link_hash_table *htab;
1459   struct elf32_sparc_link_hash_entry * eh;
1460   struct elf32_sparc_dyn_relocs *p;
1461   asection *s;
1462   unsigned int power_of_two;
1463
1464   htab = elf32_sparc_hash_table (info);
1465
1466   /* Make sure we know what is going on here.  */
1467   BFD_ASSERT (htab->elf.dynobj != NULL
1468               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1469                   || h->weakdef != NULL
1470                   || ((h->elf_link_hash_flags
1471                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1472                       && (h->elf_link_hash_flags
1473                           & ELF_LINK_HASH_REF_REGULAR) != 0
1474                       && (h->elf_link_hash_flags
1475                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1476
1477   /* If this is a function, put it in the procedure linkage table.  We
1478      will fill in the contents of the procedure linkage table later
1479      (although we could actually do it here).  The STT_NOTYPE
1480      condition is a hack specifically for the Oracle libraries
1481      delivered for Solaris; for some inexplicable reason, they define
1482      some of their functions as STT_NOTYPE when they really should be
1483      STT_FUNC.  */
1484   if (h->type == STT_FUNC
1485       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1486       || (h->type == STT_NOTYPE
1487           && (h->root.type == bfd_link_hash_defined
1488               || h->root.type == bfd_link_hash_defweak)
1489           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1490     {
1491       if (h->plt.refcount <= 0
1492           || (! info->shared
1493               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1494               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1495               && h->root.type != bfd_link_hash_undefweak
1496               && h->root.type != bfd_link_hash_undefined))
1497         {
1498           /* This case can occur if we saw a WPLT30 reloc in an input
1499              file, but the symbol was never referred to by a dynamic
1500              object, or if all references were garbage collected.  In
1501              such a case, we don't actually need to build a procedure
1502              linkage table, and we can just do a WDISP30 reloc instead.  */
1503           h->plt.offset = (bfd_vma) -1;
1504           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1505         }
1506
1507       return TRUE;
1508     }
1509   else
1510     h->plt.offset = (bfd_vma) -1;
1511
1512   /* If this is a weak symbol, and there is a real definition, the
1513      processor independent code will have arranged for us to see the
1514      real definition first, and we can just use the same value.  */
1515   if (h->weakdef != NULL)
1516     {
1517       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1518                   || h->weakdef->root.type == bfd_link_hash_defweak);
1519       h->root.u.def.section = h->weakdef->root.u.def.section;
1520       h->root.u.def.value = h->weakdef->root.u.def.value;
1521       return TRUE;
1522     }
1523
1524   /* This is a reference to a symbol defined by a dynamic object which
1525      is not a function.  */
1526
1527   /* If we are creating a shared library, we must presume that the
1528      only references to the symbol are via the global offset table.
1529      For such cases we need not do anything here; the relocations will
1530      be handled correctly by relocate_section.  */
1531   if (info->shared)
1532     return TRUE;
1533
1534   /* If there are no references to this symbol that do not use the
1535      GOT, we don't need to generate a copy reloc.  */
1536   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1537     return TRUE;
1538
1539   eh = (struct elf32_sparc_link_hash_entry *) h;
1540   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1541     {
1542       s = p->sec->output_section;
1543       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1544         break;
1545     }
1546
1547   /* If we didn't find any dynamic relocs in read-only sections, then
1548      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1549   if (p == NULL)
1550     {
1551       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1552       return TRUE;
1553     }
1554
1555   /* We must allocate the symbol in our .dynbss section, which will
1556      become part of the .bss section of the executable.  There will be
1557      an entry for this symbol in the .dynsym section.  The dynamic
1558      object will contain position independent code, so all references
1559      from the dynamic object to this symbol will go through the global
1560      offset table.  The dynamic linker will use the .dynsym entry to
1561      determine the address it must put in the global offset table, so
1562      both the dynamic object and the regular object will refer to the
1563      same memory location for the variable.  */
1564
1565   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1566      to copy the initial value out of the dynamic object and into the
1567      runtime process image.  We need to remember the offset into the
1568      .rel.bss section we are going to use.  */
1569   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1570     {
1571       htab->srelbss->size += sizeof (Elf32_External_Rela);
1572       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1573     }
1574
1575   /* We need to figure out the alignment required for this symbol.  I
1576      have no idea how ELF linkers handle this.  */
1577   power_of_two = bfd_log2 (h->size);
1578   if (power_of_two > 3)
1579     power_of_two = 3;
1580
1581   /* Apply the required alignment.  */
1582   s = htab->sdynbss;
1583   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1584   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1585     {
1586       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1587         return FALSE;
1588     }
1589
1590   /* Define the symbol as being at this point in the section.  */
1591   h->root.u.def.section = s;
1592   h->root.u.def.value = s->size;
1593
1594   /* Increment the section size to make room for the symbol.  */
1595   s->size += h->size;
1596
1597   return TRUE;
1598 }
1599
1600 /* Allocate space in .plt, .got and associated reloc sections for
1601    dynamic relocs.  */
1602
1603 static bfd_boolean
1604 allocate_dynrelocs (h, inf)
1605      struct elf_link_hash_entry *h;
1606      PTR inf;
1607 {
1608   struct bfd_link_info *info;
1609   struct elf32_sparc_link_hash_table *htab;
1610   struct elf32_sparc_link_hash_entry *eh;
1611   struct elf32_sparc_dyn_relocs *p;
1612
1613   if (h->root.type == bfd_link_hash_indirect)
1614     return TRUE;
1615
1616   if (h->root.type == bfd_link_hash_warning)
1617     /* When warning symbols are created, they **replace** the "real"
1618        entry in the hash table, thus we never get to see the real
1619        symbol in a hash traversal.  So look at it now.  */
1620     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1621
1622   info = (struct bfd_link_info *) inf;
1623   htab = elf32_sparc_hash_table (info);
1624
1625   if (htab->elf.dynamic_sections_created
1626       && h->plt.refcount > 0)
1627     {
1628       /* Make sure this symbol is output as a dynamic symbol.
1629          Undefined weak syms won't yet be marked as dynamic.  */
1630       if (h->dynindx == -1
1631           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1632         {
1633           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1634             return FALSE;
1635         }
1636
1637       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1638         {
1639           asection *s = htab->splt;
1640
1641           /* The first four entries in .plt are reserved.  */
1642           if (s->size == 0)
1643             s->size = 4 * PLT_ENTRY_SIZE;
1644
1645           /* The procedure linkage table has a maximum size.  */
1646           if (s->size >= 0x400000)
1647             {
1648               bfd_set_error (bfd_error_bad_value);
1649               return FALSE;
1650             }
1651
1652           h->plt.offset = s->size;
1653
1654           /* If this symbol is not defined in a regular file, and we are
1655              not generating a shared library, then set the symbol to this
1656              location in the .plt.  This is required to make function
1657              pointers compare as equal between the normal executable and
1658              the shared library.  */
1659           if (! info->shared
1660               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1661             {
1662               h->root.u.def.section = s;
1663               h->root.u.def.value = h->plt.offset;
1664             }
1665
1666           /* Make room for this entry.  */
1667           s->size += PLT_ENTRY_SIZE;
1668
1669           /* We also need to make an entry in the .rela.plt section.  */
1670           htab->srelplt->size += sizeof (Elf32_External_Rela);
1671         }
1672       else
1673         {
1674           h->plt.offset = (bfd_vma) -1;
1675           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1676         }
1677     }
1678   else
1679     {
1680       h->plt.offset = (bfd_vma) -1;
1681       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1682     }
1683
1684   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1685      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1686   if (h->got.refcount > 0
1687       && !info->shared
1688       && h->dynindx == -1
1689       && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE)
1690     h->got.offset = (bfd_vma) -1;
1691   else if (h->got.refcount > 0)
1692     {
1693       asection *s;
1694       bfd_boolean dyn;
1695       int tls_type = elf32_sparc_hash_entry(h)->tls_type;
1696
1697       /* Make sure this symbol is output as a dynamic symbol.
1698          Undefined weak syms won't yet be marked as dynamic.  */
1699       if (h->dynindx == -1
1700           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1701         {
1702           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1703             return FALSE;
1704         }
1705
1706       s = htab->sgot;
1707       h->got.offset = s->size;
1708       s->size += 4;
1709       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1710       if (tls_type == GOT_TLS_GD)
1711         s->size += 4;
1712       dyn = htab->elf.dynamic_sections_created;
1713       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1714          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1715          global.  */
1716       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1717           || tls_type == GOT_TLS_IE)
1718         htab->srelgot->size += sizeof (Elf32_External_Rela);
1719       else if (tls_type == GOT_TLS_GD)
1720         htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
1721       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1722         htab->srelgot->size += sizeof (Elf32_External_Rela);
1723     }
1724   else
1725     h->got.offset = (bfd_vma) -1;
1726
1727   eh = (struct elf32_sparc_link_hash_entry *) h;
1728   if (eh->dyn_relocs == NULL)
1729     return TRUE;
1730
1731   /* In the shared -Bsymbolic case, discard space allocated for
1732      dynamic pc-relative relocs against symbols which turn out to be
1733      defined in regular objects.  For the normal shared case, discard
1734      space for pc-relative relocs that have become local due to symbol
1735      visibility changes.  */
1736
1737   if (info->shared)
1738     {
1739       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1740           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1741               || info->symbolic))
1742         {
1743           struct elf32_sparc_dyn_relocs **pp;
1744
1745           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1746             {
1747               p->count -= p->pc_count;
1748               p->pc_count = 0;
1749               if (p->count == 0)
1750                 *pp = p->next;
1751               else
1752                 pp = &p->next;
1753             }
1754         }
1755     }
1756   else
1757     {
1758       /* For the non-shared case, discard space for relocs against
1759          symbols which turn out to need copy relocs or are not
1760          dynamic.  */
1761
1762       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1763           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1764                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1765               || (htab->elf.dynamic_sections_created
1766                   && (h->root.type == bfd_link_hash_undefweak
1767                       || h->root.type == bfd_link_hash_undefined))))
1768         {
1769           /* Make sure this symbol is output as a dynamic symbol.
1770              Undefined weak syms won't yet be marked as dynamic.  */
1771           if (h->dynindx == -1
1772               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1773             {
1774               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1775                 return FALSE;
1776             }
1777
1778           /* If that succeeded, we know we'll be keeping all the
1779              relocs.  */
1780           if (h->dynindx != -1)
1781             goto keep;
1782         }
1783
1784       eh->dyn_relocs = NULL;
1785
1786     keep: ;
1787     }
1788
1789   /* Finally, allocate space.  */
1790   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1791     {
1792       asection *sreloc = elf_section_data (p->sec)->sreloc;
1793       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1794     }
1795
1796   return TRUE;
1797 }
1798
1799 /* Find any dynamic relocs that apply to read-only sections.  */
1800
1801 static bfd_boolean
1802 readonly_dynrelocs (h, inf)
1803      struct elf_link_hash_entry *h;
1804      PTR inf;
1805 {
1806   struct elf32_sparc_link_hash_entry *eh;
1807   struct elf32_sparc_dyn_relocs *p;
1808
1809   if (h->root.type == bfd_link_hash_warning)
1810     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1811
1812   eh = (struct elf32_sparc_link_hash_entry *) h;
1813   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1814     {
1815       asection *s = p->sec->output_section;
1816
1817       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1818         {
1819           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1820
1821           info->flags |= DF_TEXTREL;
1822
1823           /* Not an error, just cut short the traversal.  */
1824           return FALSE;
1825         }
1826     }
1827   return TRUE;
1828 }
1829
1830 /* Set the sizes of the dynamic sections.  */
1831
1832 static bfd_boolean
1833 elf32_sparc_size_dynamic_sections (output_bfd, info)
1834      bfd *output_bfd ATTRIBUTE_UNUSED;
1835      struct bfd_link_info *info;
1836 {
1837   struct elf32_sparc_link_hash_table *htab;
1838   bfd *dynobj;
1839   asection *s;
1840   bfd *ibfd;
1841
1842   htab = elf32_sparc_hash_table (info);
1843   dynobj = htab->elf.dynobj;
1844   BFD_ASSERT (dynobj != NULL);
1845
1846   if (elf_hash_table (info)->dynamic_sections_created)
1847     {
1848       /* Set the contents of the .interp section to the interpreter.  */
1849       if (info->executable)
1850         {
1851           s = bfd_get_section_by_name (dynobj, ".interp");
1852           BFD_ASSERT (s != NULL);
1853           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1854           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1855         }
1856     }
1857
1858   /* Set up .got offsets for local syms, and space for local dynamic
1859      relocs.  */
1860   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1861     {
1862       bfd_signed_vma *local_got;
1863       bfd_signed_vma *end_local_got;
1864       char *local_tls_type;
1865       bfd_size_type locsymcount;
1866       Elf_Internal_Shdr *symtab_hdr;
1867       asection *srel;
1868
1869       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1870         continue;
1871
1872       for (s = ibfd->sections; s != NULL; s = s->next)
1873         {
1874           struct elf32_sparc_dyn_relocs *p;
1875
1876           for (p = *((struct elf32_sparc_dyn_relocs **)
1877                      &elf_section_data (s)->local_dynrel);
1878                p != NULL;
1879                p = p->next)
1880             {
1881               if (!bfd_is_abs_section (p->sec)
1882                   && bfd_is_abs_section (p->sec->output_section))
1883                 {
1884                   /* Input section has been discarded, either because
1885                      it is a copy of a linkonce section or due to
1886                      linker script /DISCARD/, so we'll be discarding
1887                      the relocs too.  */
1888                 }
1889               else if (p->count != 0)
1890                 {
1891                   srel = elf_section_data (p->sec)->sreloc;
1892                   srel->size += p->count * sizeof (Elf32_External_Rela);
1893                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1894                     info->flags |= DF_TEXTREL;
1895                 }
1896             }
1897         }
1898
1899       local_got = elf_local_got_refcounts (ibfd);
1900       if (!local_got)
1901         continue;
1902
1903       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1904       locsymcount = symtab_hdr->sh_info;
1905       end_local_got = local_got + locsymcount;
1906       local_tls_type = elf32_sparc_local_got_tls_type (ibfd);
1907       s = htab->sgot;
1908       srel = htab->srelgot;
1909       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1910         {
1911           if (*local_got > 0)
1912             {
1913               *local_got = s->size;
1914               s->size += 4;
1915               if (*local_tls_type == GOT_TLS_GD)
1916                 s->size += 4;
1917               if (info->shared
1918                   || *local_tls_type == GOT_TLS_GD
1919                   || *local_tls_type == GOT_TLS_IE)
1920                 srel->size += sizeof (Elf32_External_Rela);
1921             }
1922           else
1923             *local_got = (bfd_vma) -1;
1924         }
1925     }
1926
1927   if (htab->tls_ldm_got.refcount > 0)
1928     {
1929       /* Allocate 2 got entries and 1 dynamic reloc for
1930          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
1931       htab->tls_ldm_got.offset = htab->sgot->size;
1932       htab->sgot->size += 8;
1933       htab->srelgot->size += sizeof (Elf32_External_Rela);
1934     }
1935   else
1936     htab->tls_ldm_got.offset = -1;
1937
1938   /* Allocate global sym .plt and .got entries, and space for global
1939      sym dynamic relocs.  */
1940   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1941
1942   if (elf_hash_table (info)->dynamic_sections_created)
1943     {
1944       /* Make space for the trailing nop in .plt.  */
1945       if (htab->splt->size > 0)
1946         htab->splt->size += 4;
1947
1948       /* If the .got section is more than 0x1000 bytes, we add
1949          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1950          bit relocations have a greater chance of working.  */
1951       if (htab->sgot->size >= 0x1000
1952           && elf_hash_table (info)->hgot->root.u.def.value == 0)
1953         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1954     }
1955
1956   /* The check_relocs and adjust_dynamic_symbol entry points have
1957      determined the sizes of the various dynamic sections.  Allocate
1958      memory for them.  */
1959   for (s = dynobj->sections; s != NULL; s = s->next)
1960     {
1961       const char *name;
1962       bfd_boolean strip = FALSE;
1963
1964       if ((s->flags & SEC_LINKER_CREATED) == 0)
1965         continue;
1966
1967       /* It's OK to base decisions on the section name, because none
1968          of the dynobj section names depend upon the input files.  */
1969       name = bfd_get_section_name (dynobj, s);
1970
1971       if (strncmp (name, ".rela", 5) == 0)
1972         {
1973           if (s->size == 0)
1974             {
1975               /* If we don't need this section, strip it from the
1976                  output file.  This is to handle .rela.bss and
1977                  .rel.plt.  We must create it in
1978                  create_dynamic_sections, because it must be created
1979                  before the linker maps input sections to output
1980                  sections.  The linker does that before
1981                  adjust_dynamic_symbol is called, and it is that
1982                  function which decides whether anything needs to go
1983                  into these sections.  */
1984               strip = TRUE;
1985             }
1986           else
1987             {
1988               /* We use the reloc_count field as a counter if we need
1989                  to copy relocs into the output file.  */
1990               s->reloc_count = 0;
1991             }
1992         }
1993       else if (s != htab->splt && s != htab->sgot)
1994         {
1995           /* It's not one of our sections, so don't allocate space.  */
1996           continue;
1997         }
1998
1999       if (strip)
2000         {
2001           _bfd_strip_section_from_output (info, s);
2002           continue;
2003         }
2004
2005       /* Allocate memory for the section contents.  */
2006       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
2007          Unused entries should be reclaimed before the section's contents
2008          are written out, but at the moment this does not happen.  Thus in
2009          order to prevent writing out garbage, we initialise the section's
2010          contents to zero.  */
2011       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2012       if (s->contents == NULL && s->size != 0)
2013         return FALSE;
2014     }
2015
2016   if (elf_hash_table (info)->dynamic_sections_created)
2017     {
2018       /* Add some entries to the .dynamic section.  We fill in the
2019          values later, in elf32_sparc_finish_dynamic_sections, but we
2020          must add the entries now so that we get the correct size for
2021          the .dynamic section.  The DT_DEBUG entry is filled in by the
2022          dynamic linker and used by the debugger.  */
2023 #define add_dynamic_entry(TAG, VAL) \
2024   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2025
2026       if (info->executable)
2027         {
2028           if (!add_dynamic_entry (DT_DEBUG, 0))
2029             return FALSE;
2030         }
2031
2032       if (htab->srelplt->size != 0)
2033         {
2034           if (!add_dynamic_entry (DT_PLTGOT, 0)
2035               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2036               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2037               || !add_dynamic_entry (DT_JMPREL, 0))
2038             return FALSE;
2039         }
2040
2041       if (!add_dynamic_entry (DT_RELA, 0)
2042           || !add_dynamic_entry (DT_RELASZ, 0)
2043           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2044         return FALSE;
2045
2046       /* If any dynamic relocs apply to a read-only section,
2047          then we need a DT_TEXTREL entry.  */
2048       if ((info->flags & DF_TEXTREL) == 0)
2049         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2050                                 (PTR) info);
2051
2052       if (info->flags & DF_TEXTREL)
2053         {
2054           if (!add_dynamic_entry (DT_TEXTREL, 0))
2055             return FALSE;
2056         }
2057     }
2058 #undef add_dynamic_entry
2059
2060   return TRUE;
2061 }
2062
2063 struct elf32_sparc_section_data
2064 {
2065   struct bfd_elf_section_data elf;
2066   unsigned int do_relax;
2067 };
2068
2069 #define sec_do_relax(sec) \
2070   ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
2071
2072 static bfd_boolean
2073 elf32_sparc_new_section_hook (abfd, sec)
2074      bfd *abfd;
2075      asection *sec;
2076 {
2077   struct elf32_sparc_section_data *sdata;
2078   bfd_size_type amt = sizeof (*sdata);
2079
2080   sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt);
2081   if (sdata == NULL)
2082     return FALSE;
2083   sec->used_by_bfd = (PTR) sdata;
2084
2085   return _bfd_elf_new_section_hook (abfd, sec);
2086 }
2087
2088 static bfd_boolean
2089 elf32_sparc_relax_section (abfd, section, link_info, again)
2090      bfd *abfd ATTRIBUTE_UNUSED;
2091      asection *section ATTRIBUTE_UNUSED;
2092      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2093      bfd_boolean *again;
2094 {
2095   *again = FALSE;
2096   sec_do_relax (section) = 1;
2097   return TRUE;
2098 }
2099
2100 /* Return the base VMA address which should be subtracted from real addresses
2101    when resolving @dtpoff relocation.
2102    This is PT_TLS segment p_vaddr.  */
2103
2104 static bfd_vma
2105 dtpoff_base (info)
2106      struct bfd_link_info *info;
2107 {
2108   /* If tls_sec is NULL, we should have signalled an error already.  */
2109   if (elf_hash_table (info)->tls_sec == NULL)
2110     return 0;
2111   return elf_hash_table (info)->tls_sec->vma;
2112 }
2113
2114 /* Return the relocation value for @tpoff relocation
2115    if STT_TLS virtual address is ADDRESS.  */
2116
2117 static bfd_vma
2118 tpoff (info, address)
2119      struct bfd_link_info *info;
2120      bfd_vma address;
2121 {
2122   struct elf_link_hash_table *htab = elf_hash_table (info);
2123
2124   /* If tls_sec is NULL, we should have signalled an error already.  */
2125   if (htab->tls_sec == NULL)
2126     return 0;
2127   return address - htab->tls_size - htab->tls_sec->vma;
2128 }
2129
2130 /* Relocate a SPARC ELF section.  */
2131
2132 static bfd_boolean
2133 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
2134                               contents, relocs, local_syms, local_sections)
2135      bfd *output_bfd;
2136      struct bfd_link_info *info;
2137      bfd *input_bfd;
2138      asection *input_section;
2139      bfd_byte *contents;
2140      Elf_Internal_Rela *relocs;
2141      Elf_Internal_Sym *local_syms;
2142      asection **local_sections;
2143 {
2144   struct elf32_sparc_link_hash_table *htab;
2145   Elf_Internal_Shdr *symtab_hdr;
2146   struct elf_link_hash_entry **sym_hashes;
2147   bfd_vma *local_got_offsets;
2148   bfd_vma got_base;
2149   asection *sreloc;
2150   Elf_Internal_Rela *rel;
2151   Elf_Internal_Rela *relend;
2152
2153   if (info->relocatable)
2154     return TRUE;
2155
2156   htab = elf32_sparc_hash_table (info);
2157   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2158   sym_hashes = elf_sym_hashes (input_bfd);
2159   local_got_offsets = elf_local_got_offsets (input_bfd);
2160
2161   if (elf_hash_table (info)->hgot == NULL)
2162     got_base = 0;
2163   else
2164     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2165
2166   sreloc = elf_section_data (input_section)->sreloc;
2167
2168   rel = relocs;
2169   relend = relocs + input_section->reloc_count;
2170   for (; rel < relend; rel++)
2171     {
2172       int r_type, tls_type;
2173       reloc_howto_type *howto;
2174       unsigned long r_symndx;
2175       struct elf_link_hash_entry *h;
2176       Elf_Internal_Sym *sym;
2177       asection *sec;
2178       bfd_vma relocation, off;
2179       bfd_reloc_status_type r;
2180       bfd_boolean is_plt = FALSE;
2181       bfd_boolean unresolved_reloc;
2182
2183       r_type = ELF32_R_TYPE (rel->r_info);
2184
2185       if (r_type == R_SPARC_GNU_VTINHERIT
2186           || r_type == R_SPARC_GNU_VTENTRY)
2187         continue;
2188
2189       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2190         {
2191           bfd_set_error (bfd_error_bad_value);
2192           return FALSE;
2193         }
2194       howto = _bfd_sparc_elf_howto_table + r_type;
2195
2196       /* This is a final link.  */
2197       r_symndx = ELF32_R_SYM (rel->r_info);
2198       h = NULL;
2199       sym = NULL;
2200       sec = NULL;
2201       unresolved_reloc = FALSE;
2202       if (r_symndx < symtab_hdr->sh_info)
2203         {
2204           sym = local_syms + r_symndx;
2205           sec = local_sections[r_symndx];
2206           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2207         }
2208       else
2209         {
2210           bfd_boolean warned ATTRIBUTE_UNUSED;
2211
2212           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2213                                    r_symndx, symtab_hdr, sym_hashes,
2214                                    h, sec, relocation,
2215                                    unresolved_reloc, warned);
2216         }
2217
2218       switch (r_type)
2219         {
2220         case R_SPARC_GOT10:
2221         case R_SPARC_GOT13:
2222         case R_SPARC_GOT22:
2223           /* Relocation is to the entry for this symbol in the global
2224              offset table.  */
2225           if (htab->sgot == NULL)
2226             abort ();
2227
2228           if (h != NULL)
2229             {
2230               bfd_boolean dyn;
2231
2232               off = h->got.offset;
2233               BFD_ASSERT (off != (bfd_vma) -1);
2234               dyn = elf_hash_table (info)->dynamic_sections_created;
2235
2236               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2237                   || (info->shared
2238                       && (info->symbolic
2239                           || h->dynindx == -1
2240                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2241                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2242                 {
2243                   /* This is actually a static link, or it is a
2244                      -Bsymbolic link and the symbol is defined
2245                      locally, or the symbol was forced to be local
2246                      because of a version file.  We must initialize
2247                      this entry in the global offset table.  Since the
2248                      offset must always be a multiple of 4, we use the
2249                      least significant bit to record whether we have
2250                      initialized it already.
2251
2252                      When doing a dynamic link, we create a .rela.got
2253                      relocation entry to initialize the value.  This
2254                      is done in the finish_dynamic_symbol routine.  */
2255                   if ((off & 1) != 0)
2256                     off &= ~1;
2257                   else
2258                     {
2259                       bfd_put_32 (output_bfd, relocation,
2260                                   htab->sgot->contents + off);
2261                       h->got.offset |= 1;
2262                     }
2263                 }
2264               else
2265                 unresolved_reloc = FALSE;
2266             }
2267           else
2268             {
2269               BFD_ASSERT (local_got_offsets != NULL
2270                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2271
2272               off = local_got_offsets[r_symndx];
2273
2274               /* The offset must always be a multiple of 4.  We use
2275                  the least significant bit to record whether we have
2276                  already processed this entry.  */
2277               if ((off & 1) != 0)
2278                 off &= ~1;
2279               else
2280                 {
2281
2282                   if (info->shared)
2283                     {
2284                       asection *s;
2285                       Elf_Internal_Rela outrel;
2286                       bfd_byte *loc;
2287
2288                       /* We need to generate a R_SPARC_RELATIVE reloc
2289                          for the dynamic linker.  */
2290                       s = htab->srelgot;
2291                       BFD_ASSERT (s != NULL);
2292
2293                       outrel.r_offset = (htab->sgot->output_section->vma
2294                                          + htab->sgot->output_offset
2295                                          + off);
2296                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2297                       outrel.r_addend = relocation;
2298                       relocation = 0;
2299                       loc = s->contents;
2300                       loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2301                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2302                     }
2303
2304                   bfd_put_32 (output_bfd, relocation,
2305                               htab->sgot->contents + off);
2306                   local_got_offsets[r_symndx] |= 1;
2307                 }
2308             }
2309           relocation = htab->sgot->output_offset + off - got_base;
2310           break;
2311
2312         case R_SPARC_PLT32:
2313           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2314             {
2315               r_type = R_SPARC_32;
2316               goto r_sparc_plt32;
2317             }
2318           /* Fall through.  */
2319         case R_SPARC_WPLT30:
2320         r_sparc_wplt30:
2321           /* Relocation is to the entry for this symbol in the
2322              procedure linkage table.  */
2323
2324           /* The Solaris native assembler will generate a WPLT30 reloc
2325              for a local symbol if you assemble a call from one
2326              section to another when using -K pic.  We treat it as
2327              WDISP30.  */
2328           if (h == NULL)
2329             break;
2330
2331           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2332             {
2333               /* We didn't make a PLT entry for this symbol.  This
2334                  happens when statically linking PIC code, or when
2335                  using -Bsymbolic.  */
2336               break;
2337             }
2338
2339           relocation = (htab->splt->output_section->vma
2340                         + htab->splt->output_offset
2341                         + h->plt.offset);
2342           unresolved_reloc = FALSE;
2343           if (r_type == R_SPARC_PLT32)
2344             {
2345               r_type = R_SPARC_32;
2346               is_plt = TRUE;
2347               goto r_sparc_plt32;
2348             }
2349           break;
2350
2351         case R_SPARC_PC10:
2352         case R_SPARC_PC22:
2353           if (h != NULL
2354               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2355             break;
2356           /* Fall through.  */
2357         case R_SPARC_DISP8:
2358         case R_SPARC_DISP16:
2359         case R_SPARC_DISP32:
2360         case R_SPARC_WDISP30:
2361         case R_SPARC_WDISP22:
2362         case R_SPARC_WDISP19:
2363         case R_SPARC_WDISP16:
2364         case R_SPARC_8:
2365         case R_SPARC_16:
2366         case R_SPARC_32:
2367         case R_SPARC_HI22:
2368         case R_SPARC_22:
2369         case R_SPARC_13:
2370         case R_SPARC_LO10:
2371         case R_SPARC_UA16:
2372         case R_SPARC_UA32:
2373         r_sparc_plt32:
2374           /* r_symndx will be zero only for relocs against symbols
2375              from removed linkonce sections, or sections discarded by
2376              a linker script.  */
2377           if (r_symndx == 0
2378               || (input_section->flags & SEC_ALLOC) == 0)
2379             break;
2380
2381           if ((info->shared
2382                && (h == NULL
2383                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2384                    || h->root.type != bfd_link_hash_undefweak)
2385                && (! howto->pc_relative
2386                    || (h != NULL
2387                        && h->dynindx != -1
2388                        && (! info->symbolic
2389                            || (h->elf_link_hash_flags
2390                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2391               || (!info->shared
2392                   && h != NULL
2393                   && h->dynindx != -1
2394                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2395                   && (((h->elf_link_hash_flags
2396                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2397                        && (h->elf_link_hash_flags
2398                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2399                       || h->root.type == bfd_link_hash_undefweak
2400                       || h->root.type == bfd_link_hash_undefined)))
2401             {
2402               Elf_Internal_Rela outrel;
2403               bfd_byte *loc;
2404               bfd_boolean skip, relocate = FALSE;
2405
2406               /* When generating a shared object, these relocations
2407                  are copied into the output file to be resolved at run
2408                  time.  */
2409
2410               BFD_ASSERT (sreloc != NULL);
2411
2412               skip = FALSE;
2413
2414               outrel.r_offset =
2415                 _bfd_elf_section_offset (output_bfd, info, input_section,
2416                                          rel->r_offset);
2417               if (outrel.r_offset == (bfd_vma) -1)
2418                 skip = TRUE;
2419               else if (outrel.r_offset == (bfd_vma) -2)
2420                 skip = TRUE, relocate = TRUE;
2421               outrel.r_offset += (input_section->output_section->vma
2422                                   + input_section->output_offset);
2423
2424               /* Optimize unaligned reloc usage now that we know where
2425                  it finally resides.  */
2426               switch (r_type)
2427                 {
2428                 case R_SPARC_16:
2429                   if (outrel.r_offset & 1)
2430                     r_type = R_SPARC_UA16;
2431                   break;
2432                 case R_SPARC_UA16:
2433                   if (!(outrel.r_offset & 1))
2434                     r_type = R_SPARC_16;
2435                   break;
2436                 case R_SPARC_32:
2437                   if (outrel.r_offset & 3)
2438                     r_type = R_SPARC_UA32;
2439                   break;
2440                 case R_SPARC_UA32:
2441                   if (!(outrel.r_offset & 3))
2442                     r_type = R_SPARC_32;
2443                   break;
2444                 case R_SPARC_DISP8:
2445                 case R_SPARC_DISP16:
2446                 case R_SPARC_DISP32:
2447                   /* If the symbol is not dynamic, we should not keep
2448                      a dynamic relocation.  But an .rela.* slot has been
2449                      allocated for it, output R_SPARC_NONE.
2450                      FIXME: Add code tracking needed dynamic relocs as
2451                      e.g. i386 has.  */
2452                   if (h->dynindx == -1)
2453                     skip = TRUE, relocate = TRUE;
2454                   break;
2455                 }
2456
2457               if (skip)
2458                 memset (&outrel, 0, sizeof outrel);
2459               /* h->dynindx may be -1 if the symbol was marked to
2460                  become local.  */
2461               else if (h != NULL && ! is_plt
2462                        && ((! info->symbolic && h->dynindx != -1)
2463                            || (h->elf_link_hash_flags
2464                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2465                 {
2466                   BFD_ASSERT (h->dynindx != -1);
2467                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2468                   outrel.r_addend = rel->r_addend;
2469                 }
2470               else
2471                 {
2472                   if (r_type == R_SPARC_32)
2473                     {
2474                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2475                       outrel.r_addend = relocation + rel->r_addend;
2476                     }
2477                   else
2478                     {
2479                       long indx;
2480
2481                       if (is_plt)
2482                         sec = htab->splt;
2483
2484                       if (bfd_is_abs_section (sec))
2485                         indx = 0;
2486                       else if (sec == NULL || sec->owner == NULL)
2487                         {
2488                           bfd_set_error (bfd_error_bad_value);
2489                           return FALSE;
2490                         }
2491                       else
2492                         {
2493                           asection *osec;
2494
2495                           osec = sec->output_section;
2496                           indx = elf_section_data (osec)->dynindx;
2497
2498                           /* FIXME: we really should be able to link non-pic
2499                              shared libraries.  */
2500                           if (indx == 0)
2501                             {
2502                               BFD_FAIL ();
2503                               (*_bfd_error_handler)
2504                                 (_("%s: probably compiled without -fPIC?"),
2505                                  bfd_archive_filename (input_bfd));
2506                               bfd_set_error (bfd_error_bad_value);
2507                               return FALSE;
2508                             }
2509                         }
2510
2511                       outrel.r_info = ELF32_R_INFO (indx, r_type);
2512                       outrel.r_addend = relocation + rel->r_addend;
2513                     }
2514                 }
2515
2516               loc = sreloc->contents;
2517               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2518               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2519
2520               /* This reloc will be computed at runtime, so there's no
2521                  need to do anything now.  */
2522               if (! relocate)
2523                 continue;
2524             }
2525           break;
2526
2527         case R_SPARC_TLS_GD_HI22:
2528           if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2529             {
2530               /* R_SPARC_REV32 used the same reloc number as
2531                  R_SPARC_TLS_GD_HI22.  */
2532               r_type = R_SPARC_REV32;
2533               break;
2534             }
2535           /* Fall through */
2536
2537         case R_SPARC_TLS_GD_LO10:
2538         case R_SPARC_TLS_IE_HI22:
2539         case R_SPARC_TLS_IE_LO10:
2540           r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2541                                                h == NULL);
2542           tls_type = GOT_UNKNOWN;
2543           if (h == NULL && local_got_offsets)
2544             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2545           else if (h != NULL)
2546             {
2547               tls_type = elf32_sparc_hash_entry(h)->tls_type;
2548               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2549                 switch (ELF32_R_TYPE (rel->r_info))
2550                   {
2551                   case R_SPARC_TLS_GD_HI22:
2552                   case R_SPARC_TLS_IE_HI22:
2553                     r_type = R_SPARC_TLS_LE_HIX22;
2554                     break;
2555                   default:
2556                     r_type = R_SPARC_TLS_LE_LOX10;
2557                     break;
2558                   }
2559             }
2560           if (tls_type == GOT_TLS_IE)
2561             switch (r_type)
2562               {
2563               case R_SPARC_TLS_GD_HI22:
2564                 r_type = R_SPARC_TLS_IE_HI22;
2565                 break;
2566               case R_SPARC_TLS_GD_LO10:
2567                 r_type = R_SPARC_TLS_IE_LO10;
2568                 break;
2569               }
2570
2571           if (r_type == R_SPARC_TLS_LE_HIX22)
2572             {
2573               relocation = tpoff (info, relocation);
2574               break;
2575             }
2576           if (r_type == R_SPARC_TLS_LE_LOX10)
2577             {
2578               /* Change add into xor.  */
2579               relocation = tpoff (info, relocation);
2580               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2581                                                    contents + rel->r_offset)
2582                                        | 0x80182000), contents + rel->r_offset);
2583               break;
2584             }
2585
2586           if (h != NULL)
2587             {
2588               off = h->got.offset;
2589               h->got.offset |= 1;
2590             }
2591           else
2592             {
2593               BFD_ASSERT (local_got_offsets != NULL);
2594               off = local_got_offsets[r_symndx];
2595               local_got_offsets[r_symndx] |= 1;
2596             }
2597
2598         r_sparc_tlsldm:
2599           if (htab->sgot == NULL)
2600             abort ();
2601
2602           if ((off & 1) != 0)
2603             off &= ~1;
2604           else
2605             {
2606               Elf_Internal_Rela outrel;
2607               Elf32_External_Rela *loc;
2608               int dr_type, indx;
2609
2610               if (htab->srelgot == NULL)
2611                 abort ();
2612
2613               bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2614               outrel.r_offset = (htab->sgot->output_section->vma
2615                                  + htab->sgot->output_offset + off);
2616               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2617               if (r_type == R_SPARC_TLS_IE_HI22
2618                 || r_type == R_SPARC_TLS_IE_LO10)
2619                 dr_type = R_SPARC_TLS_TPOFF32;
2620               else
2621                 dr_type = R_SPARC_TLS_DTPMOD32;
2622               if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2623                 outrel.r_addend = relocation - dtpoff_base (info);
2624               else
2625                 outrel.r_addend = 0;
2626               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2627               loc = (Elf32_External_Rela *) htab->srelgot->contents;
2628               loc += htab->srelgot->reloc_count++;
2629               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2630                                          (bfd_byte *) loc);
2631
2632               if (r_type == R_SPARC_TLS_GD_HI22
2633                   || r_type == R_SPARC_TLS_GD_LO10)
2634                 {
2635                   if (indx == 0)
2636                     {
2637                       BFD_ASSERT (! unresolved_reloc);
2638                       bfd_put_32 (output_bfd,
2639                                   relocation - dtpoff_base (info),
2640                                   htab->sgot->contents + off + 4);
2641                     }
2642                   else
2643                     {
2644                       bfd_put_32 (output_bfd, 0,
2645                                   htab->sgot->contents + off + 4);
2646                       outrel.r_info = ELF32_R_INFO (indx,
2647                                                     R_SPARC_TLS_DTPOFF32);
2648                       outrel.r_offset += 4;
2649                       htab->srelgot->reloc_count++;
2650                       loc++;
2651                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2652                                                  (bfd_byte *) loc);
2653                     }
2654                 }
2655               else if (dr_type == R_SPARC_TLS_DTPMOD32)
2656                 {
2657                   bfd_put_32 (output_bfd, 0,
2658                               htab->sgot->contents + off + 4);
2659                 }
2660             }
2661
2662           if (off >= (bfd_vma) -2)
2663             abort ();
2664
2665           relocation = htab->sgot->output_offset + off - got_base;
2666           unresolved_reloc = FALSE;
2667           howto = _bfd_sparc_elf_howto_table + r_type;
2668           break;
2669
2670         case R_SPARC_TLS_LDM_HI22:
2671         case R_SPARC_TLS_LDM_LO10:
2672           if (! info->shared)
2673             {
2674               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2675               continue;
2676             }
2677           off = htab->tls_ldm_got.offset;
2678           htab->tls_ldm_got.offset |= 1;
2679           goto r_sparc_tlsldm;
2680
2681         case R_SPARC_TLS_LDO_HIX22:
2682         case R_SPARC_TLS_LDO_LOX10:
2683           if (info->shared)
2684             relocation -= dtpoff_base (info);
2685           else
2686             relocation = tpoff (info, relocation);
2687           break;
2688
2689         case R_SPARC_TLS_LE_HIX22:
2690         case R_SPARC_TLS_LE_LOX10:
2691           if (info->shared)
2692             {
2693               Elf_Internal_Rela outrel;
2694               bfd_boolean skip, relocate = FALSE;
2695
2696               BFD_ASSERT (sreloc != NULL);
2697               skip = FALSE;
2698               outrel.r_offset =
2699                 _bfd_elf_section_offset (output_bfd, info, input_section,
2700                                          rel->r_offset);
2701               if (outrel.r_offset == (bfd_vma) -1)
2702                 skip = TRUE;
2703               else if (outrel.r_offset == (bfd_vma) -2)
2704                 skip = TRUE, relocate = TRUE;
2705               outrel.r_offset += (input_section->output_section->vma
2706                                   + input_section->output_offset);
2707               if (skip)
2708                 memset (&outrel, 0, sizeof outrel);
2709               else
2710                 {
2711                   outrel.r_info = ELF32_R_INFO (0, r_type);
2712                   outrel.r_addend = relocation - dtpoff_base (info)
2713                                     + rel->r_addend;
2714                 }
2715
2716               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2717                                          (bfd_byte *) (((Elf32_External_Rela *)
2718                                                         sreloc->contents)
2719                                                        + sreloc->reloc_count));
2720               ++sreloc->reloc_count;
2721               continue;
2722             }
2723           relocation = tpoff (info, relocation);
2724           break;
2725
2726         case R_SPARC_TLS_LDM_CALL:
2727           if (! info->shared)
2728             {
2729               /* mov %g0, %o0 */
2730               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2731               continue;
2732             }
2733           /* Fall through */
2734
2735         case R_SPARC_TLS_GD_CALL:
2736           tls_type = GOT_UNKNOWN;
2737           if (h == NULL && local_got_offsets)
2738             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2739           else if (h != NULL)
2740             tls_type = elf32_sparc_hash_entry(h)->tls_type;
2741           if (! info->shared
2742               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2743             {
2744               bfd_vma insn;
2745
2746               if (!info->shared && (h == NULL || h->dynindx == -1))
2747                 {
2748                   /* GD -> LE */
2749                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2750                   continue;
2751                 }
2752
2753               /* GD -> IE */
2754               if (rel + 1 < relend
2755                   && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2756                   && rel[1].r_offset == rel->r_offset + 4
2757                   && ELF32_R_SYM (rel[1].r_info) == r_symndx
2758                   && (((insn = bfd_get_32 (input_bfd,
2759                                            contents + rel[1].r_offset))
2760                        >> 25) & 0x1f) == 8)
2761                 {
2762                   /* We have
2763                      call __tls_get_addr, %tgd_call(foo)
2764                       add %reg1, %reg2, %o0, %tgd_add(foo)
2765                      and change it into IE:
2766                      ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2767                      add %g7, %o0, %o0, %tie_add(foo).
2768                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2769                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2.  */
2770                   bfd_put_32 (output_bfd, insn | 0xc0000000,
2771                               contents + rel->r_offset);
2772                   bfd_put_32 (output_bfd, 0x9001c008,
2773                               contents + rel->r_offset + 4);
2774                   rel++;
2775                   continue;
2776                 }
2777
2778               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2779               continue;
2780             }
2781
2782           h = (struct elf_link_hash_entry *)
2783               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2784                                     FALSE, TRUE);
2785           BFD_ASSERT (h != NULL);
2786           r_type = R_SPARC_WPLT30;
2787           howto = _bfd_sparc_elf_howto_table + r_type;
2788           goto r_sparc_wplt30;
2789
2790         case R_SPARC_TLS_GD_ADD:
2791           tls_type = GOT_UNKNOWN;
2792           if (h == NULL && local_got_offsets)
2793             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2794           else if (h != NULL)
2795             tls_type = elf32_sparc_hash_entry(h)->tls_type;
2796           if (! info->shared || tls_type == GOT_TLS_IE)
2797             {
2798               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2799                  changed into IE:
2800                  ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2801                  or LE:
2802                  add %g7, %reg2, %reg3.  */
2803               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2804               if ((h != NULL && h->dynindx != -1) || info->shared)
2805                 relocation = insn | 0xc0000000;
2806               else
2807                 relocation = (insn & ~0x7c000) | 0x1c000;
2808               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2809             }
2810           continue;
2811
2812         case R_SPARC_TLS_LDM_ADD:
2813           if (! info->shared)
2814             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2815           continue;
2816
2817         case R_SPARC_TLS_LDO_ADD:
2818           if (! info->shared)
2819             {
2820               /* Change rs1 into %g7.  */
2821               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2822               insn = (insn & ~0x7c000) | 0x1c000;
2823               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2824             }
2825           continue;
2826
2827         case R_SPARC_TLS_IE_LD:
2828         case R_SPARC_TLS_IE_LDX:
2829           if (! info->shared && (h == NULL || h->dynindx == -1))
2830             {
2831               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2832               int rs2 = insn & 0x1f;
2833               int rd = (insn >> 25) & 0x1f;
2834
2835               if (rs2 == rd)
2836                 relocation = SPARC_NOP;
2837               else
2838                 relocation = 0x80100000 | (insn & 0x3e00001f);
2839               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2840             }
2841           continue;
2842
2843         case R_SPARC_TLS_IE_ADD:
2844           /* Totally useless relocation.  */
2845           continue;
2846
2847         case R_SPARC_TLS_DTPOFF32:
2848           relocation -= dtpoff_base (info);
2849           break;
2850
2851         default:
2852           break;
2853         }
2854
2855       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2856          because such sections are not SEC_ALLOC and thus ld.so will
2857          not process them.  */
2858       if (unresolved_reloc
2859           && !((input_section->flags & SEC_DEBUGGING) != 0
2860                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2861         (*_bfd_error_handler)
2862           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2863            bfd_archive_filename (input_bfd),
2864            bfd_get_section_name (input_bfd, input_section),
2865            (long) rel->r_offset,
2866            h->root.root.string);
2867
2868       r = bfd_reloc_continue;
2869       if (r_type == R_SPARC_WDISP16)
2870         {
2871           bfd_vma x;
2872
2873           relocation += rel->r_addend;
2874           relocation -= (input_section->output_section->vma
2875                          + input_section->output_offset);
2876           relocation -= rel->r_offset;
2877
2878           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2879           x |= ((((relocation >> 2) & 0xc000) << 6)
2880                 | ((relocation >> 2) & 0x3fff));
2881           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2882
2883           if ((bfd_signed_vma) relocation < - 0x40000
2884               || (bfd_signed_vma) relocation > 0x3ffff)
2885             r = bfd_reloc_overflow;
2886           else
2887             r = bfd_reloc_ok;
2888         }
2889       else if (r_type == R_SPARC_REV32)
2890         {
2891           bfd_vma x;
2892
2893           relocation = relocation + rel->r_addend;
2894
2895           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2896           x = x + relocation;
2897           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
2898           r = bfd_reloc_ok;
2899         }
2900       else if (r_type == R_SPARC_TLS_LDO_HIX22
2901                || r_type == R_SPARC_TLS_LE_HIX22)
2902         {
2903           bfd_vma x;
2904
2905           relocation += rel->r_addend;
2906           relocation = relocation ^ 0xffffffff;
2907
2908           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2909           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2910           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2911           r = bfd_reloc_ok;
2912         }
2913       else if (r_type == R_SPARC_TLS_LDO_LOX10
2914                || r_type == R_SPARC_TLS_LE_LOX10)
2915         {
2916           bfd_vma x;
2917
2918           relocation += rel->r_addend;
2919           relocation = (relocation & 0x3ff) | 0x1c00;
2920
2921           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2922           x = (x & ~(bfd_vma) 0x1fff) | relocation;
2923           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2924
2925           r = bfd_reloc_ok;
2926         }
2927       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
2928                && sec_do_relax (input_section)
2929                && rel->r_offset + 4 < input_section->size)
2930         {
2931 #define G0              0
2932 #define O7              15
2933 #define XCC             (2 << 20)
2934 #define COND(x)         (((x)&0xf)<<25)
2935 #define CONDA           COND(0x8)
2936 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
2937 #define INSN_BA         (F2(0,2) | CONDA)
2938 #define INSN_OR         F3(2, 0x2, 0)
2939 #define INSN_NOP        F2(0,4)
2940
2941           bfd_vma x, y;
2942
2943           /* If the instruction is a call with either:
2944              restore
2945              arithmetic instruction with rd == %o7
2946              where rs1 != %o7 and rs2 if it is register != %o7
2947              then we can optimize if the call destination is near
2948              by changing the call into a branch always.  */
2949           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2950           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2951           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2952             {
2953               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2954                    || ((y & OP3(0x28)) == 0 /* arithmetic */
2955                        && (y & RD(~0)) == RD(O7)))
2956                   && (y & RS1(~0)) != RS1(O7)
2957                   && ((y & F3I(~0))
2958                       || (y & RS2(~0)) != RS2(O7)))
2959                 {
2960                   bfd_vma reloc;
2961
2962                   reloc = relocation + rel->r_addend - rel->r_offset;
2963                   reloc -= (input_section->output_section->vma
2964                            + input_section->output_offset);
2965
2966                   /* Ensure the reloc fits into simm22.  */
2967                   if ((reloc & 3) == 0
2968                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
2969                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2970                     {
2971                       reloc >>= 2;
2972
2973                       /* Check whether it fits into simm19 on v9.  */
2974                       if (((reloc & 0x3c0000) == 0
2975                            || (reloc & 0x3c0000) == 0x3c0000)
2976                           && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2977                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2978                       else
2979                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
2980                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2981                       r = bfd_reloc_ok;
2982                       if (rel->r_offset >= 4
2983                           && (y & (0xffffffff ^ RS1(~0)))
2984                               == (INSN_OR | RD(O7) | RS2(G0)))
2985                         {
2986                           bfd_vma z;
2987                           unsigned int reg;
2988
2989                           z = bfd_get_32 (input_bfd,
2990                                           contents + rel->r_offset - 4);
2991                           if ((z & (0xffffffff ^ RD(~0)))
2992                               != (INSN_OR | RS1(O7) | RS2(G0)))
2993                             break;
2994
2995                           /* The sequence was
2996                              or %o7, %g0, %rN
2997                              call foo
2998                              or %rN, %g0, %o7
2999
3000                              If call foo was replaced with ba, replace
3001                              or %rN, %g0, %o7 with nop.  */
3002
3003                           reg = (y & RS1(~0)) >> 14;
3004                           if (reg != ((z & RD(~0)) >> 25)
3005                               || reg == G0 || reg == O7)
3006                             break;
3007
3008                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3009                                       contents + rel->r_offset + 4);
3010                         }
3011
3012                     }
3013                 }
3014             }
3015         }
3016
3017       if (r == bfd_reloc_continue)
3018         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3019                                       contents, rel->r_offset,
3020                                       relocation, rel->r_addend);
3021
3022       if (r != bfd_reloc_ok)
3023         {
3024           switch (r)
3025             {
3026             default:
3027             case bfd_reloc_outofrange:
3028               abort ();
3029             case bfd_reloc_overflow:
3030               {
3031                 const char *name;
3032
3033                 if (h != NULL)
3034                   name = h->root.root.string;
3035                 else
3036                   {
3037                     name = bfd_elf_string_from_elf_section (input_bfd,
3038                                                             symtab_hdr->sh_link,
3039                                                             sym->st_name);
3040                     if (name == NULL)
3041                       return FALSE;
3042                     if (*name == '\0')
3043                       name = bfd_section_name (input_bfd, sec);
3044                   }
3045                 if (! ((*info->callbacks->reloc_overflow)
3046                        (info, name, howto->name, (bfd_vma) 0,
3047                         input_bfd, input_section, rel->r_offset)))
3048                   return FALSE;
3049               }
3050               break;
3051             }
3052         }
3053     }
3054
3055   return TRUE;
3056 }
3057
3058 /* Finish up dynamic symbol handling.  We set the contents of various
3059    dynamic sections here.  */
3060
3061 static bfd_boolean
3062 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3063      bfd *output_bfd;
3064      struct bfd_link_info *info;
3065      struct elf_link_hash_entry *h;
3066      Elf_Internal_Sym *sym;
3067 {
3068   bfd *dynobj;
3069   struct elf32_sparc_link_hash_table *htab;
3070
3071   htab = elf32_sparc_hash_table (info);
3072   dynobj = htab->elf.dynobj;
3073
3074   if (h->plt.offset != (bfd_vma) -1)
3075     {
3076       asection *splt;
3077       asection *srela;
3078       Elf_Internal_Rela rela;
3079       bfd_byte *loc;
3080
3081       /* This symbol has an entry in the procedure linkage table.  Set
3082          it up.  */
3083
3084       BFD_ASSERT (h->dynindx != -1);
3085
3086       splt = htab->splt;
3087       srela = htab->srelplt;
3088       BFD_ASSERT (splt != NULL && srela != NULL);
3089
3090       /* Fill in the entry in the procedure linkage table.  */
3091       bfd_put_32 (output_bfd,
3092                   PLT_ENTRY_WORD0 + h->plt.offset,
3093                   splt->contents + h->plt.offset);
3094       bfd_put_32 (output_bfd,
3095                   (PLT_ENTRY_WORD1
3096                    + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3097                   splt->contents + h->plt.offset + 4);
3098       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3099                   splt->contents + h->plt.offset + 8);
3100
3101       /* Fill in the entry in the .rela.plt section.  */
3102       rela.r_offset = (splt->output_section->vma
3103                        + splt->output_offset
3104                        + h->plt.offset);
3105       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3106       rela.r_addend = 0;
3107       loc = srela->contents;
3108       loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3109       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3110
3111       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3112         {
3113           /* Mark the symbol as undefined, rather than as defined in
3114              the .plt section.  Leave the value alone.  */
3115           sym->st_shndx = SHN_UNDEF;
3116           /* If the symbol is weak, we do need to clear the value.
3117              Otherwise, the PLT entry would provide a definition for
3118              the symbol even if the symbol wasn't defined anywhere,
3119              and so the symbol would never be NULL.  */
3120           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3121               == 0)
3122             sym->st_value = 0;
3123         }
3124     }
3125
3126   if (h->got.offset != (bfd_vma) -1
3127       && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3128       && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
3129     {
3130       asection *sgot;
3131       asection *srela;
3132       Elf_Internal_Rela rela;
3133       bfd_byte *loc;
3134
3135       /* This symbol has an entry in the global offset table.  Set it
3136          up.  */
3137
3138       sgot = htab->sgot;
3139       srela = htab->srelgot;
3140       BFD_ASSERT (sgot != NULL && srela != NULL);
3141
3142       rela.r_offset = (sgot->output_section->vma
3143                        + sgot->output_offset
3144                        + (h->got.offset &~ (bfd_vma) 1));
3145
3146       /* If this is a -Bsymbolic link, and the symbol is defined
3147          locally, we just want to emit a RELATIVE reloc.  Likewise if
3148          the symbol was forced to be local because of a version file.
3149          The entry in the global offset table will already have been
3150          initialized in the relocate_section function.  */
3151       if (info->shared
3152           && (info->symbolic || h->dynindx == -1)
3153           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3154         {
3155           asection *sec = h->root.u.def.section;
3156           rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3157           rela.r_addend = (h->root.u.def.value
3158                            + sec->output_section->vma
3159                            + sec->output_offset);
3160         }
3161       else
3162         {
3163           rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
3164           rela.r_addend = 0;
3165         }
3166
3167       bfd_put_32 (output_bfd, (bfd_vma) 0,
3168                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3169       loc = srela->contents;
3170       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3171       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3172     }
3173
3174   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3175     {
3176       asection *s;
3177       Elf_Internal_Rela rela;
3178       bfd_byte *loc;
3179
3180       /* This symbols needs a copy reloc.  Set it up.  */
3181
3182       BFD_ASSERT (h->dynindx != -1);
3183
3184       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3185                                    ".rela.bss");
3186       BFD_ASSERT (s != NULL);
3187
3188       rela.r_offset = (h->root.u.def.value
3189                        + h->root.u.def.section->output_section->vma
3190                        + h->root.u.def.section->output_offset);
3191       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3192       rela.r_addend = 0;
3193       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3194       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3195     }
3196
3197   /* Mark some specially defined symbols as absolute.  */
3198   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3199       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3200       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3201     sym->st_shndx = SHN_ABS;
3202
3203   return TRUE;
3204 }
3205
3206 /* Finish up the dynamic sections.  */
3207
3208 static bfd_boolean
3209 elf32_sparc_finish_dynamic_sections (output_bfd, info)
3210      bfd *output_bfd;
3211      struct bfd_link_info *info;
3212 {
3213   bfd *dynobj;
3214   asection *sdyn;
3215   struct elf32_sparc_link_hash_table *htab;
3216
3217   htab = elf32_sparc_hash_table (info);
3218   dynobj = htab->elf.dynobj;
3219
3220   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3221
3222   if (elf_hash_table (info)->dynamic_sections_created)
3223     {
3224       asection *splt;
3225       Elf32_External_Dyn *dyncon, *dynconend;
3226
3227       splt = bfd_get_section_by_name (dynobj, ".plt");
3228       BFD_ASSERT (splt != NULL && sdyn != NULL);
3229
3230       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3231       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3232       for (; dyncon < dynconend; dyncon++)
3233         {
3234           Elf_Internal_Dyn dyn;
3235           const char *name;
3236           bfd_boolean size;
3237
3238           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3239
3240           switch (dyn.d_tag)
3241             {
3242             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3243             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3244             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3245             default:      name = NULL; size = FALSE; break;
3246             }
3247
3248           if (name != NULL)
3249             {
3250               asection *s;
3251
3252               s = bfd_get_section_by_name (output_bfd, name);
3253               if (s == NULL)
3254                 dyn.d_un.d_val = 0;
3255               else
3256                 {
3257                   if (! size)
3258                     dyn.d_un.d_ptr = s->vma;
3259                   else
3260                     dyn.d_un.d_val = s->size;
3261                 }
3262               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3263             }
3264         }
3265
3266       /* Clear the first four entries in the procedure linkage table,
3267          and put a nop in the last four bytes.  */
3268       if (splt->size > 0)
3269         {
3270           memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
3271           bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3272                       splt->contents + splt->size - 4);
3273         }
3274
3275       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
3276     }
3277
3278   /* Set the first entry in the global offset table to the address of
3279      the dynamic section.  */
3280   if (htab->sgot && htab->sgot->size > 0)
3281     {
3282       if (sdyn == NULL)
3283         bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
3284       else
3285         bfd_put_32 (output_bfd,
3286                     sdyn->output_section->vma + sdyn->output_offset,
3287                     htab->sgot->contents);
3288     }
3289
3290   if (htab->sgot)
3291     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3292
3293   return TRUE;
3294 }
3295 \f
3296 /* Functions for dealing with the e_flags field.
3297
3298    We don't define set_private_flags or copy_private_bfd_data because
3299    the only currently defined values are based on the bfd mach number,
3300    so we use the latter instead and defer setting e_flags until the
3301    file is written out.  */
3302
3303 /* Merge backend specific data from an object file to the output
3304    object file when linking.  */
3305
3306 static bfd_boolean
3307 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3308      bfd *ibfd;
3309      bfd *obfd;
3310 {
3311   bfd_boolean error;
3312   /* FIXME: This should not be static.  */
3313   static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
3314
3315   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3316       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3317     return TRUE;
3318
3319   error = FALSE;
3320
3321   if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
3322     {
3323       error = TRUE;
3324       (*_bfd_error_handler)
3325         (_("%s: compiled for a 64 bit system and target is 32 bit"),
3326          bfd_archive_filename (ibfd));
3327     }
3328   else if ((ibfd->flags & DYNAMIC) == 0)
3329     {
3330       if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3331         bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
3332     }
3333
3334   if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3335        != previous_ibfd_e_flags)
3336       && previous_ibfd_e_flags != (unsigned long) -1)
3337     {
3338       (*_bfd_error_handler)
3339         (_("%s: linking little endian files with big endian files"),
3340          bfd_archive_filename (ibfd));
3341       error = TRUE;
3342     }
3343   previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3344
3345   if (error)
3346     {
3347       bfd_set_error (bfd_error_bad_value);
3348       return FALSE;
3349     }
3350
3351   return TRUE;
3352 }
3353 \f
3354 /* Set the right machine number.  */
3355
3356 static bfd_boolean
3357 elf32_sparc_object_p (abfd)
3358      bfd *abfd;
3359 {
3360   if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3361     {
3362       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3363         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3364                                           bfd_mach_sparc_v8plusb);
3365       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3366         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3367                                           bfd_mach_sparc_v8plusa);
3368       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3369         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3370                                           bfd_mach_sparc_v8plus);
3371       else
3372         return FALSE;
3373     }
3374   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3375     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3376                                       bfd_mach_sparc_sparclite_le);
3377   else
3378     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3379 }
3380
3381 /* The final processing done just before writing out the object file.
3382    We need to set the e_machine field appropriately.  */
3383
3384 static void
3385 elf32_sparc_final_write_processing (abfd, linker)
3386      bfd *abfd;
3387      bfd_boolean linker ATTRIBUTE_UNUSED;
3388 {
3389   switch (bfd_get_mach (abfd))
3390     {
3391     case bfd_mach_sparc :
3392       break; /* nothing to do */
3393     case bfd_mach_sparc_v8plus :
3394       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3395       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3396       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
3397       break;
3398     case bfd_mach_sparc_v8plusa :
3399       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3400       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3401       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
3402       break;
3403     case bfd_mach_sparc_v8plusb :
3404       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3405       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3406       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
3407                                        | EF_SPARC_SUN_US3;
3408       break;
3409     case bfd_mach_sparc_sparclite_le :
3410       elf_elfheader (abfd)->e_machine = EM_SPARC;
3411       elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3412       break;
3413     default :
3414       abort ();
3415       break;
3416     }
3417 }
3418
3419 static enum elf_reloc_type_class
3420 elf32_sparc_reloc_type_class (rela)
3421      const Elf_Internal_Rela *rela;
3422 {
3423   switch ((int) ELF32_R_TYPE (rela->r_info))
3424     {
3425     case R_SPARC_RELATIVE:
3426       return reloc_class_relative;
3427     case R_SPARC_JMP_SLOT:
3428       return reloc_class_plt;
3429     case R_SPARC_COPY:
3430       return reloc_class_copy;
3431     default:
3432       return reloc_class_normal;
3433     }
3434 }
3435
3436 /* Return address for Ith PLT stub in section PLT, for relocation REL
3437    or (bfd_vma) -1 if it should not be included.  */
3438
3439 static bfd_vma
3440 elf32_sparc_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
3441                          const asection *plt ATTRIBUTE_UNUSED,
3442                          const arelent *rel)
3443 {
3444   return rel->address;
3445 }
3446 \f
3447 #define TARGET_BIG_SYM  bfd_elf32_sparc_vec
3448 #define TARGET_BIG_NAME "elf32-sparc"
3449 #define ELF_ARCH        bfd_arch_sparc
3450 #define ELF_MACHINE_CODE EM_SPARC
3451 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3452 #define ELF_MAXPAGESIZE 0x10000
3453
3454 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
3455 #define bfd_elf32_bfd_link_hash_table_create \
3456                                         elf32_sparc_link_hash_table_create
3457 #define bfd_elf32_bfd_relax_section     elf32_sparc_relax_section
3458 #define bfd_elf32_new_section_hook      elf32_sparc_new_section_hook
3459 #define elf_info_to_howto               elf32_sparc_info_to_howto
3460 #define elf_backend_copy_indirect_symbol \
3461                                         elf32_sparc_copy_indirect_symbol
3462 #define elf_backend_create_dynamic_sections \
3463                                         elf32_sparc_create_dynamic_sections
3464 #define elf_backend_check_relocs        elf32_sparc_check_relocs
3465 #define elf_backend_adjust_dynamic_symbol \
3466                                         elf32_sparc_adjust_dynamic_symbol
3467 #define elf_backend_size_dynamic_sections \
3468                                         elf32_sparc_size_dynamic_sections
3469 #define elf_backend_relocate_section    elf32_sparc_relocate_section
3470 #define elf_backend_finish_dynamic_symbol \
3471                                         elf32_sparc_finish_dynamic_symbol
3472 #define elf_backend_finish_dynamic_sections \
3473                                         elf32_sparc_finish_dynamic_sections
3474 #define bfd_elf32_bfd_merge_private_bfd_data \
3475                                         elf32_sparc_merge_private_bfd_data
3476 #define bfd_elf32_mkobject              elf32_sparc_mkobject
3477 #define elf_backend_object_p            elf32_sparc_object_p
3478 #define elf_backend_final_write_processing \
3479                                         elf32_sparc_final_write_processing
3480 #define elf_backend_gc_mark_hook        elf32_sparc_gc_mark_hook
3481 #define elf_backend_gc_sweep_hook       elf32_sparc_gc_sweep_hook
3482 #define elf_backend_grok_psinfo         elf32_sparc_grok_psinfo
3483 #define elf_backend_reloc_type_class    elf32_sparc_reloc_type_class
3484 #define elf_backend_plt_sym_val         elf32_sparc_plt_sym_val
3485
3486 #define elf_backend_can_gc_sections 1
3487 #define elf_backend_can_refcount 1
3488 #define elf_backend_want_got_plt 0
3489 #define elf_backend_plt_readonly 0
3490 #define elf_backend_want_plt_sym 1
3491 #define elf_backend_got_header_size 4
3492 #define elf_backend_rela_normal 1
3493
3494 #include "elf32-target.h"