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               || (input_section->flags & SEC_ALLOC) == 0)
2760             break;
2761
2762           if ((info->shared
2763                && (h == NULL
2764                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2765                    || h->root.type != bfd_link_hash_undefweak)
2766                && (! howto->pc_relative
2767                    || (h != NULL
2768                        && h->dynindx != -1
2769                        && (! info->symbolic
2770                            || !h->def_regular))))
2771               || (!info->shared
2772                   && h != NULL
2773                   && h->dynindx != -1
2774                   && !h->non_got_ref
2775                   && ((h->def_dynamic
2776                        && !h->def_regular)
2777                       || h->root.type == bfd_link_hash_undefweak
2778                       || h->root.type == bfd_link_hash_undefined)))
2779             {
2780               Elf_Internal_Rela outrel;
2781               bfd_boolean skip, relocate = FALSE;
2782
2783               /* When generating a shared object, these relocations
2784                  are copied into the output file to be resolved at run
2785                  time.  */
2786
2787               BFD_ASSERT (sreloc != NULL);
2788
2789               skip = FALSE;
2790
2791               outrel.r_offset =
2792                 _bfd_elf_section_offset (output_bfd, info, input_section,
2793                                          rel->r_offset);
2794               if (outrel.r_offset == (bfd_vma) -1)
2795                 skip = TRUE;
2796               else if (outrel.r_offset == (bfd_vma) -2)
2797                 skip = TRUE, relocate = TRUE;
2798               outrel.r_offset += (input_section->output_section->vma
2799                                   + input_section->output_offset);
2800
2801               /* Optimize unaligned reloc usage now that we know where
2802                  it finally resides.  */
2803               switch (r_type)
2804                 {
2805                 case R_SPARC_16:
2806                   if (outrel.r_offset & 1)
2807                     r_type = R_SPARC_UA16;
2808                   break;
2809                 case R_SPARC_UA16:
2810                   if (!(outrel.r_offset & 1))
2811                     r_type = R_SPARC_16;
2812                   break;
2813                 case R_SPARC_32:
2814                   if (outrel.r_offset & 3)
2815                     r_type = R_SPARC_UA32;
2816                   break;
2817                 case R_SPARC_UA32:
2818                   if (!(outrel.r_offset & 3))
2819                     r_type = R_SPARC_32;
2820                   break;
2821                 case R_SPARC_64:
2822                   if (outrel.r_offset & 7)
2823                     r_type = R_SPARC_UA64;
2824                   break;
2825                 case R_SPARC_UA64:
2826                   if (!(outrel.r_offset & 7))
2827                     r_type = R_SPARC_64;
2828                   break;
2829                 case R_SPARC_DISP8:
2830                 case R_SPARC_DISP16:
2831                 case R_SPARC_DISP32:
2832                 case R_SPARC_DISP64:
2833                   /* If the symbol is not dynamic, we should not keep
2834                      a dynamic relocation.  But an .rela.* slot has been
2835                      allocated for it, output R_SPARC_NONE.
2836                      FIXME: Add code tracking needed dynamic relocs as
2837                      e.g. i386 has.  */
2838                   if (h->dynindx == -1)
2839                     skip = TRUE, relocate = TRUE;
2840                   break;
2841                 }
2842
2843               if (skip)
2844                 memset (&outrel, 0, sizeof outrel);
2845               /* h->dynindx may be -1 if the symbol was marked to
2846                  become local.  */
2847               else if (h != NULL && ! is_plt
2848                        && ((! info->symbolic && h->dynindx != -1)
2849                            || !h->def_regular))
2850                 {
2851                   BFD_ASSERT (h->dynindx != -1);
2852                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2853                   outrel.r_addend = rel->r_addend;
2854                 }
2855               else
2856                 {
2857                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2858                     {
2859                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2860                                                         0, R_SPARC_RELATIVE);
2861                       outrel.r_addend = relocation + rel->r_addend;
2862                     }
2863                   else
2864                     {
2865                       long indx;
2866
2867                       if (is_plt)
2868                         sec = htab->splt;
2869
2870                       if (bfd_is_abs_section (sec))
2871                         indx = 0;
2872                       else if (sec == NULL || sec->owner == NULL)
2873                         {
2874                           bfd_set_error (bfd_error_bad_value);
2875                           return FALSE;
2876                         }
2877                       else
2878                         {
2879                           asection *osec;
2880
2881                           osec = sec->output_section;
2882                           indx = elf_section_data (osec)->dynindx;
2883
2884                           /* FIXME: we really should be able to link non-pic
2885                              shared libraries.  */
2886                           if (indx == 0)
2887                             {
2888                               BFD_FAIL ();
2889                               (*_bfd_error_handler)
2890                                 (_("%B: probably compiled without -fPIC?"),
2891                                  input_bfd);
2892                               bfd_set_error (bfd_error_bad_value);
2893                               return FALSE;
2894                             }
2895                         }
2896
2897                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, r_type);
2898                       outrel.r_addend = relocation + rel->r_addend;
2899                     }
2900                 }
2901
2902               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2903
2904               /* This reloc will be computed at runtime, so there's no
2905                  need to do anything now.  */
2906               if (! relocate)
2907                 continue;
2908             }
2909           break;
2910
2911         case R_SPARC_TLS_GD_HI22:
2912           if (! ABI_64_P (input_bfd)
2913               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2914             {
2915               /* R_SPARC_REV32 used the same reloc number as
2916                  R_SPARC_TLS_GD_HI22.  */
2917               r_type = R_SPARC_REV32;
2918               break;
2919             }
2920           /* Fall through */
2921
2922         case R_SPARC_TLS_GD_LO10:
2923         case R_SPARC_TLS_IE_HI22:
2924         case R_SPARC_TLS_IE_LO10:
2925           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2926           tls_type = GOT_UNKNOWN;
2927           if (h == NULL && local_got_offsets)
2928             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2929           else if (h != NULL)
2930             {
2931               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2932               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2933                 switch (SPARC_ELF_R_TYPE (rel->r_info))
2934                   {
2935                   case R_SPARC_TLS_GD_HI22:
2936                   case R_SPARC_TLS_IE_HI22:
2937                     r_type = R_SPARC_TLS_LE_HIX22;
2938                     break;
2939                   default:
2940                     r_type = R_SPARC_TLS_LE_LOX10;
2941                     break;
2942                   }
2943             }
2944           if (tls_type == GOT_TLS_IE)
2945             switch (r_type)
2946               {
2947               case R_SPARC_TLS_GD_HI22:
2948                 r_type = R_SPARC_TLS_IE_HI22;
2949                 break;
2950               case R_SPARC_TLS_GD_LO10:
2951                 r_type = R_SPARC_TLS_IE_LO10;
2952                 break;
2953               }
2954
2955           if (r_type == R_SPARC_TLS_LE_HIX22)
2956             {
2957               relocation = tpoff (info, relocation);
2958               break;
2959             }
2960           if (r_type == R_SPARC_TLS_LE_LOX10)
2961             {
2962               /* Change add into xor.  */
2963               relocation = tpoff (info, relocation);
2964               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2965                                                    contents + rel->r_offset)
2966                                        | 0x80182000), contents + rel->r_offset);
2967               break;
2968             }
2969
2970           if (h != NULL)
2971             {
2972               off = h->got.offset;
2973               h->got.offset |= 1;
2974             }
2975           else
2976             {
2977               BFD_ASSERT (local_got_offsets != NULL);
2978               off = local_got_offsets[r_symndx];
2979               local_got_offsets[r_symndx] |= 1;
2980             }
2981
2982         r_sparc_tlsldm:
2983           if (htab->sgot == NULL)
2984             abort ();
2985
2986           if ((off & 1) != 0)
2987             off &= ~1;
2988           else
2989             {
2990               Elf_Internal_Rela outrel;
2991               int dr_type, indx;
2992
2993               if (htab->srelgot == NULL)
2994                 abort ();
2995
2996               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
2997               outrel.r_offset = (htab->sgot->output_section->vma
2998                                  + htab->sgot->output_offset + off);
2999               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3000               if (r_type == R_SPARC_TLS_IE_HI22
3001                   || r_type == R_SPARC_TLS_IE_LO10)
3002                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3003               else
3004                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3005               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3006                 outrel.r_addend = relocation - dtpoff_base (info);
3007               else
3008                 outrel.r_addend = 0;
3009               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3010               SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3011
3012               if (r_type == R_SPARC_TLS_GD_HI22
3013                   || r_type == R_SPARC_TLS_GD_LO10)
3014                 {
3015                   if (indx == 0)
3016                     {
3017                       BFD_ASSERT (! unresolved_reloc);
3018                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3019                                           relocation - dtpoff_base (info),
3020                                           (htab->sgot->contents + off
3021                                            + SPARC_ELF_WORD_BYTES (htab)));
3022                     }
3023                   else
3024                     {
3025                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3026                                           (htab->sgot->contents + off
3027                                            + SPARC_ELF_WORD_BYTES (htab)));
3028                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3029                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3030                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3031                       SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3032                     }
3033                 }
3034               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3035                 {
3036                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3037                                       (htab->sgot->contents + off
3038                                        + SPARC_ELF_WORD_BYTES (htab)));
3039                 }
3040             }
3041
3042           if (off >= (bfd_vma) -2)
3043             abort ();
3044
3045           relocation = htab->sgot->output_offset + off - got_base;
3046           unresolved_reloc = FALSE;
3047           howto = _bfd_sparc_elf_howto_table + r_type;
3048           break;
3049
3050         case R_SPARC_TLS_LDM_HI22:
3051         case R_SPARC_TLS_LDM_LO10:
3052           if (! info->shared)
3053             {
3054               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3055               continue;
3056             }
3057           off = htab->tls_ldm_got.offset;
3058           htab->tls_ldm_got.offset |= 1;
3059           goto r_sparc_tlsldm;
3060
3061         case R_SPARC_TLS_LDO_HIX22:
3062         case R_SPARC_TLS_LDO_LOX10:
3063           if (info->shared)
3064             {
3065               relocation -= dtpoff_base (info);
3066               break;
3067             }
3068
3069           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3070                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3071           /* Fall through.  */
3072
3073         case R_SPARC_TLS_LE_HIX22:
3074         case R_SPARC_TLS_LE_LOX10:
3075           if (info->shared)
3076             {
3077               Elf_Internal_Rela outrel;
3078               bfd_boolean skip, relocate = FALSE;
3079
3080               BFD_ASSERT (sreloc != NULL);
3081               skip = FALSE;
3082               outrel.r_offset =
3083                 _bfd_elf_section_offset (output_bfd, info, input_section,
3084                                          rel->r_offset);
3085               if (outrel.r_offset == (bfd_vma) -1)
3086                 skip = TRUE;
3087               else if (outrel.r_offset == (bfd_vma) -2)
3088                 skip = TRUE, relocate = TRUE;
3089               outrel.r_offset += (input_section->output_section->vma
3090                                   + input_section->output_offset);
3091               if (skip)
3092                 memset (&outrel, 0, sizeof outrel);
3093               else
3094                 {
3095                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3096                   outrel.r_addend = relocation - dtpoff_base (info)
3097                                     + rel->r_addend;
3098                 }
3099
3100               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
3101               continue;
3102             }
3103           relocation = tpoff (info, relocation);
3104           break;
3105
3106         case R_SPARC_TLS_LDM_CALL:
3107           if (! info->shared)
3108             {
3109               /* mov %g0, %o0 */
3110               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3111               continue;
3112             }
3113           /* Fall through */
3114
3115         case R_SPARC_TLS_GD_CALL:
3116           tls_type = GOT_UNKNOWN;
3117           if (h == NULL && local_got_offsets)
3118             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3119           else if (h != NULL)
3120             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3121           if (! info->shared
3122               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3123             {
3124               bfd_vma insn;
3125
3126               if (!info->shared && (h == NULL || h->dynindx == -1))
3127                 {
3128                   /* GD -> LE */
3129                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3130                   continue;
3131                 }
3132
3133               /* GD -> IE */
3134               if (rel + 1 < relend
3135                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3136                   && rel[1].r_offset == rel->r_offset + 4
3137                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3138                   && (((insn = bfd_get_32 (input_bfd,
3139                                            contents + rel[1].r_offset))
3140                        >> 25) & 0x1f) == 8)
3141                 {
3142                   /* We have
3143                      call __tls_get_addr, %tgd_call(foo)
3144                       add %reg1, %reg2, %o0, %tgd_add(foo)
3145                      and change it into IE:
3146                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3147                      add %g7, %o0, %o0, %tie_add(foo).
3148                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3149                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3150                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3151                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3152                               contents + rel->r_offset);
3153                   bfd_put_32 (output_bfd, 0x9001c008,
3154                               contents + rel->r_offset + 4);
3155                   rel++;
3156                   continue;
3157                 }
3158
3159               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3160               continue;
3161             }
3162
3163           h = (struct elf_link_hash_entry *)
3164               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3165                                     FALSE, TRUE);
3166           BFD_ASSERT (h != NULL);
3167           r_type = R_SPARC_WPLT30;
3168           howto = _bfd_sparc_elf_howto_table + r_type;
3169           goto r_sparc_wplt30;
3170
3171         case R_SPARC_TLS_GD_ADD:
3172           tls_type = GOT_UNKNOWN;
3173           if (h == NULL && local_got_offsets)
3174             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3175           else if (h != NULL)
3176             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3177           if (! info->shared || tls_type == GOT_TLS_IE)
3178             {
3179               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3180                  changed into IE:
3181                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3182                  or LE:
3183                  add %g7, %reg2, %reg3.  */
3184               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3185               if ((h != NULL && h->dynindx != -1) || info->shared)
3186                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3187               else
3188                 relocation = (insn & ~0x7c000) | 0x1c000;
3189               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3190             }
3191           continue;
3192
3193         case R_SPARC_TLS_LDM_ADD:
3194           if (! info->shared)
3195             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3196           continue;
3197
3198         case R_SPARC_TLS_LDO_ADD:
3199           if (! info->shared)
3200             {
3201               /* Change rs1 into %g7.  */
3202               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3203               insn = (insn & ~0x7c000) | 0x1c000;
3204               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3205             }
3206           continue;
3207
3208         case R_SPARC_TLS_IE_LD:
3209         case R_SPARC_TLS_IE_LDX:
3210           if (! info->shared && (h == NULL || h->dynindx == -1))
3211             {
3212               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3213               int rs2 = insn & 0x1f;
3214               int rd = (insn >> 25) & 0x1f;
3215
3216               if (rs2 == rd)
3217                 relocation = SPARC_NOP;
3218               else
3219                 relocation = 0x80100000 | (insn & 0x3e00001f);
3220               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3221             }
3222           continue;
3223
3224         case R_SPARC_TLS_IE_ADD:
3225           /* Totally useless relocation.  */
3226           continue;
3227
3228         case R_SPARC_TLS_DTPOFF32:
3229         case R_SPARC_TLS_DTPOFF64:
3230           relocation -= dtpoff_base (info);
3231           break;
3232
3233         default:
3234           break;
3235         }
3236
3237       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3238          because such sections are not SEC_ALLOC and thus ld.so will
3239          not process them.  */
3240       if (unresolved_reloc
3241           && !((input_section->flags & SEC_DEBUGGING) != 0
3242                && h->def_dynamic))
3243         (*_bfd_error_handler)
3244           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3245            input_bfd,
3246            input_section,
3247            (long) rel->r_offset,
3248            howto->name,
3249            h->root.root.string);
3250
3251       r = bfd_reloc_continue;
3252       if (r_type == R_SPARC_OLO10)
3253         {
3254             bfd_vma x;
3255
3256             if (! ABI_64_P (output_bfd))
3257               abort ();
3258
3259             relocation += rel->r_addend;
3260             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3261
3262             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3263             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3264             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3265
3266             r = bfd_check_overflow (howto->complain_on_overflow,
3267                                     howto->bitsize, howto->rightshift,
3268                                     bfd_arch_bits_per_address (input_bfd),
3269                                     relocation);
3270         }
3271       else if (r_type == R_SPARC_WDISP16)
3272         {
3273           bfd_vma x;
3274
3275           relocation += rel->r_addend;
3276           relocation -= (input_section->output_section->vma
3277                          + input_section->output_offset);
3278           relocation -= rel->r_offset;
3279
3280           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3281           x |= ((((relocation >> 2) & 0xc000) << 6)
3282                 | ((relocation >> 2) & 0x3fff));
3283           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3284
3285           r = bfd_check_overflow (howto->complain_on_overflow,
3286                                   howto->bitsize, howto->rightshift,
3287                                   bfd_arch_bits_per_address (input_bfd),
3288                                   relocation);
3289         }
3290       else if (r_type == R_SPARC_REV32)
3291         {
3292           bfd_vma x;
3293
3294           relocation = relocation + rel->r_addend;
3295
3296           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3297           x = x + relocation;
3298           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3299           r = bfd_reloc_ok;
3300         }
3301       else if (r_type == R_SPARC_TLS_LDO_HIX22
3302                || r_type == R_SPARC_TLS_LE_HIX22)
3303         {
3304           bfd_vma x;
3305
3306           relocation += rel->r_addend;
3307           if (r_type == R_SPARC_TLS_LE_HIX22)
3308             relocation ^= MINUS_ONE;
3309
3310           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3311           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3312           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3313           r = bfd_reloc_ok;
3314         }
3315       else if (r_type == R_SPARC_TLS_LDO_LOX10
3316                || r_type == R_SPARC_TLS_LE_LOX10)
3317         {
3318           bfd_vma x;
3319
3320           relocation += rel->r_addend;
3321           relocation &= 0x3ff;
3322           if (r_type == R_SPARC_TLS_LE_LOX10)
3323             relocation |= 0x1c00;
3324
3325           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3326           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3327           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3328
3329           r = bfd_reloc_ok;
3330         }
3331       else if (r_type == R_SPARC_HIX22)
3332         {
3333           bfd_vma x;
3334
3335           relocation += rel->r_addend;
3336           relocation = relocation ^ MINUS_ONE;
3337
3338           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3339           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3340           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3341
3342           r = bfd_check_overflow (howto->complain_on_overflow,
3343                                   howto->bitsize, howto->rightshift,
3344                                   bfd_arch_bits_per_address (input_bfd),
3345                                   relocation);
3346         }
3347       else if (r_type == R_SPARC_LOX10)
3348         {
3349           bfd_vma x;
3350
3351           relocation += rel->r_addend;
3352           relocation = (relocation & 0x3ff) | 0x1c00;
3353
3354           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3355           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3356           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3357
3358           r = bfd_reloc_ok;
3359         }
3360       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3361                && sec_do_relax (input_section)
3362                && rel->r_offset + 4 < input_section->size)
3363         {
3364 #define G0              0
3365 #define O7              15
3366 #define XCC             (2 << 20)
3367 #define COND(x)         (((x)&0xf)<<25)
3368 #define CONDA           COND(0x8)
3369 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3370 #define INSN_BA         (F2(0,2) | CONDA)
3371 #define INSN_OR         F3(2, 0x2, 0)
3372 #define INSN_NOP        F2(0,4)
3373
3374           bfd_vma x, y;
3375
3376           /* If the instruction is a call with either:
3377              restore
3378              arithmetic instruction with rd == %o7
3379              where rs1 != %o7 and rs2 if it is register != %o7
3380              then we can optimize if the call destination is near
3381              by changing the call into a branch always.  */
3382           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3383           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3384           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3385             {
3386               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3387                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3388                        && (y & RD(~0)) == RD(O7)))
3389                   && (y & RS1(~0)) != RS1(O7)
3390                   && ((y & F3I(~0))
3391                       || (y & RS2(~0)) != RS2(O7)))
3392                 {
3393                   bfd_vma reloc;
3394
3395                   reloc = relocation + rel->r_addend - rel->r_offset;
3396                   reloc -= (input_section->output_section->vma
3397                             + input_section->output_offset);
3398
3399                   /* Ensure the branch fits into simm22.  */
3400                   if ((reloc & 3) == 0
3401                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3402                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3403                     {
3404                       reloc >>= 2;
3405
3406                       /* Check whether it fits into simm19.  */
3407                       if (((reloc & 0x3c0000) == 0
3408                            || (reloc & 0x3c0000) == 0x3c0000)
3409                           && (ABI_64_P (output_bfd)
3410                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3411                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3412                       else
3413                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3414                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3415                       r = bfd_reloc_ok;
3416                       if (rel->r_offset >= 4
3417                           && (y & (0xffffffff ^ RS1(~0)))
3418                              == (INSN_OR | RD(O7) | RS2(G0)))
3419                         {
3420                           bfd_vma z;
3421                           unsigned int reg;
3422
3423                           z = bfd_get_32 (input_bfd,
3424                                           contents + rel->r_offset - 4);
3425                           if ((z & (0xffffffff ^ RD(~0)))
3426                               != (INSN_OR | RS1(O7) | RS2(G0)))
3427                             break;
3428
3429                           /* The sequence was
3430                              or %o7, %g0, %rN
3431                              call foo
3432                              or %rN, %g0, %o7
3433
3434                              If call foo was replaced with ba, replace
3435                              or %rN, %g0, %o7 with nop.  */
3436
3437                           reg = (y & RS1(~0)) >> 14;
3438                           if (reg != ((z & RD(~0)) >> 25)
3439                               || reg == G0 || reg == O7)
3440                             break;
3441
3442                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3443                                       contents + rel->r_offset + 4);
3444                         }
3445
3446                     }
3447                 }
3448             }
3449         }
3450
3451       if (r == bfd_reloc_continue)
3452         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3453                                       contents, rel->r_offset,
3454                                       relocation, rel->r_addend);
3455
3456       if (r != bfd_reloc_ok)
3457         {
3458           switch (r)
3459             {
3460             default:
3461             case bfd_reloc_outofrange:
3462               abort ();
3463             case bfd_reloc_overflow:
3464               {
3465                 const char *name;
3466
3467                 /* The Solaris native linker silently disregards overflows.
3468                    We don't, but this breaks stabs debugging info, whose
3469                    relocations are only 32-bits wide.  Ignore overflows in
3470                    this case and also for discarded entries.  */
3471                 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3472                     && (((input_section->flags & SEC_DEBUGGING) != 0
3473                          && strcmp (bfd_section_name (input_bfd,
3474                                                       input_section),
3475                                     ".stab") == 0)
3476                         || _bfd_elf_section_offset (output_bfd, info,
3477                                                     input_section,
3478                                                     rel->r_offset)
3479                              == (bfd_vma)-1))
3480                   break;
3481
3482                 if (h != NULL)
3483                   {
3484                     /* Assume this is a call protected by other code that
3485                        detect the symbol is undefined.  If this is the case,
3486                        we can safely ignore the overflow.  If not, the
3487                        program is hosed anyway, and a little warning isn't
3488                        going to help.  */
3489                     if (h->root.type == bfd_link_hash_undefweak
3490                         && howto->pc_relative)
3491                       break;
3492
3493                     name = NULL;
3494                   }
3495                 else
3496                   {
3497                     name = bfd_elf_string_from_elf_section (input_bfd,
3498                                                             symtab_hdr->sh_link,
3499                                                             sym->st_name);
3500                     if (name == NULL)
3501                       return FALSE;
3502                     if (*name == '\0')
3503                       name = bfd_section_name (input_bfd, sec);
3504                   }
3505                 if (! ((*info->callbacks->reloc_overflow)
3506                        (info, (h ? &h->root : NULL), name, howto->name,
3507                         (bfd_vma) 0, input_bfd, input_section,
3508                         rel->r_offset)))
3509                   return FALSE;
3510               }
3511               break;
3512             }
3513         }
3514     }
3515
3516   return TRUE;
3517 }
3518
3519 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
3520    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
3521    is the offset of the associated .got.plt entry from
3522    _GLOBAL_OFFSET_TABLE_.  */
3523
3524 static void
3525 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3526                                bfd_vma plt_offset, bfd_vma plt_index,
3527                                bfd_vma got_offset)
3528 {
3529   bfd_vma got_base;
3530   const bfd_vma *plt_entry;
3531   struct _bfd_sparc_elf_link_hash_table *htab;
3532   bfd_byte *loc;
3533   Elf_Internal_Rela rela;
3534
3535   htab = _bfd_sparc_elf_hash_table (info);
3536   if (info->shared)
3537     {
3538       plt_entry = sparc_vxworks_shared_plt_entry;
3539       got_base = 0;
3540     }
3541   else
3542     {
3543       plt_entry = sparc_vxworks_exec_plt_entry;
3544       got_base = (htab->elf.hgot->root.u.def.value
3545                   + htab->elf.hgot->root.u.def.section->output_offset
3546                   + htab->elf.hgot->root.u.def.section->output_section->vma);
3547     }
3548
3549   /* Fill in the entry in the procedure linkage table.  */
3550   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3551               htab->splt->contents + plt_offset);
3552   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3553               htab->splt->contents + plt_offset + 4);
3554   bfd_put_32 (output_bfd, plt_entry[2],
3555               htab->splt->contents + plt_offset + 8);
3556   bfd_put_32 (output_bfd, plt_entry[3],
3557               htab->splt->contents + plt_offset + 12);
3558   bfd_put_32 (output_bfd, plt_entry[4],
3559               htab->splt->contents + plt_offset + 16);
3560   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3561               htab->splt->contents + plt_offset + 20);
3562   /* PC-relative displacement for a branch to the start of
3563      the PLT section.  */
3564   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3565                                           & 0x003fffff),
3566               htab->splt->contents + plt_offset + 24);
3567   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3568               htab->splt->contents + plt_offset + 28);
3569
3570   /* Fill in the .got.plt entry, pointing initially at the
3571      second half of the PLT entry.  */
3572   BFD_ASSERT (htab->sgotplt != NULL);
3573   bfd_put_32 (output_bfd,
3574               htab->splt->output_section->vma
3575               + htab->splt->output_offset
3576               + plt_offset + 20,
3577               htab->sgotplt->contents + got_offset);
3578
3579   /* Add relocations to .rela.plt.unloaded.  */
3580   if (!info->shared)
3581     {
3582       loc = (htab->srelplt2->contents
3583              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3584
3585       /* Relocate the initial sethi.  */
3586       rela.r_offset = (htab->splt->output_section->vma
3587                        + htab->splt->output_offset
3588                        + plt_offset);
3589       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3590       rela.r_addend = got_offset;
3591       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3592       loc += sizeof (Elf32_External_Rela);
3593
3594       /* Likewise the following or.  */
3595       rela.r_offset += 4;
3596       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3597       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3598       loc += sizeof (Elf32_External_Rela);
3599
3600       /* Relocate the .got.plt entry.  */
3601       rela.r_offset = (htab->sgotplt->output_section->vma
3602                        + htab->sgotplt->output_offset
3603                        + got_offset);
3604       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3605       rela.r_addend = plt_offset + 20;
3606       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3607     }
3608 }
3609
3610 /* Finish up dynamic symbol handling.  We set the contents of various
3611    dynamic sections here.  */
3612
3613 bfd_boolean
3614 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3615                                       struct bfd_link_info *info,
3616                                       struct elf_link_hash_entry *h,
3617                                       Elf_Internal_Sym *sym)
3618 {
3619   bfd *dynobj;
3620   struct _bfd_sparc_elf_link_hash_table *htab;
3621
3622   htab = _bfd_sparc_elf_hash_table (info);
3623   dynobj = htab->elf.dynobj;
3624
3625   if (h->plt.offset != (bfd_vma) -1)
3626     {
3627       asection *splt;
3628       asection *srela;
3629       Elf_Internal_Rela rela;
3630       bfd_byte *loc;
3631       bfd_vma r_offset, got_offset;
3632       int rela_index;
3633
3634       /* This symbol has an entry in the PLT.  Set it up.  */
3635
3636       BFD_ASSERT (h->dynindx != -1);
3637
3638       splt = htab->splt;
3639       srela = htab->srelplt;
3640       BFD_ASSERT (splt != NULL && srela != NULL);
3641
3642       /* Fill in the entry in the .rela.plt section.  */
3643       if (htab->is_vxworks)
3644         {
3645           /* Work out the index of this PLT entry.  */
3646           rela_index = ((h->plt.offset - htab->plt_header_size)
3647                         / htab->plt_entry_size);
3648
3649           /* Calculate the offset of the associated .got.plt entry.
3650              The first three entries are reserved.  */
3651           got_offset = (rela_index + 3) * 4;
3652
3653           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3654                                          rela_index, got_offset);
3655
3656
3657           /* On VxWorks, the relocation points to the .got.plt entry,
3658              not the .plt entry.  */
3659           rela.r_offset = (htab->sgotplt->output_section->vma
3660                            + htab->sgotplt->output_offset
3661                            + got_offset);
3662           rela.r_addend = 0;
3663         }
3664       else
3665         {
3666           /* Fill in the entry in the procedure linkage table.  */
3667           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3668                                                   h->plt.offset, splt->size,
3669                                                   &r_offset);
3670
3671           rela.r_offset = r_offset
3672             + (splt->output_section->vma + splt->output_offset);
3673           if (! ABI_64_P (output_bfd)
3674               || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3675             {
3676               rela.r_addend = 0;
3677             }
3678           else
3679             {
3680               rela.r_addend = (-(h->plt.offset + 4)
3681                                - splt->output_section->vma
3682                                - splt->output_offset);
3683             }
3684         }
3685       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3686
3687       /* Adjust for the first 4 reserved elements in the .plt section
3688          when setting the offset in the .rela.plt section.
3689          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3690          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3691
3692       loc = srela->contents;
3693 #ifdef BFD64
3694       if (ABI_64_P (output_bfd))
3695         {
3696           loc += rela_index * sizeof (Elf64_External_Rela);
3697           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3698         }
3699       else
3700 #endif
3701         {
3702           loc += rela_index * sizeof (Elf32_External_Rela);
3703           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3704         }
3705
3706       if (!h->def_regular)
3707         {
3708           /* Mark the symbol as undefined, rather than as defined in
3709              the .plt section.  Leave the value alone.  */
3710           sym->st_shndx = SHN_UNDEF;
3711           /* If the symbol is weak, we do need to clear the value.
3712              Otherwise, the PLT entry would provide a definition for
3713              the symbol even if the symbol wasn't defined anywhere,
3714              and so the symbol would never be NULL.  */
3715           if (!h->ref_regular_nonweak)
3716             sym->st_value = 0;
3717         }
3718     }
3719
3720   if (h->got.offset != (bfd_vma) -1
3721       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3722       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3723     {
3724       asection *sgot;
3725       asection *srela;
3726       Elf_Internal_Rela rela;
3727
3728       /* This symbol has an entry in the GOT.  Set it up.  */
3729
3730       sgot = htab->sgot;
3731       srela = htab->srelgot;
3732       BFD_ASSERT (sgot != NULL && srela != NULL);
3733
3734       rela.r_offset = (sgot->output_section->vma
3735                        + sgot->output_offset
3736                        + (h->got.offset &~ (bfd_vma) 1));
3737
3738       /* If this is a -Bsymbolic link, and the symbol is defined
3739          locally, we just want to emit a RELATIVE reloc.  Likewise if
3740          the symbol was forced to be local because of a version file.
3741          The entry in the global offset table will already have been
3742          initialized in the relocate_section function.  */
3743       if (info->shared
3744           && (info->symbolic || h->dynindx == -1)
3745           && h->def_regular)
3746         {
3747           asection *sec = h->root.u.def.section;
3748           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3749           rela.r_addend = (h->root.u.def.value
3750                            + sec->output_section->vma
3751                            + sec->output_offset);
3752         }
3753       else
3754         {
3755           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3756           rela.r_addend = 0;
3757         }
3758
3759       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3760                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3761       SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3762     }
3763
3764   if (h->needs_copy)
3765     {
3766       asection *s;
3767       Elf_Internal_Rela rela;
3768
3769       /* This symbols needs a copy reloc.  Set it up.  */
3770       BFD_ASSERT (h->dynindx != -1);
3771
3772       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3773                                    ".rela.bss");
3774       BFD_ASSERT (s != NULL);
3775
3776       rela.r_offset = (h->root.u.def.value
3777                        + h->root.u.def.section->output_section->vma
3778                        + h->root.u.def.section->output_offset);
3779       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3780       rela.r_addend = 0;
3781       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3782     }
3783
3784   /* Mark some specially defined symbols as absolute.  On VxWorks,
3785      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3786      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
3787   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3788       || (!htab->is_vxworks
3789           && (h == htab->elf.hgot || h == htab->elf.hplt)))
3790     sym->st_shndx = SHN_ABS;
3791
3792   return TRUE;
3793 }
3794
3795 /* Finish up the dynamic sections.  */
3796
3797 #ifdef BFD64
3798 static bfd_boolean
3799 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3800                     bfd *dynobj, asection *sdyn,
3801                     asection *splt ATTRIBUTE_UNUSED)
3802 {
3803   Elf64_External_Dyn *dyncon, *dynconend;
3804   int stt_regidx = -1;
3805
3806   dyncon = (Elf64_External_Dyn *) sdyn->contents;
3807   dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3808   for (; dyncon < dynconend; dyncon++)
3809     {
3810       Elf_Internal_Dyn dyn;
3811       const char *name;
3812       bfd_boolean size;
3813
3814       bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3815
3816       switch (dyn.d_tag)
3817         {
3818         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3819         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3820         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3821         case DT_SPARC_REGISTER:
3822           if (stt_regidx == -1)
3823             {
3824               stt_regidx =
3825                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3826               if (stt_regidx == -1)
3827                 return FALSE;
3828             }
3829           dyn.d_un.d_val = stt_regidx++;
3830           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3831           /* fallthrough */
3832         default:          name = NULL; size = FALSE; break;
3833         }
3834
3835       if (name != NULL)
3836         {
3837           asection *s;
3838
3839           s = bfd_get_section_by_name (output_bfd, name);
3840           if (s == NULL)
3841             dyn.d_un.d_val = 0;
3842           else
3843             {
3844               if (! size)
3845                 dyn.d_un.d_ptr = s->vma;
3846               else
3847                 dyn.d_un.d_val = s->size;
3848             }
3849           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3850         }
3851     }
3852   return TRUE;
3853 }
3854 #endif
3855
3856 static bfd_boolean
3857 sparc32_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3858                     bfd *dynobj, asection *sdyn,
3859                     asection *splt ATTRIBUTE_UNUSED)
3860 {
3861   Elf32_External_Dyn *dyncon, *dynconend;
3862   struct _bfd_sparc_elf_link_hash_table *htab;
3863
3864   htab = _bfd_sparc_elf_hash_table (info);
3865   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3866   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3867   for (; dyncon < dynconend; dyncon++)
3868     {
3869       Elf_Internal_Dyn dyn;
3870       const char *name;
3871       bfd_boolean size;
3872
3873       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3874
3875       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3876         {
3877           /* On VxWorks, DT_RELASZ should not include the relocations
3878              in .rela.plt.  */
3879           if (htab->srelplt)
3880             {
3881               dyn.d_un.d_val -= htab->srelplt->size;
3882               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3883             }
3884         }
3885       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3886         {
3887           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3888              not to the start of the PLT.  */
3889           if (htab->sgotplt)
3890             {
3891               dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3892                                 + htab->sgotplt->output_offset);
3893               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3894             }
3895         }
3896       else
3897         {
3898           switch (dyn.d_tag)
3899             {
3900             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3901             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3902             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3903             default:      name = NULL; size = FALSE; break;
3904             }
3905
3906           if (name != NULL)
3907             {
3908               asection *s;
3909
3910               s = bfd_get_section_by_name (output_bfd, name);
3911               if (s == NULL)
3912                 dyn.d_un.d_val = 0;
3913               else
3914                 {
3915                   if (! size)
3916                     dyn.d_un.d_ptr = s->vma;
3917                   else
3918                     dyn.d_un.d_val = s->size;
3919                 }
3920               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3921             }
3922         }
3923     }
3924   return TRUE;
3925 }
3926
3927 /* Install the first PLT entry in a VxWorks executable and make sure that
3928    .rela.plt.unloaded relocations have the correct symbol indexes.  */
3929
3930 static void
3931 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3932 {
3933   struct _bfd_sparc_elf_link_hash_table *htab;
3934   Elf_Internal_Rela rela;
3935   bfd_vma got_base;
3936   bfd_byte *loc;
3937
3938   htab = _bfd_sparc_elf_hash_table (info);
3939
3940   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
3941   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3942               + htab->elf.hgot->root.u.def.section->output_offset
3943               + htab->elf.hgot->root.u.def.value);
3944
3945   /* Install the initial PLT entry.  */
3946   bfd_put_32 (output_bfd,
3947               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3948               htab->splt->contents);
3949   bfd_put_32 (output_bfd,
3950               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3951               htab->splt->contents + 4);
3952   bfd_put_32 (output_bfd,
3953               sparc_vxworks_exec_plt0_entry[2],
3954               htab->splt->contents + 8);
3955   bfd_put_32 (output_bfd,
3956               sparc_vxworks_exec_plt0_entry[3],
3957               htab->splt->contents + 12);
3958   bfd_put_32 (output_bfd,
3959               sparc_vxworks_exec_plt0_entry[4],
3960               htab->splt->contents + 16);
3961
3962   loc = htab->srelplt2->contents;
3963
3964   /* Add an unloaded relocation for the initial entry's "sethi".  */
3965   rela.r_offset = (htab->splt->output_section->vma
3966                    + htab->splt->output_offset);
3967   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3968   rela.r_addend = 8;
3969   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3970   loc += sizeof (Elf32_External_Rela);
3971
3972   /* Likewise the following "or".  */
3973   rela.r_offset += 4;
3974   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3975   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3976   loc += sizeof (Elf32_External_Rela);
3977
3978   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
3979      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
3980      in which symbols were output.  */
3981   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
3982     {
3983       Elf_Internal_Rela rel;
3984
3985       /* The entry's initial "sethi" (against _G_O_T_).  */
3986       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
3987       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3988       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3989       loc += sizeof (Elf32_External_Rela);
3990
3991       /* The following "or" (also against _G_O_T_).  */
3992       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
3993       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3994       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3995       loc += sizeof (Elf32_External_Rela);
3996
3997       /* The .got.plt entry (against _P_L_T_).  */
3998       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
3999       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4000       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4001       loc += sizeof (Elf32_External_Rela);
4002     }
4003 }
4004
4005 /* Install the first PLT entry in a VxWorks shared object.  */
4006
4007 static void
4008 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4009 {
4010   struct _bfd_sparc_elf_link_hash_table *htab;
4011   unsigned int i;
4012
4013   htab = _bfd_sparc_elf_hash_table (info);
4014   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4015     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4016                 htab->splt->contents + i * 4);
4017 }
4018
4019 bfd_boolean
4020 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4021 {
4022   bfd *dynobj;
4023   asection *sdyn;
4024   struct _bfd_sparc_elf_link_hash_table *htab;
4025
4026   htab = _bfd_sparc_elf_hash_table (info);
4027   dynobj = htab->elf.dynobj;
4028
4029   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4030
4031   if (elf_hash_table (info)->dynamic_sections_created)
4032     {
4033       asection *splt;
4034       bfd_boolean ret;
4035
4036       splt = bfd_get_section_by_name (dynobj, ".plt");
4037       BFD_ASSERT (splt != NULL && sdyn != NULL);
4038
4039 #ifdef BFD64
4040       if (ABI_64_P (output_bfd))
4041         ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4042       else
4043 #endif
4044         ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4045
4046       if (ret != TRUE)
4047         return ret;
4048
4049       /* Initialize the contents of the .plt section.  */
4050       if (splt->size > 0)
4051         {
4052           if (htab->is_vxworks)
4053             {
4054               if (info->shared)
4055                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4056               else
4057                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4058             }
4059           else
4060             {
4061               memset (splt->contents, 0, htab->plt_header_size);
4062               if (!ABI_64_P (output_bfd))
4063                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4064                             splt->contents + splt->size - 4);
4065             }
4066         }
4067
4068       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4069         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4070           ? 0 : htab->plt_entry_size;
4071     }
4072
4073   /* Set the first entry in the global offset table to the address of
4074      the dynamic section.  */
4075   if (htab->sgot && htab->sgot->size > 0)
4076     {
4077       bfd_vma val = (sdyn ?
4078                      sdyn->output_section->vma + sdyn->output_offset :
4079                      0);
4080
4081       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4082     }
4083
4084   if (htab->sgot)
4085     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4086       SPARC_ELF_WORD_BYTES (htab);
4087
4088   return TRUE;
4089 }
4090
4091 \f
4092 /* Set the right machine number for a SPARC ELF file.  */
4093
4094 bfd_boolean
4095 _bfd_sparc_elf_object_p (bfd *abfd)
4096 {
4097   if (ABI_64_P (abfd))
4098     {
4099       unsigned long mach = bfd_mach_sparc_v9;
4100
4101       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4102         mach = bfd_mach_sparc_v9b;
4103       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4104         mach = bfd_mach_sparc_v9a;
4105       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4106     }
4107   else
4108     {
4109       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4110         {
4111           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4112             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4113                                               bfd_mach_sparc_v8plusb);
4114           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4115             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4116                                               bfd_mach_sparc_v8plusa);
4117           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4118             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4119                                               bfd_mach_sparc_v8plus);
4120           else
4121             return FALSE;
4122         }
4123       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4124         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4125                                           bfd_mach_sparc_sparclite_le);
4126       else
4127         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4128     }
4129 }
4130
4131 /* Return address for Ith PLT stub in section PLT, for relocation REL
4132    or (bfd_vma) -1 if it should not be included.  */
4133
4134 bfd_vma
4135 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4136 {
4137   if (ABI_64_P (plt->owner))
4138     {
4139       bfd_vma j;
4140
4141       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4142       if (i < PLT64_LARGE_THRESHOLD)
4143         return plt->vma + i * PLT64_ENTRY_SIZE;
4144
4145       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4146       i -= j;
4147       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4148     }
4149   else
4150     return rel->address;
4151 }