bfd/elf32-sparc.c

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