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