bfd/elfxx-sparc.c

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