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