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