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