bfd/elfxx-sparc.c

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