bfd/elf32-sparc.c

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