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           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2190           while (h->root.type == bfd_link_hash_indirect
2191                  || h->root.type == bfd_link_hash_warning)
2192             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2193
2194           relocation = 0;
2195           if (h->root.type == bfd_link_hash_defined
2196               || h->root.type == bfd_link_hash_defweak)
2197             {
2198               sec = h->root.u.def.section;
2199               if (sec->output_section == NULL)
2200                  /* Set a flag that will be cleared later if we find a
2201                    relocation value for this symbol.  output_section
2202                    is typically NULL for symbols satisfied by a shared
2203                    library.  */
2204                 unresolved_reloc = TRUE;
2205               else
2206                 relocation = (h->root.u.def.value
2207                               + sec->output_section->vma
2208                               + sec->output_offset);
2209             }
2210           else if (h->root.type == bfd_link_hash_undefweak)
2211             ;
2212           else if (!info->executable
2213                    && !info->no_undefined
2214                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2215             ;
2216           else
2217             {
2218               if (! ((*info->callbacks->undefined_symbol)
2219                      (info, h->root.root.string, input_bfd,
2220                       input_section, rel->r_offset,
2221                       (!info->shared || info->no_undefined
2222                        || ELF_ST_VISIBILITY (h->other)))))
2223                 return FALSE;
2224             }
2225         }
2226
2227       switch (r_type)
2228         {
2229         case R_SPARC_GOT10:
2230         case R_SPARC_GOT13:
2231         case R_SPARC_GOT22:
2232           /* Relocation is to the entry for this symbol in the global
2233              offset table.  */
2234           if (htab->sgot == NULL)
2235             abort ();
2236
2237           if (h != NULL)
2238             {
2239               bfd_boolean dyn;
2240
2241               off = h->got.offset;
2242               BFD_ASSERT (off != (bfd_vma) -1);
2243               dyn = elf_hash_table (info)->dynamic_sections_created;
2244
2245               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2246                   || (info->shared
2247                       && (info->symbolic
2248                           || h->dynindx == -1
2249                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2250                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2251                 {
2252                   /* This is actually a static link, or it is a
2253                      -Bsymbolic link and the symbol is defined
2254                      locally, or the symbol was forced to be local
2255                      because of a version file.  We must initialize
2256                      this entry in the global offset table.  Since the
2257                      offset must always be a multiple of 4, we use the
2258                      least significant bit to record whether we have
2259                      initialized it already.
2260
2261                      When doing a dynamic link, we create a .rela.got
2262                      relocation entry to initialize the value.  This
2263                      is done in the finish_dynamic_symbol routine.  */
2264                   if ((off & 1) != 0)
2265                     off &= ~1;
2266                   else
2267                     {
2268                       bfd_put_32 (output_bfd, relocation,
2269                                   htab->sgot->contents + off);
2270                       h->got.offset |= 1;
2271                     }
2272                 }
2273               else
2274                 unresolved_reloc = FALSE;
2275             }
2276           else
2277             {
2278               BFD_ASSERT (local_got_offsets != NULL
2279                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2280
2281               off = local_got_offsets[r_symndx];
2282
2283               /* The offset must always be a multiple of 4.  We use
2284                  the least significant bit to record whether we have
2285                  already processed this entry.  */
2286               if ((off & 1) != 0)
2287                 off &= ~1;
2288               else
2289                 {
2290
2291                   if (info->shared)
2292                     {
2293                       asection *s;
2294                       Elf_Internal_Rela outrel;
2295                       bfd_byte *loc;
2296
2297                       /* We need to generate a R_SPARC_RELATIVE reloc
2298                          for the dynamic linker.  */
2299                       s = htab->srelgot;
2300                       BFD_ASSERT (s != NULL);
2301
2302                       outrel.r_offset = (htab->sgot->output_section->vma
2303                                          + htab->sgot->output_offset
2304                                          + off);
2305                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2306                       outrel.r_addend = relocation;
2307                       relocation = 0;
2308                       loc = s->contents;
2309                       loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2310                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2311                     }
2312
2313                   bfd_put_32 (output_bfd, relocation,
2314                               htab->sgot->contents + off);
2315                   local_got_offsets[r_symndx] |= 1;
2316                 }
2317             }
2318           relocation = htab->sgot->output_offset + off - got_base;
2319           break;
2320
2321         case R_SPARC_PLT32:
2322           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2323             {
2324               r_type = R_SPARC_32;
2325               goto r_sparc_plt32;
2326             }
2327           /* Fall through.  */
2328         case R_SPARC_WPLT30:
2329         r_sparc_wplt30:
2330           /* Relocation is to the entry for this symbol in the
2331              procedure linkage table.  */
2332
2333           /* The Solaris native assembler will generate a WPLT30 reloc
2334              for a local symbol if you assemble a call from one
2335              section to another when using -K pic.  We treat it as
2336              WDISP30.  */
2337           if (h == NULL)
2338             break;
2339
2340           if (h->plt.offset == (bfd_vma) -1)
2341             {
2342               /* We didn't make a PLT entry for this symbol.  This
2343                  happens when statically linking PIC code, or when
2344                  using -Bsymbolic.  */
2345               break;
2346             }
2347
2348           if (htab->splt == NULL)
2349             abort ();
2350
2351           relocation = (htab->splt->output_section->vma
2352                         + htab->splt->output_offset
2353                         + h->plt.offset);
2354           unresolved_reloc = FALSE;
2355           if (r_type == R_SPARC_PLT32)
2356             {
2357               r_type = R_SPARC_32;
2358               is_plt = TRUE;
2359               goto r_sparc_plt32;
2360             }
2361           break;
2362
2363         case R_SPARC_PC10:
2364         case R_SPARC_PC22:
2365           if (h != NULL
2366               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2367             break;
2368           /* Fall through.  */
2369         case R_SPARC_DISP8:
2370         case R_SPARC_DISP16:
2371         case R_SPARC_DISP32:
2372         case R_SPARC_WDISP30:
2373         case R_SPARC_WDISP22:
2374         case R_SPARC_WDISP19:
2375         case R_SPARC_WDISP16:
2376         case R_SPARC_8:
2377         case R_SPARC_16:
2378         case R_SPARC_32:
2379         case R_SPARC_HI22:
2380         case R_SPARC_22:
2381         case R_SPARC_13:
2382         case R_SPARC_LO10:
2383         case R_SPARC_UA16:
2384         case R_SPARC_UA32:
2385         r_sparc_plt32:
2386           /* r_symndx will be zero only for relocs against symbols
2387              from removed linkonce sections, or sections discarded by
2388              a linker script.  */
2389           if (r_symndx == 0
2390               || (input_section->flags & SEC_ALLOC) == 0)
2391             break;
2392
2393           if ((info->shared
2394                && (! howto->pc_relative
2395                    || (h != NULL
2396                        && h->dynindx != -1
2397                        && (! info->symbolic
2398                            || (h->elf_link_hash_flags
2399                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2400               || (!info->shared
2401                   && h != NULL
2402                   && h->dynindx != -1
2403                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2404                   && (((h->elf_link_hash_flags
2405                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2406                        && (h->elf_link_hash_flags
2407                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2408                       || h->root.type == bfd_link_hash_undefweak
2409                       || h->root.type == bfd_link_hash_undefined)))
2410             {
2411               Elf_Internal_Rela outrel;
2412               bfd_byte *loc;
2413               bfd_boolean skip, relocate = FALSE;
2414
2415               /* When generating a shared object, these relocations
2416                  are copied into the output file to be resolved at run
2417                  time.  */
2418
2419               BFD_ASSERT (sreloc != NULL);
2420
2421               skip = FALSE;
2422
2423               outrel.r_offset =
2424                 _bfd_elf_section_offset (output_bfd, info, input_section,
2425                                          rel->r_offset);
2426               if (outrel.r_offset == (bfd_vma) -1)
2427                 skip = TRUE;
2428               else if (outrel.r_offset == (bfd_vma) -2)
2429                 skip = TRUE, relocate = TRUE;
2430               outrel.r_offset += (input_section->output_section->vma
2431                                   + input_section->output_offset);
2432
2433               /* Optimize unaligned reloc usage now that we know where
2434                  it finally resides.  */
2435               switch (r_type)
2436                 {
2437                 case R_SPARC_16:
2438                   if (outrel.r_offset & 1)
2439                     r_type = R_SPARC_UA16;
2440                   break;
2441                 case R_SPARC_UA16:
2442                   if (!(outrel.r_offset & 1))
2443                     r_type = R_SPARC_16;
2444                   break;
2445                 case R_SPARC_32:
2446                   if (outrel.r_offset & 3)
2447                     r_type = R_SPARC_UA32;
2448                   break;
2449                 case R_SPARC_UA32:
2450                   if (!(outrel.r_offset & 3))
2451                     r_type = R_SPARC_32;
2452                   break;
2453                 case R_SPARC_DISP8:
2454                 case R_SPARC_DISP16:
2455                 case R_SPARC_DISP32:
2456                   /* If the symbol is not dynamic, we should not keep
2457                      a dynamic relocation.  But an .rela.* slot has been
2458                      allocated for it, output R_SPARC_NONE.
2459                      FIXME: Add code tracking needed dynamic relocs as
2460                      e.g. i386 has.  */
2461                   if (h->dynindx == -1)
2462                     skip = TRUE, relocate = TRUE;
2463                   break;
2464                 }
2465
2466               if (skip)
2467                 memset (&outrel, 0, sizeof outrel);
2468               /* h->dynindx may be -1 if the symbol was marked to
2469                  become local.  */
2470               else if (h != NULL && ! is_plt
2471                        && ((! info->symbolic && h->dynindx != -1)
2472                            || (h->elf_link_hash_flags
2473                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2474                 {
2475                   BFD_ASSERT (h->dynindx != -1);
2476                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2477                   outrel.r_addend = rel->r_addend;
2478                 }
2479               else
2480                 {
2481                   if (r_type == R_SPARC_32)
2482                     {
2483                       outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2484                       outrel.r_addend = relocation + rel->r_addend;
2485                     }
2486                   else
2487                     {
2488                       long indx;
2489
2490                       if (is_plt)
2491                         sec = htab->splt;
2492                       else if (h == NULL)
2493                         sec = local_sections[r_symndx];
2494                       else
2495                         {
2496                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2497                                       || (h->root.type
2498                                           == bfd_link_hash_defweak));
2499                           sec = h->root.u.def.section;
2500                         }
2501                       if (sec != NULL && bfd_is_abs_section (sec))
2502                         indx = 0;
2503                       else if (sec == NULL || sec->owner == NULL)
2504                         {
2505                           bfd_set_error (bfd_error_bad_value);
2506                           return FALSE;
2507                         }
2508                       else
2509                         {
2510                           asection *osec;
2511
2512                           osec = sec->output_section;
2513                           indx = elf_section_data (osec)->dynindx;
2514
2515                           /* FIXME: we really should be able to link non-pic
2516                              shared libraries.  */
2517                           if (indx == 0)
2518                             {
2519                               BFD_FAIL ();
2520                               (*_bfd_error_handler)
2521                                 (_("%s: probably compiled without -fPIC?"),
2522                                  bfd_archive_filename (input_bfd));
2523                               bfd_set_error (bfd_error_bad_value);
2524                               return FALSE;
2525                             }
2526                         }
2527
2528                       outrel.r_info = ELF32_R_INFO (indx, r_type);
2529                       outrel.r_addend = relocation + rel->r_addend;
2530                     }
2531                 }
2532
2533               loc = sreloc->contents;
2534               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2535               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2536
2537               /* This reloc will be computed at runtime, so there's no
2538                  need to do anything now.  */
2539               if (! relocate)
2540                 continue;
2541             }
2542           break;
2543
2544         case R_SPARC_TLS_GD_HI22:
2545           if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2546             {
2547               /* R_SPARC_REV32 used the same reloc number as
2548                  R_SPARC_TLS_GD_HI22.  */
2549               r_type = R_SPARC_REV32;
2550               break;
2551             }
2552           /* Fall through */
2553
2554         case R_SPARC_TLS_GD_LO10:
2555         case R_SPARC_TLS_IE_HI22:
2556         case R_SPARC_TLS_IE_LO10:
2557           r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2558                                                h == NULL);
2559           tls_type = GOT_UNKNOWN;
2560           if (h == NULL && local_got_offsets)
2561             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2562           else if (h != NULL)
2563             {
2564               tls_type = elf32_sparc_hash_entry(h)->tls_type;
2565               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2566                 switch (ELF32_R_TYPE (rel->r_info))
2567                   {
2568                   case R_SPARC_TLS_GD_HI22:
2569                   case R_SPARC_TLS_IE_HI22:
2570                     r_type = R_SPARC_TLS_LE_HIX22;
2571                     break;
2572                   default:
2573                     r_type = R_SPARC_TLS_LE_LOX10;
2574                     break;
2575                   }
2576             }
2577           if (tls_type == GOT_TLS_IE)
2578             switch (r_type)
2579               {
2580               case R_SPARC_TLS_GD_HI22:
2581                 r_type = R_SPARC_TLS_IE_HI22;
2582                 break;
2583               case R_SPARC_TLS_GD_LO10:
2584                 r_type = R_SPARC_TLS_IE_LO10;
2585                 break;
2586               }
2587
2588           if (r_type == R_SPARC_TLS_LE_HIX22)
2589             {
2590               relocation = tpoff (info, relocation);
2591               break;
2592             }
2593           if (r_type == R_SPARC_TLS_LE_LOX10)
2594             {
2595               /* Change add into xor.  */
2596               relocation = tpoff (info, relocation);
2597               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2598                                                    contents + rel->r_offset)
2599                                        | 0x80182000), contents + rel->r_offset);
2600               break;
2601             }
2602
2603           if (h != NULL)
2604             {
2605               off = h->got.offset;
2606               h->got.offset |= 1;
2607             }
2608           else
2609             {
2610               BFD_ASSERT (local_got_offsets != NULL);
2611               off = local_got_offsets[r_symndx];
2612               local_got_offsets[r_symndx] |= 1;
2613             }
2614
2615         r_sparc_tlsldm:
2616           if (htab->sgot == NULL)
2617             abort ();
2618
2619           if ((off & 1) != 0)
2620             off &= ~1;
2621           else
2622             {
2623               Elf_Internal_Rela outrel;
2624               Elf32_External_Rela *loc;
2625               int dr_type, indx;
2626
2627               if (htab->srelgot == NULL)
2628                 abort ();
2629
2630               bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2631               outrel.r_offset = (htab->sgot->output_section->vma
2632                                  + htab->sgot->output_offset + off);
2633               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2634               if (r_type == R_SPARC_TLS_IE_HI22
2635                 || r_type == R_SPARC_TLS_IE_LO10)
2636                 dr_type = R_SPARC_TLS_TPOFF32;
2637               else
2638                 dr_type = R_SPARC_TLS_DTPMOD32;
2639               if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2640                 outrel.r_addend = relocation - dtpoff_base (info);
2641               else
2642                 outrel.r_addend = 0;
2643               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2644               loc = (Elf32_External_Rela *) htab->srelgot->contents;
2645               loc += htab->srelgot->reloc_count++;
2646               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2647                                          (bfd_byte *) loc);
2648
2649               if (r_type == R_SPARC_TLS_GD_HI22
2650                   || r_type == R_SPARC_TLS_GD_LO10)
2651                 {
2652                   if (indx == 0)
2653                     {
2654                       BFD_ASSERT (! unresolved_reloc);
2655                       bfd_put_32 (output_bfd,
2656                                   relocation - dtpoff_base (info),
2657                                   htab->sgot->contents + off + 4);
2658                     }
2659                   else
2660                     {
2661                       bfd_put_32 (output_bfd, 0,
2662                                   htab->sgot->contents + off + 4);
2663                       outrel.r_info = ELF32_R_INFO (indx,
2664                                                     R_SPARC_TLS_DTPOFF32);
2665                       outrel.r_offset += 4;
2666                       htab->srelgot->reloc_count++;
2667                       loc++;
2668                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2669                                                  (bfd_byte *) loc);
2670                     }
2671                 }
2672               else if (dr_type == R_SPARC_TLS_DTPMOD32)
2673                 {
2674                   bfd_put_32 (output_bfd, 0,
2675                               htab->sgot->contents + off + 4);
2676                 }
2677             }
2678
2679           if (off >= (bfd_vma) -2)
2680             abort ();
2681
2682           relocation = htab->sgot->output_offset + off - got_base;
2683           unresolved_reloc = FALSE;
2684           howto = _bfd_sparc_elf_howto_table + r_type;
2685           break;
2686
2687         case R_SPARC_TLS_LDM_HI22:
2688         case R_SPARC_TLS_LDM_LO10:
2689           if (! info->shared)
2690             {
2691               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2692               continue;
2693             }
2694           off = htab->tls_ldm_got.offset;
2695           htab->tls_ldm_got.offset |= 1;
2696           goto r_sparc_tlsldm;
2697
2698         case R_SPARC_TLS_LDO_HIX22:
2699         case R_SPARC_TLS_LDO_LOX10:
2700           if (info->shared)
2701             relocation -= dtpoff_base (info);
2702           else
2703             relocation = tpoff (info, relocation);
2704           break;
2705
2706         case R_SPARC_TLS_LE_HIX22:
2707         case R_SPARC_TLS_LE_LOX10:
2708           if (info->shared)
2709             {
2710               Elf_Internal_Rela outrel;
2711               bfd_boolean skip, relocate = FALSE;
2712
2713               BFD_ASSERT (sreloc != NULL);
2714               skip = FALSE;
2715               outrel.r_offset =
2716                 _bfd_elf_section_offset (output_bfd, info, input_section,
2717                                          rel->r_offset);
2718               if (outrel.r_offset == (bfd_vma) -1)
2719                 skip = TRUE;
2720               else if (outrel.r_offset == (bfd_vma) -2)
2721                 skip = TRUE, relocate = TRUE;
2722               outrel.r_offset += (input_section->output_section->vma
2723                                   + input_section->output_offset);
2724               if (skip)
2725                 memset (&outrel, 0, sizeof outrel);
2726               else
2727                 {
2728                   outrel.r_info = ELF32_R_INFO (0, r_type);
2729                   outrel.r_addend = relocation - dtpoff_base (info)
2730                                     + rel->r_addend;
2731                 }
2732
2733               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2734                                          (bfd_byte *) (((Elf32_External_Rela *)
2735                                                         sreloc->contents)
2736                                                        + sreloc->reloc_count));
2737               ++sreloc->reloc_count;
2738               continue;
2739             }
2740           relocation = tpoff (info, relocation);
2741           break;
2742
2743         case R_SPARC_TLS_LDM_CALL:
2744           if (! info->shared)
2745             {
2746               /* mov %g0, %o0 */
2747               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2748               continue;
2749             }
2750           /* Fall through */
2751
2752         case R_SPARC_TLS_GD_CALL:
2753           tls_type = GOT_UNKNOWN;
2754           if (h == NULL && local_got_offsets)
2755             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2756           else if (h != NULL)
2757             tls_type = elf32_sparc_hash_entry(h)->tls_type;
2758           if (! info->shared
2759               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2760             {
2761               bfd_vma insn;
2762
2763               if (!info->shared && (h == NULL || h->dynindx == -1))
2764                 {
2765                   /* GD -> LE */
2766                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2767                   continue;
2768                 }
2769
2770               /* GD -> IE */
2771               if (rel + 1 < relend
2772                   && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2773                   && rel[1].r_offset == rel->r_offset + 4
2774                   && ELF32_R_SYM (rel[1].r_info) == r_symndx
2775                   && (((insn = bfd_get_32 (input_bfd,
2776                                            contents + rel[1].r_offset))
2777                        >> 25) & 0x1f) == 8)
2778                 {
2779                   /* We have
2780                      call __tls_get_addr, %tgd_call(foo)
2781                       add %reg1, %reg2, %o0, %tgd_add(foo)
2782                      and change it into IE:
2783                      ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2784                      add %g7, %o0, %o0, %tie_add(foo).
2785                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2786                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2.  */
2787                   bfd_put_32 (output_bfd, insn | 0xc0000000,
2788                               contents + rel->r_offset);
2789                   bfd_put_32 (output_bfd, 0x9001c008,
2790                               contents + rel->r_offset + 4);
2791                   rel++;
2792                   continue;
2793                 }
2794
2795               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2796               continue;
2797             }
2798
2799           h = (struct elf_link_hash_entry *)
2800               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2801                                     FALSE, TRUE);
2802           BFD_ASSERT (h != NULL);
2803           r_type = R_SPARC_WPLT30;
2804           howto = _bfd_sparc_elf_howto_table + r_type;
2805           goto r_sparc_wplt30;
2806
2807         case R_SPARC_TLS_GD_ADD:
2808           tls_type = GOT_UNKNOWN;
2809           if (h == NULL && local_got_offsets)
2810             tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2811           else if (h != NULL)
2812             tls_type = elf32_sparc_hash_entry(h)->tls_type;
2813           if (! info->shared || tls_type == GOT_TLS_IE)
2814             {
2815               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2816                  changed into IE:
2817                  ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2818                  or LE:
2819                  add %g7, %reg2, %reg3.  */
2820               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2821               if ((h != NULL && h->dynindx != -1) || info->shared)
2822                 relocation = insn | 0xc0000000;
2823               else
2824                 relocation = (insn & ~0x7c000) | 0x1c000;
2825               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2826             }
2827           continue;
2828
2829         case R_SPARC_TLS_LDM_ADD:
2830           if (! info->shared)
2831             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2832           continue;
2833
2834         case R_SPARC_TLS_LDO_ADD:
2835           if (! info->shared)
2836             {
2837               /* Change rs1 into %g7.  */
2838               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2839               insn = (insn & ~0x7c000) | 0x1c000;
2840               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2841             }
2842           continue;
2843
2844         case R_SPARC_TLS_IE_LD:
2845         case R_SPARC_TLS_IE_LDX:
2846           if (! info->shared && (h == NULL || h->dynindx == -1))
2847             {
2848               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2849               int rs2 = insn & 0x1f;
2850               int rd = (insn >> 25) & 0x1f;
2851
2852               if (rs2 == rd)
2853                 relocation = SPARC_NOP;
2854               else
2855                 relocation = 0x80100000 | (insn & 0x3e00001f);
2856               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2857             }
2858           continue;
2859
2860         case R_SPARC_TLS_IE_ADD:
2861           /* Totally useless relocation.  */
2862           continue;
2863
2864         case R_SPARC_TLS_DTPOFF32:
2865           relocation -= dtpoff_base (info);
2866           break;
2867
2868         default:
2869           break;
2870         }
2871
2872       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2873          because such sections are not SEC_ALLOC and thus ld.so will
2874          not process them.  */
2875       if (unresolved_reloc
2876           && !((input_section->flags & SEC_DEBUGGING) != 0
2877                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2878         (*_bfd_error_handler)
2879           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2880            bfd_archive_filename (input_bfd),
2881            bfd_get_section_name (input_bfd, input_section),
2882            (long) rel->r_offset,
2883            h->root.root.string);
2884
2885       r = bfd_reloc_continue;
2886       if (r_type == R_SPARC_WDISP16)
2887         {
2888           bfd_vma x;
2889
2890           relocation += rel->r_addend;
2891           relocation -= (input_section->output_section->vma
2892                          + input_section->output_offset);
2893           relocation -= rel->r_offset;
2894
2895           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2896           x |= ((((relocation >> 2) & 0xc000) << 6)
2897                 | ((relocation >> 2) & 0x3fff));
2898           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2899
2900           if ((bfd_signed_vma) relocation < - 0x40000
2901               || (bfd_signed_vma) relocation > 0x3ffff)
2902             r = bfd_reloc_overflow;
2903           else
2904             r = bfd_reloc_ok;
2905         }
2906       else if (r_type == R_SPARC_REV32)
2907         {
2908           bfd_vma x;
2909
2910           relocation = relocation + rel->r_addend;
2911
2912           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2913           x = x + relocation;
2914           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
2915           r = bfd_reloc_ok;
2916         }
2917       else if (r_type == R_SPARC_TLS_LDO_HIX22
2918                || r_type == R_SPARC_TLS_LE_HIX22)
2919         {
2920           bfd_vma x;
2921
2922           relocation += rel->r_addend;
2923           relocation = relocation ^ 0xffffffff;
2924
2925           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2926           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2927           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2928           r = bfd_reloc_ok;
2929         }
2930       else if (r_type == R_SPARC_TLS_LDO_LOX10
2931                || r_type == R_SPARC_TLS_LE_LOX10)
2932         {
2933           bfd_vma x;
2934
2935           relocation += rel->r_addend;
2936           relocation = (relocation & 0x3ff) | 0x1c00;
2937
2938           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2939           x = (x & ~(bfd_vma) 0x1fff) | relocation;
2940           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2941
2942           r = bfd_reloc_ok;
2943         }
2944       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
2945                && sec_do_relax (input_section)
2946                && rel->r_offset + 4 < input_section->_raw_size)
2947         {
2948 #define G0              0
2949 #define O7              15
2950 #define XCC             (2 << 20)
2951 #define COND(x)         (((x)&0xf)<<25)
2952 #define CONDA           COND(0x8)
2953 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
2954 #define INSN_BA         (F2(0,2) | CONDA)
2955 #define INSN_OR         F3(2, 0x2, 0)
2956 #define INSN_NOP        F2(0,4)
2957
2958           bfd_vma x, y;
2959
2960           /* If the instruction is a call with either:
2961              restore
2962              arithmetic instruction with rd == %o7
2963              where rs1 != %o7 and rs2 if it is register != %o7
2964              then we can optimize if the call destination is near
2965              by changing the call into a branch always.  */
2966           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2967           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2968           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2969             {
2970               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2971                    || ((y & OP3(0x28)) == 0 /* arithmetic */
2972                        && (y & RD(~0)) == RD(O7)))
2973                   && (y & RS1(~0)) != RS1(O7)
2974                   && ((y & F3I(~0))
2975                       || (y & RS2(~0)) != RS2(O7)))
2976                 {
2977                   bfd_vma reloc;
2978
2979                   reloc = relocation + rel->r_addend - rel->r_offset;
2980                   reloc -= (input_section->output_section->vma
2981                            + input_section->output_offset);
2982
2983                   /* Ensure the reloc fits into simm22.  */
2984                   if ((reloc & 3) == 0
2985                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
2986                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2987                     {
2988                       reloc >>= 2;
2989
2990                       /* Check whether it fits into simm19 on v9.  */
2991                       if (((reloc & 0x3c0000) == 0
2992                            || (reloc & 0x3c0000) == 0x3c0000)
2993                           && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2994                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2995                       else
2996                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
2997                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2998                       r = bfd_reloc_ok;
2999                       if (rel->r_offset >= 4
3000                           && (y & (0xffffffff ^ RS1(~0)))
3001                               == (INSN_OR | RD(O7) | RS2(G0)))
3002                         {
3003                           bfd_vma z;
3004                           unsigned int reg;
3005
3006                           z = bfd_get_32 (input_bfd,
3007                                           contents + rel->r_offset - 4);
3008                           if ((z & (0xffffffff ^ RD(~0)))
3009                               != (INSN_OR | RS1(O7) | RS2(G0)))
3010                             break;
3011
3012                           /* The sequence was
3013                              or %o7, %g0, %rN
3014                              call foo
3015                              or %rN, %g0, %o7
3016
3017                              If call foo was replaced with ba, replace
3018                              or %rN, %g0, %o7 with nop.  */
3019
3020                           reg = (y & RS1(~0)) >> 14;
3021                           if (reg != ((z & RD(~0)) >> 25)
3022                               || reg == G0 || reg == O7)
3023                             break;
3024
3025                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3026                                       contents + rel->r_offset + 4);
3027                         }
3028
3029                     }
3030                 }
3031             }
3032         }
3033
3034       if (r == bfd_reloc_continue)
3035         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3036                                       contents, rel->r_offset,
3037                                       relocation, rel->r_addend);
3038
3039       if (r != bfd_reloc_ok)
3040         {
3041           switch (r)
3042             {
3043             default:
3044             case bfd_reloc_outofrange:
3045               abort ();
3046             case bfd_reloc_overflow:
3047               {
3048                 const char *name;
3049
3050                 if (h != NULL)
3051                   name = h->root.root.string;
3052                 else
3053                   {
3054                     name = bfd_elf_string_from_elf_section (input_bfd,
3055                                                             symtab_hdr->sh_link,
3056                                                             sym->st_name);
3057                     if (name == NULL)
3058                       return FALSE;
3059                     if (*name == '\0')
3060                       name = bfd_section_name (input_bfd, sec);
3061                   }
3062                 if (! ((*info->callbacks->reloc_overflow)
3063                        (info, name, howto->name, (bfd_vma) 0,
3064                         input_bfd, input_section, rel->r_offset)))
3065                   return FALSE;
3066               }
3067               break;
3068             }
3069         }
3070     }
3071
3072   return TRUE;
3073 }
3074
3075 /* Finish up dynamic symbol handling.  We set the contents of various
3076    dynamic sections here.  */
3077
3078 static bfd_boolean
3079 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3080      bfd *output_bfd;
3081      struct bfd_link_info *info;
3082      struct elf_link_hash_entry *h;
3083      Elf_Internal_Sym *sym;
3084 {
3085   bfd *dynobj;
3086   struct elf32_sparc_link_hash_table *htab;
3087
3088   htab = elf32_sparc_hash_table (info);
3089   dynobj = htab->elf.dynobj;
3090
3091   if (h->plt.offset != (bfd_vma) -1)
3092     {
3093       asection *splt;
3094       asection *srela;
3095       Elf_Internal_Rela rela;
3096       bfd_byte *loc;
3097
3098       /* This symbol has an entry in the procedure linkage table.  Set
3099          it up.  */
3100
3101       BFD_ASSERT (h->dynindx != -1);
3102
3103       splt = htab->splt;
3104       srela = htab->srelplt;
3105       BFD_ASSERT (splt != NULL && srela != NULL);
3106
3107       /* Fill in the entry in the procedure linkage table.  */
3108       bfd_put_32 (output_bfd,
3109                   PLT_ENTRY_WORD0 + h->plt.offset,
3110                   splt->contents + h->plt.offset);
3111       bfd_put_32 (output_bfd,
3112                   (PLT_ENTRY_WORD1
3113                    + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3114                   splt->contents + h->plt.offset + 4);
3115       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3116                   splt->contents + h->plt.offset + 8);
3117
3118       /* Fill in the entry in the .rela.plt section.  */
3119       rela.r_offset = (splt->output_section->vma
3120                        + splt->output_offset
3121                        + h->plt.offset);
3122       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3123       rela.r_addend = 0;
3124       loc = srela->contents;
3125       loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3126       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3127
3128       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3129         {
3130           /* Mark the symbol as undefined, rather than as defined in
3131              the .plt section.  Leave the value alone.  */
3132           sym->st_shndx = SHN_UNDEF;
3133           /* If the symbol is weak, we do need to clear the value.
3134              Otherwise, the PLT entry would provide a definition for
3135              the symbol even if the symbol wasn't defined anywhere,
3136              and so the symbol would never be NULL.  */
3137           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3138               == 0)
3139             sym->st_value = 0;
3140         }
3141     }
3142
3143   if (h->got.offset != (bfd_vma) -1
3144       && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3145       && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
3146     {
3147       asection *sgot;
3148       asection *srela;
3149       Elf_Internal_Rela rela;
3150       bfd_byte *loc;
3151
3152       /* This symbol has an entry in the global offset table.  Set it
3153          up.  */
3154
3155       sgot = htab->sgot;
3156       srela = htab->srelgot;
3157       BFD_ASSERT (sgot != NULL && srela != NULL);
3158
3159       rela.r_offset = (sgot->output_section->vma
3160                        + sgot->output_offset
3161                        + (h->got.offset &~ (bfd_vma) 1));
3162
3163       /* If this is a -Bsymbolic link, and the symbol is defined
3164          locally, we just want to emit a RELATIVE reloc.  Likewise if
3165          the symbol was forced to be local because of a version file.
3166          The entry in the global offset table will already have been
3167          initialized in the relocate_section function.  */
3168       if (info->shared
3169           && (info->symbolic || h->dynindx == -1)
3170           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3171         {
3172           asection *sec = h->root.u.def.section;
3173           rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3174           rela.r_addend = (h->root.u.def.value
3175                            + sec->output_section->vma
3176                            + sec->output_offset);
3177         }
3178       else
3179         {
3180           rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
3181           rela.r_addend = 0;
3182         }
3183
3184       bfd_put_32 (output_bfd, (bfd_vma) 0,
3185                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3186       loc = srela->contents;
3187       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3188       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3189     }
3190
3191   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3192     {
3193       asection *s;
3194       Elf_Internal_Rela rela;
3195       bfd_byte *loc;
3196
3197       /* This symbols needs a copy reloc.  Set it up.  */
3198
3199       BFD_ASSERT (h->dynindx != -1);
3200
3201       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3202                                    ".rela.bss");
3203       BFD_ASSERT (s != NULL);
3204
3205       rela.r_offset = (h->root.u.def.value
3206                        + h->root.u.def.section->output_section->vma
3207                        + h->root.u.def.section->output_offset);
3208       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3209       rela.r_addend = 0;
3210       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3211       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3212     }
3213
3214   /* Mark some specially defined symbols as absolute.  */
3215   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3216       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3217       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3218     sym->st_shndx = SHN_ABS;
3219
3220   return TRUE;
3221 }
3222
3223 /* Finish up the dynamic sections.  */
3224
3225 static bfd_boolean
3226 elf32_sparc_finish_dynamic_sections (output_bfd, info)
3227      bfd *output_bfd;
3228      struct bfd_link_info *info;
3229 {
3230   bfd *dynobj;
3231   asection *sdyn;
3232   struct elf32_sparc_link_hash_table *htab;
3233
3234   htab = elf32_sparc_hash_table (info);
3235   dynobj = htab->elf.dynobj;
3236
3237   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3238
3239   if (elf_hash_table (info)->dynamic_sections_created)
3240     {
3241       asection *splt;
3242       Elf32_External_Dyn *dyncon, *dynconend;
3243
3244       splt = bfd_get_section_by_name (dynobj, ".plt");
3245       BFD_ASSERT (splt != NULL && sdyn != NULL);
3246
3247       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3248       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3249       for (; dyncon < dynconend; dyncon++)
3250         {
3251           Elf_Internal_Dyn dyn;
3252           const char *name;
3253           bfd_boolean size;
3254
3255           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3256
3257           switch (dyn.d_tag)
3258             {
3259             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3260             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3261             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3262             default:      name = NULL; size = FALSE; break;
3263             }
3264
3265           if (name != NULL)
3266             {
3267               asection *s;
3268
3269               s = bfd_get_section_by_name (output_bfd, name);
3270               if (s == NULL)
3271                 dyn.d_un.d_val = 0;
3272               else
3273                 {
3274                   if (! size)
3275                     dyn.d_un.d_ptr = s->vma;
3276                   else
3277                     {
3278                       if (s->_cooked_size != 0)
3279                         dyn.d_un.d_val = s->_cooked_size;
3280                       else
3281                         dyn.d_un.d_val = s->_raw_size;
3282                     }
3283                 }
3284               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3285             }
3286         }
3287
3288       /* Clear the first four entries in the procedure linkage table,
3289          and put a nop in the last four bytes.  */
3290       if (splt->_raw_size > 0)
3291         {
3292           memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
3293           bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3294                       splt->contents + splt->_raw_size - 4);
3295         }
3296
3297       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3298         PLT_ENTRY_SIZE;
3299     }
3300
3301   /* Set the first entry in the global offset table to the address of
3302      the dynamic section.  */
3303   if (htab->sgot && htab->sgot->_raw_size > 0)
3304     {
3305       if (sdyn == NULL)
3306         bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
3307       else
3308         bfd_put_32 (output_bfd,
3309                     sdyn->output_section->vma + sdyn->output_offset,
3310                     htab->sgot->contents);
3311     }
3312
3313   if (htab->sgot)
3314     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3315
3316   return TRUE;
3317 }
3318 \f
3319 /* Functions for dealing with the e_flags field.
3320
3321    We don't define set_private_flags or copy_private_bfd_data because
3322    the only currently defined values are based on the bfd mach number,
3323    so we use the latter instead and defer setting e_flags until the
3324    file is written out.  */
3325
3326 /* Merge backend specific data from an object file to the output
3327    object file when linking.  */
3328
3329 static bfd_boolean
3330 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3331      bfd *ibfd;
3332      bfd *obfd;
3333 {
3334   bfd_boolean error;
3335   /* FIXME: This should not be static.  */
3336   static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
3337
3338   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3339       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3340     return TRUE;
3341
3342   error = FALSE;
3343
3344   if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
3345     {
3346       error = TRUE;
3347       (*_bfd_error_handler)
3348         (_("%s: compiled for a 64 bit system and target is 32 bit"),
3349          bfd_archive_filename (ibfd));
3350     }
3351   else if ((ibfd->flags & DYNAMIC) == 0)
3352     {
3353       if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3354         bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
3355     }
3356
3357   if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3358        != previous_ibfd_e_flags)
3359       && previous_ibfd_e_flags != (unsigned long) -1)
3360     {
3361       (*_bfd_error_handler)
3362         (_("%s: linking little endian files with big endian files"),
3363          bfd_archive_filename (ibfd));
3364       error = TRUE;
3365     }
3366   previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3367
3368   if (error)
3369     {
3370       bfd_set_error (bfd_error_bad_value);
3371       return FALSE;
3372     }
3373
3374   return TRUE;
3375 }
3376 \f
3377 /* Set the right machine number.  */
3378
3379 static bfd_boolean
3380 elf32_sparc_object_p (abfd)
3381      bfd *abfd;
3382 {
3383   /* Allocate our special target data.  */
3384   struct elf32_sparc_obj_tdata *new_tdata;
3385   bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
3386   new_tdata = bfd_zalloc (abfd, amt);
3387   if (new_tdata == NULL)
3388     return FALSE;
3389   new_tdata->root = *abfd->tdata.elf_obj_data;
3390   abfd->tdata.any = new_tdata;
3391
3392   if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3393     {
3394       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3395         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3396                                           bfd_mach_sparc_v8plusb);
3397       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3398         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3399                                           bfd_mach_sparc_v8plusa);
3400       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3401         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3402                                           bfd_mach_sparc_v8plus);
3403       else
3404         return FALSE;
3405     }
3406   else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3407     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3408                                       bfd_mach_sparc_sparclite_le);
3409   else
3410     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3411 }
3412
3413 /* The final processing done just before writing out the object file.
3414    We need to set the e_machine field appropriately.  */
3415
3416 static void
3417 elf32_sparc_final_write_processing (abfd, linker)
3418      bfd *abfd;
3419      bfd_boolean linker ATTRIBUTE_UNUSED;
3420 {
3421   switch (bfd_get_mach (abfd))
3422     {
3423     case bfd_mach_sparc :
3424       break; /* nothing to do */
3425     case bfd_mach_sparc_v8plus :
3426       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3427       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3428       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
3429       break;
3430     case bfd_mach_sparc_v8plusa :
3431       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3432       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3433       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
3434       break;
3435     case bfd_mach_sparc_v8plusb :
3436       elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3437       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3438       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
3439                                        | EF_SPARC_SUN_US3;
3440       break;
3441     case bfd_mach_sparc_sparclite_le :
3442       elf_elfheader (abfd)->e_machine = EM_SPARC;
3443       elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3444       break;
3445     default :
3446       abort ();
3447       break;
3448     }
3449 }
3450
3451 static enum elf_reloc_type_class
3452 elf32_sparc_reloc_type_class (rela)
3453      const Elf_Internal_Rela *rela;
3454 {
3455   switch ((int) ELF32_R_TYPE (rela->r_info))
3456     {
3457     case R_SPARC_RELATIVE:
3458       return reloc_class_relative;
3459     case R_SPARC_JMP_SLOT:
3460       return reloc_class_plt;
3461     case R_SPARC_COPY:
3462       return reloc_class_copy;
3463     default:
3464       return reloc_class_normal;
3465     }
3466 }
3467 \f
3468 #define TARGET_BIG_SYM  bfd_elf32_sparc_vec
3469 #define TARGET_BIG_NAME "elf32-sparc"
3470 #define ELF_ARCH        bfd_arch_sparc
3471 #define ELF_MACHINE_CODE EM_SPARC
3472 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3473 #define ELF_MAXPAGESIZE 0x10000
3474
3475 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
3476 #define bfd_elf32_bfd_link_hash_table_create \
3477                                         elf32_sparc_link_hash_table_create
3478 #define bfd_elf32_bfd_relax_section     elf32_sparc_relax_section
3479 #define bfd_elf32_new_section_hook      elf32_sparc_new_section_hook
3480 #define elf_info_to_howto               elf32_sparc_info_to_howto
3481 #define elf_backend_copy_indirect_symbol \
3482                                         elf32_sparc_copy_indirect_symbol
3483 #define elf_backend_create_dynamic_sections \
3484                                         elf32_sparc_create_dynamic_sections
3485 #define elf_backend_check_relocs        elf32_sparc_check_relocs
3486 #define elf_backend_adjust_dynamic_symbol \
3487                                         elf32_sparc_adjust_dynamic_symbol
3488 #define elf_backend_size_dynamic_sections \
3489                                         elf32_sparc_size_dynamic_sections
3490 #define elf_backend_relocate_section    elf32_sparc_relocate_section
3491 #define elf_backend_finish_dynamic_symbol \
3492                                         elf32_sparc_finish_dynamic_symbol
3493 #define elf_backend_finish_dynamic_sections \
3494                                         elf32_sparc_finish_dynamic_sections
3495 #define bfd_elf32_bfd_merge_private_bfd_data \
3496                                         elf32_sparc_merge_private_bfd_data
3497 #define bfd_elf32_mkobject              elf32_sparc_mkobject
3498 #define elf_backend_object_p            elf32_sparc_object_p
3499 #define elf_backend_final_write_processing \
3500                                         elf32_sparc_final_write_processing
3501 #define elf_backend_gc_mark_hook        elf32_sparc_gc_mark_hook
3502 #define elf_backend_gc_sweep_hook       elf32_sparc_gc_sweep_hook
3503 #define elf_backend_reloc_type_class    elf32_sparc_reloc_type_class
3504
3505 #define elf_backend_can_gc_sections 1
3506 #define elf_backend_can_refcount 1
3507 #define elf_backend_want_got_plt 0
3508 #define elf_backend_plt_readonly 0
3509 #define elf_backend_want_plt_sym 1
3510 #define elf_backend_got_header_size 4
3511 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
3512 #define elf_backend_rela_normal 1
3513
3514 #include "elf32-target.h"