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