bfd/elfxx-sparc.c

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