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