bfd/elfxx-sparc.c

   1 /* SPARC-specific support for ELF
   2    Copyright 2005, 2006 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* This file handles functionality common to the different SPARC ABI's.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "libiberty.h"
  27 #include "elf-bfd.h"
  28 #include "elf/sparc.h"
  29 #include "opcode/sparc.h"
  30 #include "elfxx-sparc.h"
  31 #include "elf-vxworks.h"
  32
  33 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  34 #define MINUS_ONE (~ (bfd_vma) 0)
  35
  36 #define ABI_64_P(abfd) \
  37   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
  38
  39 /* The relocation "howto" table.  */
  40
  41 /* Utility for performing the standard initial work of an instruction
  42    relocation.
  43    *PRELOCATION will contain the relocated item.
  44    *PINSN will contain the instruction from the input stream.
  45    If the result is `bfd_reloc_other' the caller can continue with
  46    performing the relocation.  Otherwise it must stop and return the
  47    value to its caller.  */
  48
  49 static bfd_reloc_status_type
  50 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
  51                  PTR data, asection *input_section, bfd *output_bfd,
  52                  bfd_vma *prelocation, bfd_vma *pinsn)
  53 {
  54   bfd_vma relocation;
  55   reloc_howto_type *howto = reloc_entry->howto;
  56
  57   if (output_bfd != (bfd *) NULL
  58       && (symbol->flags & BSF_SECTION_SYM) == 0
  59       && (! howto->partial_inplace
  60           || reloc_entry->addend == 0))
  61     {
  62       reloc_entry->address += input_section->output_offset;
  63       return bfd_reloc_ok;
  64     }
  65
  66   /* This works because partial_inplace is FALSE.  */
  67   if (output_bfd != NULL)
  68     return bfd_reloc_continue;
  69
  70   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
  71     return bfd_reloc_outofrange;
  72
  73   relocation = (symbol->value
  74                 + symbol->section->output_section->vma
  75                 + symbol->section->output_offset);
  76   relocation += reloc_entry->addend;
  77   if (howto->pc_relative)
  78     {
  79       relocation -= (input_section->output_section->vma
  80                      + input_section->output_offset);
  81       relocation -= reloc_entry->address;
  82     }
  83
  84   *prelocation = relocation;
  85   *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
  86   return bfd_reloc_other;
  87 }
  88
  89 /* For unsupported relocs.  */
  90
  91 static bfd_reloc_status_type
  92 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
  93                         arelent *reloc_entry ATTRIBUTE_UNUSED,
  94                         asymbol *symbol ATTRIBUTE_UNUSED,
  95                         PTR data ATTRIBUTE_UNUSED,
  96                         asection *input_section ATTRIBUTE_UNUSED,
  97                         bfd *output_bfd ATTRIBUTE_UNUSED,
  98                         char **error_message ATTRIBUTE_UNUSED)
  99 {
 100   return bfd_reloc_notsupported;
 101 }
 102
 103 /* Handle the WDISP16 reloc.  */
 104
 105 static bfd_reloc_status_type
 106 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
 107                          PTR data, asection *input_section, bfd *output_bfd,
 108                          char **error_message ATTRIBUTE_UNUSED)
 109 {
 110   bfd_vma relocation;
 111   bfd_vma insn;
 112   bfd_reloc_status_type status;
 113
 114   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 115                             input_section, output_bfd, &relocation, &insn);
 116   if (status != bfd_reloc_other)
 117     return status;
 118
 119   insn &= ~ (bfd_vma) 0x303fff;
 120   insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
 121   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 122
 123   if ((bfd_signed_vma) relocation < - 0x40000
 124       || (bfd_signed_vma) relocation > 0x3ffff)
 125     return bfd_reloc_overflow;
 126   else
 127     return bfd_reloc_ok;
 128 }
 129
 130 /* Handle the HIX22 reloc.  */
 131
 132 static bfd_reloc_status_type
 133 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
 134                        PTR data, asection *input_section, bfd *output_bfd,
 135                        char **error_message ATTRIBUTE_UNUSED)
 136 {
 137   bfd_vma relocation;
 138   bfd_vma insn;
 139   bfd_reloc_status_type status;
 140
 141   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 142                             input_section, output_bfd, &relocation, &insn);
 143   if (status != bfd_reloc_other)
 144     return status;
 145
 146   relocation ^= MINUS_ONE;
 147   insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
 148   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 149
 150   if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
 151     return bfd_reloc_overflow;
 152   else
 153     return bfd_reloc_ok;
 154 }
 155
 156 /* Handle the LOX10 reloc.  */
 157
 158 static bfd_reloc_status_type
 159 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
 160                        PTR data, asection *input_section, bfd *output_bfd,
 161                        char **error_message ATTRIBUTE_UNUSED)
 162 {
 163   bfd_vma relocation;
 164   bfd_vma insn;
 165   bfd_reloc_status_type status;
 166
 167   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
 168                             input_section, output_bfd, &relocation, &insn);
 169   if (status != bfd_reloc_other)
 170     return status;
 171
 172   insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
 173   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 174
 175   return bfd_reloc_ok;
 176 }
 177
 178 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
 179 {
 180   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 181   HOWTO(R_SPARC_8,         0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_8",       FALSE,0,0x000000ff,TRUE),
 182   HOWTO(R_SPARC_16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_16",      FALSE,0,0x0000ffff,TRUE),
 183   HOWTO(R_SPARC_32,        0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_32",      FALSE,0,0xffffffff,TRUE),
 184   HOWTO(R_SPARC_DISP8,     0,0, 8,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP8",   FALSE,0,0x000000ff,TRUE),
 185   HOWTO(R_SPARC_DISP16,    0,1,16,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP16",  FALSE,0,0x0000ffff,TRUE),
 186   HOWTO(R_SPARC_DISP32,    0,2,32,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP32",  FALSE,0,0xffffffff,TRUE),
 187   HOWTO(R_SPARC_WDISP30,   2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
 188   HOWTO(R_SPARC_WDISP22,   2,2,22,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
 189   HOWTO(R_SPARC_HI22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HI22",    FALSE,0,0x003fffff,TRUE),
 190   HOWTO(R_SPARC_22,        0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_22",      FALSE,0,0x003fffff,TRUE),
 191   HOWTO(R_SPARC_13,        0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_13",      FALSE,0,0x00001fff,TRUE),
 192   HOWTO(R_SPARC_LO10,      0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LO10",    FALSE,0,0x000003ff,TRUE),
 193   HOWTO(R_SPARC_GOT10,     0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT10",   FALSE,0,0x000003ff,TRUE),
 194   HOWTO(R_SPARC_GOT13,     0,2,13,FALSE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_GOT13",   FALSE,0,0x00001fff,TRUE),
 195   HOWTO(R_SPARC_GOT22,    10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT22",   FALSE,0,0x003fffff,TRUE),
 196   HOWTO(R_SPARC_PC10,      0,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC10",    FALSE,0,0x000003ff,TRUE),
 197   HOWTO(R_SPARC_PC22,     10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PC22",    FALSE,0,0x003fffff,TRUE),
 198   HOWTO(R_SPARC_WPLT30,    2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WPLT30",  FALSE,0,0x3fffffff,TRUE),
 199   HOWTO(R_SPARC_COPY,      0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_COPY",    FALSE,0,0x00000000,TRUE),
 200   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),
 201   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),
 202   HOWTO(R_SPARC_RELATIVE,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
 203   HOWTO(R_SPARC_UA32,      0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA32",    FALSE,0,0xffffffff,TRUE),
 204   HOWTO(R_SPARC_PLT32,     0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT32",   FALSE,0,0xffffffff,TRUE),
 205   HOWTO(R_SPARC_HIPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_HIPLT22",  FALSE,0,0x00000000,TRUE),
 206   HOWTO(R_SPARC_LOPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_LOPLT10",  FALSE,0,0x00000000,TRUE),
 207   HOWTO(R_SPARC_PCPLT32,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT32",  FALSE,0,0x00000000,TRUE),
 208   HOWTO(R_SPARC_PCPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT22",  FALSE,0,0x00000000,TRUE),
 209   HOWTO(R_SPARC_PCPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT10",  FALSE,0,0x00000000,TRUE),
 210   HOWTO(R_SPARC_10,        0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      FALSE,0,0x000003ff,TRUE),
 211   HOWTO(R_SPARC_11,        0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      FALSE,0,0x000007ff,TRUE),
 212   HOWTO(R_SPARC_64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_64",      FALSE,0,MINUS_ONE, TRUE),
 213   HOWTO(R_SPARC_OLO10,     0,2,13,FALSE,0,complain_overflow_signed,  sparc_elf_notsup_reloc, "R_SPARC_OLO10",   FALSE,0,0x00001fff,TRUE),
 214   HOWTO(R_SPARC_HH22,     42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_HH22",    FALSE,0,0x003fffff,TRUE),
 215   HOWTO(R_SPARC_HM10,     32,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HM10",    FALSE,0,0x000003ff,TRUE),
 216   HOWTO(R_SPARC_LM22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LM22",    FALSE,0,0x003fffff,TRUE),
 217   HOWTO(R_SPARC_PC_HH22,  42,2,22,TRUE, 0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_PC_HH22",    FALSE,0,0x003fffff,TRUE),
 218   HOWTO(R_SPARC_PC_HM10,  32,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC_HM10",    FALSE,0,0x000003ff,TRUE),
 219   HOWTO(R_SPARC_PC_LM22,  10,2,22,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC_LM22",    FALSE,0,0x003fffff,TRUE),
 220   HOWTO(R_SPARC_WDISP16,   2,2,16,TRUE, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
 221   HOWTO(R_SPARC_WDISP19,   2,2,19,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
 222   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),
 223   HOWTO(R_SPARC_7,         0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       FALSE,0,0x0000007f,TRUE),
 224   HOWTO(R_SPARC_5,         0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       FALSE,0,0x0000001f,TRUE),
 225   HOWTO(R_SPARC_6,         0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       FALSE,0,0x0000003f,TRUE),
 226   HOWTO(R_SPARC_DISP64,    0,4,64,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP64",  FALSE,0,MINUS_ONE, TRUE),
 227   HOWTO(R_SPARC_PLT64,     0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT64",   FALSE,0,MINUS_ONE, TRUE),
 228   HOWTO(R_SPARC_HIX22,     0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,  "R_SPARC_HIX22",   FALSE,0,MINUS_ONE, FALSE),
 229   HOWTO(R_SPARC_LOX10,     0,4, 0,FALSE,0,complain_overflow_dont,    sparc_elf_lox10_reloc,  "R_SPARC_LOX10",   FALSE,0,MINUS_ONE, FALSE),
 230   HOWTO(R_SPARC_H44,      22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_H44",     FALSE,0,0x003fffff,FALSE),
 231   HOWTO(R_SPARC_M44,      12,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_M44",     FALSE,0,0x000003ff,FALSE),
 232   HOWTO(R_SPARC_L44,       0,2,13,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_L44",     FALSE,0,0x00000fff,FALSE),
 233   HOWTO(R_SPARC_REGISTER,  0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
 234   HOWTO(R_SPARC_UA64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA64",      FALSE,0,MINUS_ONE, TRUE),
 235   HOWTO(R_SPARC_UA16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA16",      FALSE,0,0x0000ffff,TRUE),
 236   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),
 237   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),
 238   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),
 239   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),
 240   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),
 241   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),
 242   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),
 243   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),
 244   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),
 245   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),
 246   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),
 247   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),
 248   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),
 249   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),
 250   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),
 251   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),
 252   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),
 253   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),
 254   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),
 255   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),
 256   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),
 257   HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE),
 258   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),
 259   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)
 260 };
 261 static reloc_howto_type sparc_vtinherit_howto =
 262   HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
 263 static reloc_howto_type sparc_vtentry_howto =
 264   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);
 265 static reloc_howto_type sparc_rev32_howto =
 266   HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
 267
 268 struct elf_reloc_map {
 269   bfd_reloc_code_real_type bfd_reloc_val;
 270   unsigned char elf_reloc_val;
 271 };
 272
 273 static const struct elf_reloc_map sparc_reloc_map[] =
 274 {
 275   { BFD_RELOC_NONE, R_SPARC_NONE, },
 276   { BFD_RELOC_16, R_SPARC_16, },
 277   { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
 278   { BFD_RELOC_8, R_SPARC_8 },
 279   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
 280   { BFD_RELOC_CTOR, R_SPARC_64 },
 281   { BFD_RELOC_32, R_SPARC_32 },
 282   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
 283   { BFD_RELOC_HI22, R_SPARC_HI22 },
 284   { BFD_RELOC_LO10, R_SPARC_LO10, },
 285   { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
 286   { BFD_RELOC_64_PCREL, R_SPARC_DISP64 },
 287   { BFD_RELOC_SPARC22, R_SPARC_22 },
 288   { BFD_RELOC_SPARC13, R_SPARC_13 },
 289   { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
 290   { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
 291   { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
 292   { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
 293   { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
 294   { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
 295   { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
 296   { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
 297   { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
 298   { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
 299   { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
 300   { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
 301   { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
 302   { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
 303   { BFD_RELOC_SPARC_10, R_SPARC_10 },
 304   { BFD_RELOC_SPARC_11, R_SPARC_11 },
 305   { BFD_RELOC_SPARC_64, R_SPARC_64 },
 306   { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
 307   { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
 308   { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
 309   { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
 310   { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
 311   { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
 312   { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
 313   { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
 314   { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
 315   { BFD_RELOC_SPARC_7, R_SPARC_7 },
 316   { BFD_RELOC_SPARC_5, R_SPARC_5 },
 317   { BFD_RELOC_SPARC_6, R_SPARC_6 },
 318   { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 },
 319   { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
 320   { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
 321   { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
 322   { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
 323   { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
 324   { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
 325   { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
 326   { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
 327   { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
 328   { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
 329   { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
 330   { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
 331   { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
 332   { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
 333   { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
 334   { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
 335   { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
 336   { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
 337   { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
 338   { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
 339   { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
 340   { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
 341   { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
 342   { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
 343   { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
 344   { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 },
 345   { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 },
 346   { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 },
 347   { BFD_RELOC_SPARC_H44, R_SPARC_H44 },
 348   { BFD_RELOC_SPARC_M44, R_SPARC_M44 },
 349   { BFD_RELOC_SPARC_L44, R_SPARC_L44 },
 350   { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER },
 351   { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
 352   { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
 353   { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 },
 354 };
 355
 356 reloc_howto_type *
 357 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 358                                   bfd_reloc_code_real_type code)
 359 {
 360   unsigned int i;
 361
 362   switch (code)
 363     {
 364     case BFD_RELOC_VTABLE_INHERIT:
 365       return &sparc_vtinherit_howto;
 366
 367     case BFD_RELOC_VTABLE_ENTRY:
 368       return &sparc_vtentry_howto;
 369
 370     case BFD_RELOC_SPARC_REV32:
 371       return &sparc_rev32_howto;
 372
 373     default:
 374       for (i = 0;
 375            i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
 376            i++)
 377         {
 378           if (sparc_reloc_map[i].bfd_reloc_val == code)
 379             return (_bfd_sparc_elf_howto_table
 380                     + (int) sparc_reloc_map[i].elf_reloc_val);
 381         }
 382     }
 383     bfd_set_error (bfd_error_bad_value);
 384     return NULL;
 385 }
 386
 387 reloc_howto_type *
 388 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
 389 {
 390   switch (r_type)
 391     {
 392     case R_SPARC_GNU_VTINHERIT:
 393       return &sparc_vtinherit_howto;
 394
 395     case R_SPARC_GNU_VTENTRY:
 396       return &sparc_vtentry_howto;
 397
 398     case R_SPARC_REV32:
 399       return &sparc_rev32_howto;
 400
 401     default:
 402       if (r_type >= (unsigned int) R_SPARC_max_std)
 403         {
 404           (*_bfd_error_handler) (_("invalid relocation type %d"),
 405                                  (int) r_type);
 406           r_type = R_SPARC_NONE;
 407         }
 408       return &_bfd_sparc_elf_howto_table[r_type];
 409     }
 410 }
 411
 412 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
 413    so just take advantage of that.  */
 414 #define SPARC_ELF_R_TYPE(r_info)        \
 415         ((r_info) & 0xff)
 416
 417 void
 418 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 419                               Elf_Internal_Rela *dst)
 420 {
 421   unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
 422
 423   cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
 424 }
 425 \f
 426
 427 /* The nop opcode we use.  */
 428 #define SPARC_NOP 0x01000000
 429
 430 #define SPARC_INSN_BYTES        4
 431
 432 /* The SPARC linker needs to keep track of the number of relocs that it
 433    decides to copy as dynamic relocs in check_relocs for each symbol.
 434    This is so that it can later discard them if they are found to be
 435    unnecessary.  We store the information in a field extending the
 436    regular ELF linker hash table.  */
 437
 438 struct _bfd_sparc_elf_dyn_relocs
 439 {
 440   struct _bfd_sparc_elf_dyn_relocs *next;
 441
 442   /* The input section of the reloc.  */
 443   asection *sec;
 444
 445   /* Total number of relocs copied for the input section.  */
 446   bfd_size_type count;
 447
 448   /* Number of pc-relative relocs copied for the input section.  */
 449   bfd_size_type pc_count;
 450 };
 451
 452 /* SPARC ELF linker hash entry.  */
 453
 454 struct _bfd_sparc_elf_link_hash_entry
 455 {
 456   struct elf_link_hash_entry elf;
 457
 458   /* Track dynamic relocs copied for this symbol.  */
 459   struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
 460
 461 #define GOT_UNKNOWN     0
 462 #define GOT_NORMAL      1
 463 #define GOT_TLS_GD      2
 464 #define GOT_TLS_IE      3
 465   unsigned char tls_type;
 466 };
 467
 468 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
 469
 470 struct _bfd_sparc_elf_obj_tdata
 471 {
 472   struct elf_obj_tdata root;
 473
 474   /* tls_type for each local got entry.  */
 475   char *local_got_tls_type;
 476
 477   /* TRUE if TLS GD relocs has been seen for this object.  */
 478   bfd_boolean has_tlsgd;
 479 };
 480
 481 #define _bfd_sparc_elf_tdata(abfd) \
 482   ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
 483
 484 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
 485   (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
 486
 487 bfd_boolean
 488 _bfd_sparc_elf_mkobject (bfd *abfd)
 489 {
 490   if (abfd->tdata.any == NULL)
 491     {
 492       bfd_size_type amt = sizeof (struct _bfd_sparc_elf_obj_tdata);
 493       abfd->tdata.any = bfd_zalloc (abfd, amt);
 494       if (abfd->tdata.any == NULL)
 495         return FALSE;
 496     }
 497   return bfd_elf_mkobject (abfd);
 498 }
 499
 500 static void
 501 sparc_put_word_32 (bfd *bfd, bfd_vma val, void *ptr)
 502 {
 503   bfd_put_32 (bfd, val, ptr);
 504 }
 505
 506 static void
 507 sparc_put_word_64 (bfd *bfd, bfd_vma val, void *ptr)
 508 {
 509   bfd_put_64 (bfd, val, ptr);
 510 }
 511
 512 static void
 513 sparc_elf_append_rela_64 (bfd *abfd ATTRIBUTE_UNUSED,
 514                           asection *s ATTRIBUTE_UNUSED,
 515                           Elf_Internal_Rela *rel ATTRIBUTE_UNUSED)
 516 {
 517 #ifdef BFD64
 518   Elf64_External_Rela *loc64;
 519
 520   loc64 = (Elf64_External_Rela *) s->contents;
 521   loc64 += s->reloc_count++;
 522   bfd_elf64_swap_reloca_out (abfd, rel, (bfd_byte *) loc64);
 523 #endif
 524 }
 525
 526 static void
 527 sparc_elf_append_rela_32 (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 528 {
 529   Elf32_External_Rela *loc32;
 530
 531   loc32 = (Elf32_External_Rela *) s->contents;
 532   loc32 += s->reloc_count++;
 533   bfd_elf32_swap_reloca_out (abfd, rel, (bfd_byte *) loc32);
 534 }
 535
 536 static bfd_vma
 537 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
 538                      bfd_vma index ATTRIBUTE_UNUSED,
 539                      bfd_vma type ATTRIBUTE_UNUSED)
 540 {
 541   return ELF64_R_INFO (index,
 542                        (in_rel ?
 543                         ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
 544                                            type) : type));
 545 }
 546
 547 static bfd_vma
 548 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
 549                      bfd_vma index, bfd_vma type)
 550 {
 551   return ELF32_R_INFO (index, type);
 552 }
 553
 554 static bfd_vma
 555 sparc_elf_r_symndx_64 (bfd_vma r_info)
 556 {
 557   bfd_vma r_symndx = ELF32_R_SYM (r_info);
 558   return (r_symndx >> 24);
 559 }
 560
 561 static bfd_vma
 562 sparc_elf_r_symndx_32 (bfd_vma r_info)
 563 {
 564   return ELF32_R_SYM (r_info);
 565 }
 566
 567 /* PLT/GOT stuff */
 568
 569 #define PLT32_ENTRY_SIZE 12
 570 #define PLT32_HEADER_SIZE       (4 * PLT32_ENTRY_SIZE)
 571
 572 /* The first four entries in a 32-bit procedure linkage table are reserved,
 573    and the initial contents are unimportant (we zero them out).
 574    Subsequent entries look like this.  See the SVR4 ABI SPARC
 575    supplement to see how this works.  */
 576
 577 /* sethi %hi(.-.plt0),%g1.  We fill in the address later.  */
 578 #define PLT32_ENTRY_WORD0 0x03000000
 579 /* b,a .plt0.  We fill in the offset later.  */
 580 #define PLT32_ENTRY_WORD1 0x30800000
 581 /* nop.  */
 582 #define PLT32_ENTRY_WORD2 SPARC_NOP
 583
 584 static int
 585 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
 586                          bfd_vma max ATTRIBUTE_UNUSED,
 587                          bfd_vma *r_offset)
 588 {
 589       bfd_put_32 (output_bfd,
 590                   PLT32_ENTRY_WORD0 + offset,
 591                   splt->contents + offset);
 592       bfd_put_32 (output_bfd,
 593                   (PLT32_ENTRY_WORD1
 594                    + (((- (offset + 4)) >> 2) & 0x3fffff)),
 595                   splt->contents + offset + 4);
 596       bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
 597                   splt->contents + offset + 8);
 598
 599       *r_offset = offset;
 600
 601       return offset / PLT32_ENTRY_SIZE - 4;
 602 }
 603
 604 /* Both the headers and the entries are icache aligned.  */
 605 #define PLT64_ENTRY_SIZE        32
 606 #define PLT64_HEADER_SIZE       (4 * PLT64_ENTRY_SIZE)
 607 #define PLT64_LARGE_THRESHOLD   32768
 608
 609 static int
 610 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
 611                          bfd_vma max, bfd_vma *r_offset)
 612 {
 613   unsigned char *entry = splt->contents + offset;
 614   const unsigned int nop = SPARC_NOP;
 615   int index;
 616
 617   if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
 618     {
 619       unsigned int sethi, ba;
 620
 621       *r_offset = offset;
 622
 623       index = (offset / PLT64_ENTRY_SIZE);
 624
 625       sethi = 0x03000000 | (index * PLT64_ENTRY_SIZE);
 626       ba = 0x30680000
 627         | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
 628
 629       bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
 630       bfd_put_32 (output_bfd, (bfd_vma) ba,    entry + 4);
 631       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 8);
 632       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 12);
 633       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 16);
 634       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 20);
 635       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 24);
 636       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 28);
 637     }
 638   else
 639     {
 640       unsigned char *ptr;
 641       unsigned int ldx;
 642       int block, last_block, ofs, last_ofs, chunks_this_block;
 643       const int insn_chunk_size = (6 * 4);
 644       const int ptr_chunk_size = (1 * 8);
 645       const int entries_per_block = 160;
 646       const int block_size = entries_per_block * (insn_chunk_size
 647                                                   + ptr_chunk_size);
 648
 649       /* Entries 32768 and higher are grouped into blocks of 160.
 650          The blocks are further subdivided into 160 sequences of
 651          6 instructions and 160 pointers.  If a block does not require
 652          the full 160 entries, let's say it requires N, then there
 653          will be N sequences of 6 instructions and N pointers.  */
 654
 655       offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
 656       max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
 657
 658       block = offset / block_size;
 659       last_block = max / block_size;
 660       if (block != last_block)
 661         {
 662           chunks_this_block = 160;
 663         }
 664       else
 665         {
 666           last_ofs = max % block_size;
 667           chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
 668         }
 669
 670       ofs = offset % block_size;
 671
 672       index = (PLT64_LARGE_THRESHOLD +
 673                (block * 160) +
 674                (ofs / insn_chunk_size));
 675
 676       ptr = splt->contents
 677         + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
 678         + (block * block_size)
 679         + (chunks_this_block * insn_chunk_size)
 680         + (ofs / insn_chunk_size) * ptr_chunk_size;
 681
 682       *r_offset = (bfd_vma) (ptr - splt->contents);
 683
 684       ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
 685
 686       /* mov %o7,%g5
 687          call .+8
 688          nop
 689          ldx [%o7+P],%g1
 690          jmpl %o7+%g1,%g1
 691          mov %g5,%o7  */
 692       bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
 693       bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
 694       bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,  entry + 8);
 695       bfd_put_32 (output_bfd, (bfd_vma) ldx,        entry + 12);
 696       bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
 697       bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
 698
 699       bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
 700     }
 701
 702   return index - 4;
 703 }
 704
 705 /* The format of the first PLT entry in a VxWorks executable.  */
 706 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
 707   {
 708     0x05000000, /* sethi  %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
 709     0x8410a000, /* or     %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
 710     0xc4008000, /* ld     [ %g2 ], %g2 */
 711     0x81c08000, /* jmp    %g2 */
 712     0x01000000  /* nop */
 713   };
 714
 715 /* The format of subsequent PLT entries.  */
 716 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
 717   {
 718     0x03000000, /* sethi  %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
 719     0x82106000, /* or     %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
 720     0xc2004000, /* ld     [ %g1 ], %g1 */
 721     0x81c04000, /* jmp    %g1 */
 722     0x01000000, /* nop */
 723     0x03000000, /* sethi  %hi(f@pltindex), %g1 */
 724     0x10800000, /* b      _PLT_resolve */
 725     0x82106000  /* or     %g1, %lo(f@pltindex), %g1 */
 726   };
 727
 728 /* The format of the first PLT entry in a VxWorks shared object.  */
 729 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
 730   {
 731     0xc405e008, /* ld     [ %l7 + 8 ], %g2 */
 732     0x81c08000, /* jmp    %g2 */
 733     0x01000000  /* nop */
 734   };
 735
 736 /* The format of subsequent PLT entries.  */
 737 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
 738   {
 739     0x03000000, /* sethi  %hi(f@got), %g1 */
 740     0x82106000, /* or     %g1, %lo(f@got), %g1 */
 741     0xc205c001, /* ld     [ %l7 + %g1 ], %g1 */
 742     0x81c04000, /* jmp    %g1 */
 743     0x01000000, /* nop */
 744     0x03000000, /* sethi  %hi(f@pltindex), %g1 */
 745     0x10800000, /* b      _PLT_resolve */
 746     0x82106000  /* or     %g1, %lo(f@pltindex), %g1 */
 747   };
 748
 749 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
 750         htab->put_word(bfd, val, ptr)
 751
 752 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela)     \
 753         htab->append_rela(bfd, sec, rela)
 754
 755 #define SPARC_ELF_R_INFO(htab, in_rel, index, type)     \
 756         htab->r_info(in_rel, index, type)
 757
 758 #define SPARC_ELF_R_SYMNDX(htab, r_info)        \
 759         htab->r_symndx(r_info)
 760
 761 #define SPARC_ELF_WORD_BYTES(htab)      \
 762         htab->bytes_per_word
 763
 764 #define SPARC_ELF_RELA_BYTES(htab)      \
 765         htab->bytes_per_rela
 766
 767 #define SPARC_ELF_DTPOFF_RELOC(htab)    \
 768         htab->dtpoff_reloc
 769
 770 #define SPARC_ELF_DTPMOD_RELOC(htab)    \
 771         htab->dtpmod_reloc
 772
 773 #define SPARC_ELF_TPOFF_RELOC(htab)     \
 774         htab->tpoff_reloc
 775
 776 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
 777         htab->build_plt_entry (obfd, splt, off, max, r_off)
 778
 779 /* Create an entry in an SPARC ELF linker hash table.  */
 780
 781 static struct bfd_hash_entry *
 782 link_hash_newfunc (struct bfd_hash_entry *entry,
 783                    struct bfd_hash_table *table, const char *string)
 784 {
 785   /* Allocate the structure if it has not already been allocated by a
 786      subclass.  */
 787   if (entry == NULL)
 788     {
 789       entry = bfd_hash_allocate (table,
 790                                  sizeof (struct _bfd_sparc_elf_link_hash_entry));
 791       if (entry == NULL)
 792         return entry;
 793     }
 794
 795   /* Call the allocation method of the superclass.  */
 796   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 797   if (entry != NULL)
 798     {
 799       struct _bfd_sparc_elf_link_hash_entry *eh;
 800
 801       eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
 802       eh->dyn_relocs = NULL;
 803       eh->tls_type = GOT_UNKNOWN;
 804     }
 805
 806   return entry;
 807 }
 808
 809 /* The name of the dynamic interpreter.  This is put in the .interp
 810    section.  */
 811
 812 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 813 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
 814
 815 /* Create a SPARC ELF linker hash table.  */
 816
 817 struct bfd_link_hash_table *
 818 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
 819 {
 820   struct _bfd_sparc_elf_link_hash_table *ret;
 821   bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
 822
 823   ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
 824   if (ret == NULL)
 825     return NULL;
 826
 827   if (ABI_64_P (abfd))
 828     {
 829       ret->put_word = sparc_put_word_64;
 830       ret->append_rela = sparc_elf_append_rela_64;
 831       ret->r_info = sparc_elf_r_info_64;
 832       ret->r_symndx = sparc_elf_r_symndx_64;
 833       ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
 834       ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
 835       ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
 836       ret->word_align_power = 3;
 837       ret->align_power_max = 4;
 838       ret->bytes_per_word = 8;
 839       ret->bytes_per_rela = sizeof (Elf64_External_Rela);
 840       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
 841       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
 842     }
 843   else
 844     {
 845       ret->put_word = sparc_put_word_32;
 846       ret->append_rela = sparc_elf_append_rela_32;
 847       ret->r_info = sparc_elf_r_info_32;
 848       ret->r_symndx = sparc_elf_r_symndx_32;
 849       ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
 850       ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
 851       ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
 852       ret->word_align_power = 2;
 853       ret->align_power_max = 3;
 854       ret->bytes_per_word = 4;
 855       ret->bytes_per_rela = sizeof (Elf32_External_Rela);
 856       ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
 857       ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
 858     }
 859
 860   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 861                                       sizeof (struct _bfd_sparc_elf_link_hash_entry)))
 862     {
 863       free (ret);
 864       return NULL;
 865     }
 866
 867   return &ret->elf.root;
 868 }
 869
 870 /* Create .got and .rela.got sections in DYNOBJ, and set up
 871    shortcuts to them in our hash table.  */
 872
 873 static bfd_boolean
 874 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 875 {
 876   struct _bfd_sparc_elf_link_hash_table *htab;
 877
 878   if (! _bfd_elf_create_got_section (dynobj, info))
 879     return FALSE;
 880
 881   htab = _bfd_sparc_elf_hash_table (info);
 882   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 883   BFD_ASSERT (htab->sgot != NULL);
 884
 885   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
 886                                                SEC_ALLOC
 887                                                | SEC_LOAD
 888                                                | SEC_HAS_CONTENTS
 889                                                | SEC_IN_MEMORY
 890                                                | SEC_LINKER_CREATED
 891                                                | SEC_READONLY);
 892   if (htab->srelgot == NULL
 893       || ! bfd_set_section_alignment (dynobj, htab->srelgot,
 894                                       htab->word_align_power))
 895     return FALSE;
 896
 897   if (htab->is_vxworks)
 898     {
 899       htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 900       if (!htab->sgotplt)
 901         return FALSE;
 902     }
 903
 904   return TRUE;
 905 }
 906
 907 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
 908    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 909    hash table.  */
 910
 911 bfd_boolean
 912 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
 913                                         struct bfd_link_info *info)
 914 {
 915   struct _bfd_sparc_elf_link_hash_table *htab;
 916
 917   htab = _bfd_sparc_elf_hash_table (info);
 918   if (!htab->sgot && !create_got_section (dynobj, info))
 919     return FALSE;
 920
 921   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 922     return FALSE;
 923
 924   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 925   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 926   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 927   if (!info->shared)
 928     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 929
 930   if (htab->is_vxworks)
 931     {
 932       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
 933         return FALSE;
 934       if (info->shared)
 935         {
 936           htab->plt_header_size
 937             = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
 938           htab->plt_entry_size
 939             = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
 940         }
 941       else
 942         {
 943           htab->plt_header_size
 944             = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
 945           htab->plt_entry_size
 946             = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
 947         }
 948     }
 949   else
 950     {
 951       if (ABI_64_P (dynobj))
 952         {
 953           htab->build_plt_entry = sparc64_plt_entry_build;
 954           htab->plt_header_size = PLT64_HEADER_SIZE;
 955           htab->plt_entry_size = PLT64_ENTRY_SIZE;
 956         }
 957       else
 958         {
 959           htab->build_plt_entry = sparc32_plt_entry_build;
 960           htab->plt_header_size = PLT32_HEADER_SIZE;
 961           htab->plt_entry_size = PLT32_ENTRY_SIZE;
 962         }
 963     }
 964
 965   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 966       || (!info->shared && !htab->srelbss))
 967     abort ();
 968
 969   return TRUE;
 970 }
 971
 972 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 973
 974 void
 975 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
 976                                      struct elf_link_hash_entry *dir,
 977                                      struct elf_link_hash_entry *ind)
 978 {
 979   struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
 980
 981   edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
 982   eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
 983
 984   if (eind->dyn_relocs != NULL)
 985     {
 986       if (edir->dyn_relocs != NULL)
 987         {
 988           struct _bfd_sparc_elf_dyn_relocs **pp;
 989           struct _bfd_sparc_elf_dyn_relocs *p;
 990
 991           /* Add reloc counts against the indirect sym to the direct sym
 992              list.  Merge any entries against the same section.  */
 993           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 994             {
 995               struct _bfd_sparc_elf_dyn_relocs *q;
 996
 997               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 998                 if (q->sec == p->sec)
 999                   {
1000                     q->pc_count += p->pc_count;
1001                     q->count += p->count;
1002                     *pp = p->next;
1003                     break;
1004                   }
1005               if (q == NULL)
1006                 pp = &p->next;
1007             }
1008           *pp = edir->dyn_relocs;
1009         }
1010
1011       edir->dyn_relocs = eind->dyn_relocs;
1012       eind->dyn_relocs = NULL;
1013     }
1014
1015   if (ind->root.type == bfd_link_hash_indirect
1016       && dir->got.refcount <= 0)
1017     {
1018       edir->tls_type = eind->tls_type;
1019       eind->tls_type = GOT_UNKNOWN;
1020     }
1021   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1022 }
1023
1024 static int
1025 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1026                           int r_type, int is_local)
1027 {
1028   if (! ABI_64_P (abfd)
1029       && r_type == R_SPARC_TLS_GD_HI22
1030       && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1031     r_type = R_SPARC_REV32;
1032
1033   if (info->shared)
1034     return r_type;
1035
1036   switch (r_type)
1037     {
1038     case R_SPARC_TLS_GD_HI22:
1039       if (is_local)
1040         return R_SPARC_TLS_LE_HIX22;
1041       return R_SPARC_TLS_IE_HI22;
1042     case R_SPARC_TLS_GD_LO10:
1043       if (is_local)
1044         return R_SPARC_TLS_LE_LOX10;
1045       return R_SPARC_TLS_IE_LO10;
1046     case R_SPARC_TLS_IE_HI22:
1047       if (is_local)
1048         return R_SPARC_TLS_LE_HIX22;
1049       return r_type;
1050     case R_SPARC_TLS_IE_LO10:
1051       if (is_local)
1052         return R_SPARC_TLS_LE_LOX10;
1053       return r_type;
1054     case R_SPARC_TLS_LDM_HI22:
1055       return R_SPARC_TLS_LE_HIX22;
1056     case R_SPARC_TLS_LDM_LO10:
1057       return R_SPARC_TLS_LE_LOX10;
1058     }
1059
1060   return r_type;
1061 }
1062 \f
1063 /* Look through the relocs for a section during the first phase, and
1064    allocate space in the global offset table or procedure linkage
1065    table.  */
1066
1067 bfd_boolean
1068 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1069                              asection *sec, const Elf_Internal_Rela *relocs)
1070 {
1071   struct _bfd_sparc_elf_link_hash_table *htab;
1072   Elf_Internal_Shdr *symtab_hdr;
1073   struct elf_link_hash_entry **sym_hashes;
1074   bfd_vma *local_got_offsets;
1075   const Elf_Internal_Rela *rel;
1076   const Elf_Internal_Rela *rel_end;
1077   asection *sreloc;
1078   int num_relocs;
1079   bfd_boolean checked_tlsgd = FALSE;
1080
1081   if (info->relocatable)
1082     return TRUE;
1083
1084   htab = _bfd_sparc_elf_hash_table (info);
1085   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1086   sym_hashes = elf_sym_hashes (abfd);
1087   local_got_offsets = elf_local_got_offsets (abfd);
1088
1089   sreloc = NULL;
1090
1091   if (ABI_64_P (abfd))
1092     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1093   else
1094     num_relocs = sec->reloc_count;
1095   rel_end = relocs + num_relocs;
1096   for (rel = relocs; rel < rel_end; rel++)
1097     {
1098       unsigned int r_type;
1099       unsigned long r_symndx;
1100       struct elf_link_hash_entry *h;
1101
1102       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1103       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1104
1105       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1106         {
1107           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1108                                  abfd, r_symndx);
1109           return FALSE;
1110         }
1111
1112       if (r_symndx < symtab_hdr->sh_info)
1113         h = NULL;
1114       else
1115         {
1116           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1117           while (h->root.type == bfd_link_hash_indirect
1118                  || h->root.type == bfd_link_hash_warning)
1119             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1120         }
1121
1122       /* Compatibility with old R_SPARC_REV32 reloc conflicting
1123          with R_SPARC_TLS_GD_HI22.  */
1124       if (! ABI_64_P (abfd) && ! checked_tlsgd)
1125         switch (r_type)
1126           {
1127           case R_SPARC_TLS_GD_HI22:
1128             {
1129               const Elf_Internal_Rela *relt;
1130
1131               for (relt = rel + 1; relt < rel_end; relt++)
1132                 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1133                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1134                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1135                   break;
1136               checked_tlsgd = TRUE;
1137               _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1138             }
1139             break;
1140           case R_SPARC_TLS_GD_LO10:
1141           case R_SPARC_TLS_GD_ADD:
1142           case R_SPARC_TLS_GD_CALL:
1143             checked_tlsgd = TRUE;
1144             _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1145             break;
1146           }
1147
1148       r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1149       switch (r_type)
1150         {
1151         case R_SPARC_TLS_LDM_HI22:
1152         case R_SPARC_TLS_LDM_LO10:
1153           htab->tls_ldm_got.refcount += 1;
1154           break;
1155
1156         case R_SPARC_TLS_LE_HIX22:
1157         case R_SPARC_TLS_LE_LOX10:
1158           if (info->shared)
1159             goto r_sparc_plt32;
1160           break;
1161
1162         case R_SPARC_TLS_IE_HI22:
1163         case R_SPARC_TLS_IE_LO10:
1164           if (info->shared)
1165             info->flags |= DF_STATIC_TLS;
1166           /* Fall through */
1167
1168         case R_SPARC_GOT10:
1169         case R_SPARC_GOT13:
1170         case R_SPARC_GOT22:
1171         case R_SPARC_TLS_GD_HI22:
1172         case R_SPARC_TLS_GD_LO10:
1173           /* This symbol requires a global offset table entry.  */
1174           {
1175             int tls_type, old_tls_type;
1176
1177             switch (r_type)
1178               {
1179               default:
1180               case R_SPARC_GOT10:
1181               case R_SPARC_GOT13:
1182               case R_SPARC_GOT22:
1183                 tls_type = GOT_NORMAL;
1184                 break;
1185               case R_SPARC_TLS_GD_HI22:
1186               case R_SPARC_TLS_GD_LO10:
1187                 tls_type = GOT_TLS_GD;
1188                 break;
1189               case R_SPARC_TLS_IE_HI22:
1190               case R_SPARC_TLS_IE_LO10:
1191                 tls_type = GOT_TLS_IE;
1192                 break;
1193               }
1194
1195             if (h != NULL)
1196               {
1197                 h->got.refcount += 1;
1198                 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1199               }
1200             else
1201               {
1202                 bfd_signed_vma *local_got_refcounts;
1203
1204                 /* This is a global offset table entry for a local symbol.  */
1205                 local_got_refcounts = elf_local_got_refcounts (abfd);
1206                 if (local_got_refcounts == NULL)
1207                   {
1208                     bfd_size_type size;
1209
1210                     size = symtab_hdr->sh_info;
1211                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
1212                     local_got_refcounts = ((bfd_signed_vma *)
1213                                            bfd_zalloc (abfd, size));
1214                     if (local_got_refcounts == NULL)
1215                       return FALSE;
1216                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1217                     _bfd_sparc_elf_local_got_tls_type (abfd)
1218                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1219                   }
1220                 local_got_refcounts[r_symndx] += 1;
1221                 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1222               }
1223
1224             /* If a TLS symbol is accessed using IE at least once,
1225                there is no point to use dynamic model for it.  */
1226             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1227                 && (old_tls_type != GOT_TLS_GD
1228                     || tls_type != GOT_TLS_IE))
1229               {
1230                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1231                   tls_type = old_tls_type;
1232                 else
1233                   {
1234                     (*_bfd_error_handler)
1235                       (_("%B: `%s' accessed both as normal and thread local symbol"),
1236                        abfd, h ? h->root.root.string : "<local>");
1237                     return FALSE;
1238                   }
1239               }
1240
1241             if (old_tls_type != tls_type)
1242               {
1243                 if (h != NULL)
1244                   _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1245                 else
1246                   _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1247               }
1248           }
1249
1250           if (htab->sgot == NULL)
1251             {
1252               if (htab->elf.dynobj == NULL)
1253                 htab->elf.dynobj = abfd;
1254               if (!create_got_section (htab->elf.dynobj, info))
1255                 return FALSE;
1256             }
1257           break;
1258
1259         case R_SPARC_TLS_GD_CALL:
1260         case R_SPARC_TLS_LDM_CALL:
1261           if (info->shared)
1262             {
1263               /* These are basically R_SPARC_TLS_WPLT30 relocs against
1264                  __tls_get_addr.  */
1265               struct bfd_link_hash_entry *bh = NULL;
1266               if (! _bfd_generic_link_add_one_symbol (info, abfd,
1267                                                       "__tls_get_addr", 0,
1268                                                       bfd_und_section_ptr, 0,
1269                                                       NULL, FALSE, FALSE,
1270                                                       &bh))
1271                 return FALSE;
1272               h = (struct elf_link_hash_entry *) bh;
1273             }
1274           else
1275             break;
1276           /* Fall through */
1277
1278         case R_SPARC_PLT32:
1279         case R_SPARC_WPLT30:
1280         case R_SPARC_HIPLT22:
1281         case R_SPARC_LOPLT10:
1282         case R_SPARC_PCPLT32:
1283         case R_SPARC_PCPLT22:
1284         case R_SPARC_PCPLT10:
1285         case R_SPARC_PLT64:
1286           /* This symbol requires a procedure linkage table entry.  We
1287              actually build the entry in adjust_dynamic_symbol,
1288              because this might be a case of linking PIC code without
1289              linking in any dynamic objects, in which case we don't
1290              need to generate a procedure linkage table after all.  */
1291
1292           if (h == NULL)
1293             {
1294               if (! ABI_64_P (abfd))
1295                 {
1296                   /* The Solaris native assembler will generate a WPLT30
1297                      reloc for a local symbol if you assemble a call from
1298                      one section to another when using -K pic.  We treat
1299                      it as WDISP30.  */
1300                   if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1301                     goto r_sparc_plt32;
1302                   break;
1303                 }
1304
1305               /* It does not make sense to have a procedure linkage
1306                  table entry for a local symbol.  */
1307               bfd_set_error (bfd_error_bad_value);
1308               return FALSE;
1309             }
1310
1311           h->needs_plt = 1;
1312
1313           {
1314             int this_r_type;
1315
1316             this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1317             if (this_r_type == R_SPARC_PLT32
1318                 || this_r_type == R_SPARC_PLT64)
1319               goto r_sparc_plt32;
1320           }
1321           h->plt.refcount += 1;
1322           break;
1323
1324         case R_SPARC_PC10:
1325         case R_SPARC_PC22:
1326         case R_SPARC_PC_HH22:
1327         case R_SPARC_PC_HM10:
1328         case R_SPARC_PC_LM22:
1329           if (h != NULL)
1330             h->non_got_ref = 1;
1331
1332           if (h != NULL
1333               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1334             break;
1335           /* Fall through.  */
1336
1337         case R_SPARC_DISP8:
1338         case R_SPARC_DISP16:
1339         case R_SPARC_DISP32:
1340         case R_SPARC_DISP64:
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         case R_SPARC_10:
1355         case R_SPARC_11:
1356         case R_SPARC_64:
1357         case R_SPARC_OLO10:
1358         case R_SPARC_HH22:
1359         case R_SPARC_HM10:
1360         case R_SPARC_LM22:
1361         case R_SPARC_7:
1362         case R_SPARC_5:
1363         case R_SPARC_6:
1364         case R_SPARC_HIX22:
1365         case R_SPARC_LOX10:
1366         case R_SPARC_H44:
1367         case R_SPARC_M44:
1368         case R_SPARC_L44:
1369         case R_SPARC_UA64:
1370           if (h != NULL)
1371             h->non_got_ref = 1;
1372
1373         r_sparc_plt32:
1374           if (h != NULL && !info->shared)
1375             {
1376               /* We may need a .plt entry if the function this reloc
1377                  refers to is in a shared lib.  */
1378               h->plt.refcount += 1;
1379             }
1380
1381           /* If we are creating a shared library, and this is a reloc
1382              against a global symbol, or a non PC relative reloc
1383              against a local symbol, then we need to copy the reloc
1384              into the shared library.  However, if we are linking with
1385              -Bsymbolic, we do not need to copy a reloc against a
1386              global symbol which is defined in an object we are
1387              including in the link (i.e., DEF_REGULAR is set).  At
1388              this point we have not seen all the input files, so it is
1389              possible that DEF_REGULAR is not set now but will be set
1390              later (it is never cleared).  In case of a weak definition,
1391              DEF_REGULAR may be cleared later by a strong definition in
1392              a shared library.  We account for that possibility below by
1393              storing information in the relocs_copied field of the hash
1394              table entry.  A similar situation occurs when creating
1395              shared libraries and symbol visibility changes render the
1396              symbol local.
1397
1398              If on the other hand, we are creating an executable, we
1399              may need to keep relocations for symbols satisfied by a
1400              dynamic library if we manage to avoid copy relocs for the
1401              symbol.  */
1402           if ((info->shared
1403                && (sec->flags & SEC_ALLOC) != 0
1404                && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1405                    || (h != NULL
1406                        && (! info->symbolic
1407                            || h->root.type == bfd_link_hash_defweak
1408                            || !h->def_regular))))
1409               || (!info->shared
1410                   && (sec->flags & SEC_ALLOC) != 0
1411                   && h != NULL
1412                   && (h->root.type == bfd_link_hash_defweak
1413                       || !h->def_regular)))
1414             {
1415               struct _bfd_sparc_elf_dyn_relocs *p;
1416               struct _bfd_sparc_elf_dyn_relocs **head;
1417
1418               /* When creating a shared object, we must copy these
1419                  relocs into the output file.  We create a reloc
1420                  section in dynobj and make room for the reloc.  */
1421               if (sreloc == NULL)
1422                 {
1423                   const char *name;
1424                   bfd *dynobj;
1425
1426                   name = (bfd_elf_string_from_elf_section
1427                           (abfd,
1428                            elf_elfheader (abfd)->e_shstrndx,
1429                            elf_section_data (sec)->rel_hdr.sh_name));
1430                   if (name == NULL)
1431                     return FALSE;
1432
1433                   BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1434                               && strcmp (bfd_get_section_name (abfd, sec),
1435                                          name + 5) == 0);
1436
1437                   if (htab->elf.dynobj == NULL)
1438                     htab->elf.dynobj = abfd;
1439                   dynobj = htab->elf.dynobj;
1440
1441                   sreloc = bfd_get_section_by_name (dynobj, name);
1442                   if (sreloc == NULL)
1443                     {
1444                       flagword flags;
1445
1446                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1447                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1448                       if ((sec->flags & SEC_ALLOC) != 0)
1449                         flags |= SEC_ALLOC | SEC_LOAD;
1450                       sreloc = bfd_make_section_with_flags (dynobj,
1451                                                             name,
1452                                                             flags);
1453                       if (sreloc == NULL
1454                           || ! bfd_set_section_alignment (dynobj, sreloc,
1455                                                           htab->word_align_power))
1456                         return FALSE;
1457                     }
1458                   elf_section_data (sec)->sreloc = sreloc;
1459                 }
1460
1461               /* If this is a global symbol, we count the number of
1462                  relocations we need for this symbol.  */
1463               if (h != NULL)
1464                 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1465               else
1466                 {
1467                   /* Track dynamic relocs needed for local syms too.
1468                      We really need local syms available to do this
1469                      easily.  Oh well.  */
1470
1471                   asection *s;
1472                   void *vpp;
1473
1474                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1475                                                  sec, r_symndx);
1476                   if (s == NULL)
1477                     return FALSE;
1478
1479                   vpp = &elf_section_data (s)->local_dynrel;
1480                   head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1481                 }
1482
1483               p = *head;
1484               if (p == NULL || p->sec != sec)
1485                 {
1486                   bfd_size_type amt = sizeof *p;
1487                   p = ((struct _bfd_sparc_elf_dyn_relocs *)
1488                        bfd_alloc (htab->elf.dynobj, amt));
1489                   if (p == NULL)
1490                     return FALSE;
1491                   p->next = *head;
1492                   *head = p;
1493                   p->sec = sec;
1494                   p->count = 0;
1495                   p->pc_count = 0;
1496                 }
1497
1498               p->count += 1;
1499               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1500                 p->pc_count += 1;
1501             }
1502
1503           break;
1504
1505         case R_SPARC_GNU_VTINHERIT:
1506           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1507             return FALSE;
1508           break;
1509
1510         case R_SPARC_GNU_VTENTRY:
1511           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1512             return FALSE;
1513           break;
1514
1515         case R_SPARC_REGISTER:
1516           /* Nothing to do.  */
1517           break;
1518
1519         default:
1520           break;
1521         }
1522     }
1523
1524   return TRUE;
1525 }
1526 \f
1527 asection *
1528 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1529                              struct bfd_link_info *info,
1530                              Elf_Internal_Rela *rel,
1531                              struct elf_link_hash_entry *h,
1532                              Elf_Internal_Sym *sym)
1533 {
1534   if (h != NULL)
1535     switch (SPARC_ELF_R_TYPE (rel->r_info))
1536       {
1537       case R_SPARC_GNU_VTINHERIT:
1538       case R_SPARC_GNU_VTENTRY:
1539         return NULL;
1540       }
1541
1542   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1543 }
1544
1545 /* Update the got entry reference counts for the section being removed.  */
1546 bfd_boolean
1547 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1548                               asection *sec, const Elf_Internal_Rela *relocs)
1549 {
1550   struct _bfd_sparc_elf_link_hash_table *htab;
1551   Elf_Internal_Shdr *symtab_hdr;
1552   struct elf_link_hash_entry **sym_hashes;
1553   bfd_signed_vma *local_got_refcounts;
1554   const Elf_Internal_Rela *rel, *relend;
1555
1556   elf_section_data (sec)->local_dynrel = NULL;
1557
1558   htab = _bfd_sparc_elf_hash_table (info);
1559   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1560   sym_hashes = elf_sym_hashes (abfd);
1561   local_got_refcounts = elf_local_got_refcounts (abfd);
1562
1563   relend = relocs + sec->reloc_count;
1564   for (rel = relocs; rel < relend; rel++)
1565     {
1566       unsigned long r_symndx;
1567       unsigned int r_type;
1568       struct elf_link_hash_entry *h = NULL;
1569
1570       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1571       if (r_symndx >= symtab_hdr->sh_info)
1572         {
1573           struct _bfd_sparc_elf_link_hash_entry *eh;
1574           struct _bfd_sparc_elf_dyn_relocs **pp;
1575           struct _bfd_sparc_elf_dyn_relocs *p;
1576
1577           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1578           while (h->root.type == bfd_link_hash_indirect
1579                  || h->root.type == bfd_link_hash_warning)
1580             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1581           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1582           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1583             if (p->sec == sec)
1584               {
1585                 /* Everything must go for SEC.  */
1586                 *pp = p->next;
1587                 break;
1588               }
1589         }
1590
1591       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1592       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1593       switch (r_type)
1594         {
1595         case R_SPARC_TLS_LDM_HI22:
1596         case R_SPARC_TLS_LDM_LO10:
1597           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1598             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1599           break;
1600
1601         case R_SPARC_TLS_GD_HI22:
1602         case R_SPARC_TLS_GD_LO10:
1603         case R_SPARC_TLS_IE_HI22:
1604         case R_SPARC_TLS_IE_LO10:
1605         case R_SPARC_GOT10:
1606         case R_SPARC_GOT13:
1607         case R_SPARC_GOT22:
1608           if (h != NULL)
1609             {
1610               if (h->got.refcount > 0)
1611                 h->got.refcount--;
1612             }
1613           else
1614             {
1615               if (local_got_refcounts[r_symndx] > 0)
1616                 local_got_refcounts[r_symndx]--;
1617             }
1618           break;
1619
1620         case R_SPARC_PC10:
1621         case R_SPARC_PC22:
1622         case R_SPARC_PC_HH22:
1623         case R_SPARC_PC_HM10:
1624         case R_SPARC_PC_LM22:
1625           if (h != NULL
1626               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1627             break;
1628           /* Fall through.  */
1629
1630         case R_SPARC_DISP8:
1631         case R_SPARC_DISP16:
1632         case R_SPARC_DISP32:
1633         case R_SPARC_DISP64:
1634         case R_SPARC_WDISP30:
1635         case R_SPARC_WDISP22:
1636         case R_SPARC_WDISP19:
1637         case R_SPARC_WDISP16:
1638         case R_SPARC_8:
1639         case R_SPARC_16:
1640         case R_SPARC_32:
1641         case R_SPARC_HI22:
1642         case R_SPARC_22:
1643         case R_SPARC_13:
1644         case R_SPARC_LO10:
1645         case R_SPARC_UA16:
1646         case R_SPARC_UA32:
1647         case R_SPARC_PLT32:
1648         case R_SPARC_10:
1649         case R_SPARC_11:
1650         case R_SPARC_64:
1651         case R_SPARC_OLO10:
1652         case R_SPARC_HH22:
1653         case R_SPARC_HM10:
1654         case R_SPARC_LM22:
1655         case R_SPARC_7:
1656         case R_SPARC_5:
1657         case R_SPARC_6:
1658         case R_SPARC_HIX22:
1659         case R_SPARC_LOX10:
1660         case R_SPARC_H44:
1661         case R_SPARC_M44:
1662         case R_SPARC_L44:
1663         case R_SPARC_UA64:
1664           if (info->shared)
1665             break;
1666           /* Fall through.  */
1667
1668         case R_SPARC_WPLT30:
1669           if (h != NULL)
1670             {
1671               if (h->plt.refcount > 0)
1672                 h->plt.refcount--;
1673             }
1674           break;
1675
1676         default:
1677           break;
1678         }
1679     }
1680
1681   return TRUE;
1682 }
1683
1684 /* Adjust a symbol defined by a dynamic object and referenced by a
1685    regular object.  The current definition is in some section of the
1686    dynamic object, but we're not including those sections.  We have to
1687    change the definition to something the rest of the link can
1688    understand.  */
1689
1690 bfd_boolean
1691 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1692                                      struct elf_link_hash_entry *h)
1693 {
1694   struct _bfd_sparc_elf_link_hash_table *htab;
1695   struct _bfd_sparc_elf_link_hash_entry * eh;
1696   struct _bfd_sparc_elf_dyn_relocs *p;
1697   asection *s;
1698   unsigned int power_of_two;
1699
1700   htab = _bfd_sparc_elf_hash_table (info);
1701
1702   /* Make sure we know what is going on here.  */
1703   BFD_ASSERT (htab->elf.dynobj != NULL
1704               && (h->needs_plt
1705                   || h->u.weakdef != NULL
1706                   || (h->def_dynamic
1707                       && h->ref_regular
1708                       && !h->def_regular)));
1709
1710   /* If this is a function, put it in the procedure linkage table.  We
1711      will fill in the contents of the procedure linkage table later
1712      (although we could actually do it here).  The STT_NOTYPE
1713      condition is a hack specifically for the Oracle libraries
1714      delivered for Solaris; for some inexplicable reason, they define
1715      some of their functions as STT_NOTYPE when they really should be
1716      STT_FUNC.  */
1717   if (h->type == STT_FUNC
1718       || h->needs_plt
1719       || (h->type == STT_NOTYPE
1720           && (h->root.type == bfd_link_hash_defined
1721               || h->root.type == bfd_link_hash_defweak)
1722           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1723     {
1724       if (h->plt.refcount <= 0
1725           || (! info->shared
1726               && !h->def_dynamic
1727               && !h->ref_dynamic
1728               && h->root.type != bfd_link_hash_undefweak
1729               && h->root.type != bfd_link_hash_undefined))
1730         {
1731           /* This case can occur if we saw a WPLT30 reloc in an input
1732              file, but the symbol was never referred to by a dynamic
1733              object, or if all references were garbage collected.  In
1734              such a case, we don't actually need to build a procedure
1735              linkage table, and we can just do a WDISP30 reloc instead.  */
1736           h->plt.offset = (bfd_vma) -1;
1737           h->needs_plt = 0;
1738         }
1739
1740       return TRUE;
1741     }
1742   else
1743     h->plt.offset = (bfd_vma) -1;
1744
1745   /* If this is a weak symbol, and there is a real definition, the
1746      processor independent code will have arranged for us to see the
1747      real definition first, and we can just use the same value.  */
1748   if (h->u.weakdef != NULL)
1749     {
1750       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1751                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1752       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1753       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1754       return TRUE;
1755     }
1756
1757   /* This is a reference to a symbol defined by a dynamic object which
1758      is not a function.  */
1759
1760   /* If we are creating a shared library, we must presume that the
1761      only references to the symbol are via the global offset table.
1762      For such cases we need not do anything here; the relocations will
1763      be handled correctly by relocate_section.  */
1764   if (info->shared)
1765     return TRUE;
1766
1767   /* If there are no references to this symbol that do not use the
1768      GOT, we don't need to generate a copy reloc.  */
1769   if (!h->non_got_ref)
1770     return TRUE;
1771
1772   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1773   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1774     {
1775       s = p->sec->output_section;
1776       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1777         break;
1778     }
1779
1780   /* If we didn't find any dynamic relocs in read-only sections, then
1781      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1782   if (p == NULL)
1783     {
1784       h->non_got_ref = 0;
1785       return TRUE;
1786     }
1787
1788   if (h->size == 0)
1789     {
1790       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1791                              h->root.root.string);
1792       return TRUE;
1793     }
1794
1795   /* We must allocate the symbol in our .dynbss section, which will
1796      become part of the .bss section of the executable.  There will be
1797      an entry for this symbol in the .dynsym section.  The dynamic
1798      object will contain position independent code, so all references
1799      from the dynamic object to this symbol will go through the global
1800      offset table.  The dynamic linker will use the .dynsym entry to
1801      determine the address it must put in the global offset table, so
1802      both the dynamic object and the regular object will refer to the
1803      same memory location for the variable.  */
1804
1805   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1806      to copy the initial value out of the dynamic object and into the
1807      runtime process image.  We need to remember the offset into the
1808      .rel.bss section we are going to use.  */
1809   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1810     {
1811       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1812       h->needs_copy = 1;
1813     }
1814
1815   /* We need to figure out the alignment required for this symbol.  I
1816      have no idea how ELF linkers handle this.  */
1817   power_of_two = bfd_log2 (h->size);
1818   if (power_of_two > htab->align_power_max)
1819     power_of_two = htab->align_power_max;
1820
1821   /* Apply the required alignment.  */
1822   s = htab->sdynbss;
1823   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1824   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1825     {
1826       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1827         return FALSE;
1828     }
1829
1830   /* Define the symbol as being at this point in the section.  */
1831   h->root.u.def.section = s;
1832   h->root.u.def.value = s->size;
1833
1834   /* Increment the section size to make room for the symbol.  */
1835   s->size += h->size;
1836
1837   return TRUE;
1838 }
1839
1840 /* Allocate space in .plt, .got and associated reloc sections for
1841    dynamic relocs.  */
1842
1843 static bfd_boolean
1844 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1845 {
1846   struct bfd_link_info *info;
1847   struct _bfd_sparc_elf_link_hash_table *htab;
1848   struct _bfd_sparc_elf_link_hash_entry *eh;
1849   struct _bfd_sparc_elf_dyn_relocs *p;
1850
1851   if (h->root.type == bfd_link_hash_indirect)
1852     return TRUE;
1853
1854   if (h->root.type == bfd_link_hash_warning)
1855     /* When warning symbols are created, they **replace** the "real"
1856        entry in the hash table, thus we never get to see the real
1857        symbol in a hash traversal.  So look at it now.  */
1858     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1859
1860   info = (struct bfd_link_info *) inf;
1861   htab = _bfd_sparc_elf_hash_table (info);
1862
1863   if (htab->elf.dynamic_sections_created
1864       && h->plt.refcount > 0)
1865     {
1866       /* Make sure this symbol is output as a dynamic symbol.
1867          Undefined weak syms won't yet be marked as dynamic.  */
1868       if (h->dynindx == -1
1869           && !h->forced_local)
1870         {
1871           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872             return FALSE;
1873         }
1874
1875       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1876         {
1877           asection *s = htab->splt;
1878
1879           /* Allocate room for the header.  */
1880           if (s->size == 0)
1881             {
1882               s->size = htab->plt_header_size;
1883
1884               /* Allocate space for the .rela.plt.unloaded relocations.  */
1885               if (htab->is_vxworks && !info->shared)
1886                 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1887             }
1888
1889           /* The procedure linkage table size is bounded by the magnitude
1890              of the offset we can describe in the entry.  */
1891           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1892                           (((bfd_vma)1 << 31) << 1) : 0x400000))
1893             {
1894               bfd_set_error (bfd_error_bad_value);
1895               return FALSE;
1896             }
1897
1898           if (SPARC_ELF_WORD_BYTES(htab) == 8
1899               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1900             {
1901               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1902
1903
1904               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1905
1906               h->plt.offset = (s->size - (off * 8));
1907             }
1908           else
1909             h->plt.offset = s->size;
1910
1911           /* If this symbol is not defined in a regular file, and we are
1912              not generating a shared library, then set the symbol to this
1913              location in the .plt.  This is required to make function
1914              pointers compare as equal between the normal executable and
1915              the shared library.  */
1916           if (! info->shared
1917               && !h->def_regular)
1918             {
1919               h->root.u.def.section = s;
1920               h->root.u.def.value = h->plt.offset;
1921             }
1922
1923           /* Make room for this entry.  */
1924           s->size += htab->plt_entry_size;
1925
1926           /* We also need to make an entry in the .rela.plt section.  */
1927           htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1928
1929           if (htab->is_vxworks)
1930             {
1931               /* Allocate space for the .got.plt entry.  */
1932               htab->sgotplt->size += 4;
1933
1934               /* ...and for the .rela.plt.unloaded relocations.  */
1935               if (!info->shared)
1936                 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1937             }
1938         }
1939       else
1940         {
1941           h->plt.offset = (bfd_vma) -1;
1942           h->needs_plt = 0;
1943         }
1944     }
1945   else
1946     {
1947       h->plt.offset = (bfd_vma) -1;
1948       h->needs_plt = 0;
1949     }
1950
1951   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1952      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1953   if (h->got.refcount > 0
1954       && !info->shared
1955       && h->dynindx == -1
1956       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1957     h->got.offset = (bfd_vma) -1;
1958   else if (h->got.refcount > 0)
1959     {
1960       asection *s;
1961       bfd_boolean dyn;
1962       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1963
1964       /* Make sure this symbol is output as a dynamic symbol.
1965          Undefined weak syms won't yet be marked as dynamic.  */
1966       if (h->dynindx == -1
1967           && !h->forced_local)
1968         {
1969           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1970             return FALSE;
1971         }
1972
1973       s = htab->sgot;
1974       h->got.offset = s->size;
1975       s->size += SPARC_ELF_WORD_BYTES (htab);
1976       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1977       if (tls_type == GOT_TLS_GD)
1978         s->size += SPARC_ELF_WORD_BYTES (htab);
1979       dyn = htab->elf.dynamic_sections_created;
1980       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1981          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1982          global.  */
1983       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1984           || tls_type == GOT_TLS_IE)
1985         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1986       else if (tls_type == GOT_TLS_GD)
1987         htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
1988       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1989         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1990     }
1991   else
1992     h->got.offset = (bfd_vma) -1;
1993
1994   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1995   if (eh->dyn_relocs == NULL)
1996     return TRUE;
1997
1998   /* In the shared -Bsymbolic case, discard space allocated for
1999      dynamic pc-relative relocs against symbols which turn out to be
2000      defined in regular objects.  For the normal shared case, discard
2001      space for pc-relative relocs that have become local due to symbol
2002      visibility changes.  */
2003
2004   if (info->shared)
2005     {
2006       if (h->def_regular
2007           && (h->forced_local
2008               || info->symbolic))
2009         {
2010           struct _bfd_sparc_elf_dyn_relocs **pp;
2011
2012           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2013             {
2014               p->count -= p->pc_count;
2015               p->pc_count = 0;
2016               if (p->count == 0)
2017                 *pp = p->next;
2018               else
2019                 pp = &p->next;
2020             }
2021         }
2022
2023       /* Also discard relocs on undefined weak syms with non-default
2024          visibility.  */
2025       if (eh->dyn_relocs != NULL
2026           && h->root.type == bfd_link_hash_undefweak)
2027         {
2028           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2029             eh->dyn_relocs = NULL;
2030
2031           /* Make sure undefined weak symbols are output as a dynamic
2032              symbol in PIEs.  */
2033           else if (h->dynindx == -1
2034                    && !h->forced_local)
2035             {
2036               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2037                 return FALSE;
2038             }
2039         }
2040     }
2041   else
2042     {
2043       /* For the non-shared case, discard space for relocs against
2044          symbols which turn out to need copy relocs or are not
2045          dynamic.  */
2046
2047       if (!h->non_got_ref
2048           && ((h->def_dynamic
2049                && !h->def_regular)
2050               || (htab->elf.dynamic_sections_created
2051                   && (h->root.type == bfd_link_hash_undefweak
2052                       || h->root.type == bfd_link_hash_undefined))))
2053         {
2054           /* Make sure this symbol is output as a dynamic symbol.
2055              Undefined weak syms won't yet be marked as dynamic.  */
2056           if (h->dynindx == -1
2057               && !h->forced_local)
2058             {
2059               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2060                 return FALSE;
2061             }
2062
2063           /* If that succeeded, we know we'll be keeping all the
2064              relocs.  */
2065           if (h->dynindx != -1)
2066             goto keep;
2067         }
2068
2069       eh->dyn_relocs = NULL;
2070
2071     keep: ;
2072     }
2073
2074   /* Finally, allocate space.  */
2075   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2076     {
2077       asection *sreloc = elf_section_data (p->sec)->sreloc;
2078       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2079     }
2080
2081   return TRUE;
2082 }
2083
2084 /* Find any dynamic relocs that apply to read-only sections.  */
2085
2086 static bfd_boolean
2087 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2088 {
2089   struct _bfd_sparc_elf_link_hash_entry *eh;
2090   struct _bfd_sparc_elf_dyn_relocs *p;
2091
2092   if (h->root.type == bfd_link_hash_warning)
2093     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2094
2095   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2096   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2097     {
2098       asection *s = p->sec->output_section;
2099
2100       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2101         {
2102           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2103
2104           info->flags |= DF_TEXTREL;
2105
2106           /* Not an error, just cut short the traversal.  */
2107           return FALSE;
2108         }
2109     }
2110   return TRUE;
2111 }
2112
2113 /* Return true if the dynamic symbol for a given section should be
2114    omitted when creating a shared library.  */
2115
2116 bfd_boolean
2117 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2118                                     struct bfd_link_info *info,
2119                                     asection *p)
2120 {
2121   /* We keep the .got section symbol so that explicit relocations
2122      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2123      can be turned into relocations against the .got symbol.  */
2124   if (strcmp (p->name, ".got") == 0)
2125     return FALSE;
2126
2127   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2128 }
2129
2130 /* Set the sizes of the dynamic sections.  */
2131
2132 bfd_boolean
2133 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2134                                       struct bfd_link_info *info)
2135 {
2136   struct _bfd_sparc_elf_link_hash_table *htab;
2137   bfd *dynobj;
2138   asection *s;
2139   bfd *ibfd;
2140
2141   htab = _bfd_sparc_elf_hash_table (info);
2142   dynobj = htab->elf.dynobj;
2143   BFD_ASSERT (dynobj != NULL);
2144
2145   if (elf_hash_table (info)->dynamic_sections_created)
2146     {
2147       /* Set the contents of the .interp section to the interpreter.  */
2148       if (info->executable)
2149         {
2150           s = bfd_get_section_by_name (dynobj, ".interp");
2151           BFD_ASSERT (s != NULL);
2152           s->size = htab->dynamic_interpreter_size;
2153           s->contents = (unsigned char *) htab->dynamic_interpreter;
2154         }
2155     }
2156
2157   /* Set up .got offsets for local syms, and space for local dynamic
2158      relocs.  */
2159   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2160     {
2161       bfd_signed_vma *local_got;
2162       bfd_signed_vma *end_local_got;
2163       char *local_tls_type;
2164       bfd_size_type locsymcount;
2165       Elf_Internal_Shdr *symtab_hdr;
2166       asection *srel;
2167
2168       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2169         continue;
2170
2171       for (s = ibfd->sections; s != NULL; s = s->next)
2172         {
2173           struct _bfd_sparc_elf_dyn_relocs *p;
2174
2175           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2176             {
2177               if (!bfd_is_abs_section (p->sec)
2178                   && bfd_is_abs_section (p->sec->output_section))
2179                 {
2180                   /* Input section has been discarded, either because
2181                      it is a copy of a linkonce section or due to
2182                      linker script /DISCARD/, so we'll be discarding
2183                      the relocs too.  */
2184                 }
2185               else if (p->count != 0)
2186                 {
2187                   srel = elf_section_data (p->sec)->sreloc;
2188                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2189                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2190                     info->flags |= DF_TEXTREL;
2191                 }
2192             }
2193         }
2194
2195       local_got = elf_local_got_refcounts (ibfd);
2196       if (!local_got)
2197         continue;
2198
2199       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2200       locsymcount = symtab_hdr->sh_info;
2201       end_local_got = local_got + locsymcount;
2202       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2203       s = htab->sgot;
2204       srel = htab->srelgot;
2205       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2206         {
2207           if (*local_got > 0)
2208             {
2209               *local_got = s->size;
2210               s->size += SPARC_ELF_WORD_BYTES (htab);
2211               if (*local_tls_type == GOT_TLS_GD)
2212                 s->size += SPARC_ELF_WORD_BYTES (htab);
2213               if (info->shared
2214                   || *local_tls_type == GOT_TLS_GD
2215                   || *local_tls_type == GOT_TLS_IE)
2216                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2217             }
2218           else
2219             *local_got = (bfd_vma) -1;
2220         }
2221     }
2222
2223   if (htab->tls_ldm_got.refcount > 0)
2224     {
2225       /* Allocate 2 got entries and 1 dynamic reloc for
2226          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2227       htab->tls_ldm_got.offset = htab->sgot->size;
2228       htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2229       htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2230     }
2231   else
2232     htab->tls_ldm_got.offset = -1;
2233
2234   /* Allocate global sym .plt and .got entries, and space for global
2235      sym dynamic relocs.  */
2236   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2237
2238   if (! ABI_64_P (output_bfd)
2239       && !htab->is_vxworks
2240       && elf_hash_table (info)->dynamic_sections_created)
2241     {
2242       /* Make space for the trailing nop in .plt.  */
2243       if (htab->splt->size > 0)
2244         htab->splt->size += 1 * SPARC_INSN_BYTES;
2245
2246       /* If the .got section is more than 0x1000 bytes, we add
2247          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2248          bit relocations have a greater chance of working.
2249
2250          FIXME: Make this optimization work for 64-bit too.  */
2251       if (htab->sgot->size >= 0x1000
2252           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2253         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2254     }
2255
2256   /* The check_relocs and adjust_dynamic_symbol entry points have
2257      determined the sizes of the various dynamic sections.  Allocate
2258      memory for them.  */
2259   for (s = dynobj->sections; s != NULL; s = s->next)
2260     {
2261       if ((s->flags & SEC_LINKER_CREATED) == 0)
2262         continue;
2263
2264       if (s == htab->splt
2265           || s == htab->sgot
2266           || s == htab->sdynbss
2267           || s == htab->sgotplt)
2268         {
2269           /* Strip this section if we don't need it; see the
2270              comment below.  */
2271         }
2272       else if (CONST_STRNEQ (s->name, ".rela"))
2273         {
2274           if (s->size != 0)
2275             {
2276               /* We use the reloc_count field as a counter if we need
2277                  to copy relocs into the output file.  */
2278               s->reloc_count = 0;
2279             }
2280         }
2281       else
2282         {
2283           /* It's not one of our sections.  */
2284           continue;
2285         }
2286
2287       if (s->size == 0)
2288         {
2289           /* If we don't need this section, strip it from the
2290              output file.  This is mostly to handle .rela.bss and
2291              .rela.plt.  We must create both sections in
2292              create_dynamic_sections, because they must be created
2293              before the linker maps input sections to output
2294              sections.  The linker does that before
2295              adjust_dynamic_symbol is called, and it is that
2296              function which decides whether anything needs to go
2297              into these sections.  */
2298           s->flags |= SEC_EXCLUDE;
2299           continue;
2300         }
2301
2302       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2303         continue;
2304
2305       /* Allocate memory for the section contents.  Zero the memory
2306          for the benefit of .rela.plt, which has 4 unused entries
2307          at the beginning, and we don't want garbage.  */
2308       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2309       if (s->contents == NULL)
2310         return FALSE;
2311     }
2312
2313   if (elf_hash_table (info)->dynamic_sections_created)
2314     {
2315       /* Add some entries to the .dynamic section.  We fill in the
2316          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2317          must add the entries now so that we get the correct size for
2318          the .dynamic section.  The DT_DEBUG entry is filled in by the
2319          dynamic linker and used by the debugger.  */
2320 #define add_dynamic_entry(TAG, VAL) \
2321   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2322
2323       if (info->executable)
2324         {
2325           if (!add_dynamic_entry (DT_DEBUG, 0))
2326             return FALSE;
2327         }
2328
2329       if (htab->srelplt->size != 0)
2330         {
2331           if (!add_dynamic_entry (DT_PLTGOT, 0)
2332               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2333               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2334               || !add_dynamic_entry (DT_JMPREL, 0))
2335             return FALSE;
2336         }
2337
2338       if (!add_dynamic_entry (DT_RELA, 0)
2339           || !add_dynamic_entry (DT_RELASZ, 0)
2340           || !add_dynamic_entry (DT_RELAENT,
2341                                  SPARC_ELF_RELA_BYTES (htab)))
2342         return FALSE;
2343
2344       /* If any dynamic relocs apply to a read-only section,
2345          then we need a DT_TEXTREL entry.  */
2346       if ((info->flags & DF_TEXTREL) == 0)
2347         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2348                                 (PTR) info);
2349
2350       if (info->flags & DF_TEXTREL)
2351         {
2352           if (!add_dynamic_entry (DT_TEXTREL, 0))
2353             return FALSE;
2354         }
2355
2356       if (ABI_64_P (output_bfd))
2357         {
2358           int reg;
2359           struct _bfd_sparc_elf_app_reg * app_regs;
2360           struct elf_strtab_hash *dynstr;
2361           struct elf_link_hash_table *eht = elf_hash_table (info);
2362
2363           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2364              entries if needed.  */
2365           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2366           dynstr = eht->dynstr;
2367
2368           for (reg = 0; reg < 4; reg++)
2369             if (app_regs [reg].name != NULL)
2370               {
2371                 struct elf_link_local_dynamic_entry *entry, *e;
2372
2373                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2374                   return FALSE;
2375
2376                 entry = (struct elf_link_local_dynamic_entry *)
2377                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2378                 if (entry == NULL)
2379                   return FALSE;
2380
2381                 /* We cheat here a little bit: the symbol will not be local, so we
2382                    put it at the end of the dynlocal linked list.  We will fix it
2383                    later on, as we have to fix other fields anyway.  */
2384                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2385                 entry->isym.st_size = 0;
2386                 if (*app_regs [reg].name != '\0')
2387                   entry->isym.st_name
2388                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2389                 else
2390                   entry->isym.st_name = 0;
2391                 entry->isym.st_other = 0;
2392                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2393                                                    STT_REGISTER);
2394                 entry->isym.st_shndx = app_regs [reg].shndx;
2395                 entry->next = NULL;
2396                 entry->input_bfd = output_bfd;
2397                 entry->input_indx = -1;
2398
2399                 if (eht->dynlocal == NULL)
2400                   eht->dynlocal = entry;
2401                 else
2402                   {
2403                     for (e = eht->dynlocal; e->next; e = e->next)
2404                       ;
2405                     e->next = entry;
2406                   }
2407                 eht->dynsymcount++;
2408               }
2409         }
2410     }
2411 #undef add_dynamic_entry
2412
2413   return TRUE;
2414 }
2415 \f
2416 bfd_boolean
2417 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2418 {
2419   if (!sec->used_by_bfd)
2420     {
2421       struct _bfd_sparc_elf_section_data *sdata;
2422       bfd_size_type amt = sizeof (*sdata);
2423
2424       sdata = bfd_zalloc (abfd, amt);
2425       if (sdata == NULL)
2426         return FALSE;
2427       sec->used_by_bfd = sdata;
2428     }
2429
2430   return _bfd_elf_new_section_hook (abfd, sec);
2431 }
2432
2433 bfd_boolean
2434 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2435                               struct bfd_section *section,
2436                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2437                               bfd_boolean *again)
2438 {
2439   *again = FALSE;
2440   sec_do_relax (section) = 1;
2441   return TRUE;
2442 }
2443 \f
2444 /* Return the base VMA address which should be subtracted from real addresses
2445    when resolving @dtpoff relocation.
2446    This is PT_TLS segment p_vaddr.  */
2447
2448 static bfd_vma
2449 dtpoff_base (struct bfd_link_info *info)
2450 {
2451   /* If tls_sec is NULL, we should have signalled an error already.  */
2452   if (elf_hash_table (info)->tls_sec == NULL)
2453     return 0;
2454   return elf_hash_table (info)->tls_sec->vma;
2455 }
2456
2457 /* Return the relocation value for @tpoff relocation
2458    if STT_TLS virtual address is ADDRESS.  */
2459
2460 static bfd_vma
2461 tpoff (struct bfd_link_info *info, bfd_vma address)
2462 {
2463   struct elf_link_hash_table *htab = elf_hash_table (info);
2464
2465   /* If tls_sec is NULL, we should have signalled an error already.  */
2466   if (htab->tls_sec == NULL)
2467     return 0;
2468   return address - htab->tls_size - htab->tls_sec->vma;
2469 }
2470
2471 /* Relocate a SPARC ELF section.  */
2472
2473 bfd_boolean
2474 _bfd_sparc_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2475                                  bfd *input_bfd, asection *input_section,
2476                                  bfd_byte *contents, Elf_Internal_Rela *relocs,
2477                                  Elf_Internal_Sym *local_syms, asection **local_sections)
2478 {
2479   struct _bfd_sparc_elf_link_hash_table *htab;
2480   Elf_Internal_Shdr *symtab_hdr;
2481   struct elf_link_hash_entry **sym_hashes;
2482   bfd_vma *local_got_offsets;
2483   bfd_vma got_base;
2484   asection *sreloc;
2485   Elf_Internal_Rela *rel;
2486   Elf_Internal_Rela *relend;
2487   int num_relocs;
2488
2489   if (info->relocatable)
2490     return TRUE;
2491
2492   htab = _bfd_sparc_elf_hash_table (info);
2493   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2494   sym_hashes = elf_sym_hashes (input_bfd);
2495   local_got_offsets = elf_local_got_offsets (input_bfd);
2496
2497   if (elf_hash_table (info)->hgot == NULL)
2498     got_base = 0;
2499   else
2500     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2501
2502   sreloc = elf_section_data (input_section)->sreloc;
2503
2504   rel = relocs;
2505   if (ABI_64_P (output_bfd))
2506     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2507   else
2508     num_relocs = input_section->reloc_count;
2509   relend = relocs + num_relocs;
2510   for (; rel < relend; rel++)
2511     {
2512       int r_type, tls_type;
2513       reloc_howto_type *howto;
2514       unsigned long r_symndx;
2515       struct elf_link_hash_entry *h;
2516       Elf_Internal_Sym *sym;
2517       asection *sec;
2518       bfd_vma relocation, off;
2519       bfd_reloc_status_type r;
2520       bfd_boolean is_plt = FALSE;
2521       bfd_boolean unresolved_reloc;
2522
2523       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2524       if (r_type == R_SPARC_GNU_VTINHERIT
2525           || r_type == R_SPARC_GNU_VTENTRY)
2526         continue;
2527
2528       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2529         {
2530           bfd_set_error (bfd_error_bad_value);
2531           return FALSE;
2532         }
2533       howto = _bfd_sparc_elf_howto_table + r_type;
2534
2535       /* This is a final link.  */
2536       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2537       h = NULL;
2538       sym = NULL;
2539       sec = NULL;
2540       unresolved_reloc = FALSE;
2541       if (r_symndx < symtab_hdr->sh_info)
2542         {
2543           sym = local_syms + r_symndx;
2544           sec = local_sections[r_symndx];
2545           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2546         }
2547       else
2548         {
2549           bfd_boolean warned;
2550
2551           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2552                                    r_symndx, symtab_hdr, sym_hashes,
2553                                    h, sec, relocation,
2554                                    unresolved_reloc, warned);
2555           if (warned)
2556             {
2557               /* To avoid generating warning messages about truncated
2558                  relocations, set the relocation's address to be the same as
2559                  the start of this section.  */
2560               if (input_section->output_section != NULL)
2561                 relocation = input_section->output_section->vma;
2562               else
2563                 relocation = 0;
2564             }
2565         }
2566
2567       switch (r_type)
2568         {
2569         case R_SPARC_GOT10:
2570         case R_SPARC_GOT13:
2571         case R_SPARC_GOT22:
2572           /* Relocation is to the entry for this symbol in the global
2573              offset table.  */
2574           if (htab->sgot == NULL)
2575             abort ();
2576
2577           if (h != NULL)
2578             {
2579               bfd_boolean dyn;
2580
2581               off = h->got.offset;
2582               BFD_ASSERT (off != (bfd_vma) -1);
2583               dyn = elf_hash_table (info)->dynamic_sections_created;
2584
2585               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2586                   || (info->shared
2587                       && (info->symbolic
2588                           || h->dynindx == -1
2589                           || h->forced_local)
2590                       && h->def_regular))
2591                 {
2592                   /* This is actually a static link, or it is a
2593                      -Bsymbolic link and the symbol is defined
2594                      locally, or the symbol was forced to be local
2595                      because of a version file.  We must initialize
2596                      this entry in the global offset table.  Since the
2597                      offset must always be a multiple of 8 for 64-bit
2598                      and 4 for 32-bit, we use the least significant bit
2599                      to record whether we have initialized it already.
2600
2601                      When doing a dynamic link, we create a .rela.got
2602                      relocation entry to initialize the value.  This
2603                      is done in the finish_dynamic_symbol routine.  */
2604                   if ((off & 1) != 0)
2605                     off &= ~1;
2606                   else
2607                     {
2608                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2609                                           htab->sgot->contents + off);
2610                       h->got.offset |= 1;
2611                     }
2612                 }
2613               else
2614                 unresolved_reloc = FALSE;
2615             }
2616           else
2617             {
2618               BFD_ASSERT (local_got_offsets != NULL
2619                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2620
2621               off = local_got_offsets[r_symndx];
2622
2623               /* The offset must always be a multiple of 8 on 64-bit and
2624                  4 on 32-bit.  We use the least significant bit to record
2625                  whether we have already processed this entry.  */
2626               if ((off & 1) != 0)
2627                 off &= ~1;
2628               else
2629                 {
2630
2631                   if (info->shared)
2632                     {
2633                       asection *s;
2634                       Elf_Internal_Rela outrel;
2635
2636                       /* We need to generate a R_SPARC_RELATIVE reloc
2637                          for the dynamic linker.  */
2638                       s = htab->srelgot;
2639                       BFD_ASSERT (s != NULL);
2640
2641                       outrel.r_offset = (htab->sgot->output_section->vma
2642                                          + htab->sgot->output_offset
2643                                          + off);
2644                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2645                                                         0, R_SPARC_RELATIVE);
2646                       outrel.r_addend = relocation;
2647                       relocation = 0;
2648                       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &outrel);
2649                     }
2650
2651                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2652                                       htab->sgot->contents + off);
2653                   local_got_offsets[r_symndx] |= 1;
2654                 }
2655             }
2656           relocation = htab->sgot->output_offset + off - got_base;
2657           break;
2658
2659         case R_SPARC_PLT32:
2660         case R_SPARC_PLT64:
2661           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2662             {
2663               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2664               goto r_sparc_plt32;
2665             }
2666           /* Fall through.  */
2667
2668         case R_SPARC_WPLT30:
2669         case R_SPARC_HIPLT22:
2670         case R_SPARC_LOPLT10:
2671         case R_SPARC_PCPLT32:
2672         case R_SPARC_PCPLT22:
2673         case R_SPARC_PCPLT10:
2674         r_sparc_wplt30:
2675           /* Relocation is to the entry for this symbol in the
2676              procedure linkage table.  */
2677
2678           if (! ABI_64_P (output_bfd))
2679             {
2680               /* The Solaris native assembler will generate a WPLT30 reloc
2681                  for a local symbol if you assemble a call from one
2682                  section to another when using -K pic.  We treat it as
2683                  WDISP30.  */
2684               if (h == NULL)
2685                 break;
2686             }
2687           else
2688             {
2689               BFD_ASSERT (h != NULL);
2690             }
2691
2692           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2693             {
2694               /* We didn't make a PLT entry for this symbol.  This
2695                  happens when statically linking PIC code, or when
2696                  using -Bsymbolic.  */
2697               break;
2698             }
2699
2700           relocation = (htab->splt->output_section->vma
2701                         + htab->splt->output_offset
2702                         + h->plt.offset);
2703           unresolved_reloc = FALSE;
2704           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2705             {
2706               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2707               is_plt = TRUE;
2708               goto r_sparc_plt32;
2709             }
2710           break;
2711
2712         case R_SPARC_PC10:
2713         case R_SPARC_PC22:
2714         case R_SPARC_PC_HH22:
2715         case R_SPARC_PC_HM10:
2716         case R_SPARC_PC_LM22:
2717           if (h != NULL
2718               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2719             break;
2720           /* Fall through.  */
2721         case R_SPARC_DISP8:
2722         case R_SPARC_DISP16:
2723         case R_SPARC_DISP32:
2724         case R_SPARC_DISP64:
2725         case R_SPARC_WDISP30:
2726         case R_SPARC_WDISP22:
2727         case R_SPARC_WDISP19:
2728         case R_SPARC_WDISP16:
2729         case R_SPARC_8:
2730         case R_SPARC_16:
2731         case R_SPARC_32:
2732         case R_SPARC_HI22:
2733         case R_SPARC_22:
2734         case R_SPARC_13:
2735         case R_SPARC_LO10:
2736         case R_SPARC_UA16:
2737         case R_SPARC_UA32:
2738         case R_SPARC_10:
2739         case R_SPARC_11:
2740         case R_SPARC_64:
2741         case R_SPARC_OLO10:
2742         case R_SPARC_HH22:
2743         case R_SPARC_HM10:
2744         case R_SPARC_LM22:
2745         case R_SPARC_7:
2746         case R_SPARC_5:
2747         case R_SPARC_6:
2748         case R_SPARC_HIX22:
2749         case R_SPARC_LOX10:
2750         case R_SPARC_H44:
2751         case R_SPARC_M44:
2752         case R_SPARC_L44:
2753         case R_SPARC_UA64:
2754         r_sparc_plt32:
2755           /* r_symndx will be zero only for relocs against symbols
2756              from removed linkonce sections, or sections discarded by
2757              a linker script.  */
2758           if (r_symndx == 0)
2759             {
2760               _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2761               break;
2762             }
2763
2764           if ((input_section->flags & SEC_ALLOC) == 0)
2765             break;
2766
2767           if ((info->shared
2768                && (h == NULL
2769                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2770                    || h->root.type != bfd_link_hash_undefweak)
2771                && (! howto->pc_relative
2772                    || (h != NULL
2773                        && h->dynindx != -1
2774                        && (! info->symbolic
2775                            || !h->def_regular))))
2776               || (!info->shared
2777                   && h != NULL
2778                   && h->dynindx != -1
2779                   && !h->non_got_ref
2780                   && ((h->def_dynamic
2781                        && !h->def_regular)
2782                       || h->root.type == bfd_link_hash_undefweak
2783                       || h->root.type == bfd_link_hash_undefined)))
2784             {
2785               Elf_Internal_Rela outrel;
2786               bfd_boolean skip, relocate = FALSE;
2787
2788               /* When generating a shared object, these relocations
2789                  are copied into the output file to be resolved at run
2790                  time.  */
2791
2792               BFD_ASSERT (sreloc != NULL);
2793
2794               skip = FALSE;
2795
2796               outrel.r_offset =
2797                 _bfd_elf_section_offset (output_bfd, info, input_section,
2798                                          rel->r_offset);
2799               if (outrel.r_offset == (bfd_vma) -1)
2800                 skip = TRUE;
2801               else if (outrel.r_offset == (bfd_vma) -2)
2802                 skip = TRUE, relocate = TRUE;
2803               outrel.r_offset += (input_section->output_section->vma
2804                                   + input_section->output_offset);
2805
2806               /* Optimize unaligned reloc usage now that we know where
2807                  it finally resides.  */
2808               switch (r_type)
2809                 {
2810                 case R_SPARC_16:
2811                   if (outrel.r_offset & 1)
2812                     r_type = R_SPARC_UA16;
2813                   break;
2814                 case R_SPARC_UA16:
2815                   if (!(outrel.r_offset & 1))
2816                     r_type = R_SPARC_16;
2817                   break;
2818                 case R_SPARC_32:
2819                   if (outrel.r_offset & 3)
2820                     r_type = R_SPARC_UA32;
2821                   break;
2822                 case R_SPARC_UA32:
2823                   if (!(outrel.r_offset & 3))
2824                     r_type = R_SPARC_32;
2825                   break;
2826                 case R_SPARC_64:
2827                   if (outrel.r_offset & 7)
2828                     r_type = R_SPARC_UA64;
2829                   break;
2830                 case R_SPARC_UA64:
2831                   if (!(outrel.r_offset & 7))
2832                     r_type = R_SPARC_64;
2833                   break;
2834                 case R_SPARC_DISP8:
2835                 case R_SPARC_DISP16:
2836                 case R_SPARC_DISP32:
2837                 case R_SPARC_DISP64:
2838                   /* If the symbol is not dynamic, we should not keep
2839                      a dynamic relocation.  But an .rela.* slot has been
2840                      allocated for it, output R_SPARC_NONE.
2841                      FIXME: Add code tracking needed dynamic relocs as
2842                      e.g. i386 has.  */
2843                   if (h->dynindx == -1)
2844                     skip = TRUE, relocate = TRUE;
2845                   break;
2846                 }
2847
2848               if (skip)
2849                 memset (&outrel, 0, sizeof outrel);
2850               /* h->dynindx may be -1 if the symbol was marked to
2851                  become local.  */
2852               else if (h != NULL && ! is_plt
2853                        && ((! info->symbolic && h->dynindx != -1)
2854                            || !h->def_regular))
2855                 {
2856                   BFD_ASSERT (h->dynindx != -1);
2857                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2858                   outrel.r_addend = rel->r_addend;
2859                 }
2860               else
2861                 {
2862                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2863                     {
2864                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2865                                                         0, R_SPARC_RELATIVE);
2866                       outrel.r_addend = relocation + rel->r_addend;
2867                     }
2868                   else
2869                     {
2870                       long indx;
2871
2872                       outrel.r_addend = relocation + rel->r_addend;
2873
2874                       if (is_plt)
2875                         sec = htab->splt;
2876
2877                       if (bfd_is_abs_section (sec))
2878                         indx = 0;
2879                       else if (sec == NULL || sec->owner == NULL)
2880                         {
2881                           bfd_set_error (bfd_error_bad_value);
2882                           return FALSE;
2883                         }
2884                       else
2885                         {
2886                           asection *osec;
2887
2888                           /* We are turning this relocation into one
2889                              against a section symbol.  It would be
2890                              proper to subtract the symbol's value,
2891                              osec->vma, from the emitted reloc addend,
2892                              but ld.so expects buggy relocs.  */
2893                           osec = sec->output_section;
2894                           indx = elf_section_data (osec)->dynindx;
2895
2896                           if (indx == 0)
2897                             {
2898                               osec = htab->elf.text_index_section;
2899                               indx = elf_section_data (osec)->dynindx;
2900                             }
2901
2902                           /* FIXME: we really should be able to link non-pic
2903                              shared libraries.  */
2904                           if (indx == 0)
2905                             {
2906                               BFD_FAIL ();
2907                               (*_bfd_error_handler)
2908                                 (_("%B: probably compiled without -fPIC?"),
2909                                  input_bfd);
2910                               bfd_set_error (bfd_error_bad_value);
2911                               return FALSE;
2912                             }
2913                         }
2914
2915                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
2916                                                         r_type);
2917                     }
2918                 }
2919
2920               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2921
2922               /* This reloc will be computed at runtime, so there's no
2923                  need to do anything now.  */
2924               if (! relocate)
2925                 continue;
2926             }
2927           break;
2928
2929         case R_SPARC_TLS_GD_HI22:
2930           if (! ABI_64_P (input_bfd)
2931               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2932             {
2933               /* R_SPARC_REV32 used the same reloc number as
2934                  R_SPARC_TLS_GD_HI22.  */
2935               r_type = R_SPARC_REV32;
2936               break;
2937             }
2938           /* Fall through */
2939
2940         case R_SPARC_TLS_GD_LO10:
2941         case R_SPARC_TLS_IE_HI22:
2942         case R_SPARC_TLS_IE_LO10:
2943           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2944           tls_type = GOT_UNKNOWN;
2945           if (h == NULL && local_got_offsets)
2946             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2947           else if (h != NULL)
2948             {
2949               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2950               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2951                 switch (SPARC_ELF_R_TYPE (rel->r_info))
2952                   {
2953                   case R_SPARC_TLS_GD_HI22:
2954                   case R_SPARC_TLS_IE_HI22:
2955                     r_type = R_SPARC_TLS_LE_HIX22;
2956                     break;
2957                   default:
2958                     r_type = R_SPARC_TLS_LE_LOX10;
2959                     break;
2960                   }
2961             }
2962           if (tls_type == GOT_TLS_IE)
2963             switch (r_type)
2964               {
2965               case R_SPARC_TLS_GD_HI22:
2966                 r_type = R_SPARC_TLS_IE_HI22;
2967                 break;
2968               case R_SPARC_TLS_GD_LO10:
2969                 r_type = R_SPARC_TLS_IE_LO10;
2970                 break;
2971               }
2972
2973           if (r_type == R_SPARC_TLS_LE_HIX22)
2974             {
2975               relocation = tpoff (info, relocation);
2976               break;
2977             }
2978           if (r_type == R_SPARC_TLS_LE_LOX10)
2979             {
2980               /* Change add into xor.  */
2981               relocation = tpoff (info, relocation);
2982               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2983                                                    contents + rel->r_offset)
2984                                        | 0x80182000), contents + rel->r_offset);
2985               break;
2986             }
2987
2988           if (h != NULL)
2989             {
2990               off = h->got.offset;
2991               h->got.offset |= 1;
2992             }
2993           else
2994             {
2995               BFD_ASSERT (local_got_offsets != NULL);
2996               off = local_got_offsets[r_symndx];
2997               local_got_offsets[r_symndx] |= 1;
2998             }
2999
3000         r_sparc_tlsldm:
3001           if (htab->sgot == NULL)
3002             abort ();
3003
3004           if ((off & 1) != 0)
3005             off &= ~1;
3006           else
3007             {
3008               Elf_Internal_Rela outrel;
3009               int dr_type, indx;
3010
3011               if (htab->srelgot == NULL)
3012                 abort ();
3013
3014               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3015               outrel.r_offset = (htab->sgot->output_section->vma
3016                                  + htab->sgot->output_offset + off);
3017               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3018               if (r_type == R_SPARC_TLS_IE_HI22
3019                   || r_type == R_SPARC_TLS_IE_LO10)
3020                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3021               else
3022                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3023               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3024                 outrel.r_addend = relocation - dtpoff_base (info);
3025               else
3026                 outrel.r_addend = 0;
3027               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3028               SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3029
3030               if (r_type == R_SPARC_TLS_GD_HI22
3031                   || r_type == R_SPARC_TLS_GD_LO10)
3032                 {
3033                   if (indx == 0)
3034                     {
3035                       BFD_ASSERT (! unresolved_reloc);
3036                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3037                                           relocation - dtpoff_base (info),
3038                                           (htab->sgot->contents + off
3039                                            + SPARC_ELF_WORD_BYTES (htab)));
3040                     }
3041                   else
3042                     {
3043                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3044                                           (htab->sgot->contents + off
3045                                            + SPARC_ELF_WORD_BYTES (htab)));
3046                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3047                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3048                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3049                       SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3050                     }
3051                 }
3052               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3053                 {
3054                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3055                                       (htab->sgot->contents + off
3056                                        + SPARC_ELF_WORD_BYTES (htab)));
3057                 }
3058             }
3059
3060           if (off >= (bfd_vma) -2)
3061             abort ();
3062
3063           relocation = htab->sgot->output_offset + off - got_base;
3064           unresolved_reloc = FALSE;
3065           howto = _bfd_sparc_elf_howto_table + r_type;
3066           break;
3067
3068         case R_SPARC_TLS_LDM_HI22:
3069         case R_SPARC_TLS_LDM_LO10:
3070           if (! info->shared)
3071             {
3072               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3073               continue;
3074             }
3075           off = htab->tls_ldm_got.offset;
3076           htab->tls_ldm_got.offset |= 1;
3077           goto r_sparc_tlsldm;
3078
3079         case R_SPARC_TLS_LDO_HIX22:
3080         case R_SPARC_TLS_LDO_LOX10:
3081           if (info->shared)
3082             {
3083               relocation -= dtpoff_base (info);
3084               break;
3085             }
3086
3087           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3088                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3089           /* Fall through.  */
3090
3091         case R_SPARC_TLS_LE_HIX22:
3092         case R_SPARC_TLS_LE_LOX10:
3093           if (info->shared)
3094             {
3095               Elf_Internal_Rela outrel;
3096               bfd_boolean skip, relocate = FALSE;
3097
3098               BFD_ASSERT (sreloc != NULL);
3099               skip = FALSE;
3100               outrel.r_offset =
3101                 _bfd_elf_section_offset (output_bfd, info, input_section,
3102                                          rel->r_offset);
3103               if (outrel.r_offset == (bfd_vma) -1)
3104                 skip = TRUE;
3105               else if (outrel.r_offset == (bfd_vma) -2)
3106                 skip = TRUE, relocate = TRUE;
3107               outrel.r_offset += (input_section->output_section->vma
3108                                   + input_section->output_offset);
3109               if (skip)
3110                 memset (&outrel, 0, sizeof outrel);
3111               else
3112                 {
3113                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3114                   outrel.r_addend = relocation - dtpoff_base (info)
3115                                     + rel->r_addend;
3116                 }
3117
3118               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
3119               continue;
3120             }
3121           relocation = tpoff (info, relocation);
3122           break;
3123
3124         case R_SPARC_TLS_LDM_CALL:
3125           if (! info->shared)
3126             {
3127               /* mov %g0, %o0 */
3128               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3129               continue;
3130             }
3131           /* Fall through */
3132
3133         case R_SPARC_TLS_GD_CALL:
3134           tls_type = GOT_UNKNOWN;
3135           if (h == NULL && local_got_offsets)
3136             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3137           else if (h != NULL)
3138             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3139           if (! info->shared
3140               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3141             {
3142               bfd_vma insn;
3143
3144               if (!info->shared && (h == NULL || h->dynindx == -1))
3145                 {
3146                   /* GD -> LE */
3147                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3148                   continue;
3149                 }
3150
3151               /* GD -> IE */
3152               if (rel + 1 < relend
3153                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3154                   && rel[1].r_offset == rel->r_offset + 4
3155                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3156                   && (((insn = bfd_get_32 (input_bfd,
3157                                            contents + rel[1].r_offset))
3158                        >> 25) & 0x1f) == 8)
3159                 {
3160                   /* We have
3161                      call __tls_get_addr, %tgd_call(foo)
3162                       add %reg1, %reg2, %o0, %tgd_add(foo)
3163                      and change it into IE:
3164                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3165                      add %g7, %o0, %o0, %tie_add(foo).
3166                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3167                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3168                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3169                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3170                               contents + rel->r_offset);
3171                   bfd_put_32 (output_bfd, 0x9001c008,
3172                               contents + rel->r_offset + 4);
3173                   rel++;
3174                   continue;
3175                 }
3176
3177               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3178               continue;
3179             }
3180
3181           h = (struct elf_link_hash_entry *)
3182               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3183                                     FALSE, TRUE);
3184           BFD_ASSERT (h != NULL);
3185           r_type = R_SPARC_WPLT30;
3186           howto = _bfd_sparc_elf_howto_table + r_type;
3187           goto r_sparc_wplt30;
3188
3189         case R_SPARC_TLS_GD_ADD:
3190           tls_type = GOT_UNKNOWN;
3191           if (h == NULL && local_got_offsets)
3192             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3193           else if (h != NULL)
3194             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3195           if (! info->shared || tls_type == GOT_TLS_IE)
3196             {
3197               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3198                  changed into IE:
3199                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3200                  or LE:
3201                  add %g7, %reg2, %reg3.  */
3202               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3203               if ((h != NULL && h->dynindx != -1) || info->shared)
3204                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3205               else
3206                 relocation = (insn & ~0x7c000) | 0x1c000;
3207               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3208             }
3209           continue;
3210
3211         case R_SPARC_TLS_LDM_ADD:
3212           if (! info->shared)
3213             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3214           continue;
3215
3216         case R_SPARC_TLS_LDO_ADD:
3217           if (! info->shared)
3218             {
3219               /* Change rs1 into %g7.  */
3220               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3221               insn = (insn & ~0x7c000) | 0x1c000;
3222               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3223             }
3224           continue;
3225
3226         case R_SPARC_TLS_IE_LD:
3227         case R_SPARC_TLS_IE_LDX:
3228           if (! info->shared && (h == NULL || h->dynindx == -1))
3229             {
3230               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3231               int rs2 = insn & 0x1f;
3232               int rd = (insn >> 25) & 0x1f;
3233
3234               if (rs2 == rd)
3235                 relocation = SPARC_NOP;
3236               else
3237                 relocation = 0x80100000 | (insn & 0x3e00001f);
3238               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3239             }
3240           continue;
3241
3242         case R_SPARC_TLS_IE_ADD:
3243           /* Totally useless relocation.  */
3244           continue;
3245
3246         case R_SPARC_TLS_DTPOFF32:
3247         case R_SPARC_TLS_DTPOFF64:
3248           relocation -= dtpoff_base (info);
3249           break;
3250
3251         default:
3252           break;
3253         }
3254
3255       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3256          because such sections are not SEC_ALLOC and thus ld.so will
3257          not process them.  */
3258       if (unresolved_reloc
3259           && !((input_section->flags & SEC_DEBUGGING) != 0
3260                && h->def_dynamic))
3261         (*_bfd_error_handler)
3262           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3263            input_bfd,
3264            input_section,
3265            (long) rel->r_offset,
3266            howto->name,
3267            h->root.root.string);
3268
3269       r = bfd_reloc_continue;
3270       if (r_type == R_SPARC_OLO10)
3271         {
3272             bfd_vma x;
3273
3274             if (! ABI_64_P (output_bfd))
3275               abort ();
3276
3277             relocation += rel->r_addend;
3278             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3279
3280             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3281             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3282             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3283
3284             r = bfd_check_overflow (howto->complain_on_overflow,
3285                                     howto->bitsize, howto->rightshift,
3286                                     bfd_arch_bits_per_address (input_bfd),
3287                                     relocation);
3288         }
3289       else if (r_type == R_SPARC_WDISP16)
3290         {
3291           bfd_vma x;
3292
3293           relocation += rel->r_addend;
3294           relocation -= (input_section->output_section->vma
3295                          + input_section->output_offset);
3296           relocation -= rel->r_offset;
3297
3298           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3299           x |= ((((relocation >> 2) & 0xc000) << 6)
3300                 | ((relocation >> 2) & 0x3fff));
3301           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3302
3303           r = bfd_check_overflow (howto->complain_on_overflow,
3304                                   howto->bitsize, howto->rightshift,
3305                                   bfd_arch_bits_per_address (input_bfd),
3306                                   relocation);
3307         }
3308       else if (r_type == R_SPARC_REV32)
3309         {
3310           bfd_vma x;
3311
3312           relocation = relocation + rel->r_addend;
3313
3314           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3315           x = x + relocation;
3316           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3317           r = bfd_reloc_ok;
3318         }
3319       else if (r_type == R_SPARC_TLS_LDO_HIX22
3320                || r_type == R_SPARC_TLS_LE_HIX22)
3321         {
3322           bfd_vma x;
3323
3324           relocation += rel->r_addend;
3325           if (r_type == R_SPARC_TLS_LE_HIX22)
3326             relocation ^= MINUS_ONE;
3327
3328           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3329           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3330           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3331           r = bfd_reloc_ok;
3332         }
3333       else if (r_type == R_SPARC_TLS_LDO_LOX10
3334                || r_type == R_SPARC_TLS_LE_LOX10)
3335         {
3336           bfd_vma x;
3337
3338           relocation += rel->r_addend;
3339           relocation &= 0x3ff;
3340           if (r_type == R_SPARC_TLS_LE_LOX10)
3341             relocation |= 0x1c00;
3342
3343           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3344           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3345           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3346
3347           r = bfd_reloc_ok;
3348         }
3349       else if (r_type == R_SPARC_HIX22)
3350         {
3351           bfd_vma x;
3352
3353           relocation += rel->r_addend;
3354           relocation = relocation ^ MINUS_ONE;
3355
3356           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3357           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3358           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3359
3360           r = bfd_check_overflow (howto->complain_on_overflow,
3361                                   howto->bitsize, howto->rightshift,
3362                                   bfd_arch_bits_per_address (input_bfd),
3363                                   relocation);
3364         }
3365       else if (r_type == R_SPARC_LOX10)
3366         {
3367           bfd_vma x;
3368
3369           relocation += rel->r_addend;
3370           relocation = (relocation & 0x3ff) | 0x1c00;
3371
3372           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3373           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3374           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3375
3376           r = bfd_reloc_ok;
3377         }
3378       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3379                && sec_do_relax (input_section)
3380                && rel->r_offset + 4 < input_section->size)
3381         {
3382 #define G0              0
3383 #define O7              15
3384 #define XCC             (2 << 20)
3385 #define COND(x)         (((x)&0xf)<<25)
3386 #define CONDA           COND(0x8)
3387 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3388 #define INSN_BA         (F2(0,2) | CONDA)
3389 #define INSN_OR         F3(2, 0x2, 0)
3390 #define INSN_NOP        F2(0,4)
3391
3392           bfd_vma x, y;
3393
3394           /* If the instruction is a call with either:
3395              restore
3396              arithmetic instruction with rd == %o7
3397              where rs1 != %o7 and rs2 if it is register != %o7
3398              then we can optimize if the call destination is near
3399              by changing the call into a branch always.  */
3400           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3401           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3402           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3403             {
3404               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3405                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3406                        && (y & RD(~0)) == RD(O7)))
3407                   && (y & RS1(~0)) != RS1(O7)
3408                   && ((y & F3I(~0))
3409                       || (y & RS2(~0)) != RS2(O7)))
3410                 {
3411                   bfd_vma reloc;
3412
3413                   reloc = relocation + rel->r_addend - rel->r_offset;
3414                   reloc -= (input_section->output_section->vma
3415                             + input_section->output_offset);
3416
3417                   /* Ensure the branch fits into simm22.  */
3418                   if ((reloc & 3) == 0
3419                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3420                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3421                     {
3422                       reloc >>= 2;
3423
3424                       /* Check whether it fits into simm19.  */
3425                       if (((reloc & 0x3c0000) == 0
3426                            || (reloc & 0x3c0000) == 0x3c0000)
3427                           && (ABI_64_P (output_bfd)
3428                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3429                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3430                       else
3431                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3432                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3433                       r = bfd_reloc_ok;
3434                       if (rel->r_offset >= 4
3435                           && (y & (0xffffffff ^ RS1(~0)))
3436                              == (INSN_OR | RD(O7) | RS2(G0)))
3437                         {
3438                           bfd_vma z;
3439                           unsigned int reg;
3440
3441                           z = bfd_get_32 (input_bfd,
3442                                           contents + rel->r_offset - 4);
3443                           if ((z & (0xffffffff ^ RD(~0)))
3444                               != (INSN_OR | RS1(O7) | RS2(G0)))
3445                             break;
3446
3447                           /* The sequence was
3448                              or %o7, %g0, %rN
3449                              call foo
3450                              or %rN, %g0, %o7
3451
3452                              If call foo was replaced with ba, replace
3453                              or %rN, %g0, %o7 with nop.  */
3454
3455                           reg = (y & RS1(~0)) >> 14;
3456                           if (reg != ((z & RD(~0)) >> 25)
3457                               || reg == G0 || reg == O7)
3458                             break;
3459
3460                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3461                                       contents + rel->r_offset + 4);
3462                         }
3463
3464                     }
3465                 }
3466             }
3467         }
3468
3469       if (r == bfd_reloc_continue)
3470         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3471                                       contents, rel->r_offset,
3472                                       relocation, rel->r_addend);
3473
3474       if (r != bfd_reloc_ok)
3475         {
3476           switch (r)
3477             {
3478             default:
3479             case bfd_reloc_outofrange:
3480               abort ();
3481             case bfd_reloc_overflow:
3482               {
3483                 const char *name;
3484
3485                 /* The Solaris native linker silently disregards overflows.
3486                    We don't, but this breaks stabs debugging info, whose
3487                    relocations are only 32-bits wide.  Ignore overflows in
3488                    this case and also for discarded entries.  */
3489                 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3490                     && (((input_section->flags & SEC_DEBUGGING) != 0
3491                          && strcmp (bfd_section_name (input_bfd,
3492                                                       input_section),
3493                                     ".stab") == 0)
3494                         || _bfd_elf_section_offset (output_bfd, info,
3495                                                     input_section,
3496                                                     rel->r_offset)
3497                              == (bfd_vma)-1))
3498                   break;
3499
3500                 if (h != NULL)
3501                   {
3502                     /* Assume this is a call protected by other code that
3503                        detect the symbol is undefined.  If this is the case,
3504                        we can safely ignore the overflow.  If not, the
3505                        program is hosed anyway, and a little warning isn't
3506                        going to help.  */
3507                     if (h->root.type == bfd_link_hash_undefweak
3508                         && howto->pc_relative)
3509                       break;
3510
3511                     name = NULL;
3512                   }
3513                 else
3514                   {
3515                     name = bfd_elf_string_from_elf_section (input_bfd,
3516                                                             symtab_hdr->sh_link,
3517                                                             sym->st_name);
3518                     if (name == NULL)
3519                       return FALSE;
3520                     if (*name == '\0')
3521                       name = bfd_section_name (input_bfd, sec);
3522                   }
3523                 if (! ((*info->callbacks->reloc_overflow)
3524                        (info, (h ? &h->root : NULL), name, howto->name,
3525                         (bfd_vma) 0, input_bfd, input_section,
3526                         rel->r_offset)))
3527                   return FALSE;
3528               }
3529               break;
3530             }
3531         }
3532     }
3533
3534   return TRUE;
3535 }
3536
3537 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
3538    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
3539    is the offset of the associated .got.plt entry from
3540    _GLOBAL_OFFSET_TABLE_.  */
3541
3542 static void
3543 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3544                                bfd_vma plt_offset, bfd_vma plt_index,
3545                                bfd_vma got_offset)
3546 {
3547   bfd_vma got_base;
3548   const bfd_vma *plt_entry;
3549   struct _bfd_sparc_elf_link_hash_table *htab;
3550   bfd_byte *loc;
3551   Elf_Internal_Rela rela;
3552
3553   htab = _bfd_sparc_elf_hash_table (info);
3554   if (info->shared)
3555     {
3556       plt_entry = sparc_vxworks_shared_plt_entry;
3557       got_base = 0;
3558     }
3559   else
3560     {
3561       plt_entry = sparc_vxworks_exec_plt_entry;
3562       got_base = (htab->elf.hgot->root.u.def.value
3563                   + htab->elf.hgot->root.u.def.section->output_offset
3564                   + htab->elf.hgot->root.u.def.section->output_section->vma);
3565     }
3566
3567   /* Fill in the entry in the procedure linkage table.  */
3568   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3569               htab->splt->contents + plt_offset);
3570   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3571               htab->splt->contents + plt_offset + 4);
3572   bfd_put_32 (output_bfd, plt_entry[2],
3573               htab->splt->contents + plt_offset + 8);
3574   bfd_put_32 (output_bfd, plt_entry[3],
3575               htab->splt->contents + plt_offset + 12);
3576   bfd_put_32 (output_bfd, plt_entry[4],
3577               htab->splt->contents + plt_offset + 16);
3578   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3579               htab->splt->contents + plt_offset + 20);
3580   /* PC-relative displacement for a branch to the start of
3581      the PLT section.  */
3582   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3583                                           & 0x003fffff),
3584               htab->splt->contents + plt_offset + 24);
3585   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3586               htab->splt->contents + plt_offset + 28);
3587
3588   /* Fill in the .got.plt entry, pointing initially at the
3589      second half of the PLT entry.  */
3590   BFD_ASSERT (htab->sgotplt != NULL);
3591   bfd_put_32 (output_bfd,
3592               htab->splt->output_section->vma
3593               + htab->splt->output_offset
3594               + plt_offset + 20,
3595               htab->sgotplt->contents + got_offset);
3596
3597   /* Add relocations to .rela.plt.unloaded.  */
3598   if (!info->shared)
3599     {
3600       loc = (htab->srelplt2->contents
3601              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3602
3603       /* Relocate the initial sethi.  */
3604       rela.r_offset = (htab->splt->output_section->vma
3605                        + htab->splt->output_offset
3606                        + plt_offset);
3607       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3608       rela.r_addend = got_offset;
3609       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3610       loc += sizeof (Elf32_External_Rela);
3611
3612       /* Likewise the following or.  */
3613       rela.r_offset += 4;
3614       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3615       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3616       loc += sizeof (Elf32_External_Rela);
3617
3618       /* Relocate the .got.plt entry.  */
3619       rela.r_offset = (htab->sgotplt->output_section->vma
3620                        + htab->sgotplt->output_offset
3621                        + got_offset);
3622       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3623       rela.r_addend = plt_offset + 20;
3624       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3625     }
3626 }
3627
3628 /* Finish up dynamic symbol handling.  We set the contents of various
3629    dynamic sections here.  */
3630
3631 bfd_boolean
3632 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3633                                       struct bfd_link_info *info,
3634                                       struct elf_link_hash_entry *h,
3635                                       Elf_Internal_Sym *sym)
3636 {
3637   bfd *dynobj;
3638   struct _bfd_sparc_elf_link_hash_table *htab;
3639
3640   htab = _bfd_sparc_elf_hash_table (info);
3641   dynobj = htab->elf.dynobj;
3642
3643   if (h->plt.offset != (bfd_vma) -1)
3644     {
3645       asection *splt;
3646       asection *srela;
3647       Elf_Internal_Rela rela;
3648       bfd_byte *loc;
3649       bfd_vma r_offset, got_offset;
3650       int rela_index;
3651
3652       /* This symbol has an entry in the PLT.  Set it up.  */
3653
3654       BFD_ASSERT (h->dynindx != -1);
3655
3656       splt = htab->splt;
3657       srela = htab->srelplt;
3658       BFD_ASSERT (splt != NULL && srela != NULL);
3659
3660       /* Fill in the entry in the .rela.plt section.  */
3661       if (htab->is_vxworks)
3662         {
3663           /* Work out the index of this PLT entry.  */
3664           rela_index = ((h->plt.offset - htab->plt_header_size)
3665                         / htab->plt_entry_size);
3666
3667           /* Calculate the offset of the associated .got.plt entry.
3668              The first three entries are reserved.  */
3669           got_offset = (rela_index + 3) * 4;
3670
3671           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3672                                          rela_index, got_offset);
3673
3674
3675           /* On VxWorks, the relocation points to the .got.plt entry,
3676              not the .plt entry.  */
3677           rela.r_offset = (htab->sgotplt->output_section->vma
3678                            + htab->sgotplt->output_offset
3679                            + got_offset);
3680           rela.r_addend = 0;
3681         }
3682       else
3683         {
3684           /* Fill in the entry in the procedure linkage table.  */
3685           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3686                                                   h->plt.offset, splt->size,
3687                                                   &r_offset);
3688
3689           rela.r_offset = r_offset
3690             + (splt->output_section->vma + splt->output_offset);
3691           if (! ABI_64_P (output_bfd)
3692               || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3693             {
3694               rela.r_addend = 0;
3695             }
3696           else
3697             {
3698               rela.r_addend = (-(h->plt.offset + 4)
3699                                - splt->output_section->vma
3700                                - splt->output_offset);
3701             }
3702         }
3703       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3704
3705       /* Adjust for the first 4 reserved elements in the .plt section
3706          when setting the offset in the .rela.plt section.
3707          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3708          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3709
3710       loc = srela->contents;
3711 #ifdef BFD64
3712       if (ABI_64_P (output_bfd))
3713         {
3714           loc += rela_index * sizeof (Elf64_External_Rela);
3715           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3716         }
3717       else
3718 #endif
3719         {
3720           loc += rela_index * sizeof (Elf32_External_Rela);
3721           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3722         }
3723
3724       if (!h->def_regular)
3725         {
3726           /* Mark the symbol as undefined, rather than as defined in
3727              the .plt section.  Leave the value alone.  */
3728           sym->st_shndx = SHN_UNDEF;
3729           /* If the symbol is weak, we do need to clear the value.
3730              Otherwise, the PLT entry would provide a definition for
3731              the symbol even if the symbol wasn't defined anywhere,
3732              and so the symbol would never be NULL.  */
3733           if (!h->ref_regular_nonweak)
3734             sym->st_value = 0;
3735         }
3736     }
3737
3738   if (h->got.offset != (bfd_vma) -1
3739       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3740       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3741     {
3742       asection *sgot;
3743       asection *srela;
3744       Elf_Internal_Rela rela;
3745
3746       /* This symbol has an entry in the GOT.  Set it up.  */
3747
3748       sgot = htab->sgot;
3749       srela = htab->srelgot;
3750       BFD_ASSERT (sgot != NULL && srela != NULL);
3751
3752       rela.r_offset = (sgot->output_section->vma
3753                        + sgot->output_offset
3754                        + (h->got.offset &~ (bfd_vma) 1));
3755
3756       /* If this is a -Bsymbolic link, and the symbol is defined
3757          locally, we just want to emit a RELATIVE reloc.  Likewise if
3758          the symbol was forced to be local because of a version file.
3759          The entry in the global offset table will already have been
3760          initialized in the relocate_section function.  */
3761       if (info->shared
3762           && (info->symbolic || h->dynindx == -1)
3763           && h->def_regular)
3764         {
3765           asection *sec = h->root.u.def.section;
3766           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3767           rela.r_addend = (h->root.u.def.value
3768                            + sec->output_section->vma
3769                            + sec->output_offset);
3770         }
3771       else
3772         {
3773           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3774           rela.r_addend = 0;
3775         }
3776
3777       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3778                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3779       SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3780     }
3781
3782   if (h->needs_copy)
3783     {
3784       asection *s;
3785       Elf_Internal_Rela rela;
3786
3787       /* This symbols needs a copy reloc.  Set it up.  */
3788       BFD_ASSERT (h->dynindx != -1);
3789
3790       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3791                                    ".rela.bss");
3792       BFD_ASSERT (s != NULL);
3793
3794       rela.r_offset = (h->root.u.def.value
3795                        + h->root.u.def.section->output_section->vma
3796                        + h->root.u.def.section->output_offset);
3797       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3798       rela.r_addend = 0;
3799       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3800     }
3801
3802   /* Mark some specially defined symbols as absolute.  On VxWorks,
3803      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3804      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
3805   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3806       || (!htab->is_vxworks
3807           && (h == htab->elf.hgot || h == htab->elf.hplt)))
3808     sym->st_shndx = SHN_ABS;
3809
3810   return TRUE;
3811 }
3812
3813 /* Finish up the dynamic sections.  */
3814
3815 #ifdef BFD64
3816 static bfd_boolean
3817 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3818                     bfd *dynobj, asection *sdyn,
3819                     asection *splt ATTRIBUTE_UNUSED)
3820 {
3821   Elf64_External_Dyn *dyncon, *dynconend;
3822   int stt_regidx = -1;
3823
3824   dyncon = (Elf64_External_Dyn *) sdyn->contents;
3825   dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3826   for (; dyncon < dynconend; dyncon++)
3827     {
3828       Elf_Internal_Dyn dyn;
3829       const char *name;
3830       bfd_boolean size;
3831
3832       bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3833
3834       switch (dyn.d_tag)
3835         {
3836         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3837         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3838         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3839         case DT_SPARC_REGISTER:
3840           if (stt_regidx == -1)
3841             {
3842               stt_regidx =
3843                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3844               if (stt_regidx == -1)
3845                 return FALSE;
3846             }
3847           dyn.d_un.d_val = stt_regidx++;
3848           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3849           /* fallthrough */
3850         default:          name = NULL; size = FALSE; break;
3851         }
3852
3853       if (name != NULL)
3854         {
3855           asection *s;
3856
3857           s = bfd_get_section_by_name (output_bfd, name);
3858           if (s == NULL)
3859             dyn.d_un.d_val = 0;
3860           else
3861             {
3862               if (! size)
3863                 dyn.d_un.d_ptr = s->vma;
3864               else
3865                 dyn.d_un.d_val = s->size;
3866             }
3867           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3868         }
3869     }
3870   return TRUE;
3871 }
3872 #endif
3873
3874 static bfd_boolean
3875 sparc32_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3876                     bfd *dynobj, asection *sdyn,
3877                     asection *splt ATTRIBUTE_UNUSED)
3878 {
3879   Elf32_External_Dyn *dyncon, *dynconend;
3880   struct _bfd_sparc_elf_link_hash_table *htab;
3881
3882   htab = _bfd_sparc_elf_hash_table (info);
3883   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3884   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3885   for (; dyncon < dynconend; dyncon++)
3886     {
3887       Elf_Internal_Dyn dyn;
3888       const char *name;
3889       bfd_boolean size;
3890
3891       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3892
3893       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3894         {
3895           /* On VxWorks, DT_RELASZ should not include the relocations
3896              in .rela.plt.  */
3897           if (htab->srelplt)
3898             {
3899               dyn.d_un.d_val -= htab->srelplt->size;
3900               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3901             }
3902         }
3903       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3904         {
3905           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3906              not to the start of the PLT.  */
3907           if (htab->sgotplt)
3908             {
3909               dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3910                                 + htab->sgotplt->output_offset);
3911               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3912             }
3913         }
3914       else
3915         {
3916           switch (dyn.d_tag)
3917             {
3918             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3919             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3920             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3921             default:      name = NULL; size = FALSE; break;
3922             }
3923
3924           if (name != NULL)
3925             {
3926               asection *s;
3927
3928               s = bfd_get_section_by_name (output_bfd, name);
3929               if (s == NULL)
3930                 dyn.d_un.d_val = 0;
3931               else
3932                 {
3933                   if (! size)
3934                     dyn.d_un.d_ptr = s->vma;
3935                   else
3936                     dyn.d_un.d_val = s->size;
3937                 }
3938               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3939             }
3940         }
3941     }
3942   return TRUE;
3943 }
3944
3945 /* Install the first PLT entry in a VxWorks executable and make sure that
3946    .rela.plt.unloaded relocations have the correct symbol indexes.  */
3947
3948 static void
3949 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3950 {
3951   struct _bfd_sparc_elf_link_hash_table *htab;
3952   Elf_Internal_Rela rela;
3953   bfd_vma got_base;
3954   bfd_byte *loc;
3955
3956   htab = _bfd_sparc_elf_hash_table (info);
3957
3958   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
3959   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3960               + htab->elf.hgot->root.u.def.section->output_offset
3961               + htab->elf.hgot->root.u.def.value);
3962
3963   /* Install the initial PLT entry.  */
3964   bfd_put_32 (output_bfd,
3965               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3966               htab->splt->contents);
3967   bfd_put_32 (output_bfd,
3968               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3969               htab->splt->contents + 4);
3970   bfd_put_32 (output_bfd,
3971               sparc_vxworks_exec_plt0_entry[2],
3972               htab->splt->contents + 8);
3973   bfd_put_32 (output_bfd,
3974               sparc_vxworks_exec_plt0_entry[3],
3975               htab->splt->contents + 12);
3976   bfd_put_32 (output_bfd,
3977               sparc_vxworks_exec_plt0_entry[4],
3978               htab->splt->contents + 16);
3979
3980   loc = htab->srelplt2->contents;
3981
3982   /* Add an unloaded relocation for the initial entry's "sethi".  */
3983   rela.r_offset = (htab->splt->output_section->vma
3984                    + htab->splt->output_offset);
3985   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3986   rela.r_addend = 8;
3987   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3988   loc += sizeof (Elf32_External_Rela);
3989
3990   /* Likewise the following "or".  */
3991   rela.r_offset += 4;
3992   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3993   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3994   loc += sizeof (Elf32_External_Rela);
3995
3996   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
3997      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
3998      in which symbols were output.  */
3999   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4000     {
4001       Elf_Internal_Rela rel;
4002
4003       /* The entry's initial "sethi" (against _G_O_T_).  */
4004       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4005       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4006       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4007       loc += sizeof (Elf32_External_Rela);
4008
4009       /* The following "or" (also against _G_O_T_).  */
4010       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4011       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4012       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4013       loc += sizeof (Elf32_External_Rela);
4014
4015       /* The .got.plt entry (against _P_L_T_).  */
4016       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4017       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4018       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4019       loc += sizeof (Elf32_External_Rela);
4020     }
4021 }
4022
4023 /* Install the first PLT entry in a VxWorks shared object.  */
4024
4025 static void
4026 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4027 {
4028   struct _bfd_sparc_elf_link_hash_table *htab;
4029   unsigned int i;
4030
4031   htab = _bfd_sparc_elf_hash_table (info);
4032   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4033     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4034                 htab->splt->contents + i * 4);
4035 }
4036
4037 bfd_boolean
4038 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4039 {
4040   bfd *dynobj;
4041   asection *sdyn;
4042   struct _bfd_sparc_elf_link_hash_table *htab;
4043
4044   htab = _bfd_sparc_elf_hash_table (info);
4045   dynobj = htab->elf.dynobj;
4046
4047   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4048
4049   if (elf_hash_table (info)->dynamic_sections_created)
4050     {
4051       asection *splt;
4052       bfd_boolean ret;
4053
4054       splt = bfd_get_section_by_name (dynobj, ".plt");
4055       BFD_ASSERT (splt != NULL && sdyn != NULL);
4056
4057 #ifdef BFD64
4058       if (ABI_64_P (output_bfd))
4059         ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4060       else
4061 #endif
4062         ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4063
4064       if (ret != TRUE)
4065         return ret;
4066
4067       /* Initialize the contents of the .plt section.  */
4068       if (splt->size > 0)
4069         {
4070           if (htab->is_vxworks)
4071             {
4072               if (info->shared)
4073                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4074               else
4075                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4076             }
4077           else
4078             {
4079               memset (splt->contents, 0, htab->plt_header_size);
4080               if (!ABI_64_P (output_bfd))
4081                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4082                             splt->contents + splt->size - 4);
4083             }
4084         }
4085
4086       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4087         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4088           ? 0 : htab->plt_entry_size;
4089     }
4090
4091   /* Set the first entry in the global offset table to the address of
4092      the dynamic section.  */
4093   if (htab->sgot && htab->sgot->size > 0)
4094     {
4095       bfd_vma val = (sdyn ?
4096                      sdyn->output_section->vma + sdyn->output_offset :
4097                      0);
4098
4099       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4100     }
4101
4102   if (htab->sgot)
4103     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4104       SPARC_ELF_WORD_BYTES (htab);
4105
4106   return TRUE;
4107 }
4108
4109 \f
4110 /* Set the right machine number for a SPARC ELF file.  */
4111
4112 bfd_boolean
4113 _bfd_sparc_elf_object_p (bfd *abfd)
4114 {
4115   if (ABI_64_P (abfd))
4116     {
4117       unsigned long mach = bfd_mach_sparc_v9;
4118
4119       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4120         mach = bfd_mach_sparc_v9b;
4121       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4122         mach = bfd_mach_sparc_v9a;
4123       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4124     }
4125   else
4126     {
4127       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4128         {
4129           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4130             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4131                                               bfd_mach_sparc_v8plusb);
4132           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4133             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4134                                               bfd_mach_sparc_v8plusa);
4135           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4136             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4137                                               bfd_mach_sparc_v8plus);
4138           else
4139             return FALSE;
4140         }
4141       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4142         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4143                                           bfd_mach_sparc_sparclite_le);
4144       else
4145         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4146     }
4147 }
4148
4149 /* Return address for Ith PLT stub in section PLT, for relocation REL
4150    or (bfd_vma) -1 if it should not be included.  */
4151
4152 bfd_vma
4153 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4154 {
4155   if (ABI_64_P (plt->owner))
4156     {
4157       bfd_vma j;
4158
4159       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4160       if (i < PLT64_LARGE_THRESHOLD)
4161         return plt->vma + i * PLT64_ENTRY_SIZE;
4162
4163       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4164       i -= j;
4165       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4166     }
4167   else
4168     return rel->address;
4169 }