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 (const struct elf_backend_data *bed,
 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           if (ind->root.type == bfd_link_hash_indirect)
 901             abort ();
 902
 903           /* Add reloc counts against the weak sym to the strong sym
 904              list.  Merge any entries against the same section.  */
 905           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 906             {
 907               struct _bfd_sparc_elf_dyn_relocs *q;
 908
 909               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 910                 if (q->sec == p->sec)
 911                   {
 912                     q->pc_count += p->pc_count;
 913                     q->count += p->count;
 914                     *pp = p->next;
 915                     break;
 916                   }
 917               if (q == NULL)
 918                 pp = &p->next;
 919             }
 920           *pp = edir->dyn_relocs;
 921         }
 922
 923       edir->dyn_relocs = eind->dyn_relocs;
 924       eind->dyn_relocs = NULL;
 925     }
 926
 927   if (ind->root.type == bfd_link_hash_indirect
 928       && dir->got.refcount <= 0)
 929     {
 930       edir->tls_type = eind->tls_type;
 931       eind->tls_type = GOT_UNKNOWN;
 932     }
 933   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 934 }
 935
 936 static int
 937 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
 938                           int r_type, int is_local)
 939 {
 940   if (! ABI_64_P (abfd)
 941       && r_type == R_SPARC_TLS_GD_HI22
 942       && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
 943     r_type = R_SPARC_REV32;
 944
 945   if (info->shared)
 946     return r_type;
 947
 948   switch (r_type)
 949     {
 950     case R_SPARC_TLS_GD_HI22:
 951       if (is_local)
 952         return R_SPARC_TLS_LE_HIX22;
 953       return R_SPARC_TLS_IE_HI22;
 954     case R_SPARC_TLS_GD_LO10:
 955       if (is_local)
 956         return R_SPARC_TLS_LE_LOX10;
 957       return R_SPARC_TLS_IE_LO10;
 958     case R_SPARC_TLS_IE_HI22:
 959       if (is_local)
 960         return R_SPARC_TLS_LE_HIX22;
 961       return r_type;
 962     case R_SPARC_TLS_IE_LO10:
 963       if (is_local)
 964         return R_SPARC_TLS_LE_LOX10;
 965       return r_type;
 966     case R_SPARC_TLS_LDM_HI22:
 967       return R_SPARC_TLS_LE_HIX22;
 968     case R_SPARC_TLS_LDM_LO10:
 969       return R_SPARC_TLS_LE_LOX10;
 970     }
 971
 972   return r_type;
 973 }
 974 \f
 975 /* Look through the relocs for a section during the first phase, and
 976    allocate space in the global offset table or procedure linkage
 977    table.  */
 978
 979 bfd_boolean
 980 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
 981                              asection *sec, const Elf_Internal_Rela *relocs)
 982 {
 983   struct _bfd_sparc_elf_link_hash_table *htab;
 984   Elf_Internal_Shdr *symtab_hdr;
 985   struct elf_link_hash_entry **sym_hashes;
 986   bfd_vma *local_got_offsets;
 987   const Elf_Internal_Rela *rel;
 988   const Elf_Internal_Rela *rel_end;
 989   asection *sreloc;
 990   int num_relocs;
 991   bfd_boolean checked_tlsgd = FALSE;
 992
 993   if (info->relocatable)
 994     return TRUE;
 995
 996   htab = _bfd_sparc_elf_hash_table (info);
 997   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 998   sym_hashes = elf_sym_hashes (abfd);
 999   local_got_offsets = elf_local_got_offsets (abfd);
1000
1001   sreloc = NULL;
1002
1003   if (ABI_64_P (abfd))
1004     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1005   else
1006     num_relocs = sec->reloc_count;
1007   rel_end = relocs + num_relocs;
1008   for (rel = relocs; rel < rel_end; rel++)
1009     {
1010       unsigned int r_type;
1011       unsigned long r_symndx;
1012       struct elf_link_hash_entry *h;
1013
1014       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1015       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1016
1017       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1018         {
1019           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1020                                  abfd, r_symndx);
1021           return FALSE;
1022         }
1023
1024       if (r_symndx < symtab_hdr->sh_info)
1025         h = NULL;
1026       else
1027         {
1028           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1029           while (h->root.type == bfd_link_hash_indirect
1030                  || h->root.type == bfd_link_hash_warning)
1031             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1032         }
1033
1034       /* Compatibility with old R_SPARC_REV32 reloc conflicting
1035          with R_SPARC_TLS_GD_HI22.  */
1036       if (! ABI_64_P (abfd) && ! checked_tlsgd)
1037         switch (r_type)
1038           {
1039           case R_SPARC_TLS_GD_HI22:
1040             {
1041               const Elf_Internal_Rela *relt;
1042
1043               for (relt = rel + 1; relt < rel_end; relt++)
1044                 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1045                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1046                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1047                   break;
1048               checked_tlsgd = TRUE;
1049               _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1050             }
1051             break;
1052           case R_SPARC_TLS_GD_LO10:
1053           case R_SPARC_TLS_GD_ADD:
1054           case R_SPARC_TLS_GD_CALL:
1055             checked_tlsgd = TRUE;
1056             _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1057             break;
1058           }
1059
1060       r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1061       switch (r_type)
1062         {
1063         case R_SPARC_TLS_LDM_HI22:
1064         case R_SPARC_TLS_LDM_LO10:
1065           htab->tls_ldm_got.refcount += 1;
1066           break;
1067
1068         case R_SPARC_TLS_LE_HIX22:
1069         case R_SPARC_TLS_LE_LOX10:
1070           if (info->shared)
1071             goto r_sparc_plt32;
1072           break;
1073
1074         case R_SPARC_TLS_IE_HI22:
1075         case R_SPARC_TLS_IE_LO10:
1076           if (info->shared)
1077             info->flags |= DF_STATIC_TLS;
1078           /* Fall through */
1079
1080         case R_SPARC_GOT10:
1081         case R_SPARC_GOT13:
1082         case R_SPARC_GOT22:
1083         case R_SPARC_TLS_GD_HI22:
1084         case R_SPARC_TLS_GD_LO10:
1085           /* This symbol requires a global offset table entry.  */
1086           {
1087             int tls_type, old_tls_type;
1088
1089             switch (r_type)
1090               {
1091               default:
1092               case R_SPARC_GOT10:
1093               case R_SPARC_GOT13:
1094               case R_SPARC_GOT22:
1095                 tls_type = GOT_NORMAL;
1096                 break;
1097               case R_SPARC_TLS_GD_HI22:
1098               case R_SPARC_TLS_GD_LO10:
1099                 tls_type = GOT_TLS_GD;
1100                 break;
1101               case R_SPARC_TLS_IE_HI22:
1102               case R_SPARC_TLS_IE_LO10:
1103                 tls_type = GOT_TLS_IE;
1104                 break;
1105               }
1106
1107             if (h != NULL)
1108               {
1109                 h->got.refcount += 1;
1110                 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1111               }
1112             else
1113               {
1114                 bfd_signed_vma *local_got_refcounts;
1115
1116                 /* This is a global offset table entry for a local symbol.  */
1117                 local_got_refcounts = elf_local_got_refcounts (abfd);
1118                 if (local_got_refcounts == NULL)
1119                   {
1120                     bfd_size_type size;
1121
1122                     size = symtab_hdr->sh_info;
1123                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
1124                     local_got_refcounts = ((bfd_signed_vma *)
1125                                            bfd_zalloc (abfd, size));
1126                     if (local_got_refcounts == NULL)
1127                       return FALSE;
1128                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1129                     _bfd_sparc_elf_local_got_tls_type (abfd)
1130                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1131                   }
1132                 local_got_refcounts[r_symndx] += 1;
1133                 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1134               }
1135
1136             /* If a TLS symbol is accessed using IE at least once,
1137                there is no point to use dynamic model for it.  */
1138             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1139                 && (old_tls_type != GOT_TLS_GD
1140                     || tls_type != GOT_TLS_IE))
1141               {
1142                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1143                   tls_type = old_tls_type;
1144                 else
1145                   {
1146                     (*_bfd_error_handler)
1147                       (_("%B: `%s' accessed both as normal and thread local symbol"),
1148                        abfd, h ? h->root.root.string : "<local>");
1149                     return FALSE;
1150                   }
1151               }
1152
1153             if (old_tls_type != tls_type)
1154               {
1155                 if (h != NULL)
1156                   _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1157                 else
1158                   _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1159               }
1160           }
1161
1162           if (htab->sgot == NULL)
1163             {
1164               if (htab->elf.dynobj == NULL)
1165                 htab->elf.dynobj = abfd;
1166               if (!create_got_section (htab->elf.dynobj, info))
1167                 return FALSE;
1168             }
1169           break;
1170
1171         case R_SPARC_TLS_GD_CALL:
1172         case R_SPARC_TLS_LDM_CALL:
1173           if (info->shared)
1174             {
1175               /* These are basically R_SPARC_TLS_WPLT30 relocs against
1176                  __tls_get_addr.  */
1177               struct bfd_link_hash_entry *bh = NULL;
1178               if (! _bfd_generic_link_add_one_symbol (info, abfd,
1179                                                       "__tls_get_addr", 0,
1180                                                       bfd_und_section_ptr, 0,
1181                                                       NULL, FALSE, FALSE,
1182                                                       &bh))
1183                 return FALSE;
1184               h = (struct elf_link_hash_entry *) bh;
1185             }
1186           else
1187             break;
1188           /* Fall through */
1189
1190         case R_SPARC_PLT32:
1191         case R_SPARC_WPLT30:
1192         case R_SPARC_HIPLT22:
1193         case R_SPARC_LOPLT10:
1194         case R_SPARC_PCPLT32:
1195         case R_SPARC_PCPLT22:
1196         case R_SPARC_PCPLT10:
1197         case R_SPARC_PLT64:
1198           /* This symbol requires a procedure linkage table entry.  We
1199              actually build the entry in adjust_dynamic_symbol,
1200              because this might be a case of linking PIC code without
1201              linking in any dynamic objects, in which case we don't
1202              need to generate a procedure linkage table after all.  */
1203
1204           if (h == NULL)
1205             {
1206               if (! ABI_64_P (abfd))
1207                 {
1208                   /* The Solaris native assembler will generate a WPLT30
1209                      reloc for a local symbol if you assemble a call from
1210                      one section to another when using -K pic.  We treat
1211                      it as WDISP30.  */
1212                   if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1213                     goto r_sparc_plt32;
1214                   break;
1215                 }
1216
1217               /* It does not make sense to have a procedure linkage
1218                  table entry for a local symbol.  */
1219               bfd_set_error (bfd_error_bad_value);
1220               return FALSE;
1221             }
1222
1223           h->needs_plt = 1;
1224
1225           {
1226             int this_r_type;
1227
1228             this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1229             if (this_r_type == R_SPARC_PLT32
1230                 || this_r_type == R_SPARC_PLT64)
1231               goto r_sparc_plt32;
1232           }
1233           h->plt.refcount += 1;
1234           break;
1235
1236         case R_SPARC_PC10:
1237         case R_SPARC_PC22:
1238         case R_SPARC_PC_HH22:
1239         case R_SPARC_PC_HM10:
1240         case R_SPARC_PC_LM22:
1241           if (h != NULL)
1242             h->non_got_ref = 1;
1243
1244           if (h != NULL
1245               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1246             break;
1247           /* Fall through.  */
1248
1249         case R_SPARC_DISP8:
1250         case R_SPARC_DISP16:
1251         case R_SPARC_DISP32:
1252         case R_SPARC_DISP64:
1253         case R_SPARC_WDISP30:
1254         case R_SPARC_WDISP22:
1255         case R_SPARC_WDISP19:
1256         case R_SPARC_WDISP16:
1257         case R_SPARC_8:
1258         case R_SPARC_16:
1259         case R_SPARC_32:
1260         case R_SPARC_HI22:
1261         case R_SPARC_22:
1262         case R_SPARC_13:
1263         case R_SPARC_LO10:
1264         case R_SPARC_UA16:
1265         case R_SPARC_UA32:
1266         case R_SPARC_10:
1267         case R_SPARC_11:
1268         case R_SPARC_64:
1269         case R_SPARC_OLO10:
1270         case R_SPARC_HH22:
1271         case R_SPARC_HM10:
1272         case R_SPARC_LM22:
1273         case R_SPARC_7:
1274         case R_SPARC_5:
1275         case R_SPARC_6:
1276         case R_SPARC_HIX22:
1277         case R_SPARC_LOX10:
1278         case R_SPARC_H44:
1279         case R_SPARC_M44:
1280         case R_SPARC_L44:
1281         case R_SPARC_UA64:
1282           if (h != NULL)
1283             h->non_got_ref = 1;
1284
1285         r_sparc_plt32:
1286           if (h != NULL && !info->shared)
1287             {
1288               /* We may need a .plt entry if the function this reloc
1289                  refers to is in a shared lib.  */
1290               h->plt.refcount += 1;
1291             }
1292
1293           /* If we are creating a shared library, and this is a reloc
1294              against a global symbol, or a non PC relative reloc
1295              against a local symbol, then we need to copy the reloc
1296              into the shared library.  However, if we are linking with
1297              -Bsymbolic, we do not need to copy a reloc against a
1298              global symbol which is defined in an object we are
1299              including in the link (i.e., DEF_REGULAR is set).  At
1300              this point we have not seen all the input files, so it is
1301              possible that DEF_REGULAR is not set now but will be set
1302              later (it is never cleared).  In case of a weak definition,
1303              DEF_REGULAR may be cleared later by a strong definition in
1304              a shared library.  We account for that possibility below by
1305              storing information in the relocs_copied field of the hash
1306              table entry.  A similar situation occurs when creating
1307              shared libraries and symbol visibility changes render the
1308              symbol local.
1309
1310              If on the other hand, we are creating an executable, we
1311              may need to keep relocations for symbols satisfied by a
1312              dynamic library if we manage to avoid copy relocs for the
1313              symbol.  */
1314           if ((info->shared
1315                && (sec->flags & SEC_ALLOC) != 0
1316                && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1317                    || (h != NULL
1318                        && (! info->symbolic
1319                            || h->root.type == bfd_link_hash_defweak
1320                            || !h->def_regular))))
1321               || (!info->shared
1322                   && (sec->flags & SEC_ALLOC) != 0
1323                   && h != NULL
1324                   && (h->root.type == bfd_link_hash_defweak
1325                       || !h->def_regular)))
1326             {
1327               struct _bfd_sparc_elf_dyn_relocs *p;
1328               struct _bfd_sparc_elf_dyn_relocs **head;
1329
1330               /* When creating a shared object, we must copy these
1331                  relocs into the output file.  We create a reloc
1332                  section in dynobj and make room for the reloc.  */
1333               if (sreloc == NULL)
1334                 {
1335                   const char *name;
1336                   bfd *dynobj;
1337
1338                   name = (bfd_elf_string_from_elf_section
1339                           (abfd,
1340                            elf_elfheader (abfd)->e_shstrndx,
1341                            elf_section_data (sec)->rel_hdr.sh_name));
1342                   if (name == NULL)
1343                     return FALSE;
1344
1345                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1346                               && strcmp (bfd_get_section_name (abfd, sec),
1347                                          name + 5) == 0);
1348
1349                   if (htab->elf.dynobj == NULL)
1350                     htab->elf.dynobj = abfd;
1351                   dynobj = htab->elf.dynobj;
1352
1353                   sreloc = bfd_get_section_by_name (dynobj, name);
1354                   if (sreloc == NULL)
1355                     {
1356                       flagword flags;
1357
1358                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1359                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1360                       if ((sec->flags & SEC_ALLOC) != 0)
1361                         flags |= SEC_ALLOC | SEC_LOAD;
1362                       sreloc = bfd_make_section_with_flags (dynobj,
1363                                                             name,
1364                                                             flags);
1365                       if (sreloc == NULL
1366                           || ! bfd_set_section_alignment (dynobj, sreloc,
1367                                                           htab->word_align_power))
1368                         return FALSE;
1369                     }
1370                   elf_section_data (sec)->sreloc = sreloc;
1371                 }
1372
1373               /* If this is a global symbol, we count the number of
1374                  relocations we need for this symbol.  */
1375               if (h != NULL)
1376                 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1377               else
1378                 {
1379                   /* Track dynamic relocs needed for local syms too.
1380                      We really need local syms available to do this
1381                      easily.  Oh well.  */
1382
1383                   asection *s;
1384                   void *vpp;
1385
1386                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1387                                                  sec, r_symndx);
1388                   if (s == NULL)
1389                     return FALSE;
1390
1391                   vpp = &elf_section_data (s)->local_dynrel;
1392                   head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1393                 }
1394
1395               p = *head;
1396               if (p == NULL || p->sec != sec)
1397                 {
1398                   bfd_size_type amt = sizeof *p;
1399                   p = ((struct _bfd_sparc_elf_dyn_relocs *)
1400                        bfd_alloc (htab->elf.dynobj, amt));
1401                   if (p == NULL)
1402                     return FALSE;
1403                   p->next = *head;
1404                   *head = p;
1405                   p->sec = sec;
1406                   p->count = 0;
1407                   p->pc_count = 0;
1408                 }
1409
1410               p->count += 1;
1411               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1412                 p->pc_count += 1;
1413             }
1414
1415           break;
1416
1417         case R_SPARC_GNU_VTINHERIT:
1418           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1419             return FALSE;
1420           break;
1421
1422         case R_SPARC_GNU_VTENTRY:
1423           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1424             return FALSE;
1425           break;
1426
1427         case R_SPARC_REGISTER:
1428           /* Nothing to do.  */
1429           break;
1430
1431         default:
1432           break;
1433         }
1434     }
1435
1436   return TRUE;
1437 }
1438 \f
1439 asection *
1440 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1441                              struct bfd_link_info *info,
1442                              Elf_Internal_Rela *rel,
1443                              struct elf_link_hash_entry *h,
1444                              Elf_Internal_Sym *sym)
1445 {
1446   if (h != NULL)
1447     {
1448       struct _bfd_sparc_elf_link_hash_table *htab;
1449
1450       htab = _bfd_sparc_elf_hash_table (info);
1451       switch (SPARC_ELF_R_TYPE (rel->r_info))
1452       {
1453       case R_SPARC_GNU_VTINHERIT:
1454       case R_SPARC_GNU_VTENTRY:
1455         break;
1456
1457       default:
1458         switch (h->root.type)
1459           {
1460           case bfd_link_hash_defined:
1461           case bfd_link_hash_defweak:
1462             return h->root.u.def.section;
1463
1464           case bfd_link_hash_common:
1465             return h->root.u.c.p->section;
1466
1467           default:
1468             break;
1469           }
1470       }
1471     }
1472   else
1473     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1474
1475   return NULL;
1476 }
1477
1478 /* Update the got entry reference counts for the section being removed.  */
1479 bfd_boolean
1480 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1481                               asection *sec, const Elf_Internal_Rela *relocs)
1482 {
1483   struct _bfd_sparc_elf_link_hash_table *htab;
1484   Elf_Internal_Shdr *symtab_hdr;
1485   struct elf_link_hash_entry **sym_hashes;
1486   bfd_signed_vma *local_got_refcounts;
1487   const Elf_Internal_Rela *rel, *relend;
1488
1489   elf_section_data (sec)->local_dynrel = NULL;
1490
1491   htab = _bfd_sparc_elf_hash_table (info);
1492   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1493   sym_hashes = elf_sym_hashes (abfd);
1494   local_got_refcounts = elf_local_got_refcounts (abfd);
1495
1496   relend = relocs + sec->reloc_count;
1497   for (rel = relocs; rel < relend; rel++)
1498     {
1499       unsigned long r_symndx;
1500       unsigned int r_type;
1501       struct elf_link_hash_entry *h = NULL;
1502
1503       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1504       if (r_symndx >= symtab_hdr->sh_info)
1505         {
1506           struct _bfd_sparc_elf_link_hash_entry *eh;
1507           struct _bfd_sparc_elf_dyn_relocs **pp;
1508           struct _bfd_sparc_elf_dyn_relocs *p;
1509
1510           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1511           while (h->root.type == bfd_link_hash_indirect
1512                  || h->root.type == bfd_link_hash_warning)
1513             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1514           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1515           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1516             if (p->sec == sec)
1517               {
1518                 /* Everything must go for SEC.  */
1519                 *pp = p->next;
1520                 break;
1521               }
1522         }
1523
1524       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1525       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1526       switch (r_type)
1527         {
1528         case R_SPARC_TLS_LDM_HI22:
1529         case R_SPARC_TLS_LDM_LO10:
1530           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1531             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1532           break;
1533
1534         case R_SPARC_TLS_GD_HI22:
1535         case R_SPARC_TLS_GD_LO10:
1536         case R_SPARC_TLS_IE_HI22:
1537         case R_SPARC_TLS_IE_LO10:
1538         case R_SPARC_GOT10:
1539         case R_SPARC_GOT13:
1540         case R_SPARC_GOT22:
1541           if (h != NULL)
1542             {
1543               if (h->got.refcount > 0)
1544                 h->got.refcount--;
1545             }
1546           else
1547             {
1548               if (local_got_refcounts[r_symndx] > 0)
1549                 local_got_refcounts[r_symndx]--;
1550             }
1551           break;
1552
1553         case R_SPARC_PC10:
1554         case R_SPARC_PC22:
1555         case R_SPARC_PC_HH22:
1556         case R_SPARC_PC_HM10:
1557         case R_SPARC_PC_LM22:
1558           if (h != NULL
1559               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1560             break;
1561           /* Fall through.  */
1562
1563         case R_SPARC_DISP8:
1564         case R_SPARC_DISP16:
1565         case R_SPARC_DISP32:
1566         case R_SPARC_DISP64:
1567         case R_SPARC_WDISP30:
1568         case R_SPARC_WDISP22:
1569         case R_SPARC_WDISP19:
1570         case R_SPARC_WDISP16:
1571         case R_SPARC_8:
1572         case R_SPARC_16:
1573         case R_SPARC_32:
1574         case R_SPARC_HI22:
1575         case R_SPARC_22:
1576         case R_SPARC_13:
1577         case R_SPARC_LO10:
1578         case R_SPARC_UA16:
1579         case R_SPARC_UA32:
1580         case R_SPARC_PLT32:
1581         case R_SPARC_10:
1582         case R_SPARC_11:
1583         case R_SPARC_64:
1584         case R_SPARC_OLO10:
1585         case R_SPARC_HH22:
1586         case R_SPARC_HM10:
1587         case R_SPARC_LM22:
1588         case R_SPARC_7:
1589         case R_SPARC_5:
1590         case R_SPARC_6:
1591         case R_SPARC_HIX22:
1592         case R_SPARC_LOX10:
1593         case R_SPARC_H44:
1594         case R_SPARC_M44:
1595         case R_SPARC_L44:
1596         case R_SPARC_UA64:
1597           if (info->shared)
1598             break;
1599           /* Fall through.  */
1600
1601         case R_SPARC_WPLT30:
1602           if (h != NULL)
1603             {
1604               if (h->plt.refcount > 0)
1605                 h->plt.refcount--;
1606             }
1607           break;
1608
1609         default:
1610           break;
1611         }
1612     }
1613
1614   return TRUE;
1615 }
1616
1617 /* Adjust a symbol defined by a dynamic object and referenced by a
1618    regular object.  The current definition is in some section of the
1619    dynamic object, but we're not including those sections.  We have to
1620    change the definition to something the rest of the link can
1621    understand.  */
1622
1623 bfd_boolean
1624 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1625                                      struct elf_link_hash_entry *h)
1626 {
1627   struct _bfd_sparc_elf_link_hash_table *htab;
1628   struct _bfd_sparc_elf_link_hash_entry * eh;
1629   struct _bfd_sparc_elf_dyn_relocs *p;
1630   asection *s;
1631   unsigned int power_of_two;
1632
1633   htab = _bfd_sparc_elf_hash_table (info);
1634
1635   /* Make sure we know what is going on here.  */
1636   BFD_ASSERT (htab->elf.dynobj != NULL
1637               && (h->needs_plt
1638                   || h->u.weakdef != NULL
1639                   || (h->def_dynamic
1640                       && h->ref_regular
1641                       && !h->def_regular)));
1642
1643   /* If this is a function, put it in the procedure linkage table.  We
1644      will fill in the contents of the procedure linkage table later
1645      (although we could actually do it here).  The STT_NOTYPE
1646      condition is a hack specifically for the Oracle libraries
1647      delivered for Solaris; for some inexplicable reason, they define
1648      some of their functions as STT_NOTYPE when they really should be
1649      STT_FUNC.  */
1650   if (h->type == STT_FUNC
1651       || h->needs_plt
1652       || (h->type == STT_NOTYPE
1653           && (h->root.type == bfd_link_hash_defined
1654               || h->root.type == bfd_link_hash_defweak)
1655           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1656     {
1657       if (h->plt.refcount <= 0
1658           || (! info->shared
1659               && !h->def_dynamic
1660               && !h->ref_dynamic
1661               && h->root.type != bfd_link_hash_undefweak
1662               && h->root.type != bfd_link_hash_undefined))
1663         {
1664           /* This case can occur if we saw a WPLT30 reloc in an input
1665              file, but the symbol was never referred to by a dynamic
1666              object, or if all references were garbage collected.  In
1667              such a case, we don't actually need to build a procedure
1668              linkage table, and we can just do a WDISP30 reloc instead.  */
1669           h->plt.offset = (bfd_vma) -1;
1670           h->needs_plt = 0;
1671         }
1672
1673       return TRUE;
1674     }
1675   else
1676     h->plt.offset = (bfd_vma) -1;
1677
1678   /* If this is a weak symbol, and there is a real definition, the
1679      processor independent code will have arranged for us to see the
1680      real definition first, and we can just use the same value.  */
1681   if (h->u.weakdef != NULL)
1682     {
1683       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1684                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1685       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1686       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1687       return TRUE;
1688     }
1689
1690   /* This is a reference to a symbol defined by a dynamic object which
1691      is not a function.  */
1692
1693   /* If we are creating a shared library, we must presume that the
1694      only references to the symbol are via the global offset table.
1695      For such cases we need not do anything here; the relocations will
1696      be handled correctly by relocate_section.  */
1697   if (info->shared)
1698     return TRUE;
1699
1700   /* If there are no references to this symbol that do not use the
1701      GOT, we don't need to generate a copy reloc.  */
1702   if (!h->non_got_ref)
1703     return TRUE;
1704
1705   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1706   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1707     {
1708       s = p->sec->output_section;
1709       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1710         break;
1711     }
1712
1713   /* If we didn't find any dynamic relocs in read-only sections, then
1714      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1715   if (p == NULL)
1716     {
1717       h->non_got_ref = 0;
1718       return TRUE;
1719     }
1720
1721   if (h->size == 0)
1722     {
1723       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1724                              h->root.root.string);
1725       return TRUE;
1726     }
1727
1728   /* We must allocate the symbol in our .dynbss section, which will
1729      become part of the .bss section of the executable.  There will be
1730      an entry for this symbol in the .dynsym section.  The dynamic
1731      object will contain position independent code, so all references
1732      from the dynamic object to this symbol will go through the global
1733      offset table.  The dynamic linker will use the .dynsym entry to
1734      determine the address it must put in the global offset table, so
1735      both the dynamic object and the regular object will refer to the
1736      same memory location for the variable.  */
1737
1738   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1739      to copy the initial value out of the dynamic object and into the
1740      runtime process image.  We need to remember the offset into the
1741      .rel.bss section we are going to use.  */
1742   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1743     {
1744       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1745       h->needs_copy = 1;
1746     }
1747
1748   /* We need to figure out the alignment required for this symbol.  I
1749      have no idea how ELF linkers handle this.  */
1750   power_of_two = bfd_log2 (h->size);
1751   if (power_of_two > htab->align_power_max)
1752     power_of_two = htab->align_power_max;
1753
1754   /* Apply the required alignment.  */
1755   s = htab->sdynbss;
1756   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1757   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1758     {
1759       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1760         return FALSE;
1761     }
1762
1763   /* Define the symbol as being at this point in the section.  */
1764   h->root.u.def.section = s;
1765   h->root.u.def.value = s->size;
1766
1767   /* Increment the section size to make room for the symbol.  */
1768   s->size += h->size;
1769
1770   return TRUE;
1771 }
1772
1773 /* Allocate space in .plt, .got and associated reloc sections for
1774    dynamic relocs.  */
1775
1776 static bfd_boolean
1777 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1778 {
1779   struct bfd_link_info *info;
1780   struct _bfd_sparc_elf_link_hash_table *htab;
1781   struct _bfd_sparc_elf_link_hash_entry *eh;
1782   struct _bfd_sparc_elf_dyn_relocs *p;
1783
1784   if (h->root.type == bfd_link_hash_indirect)
1785     return TRUE;
1786
1787   if (h->root.type == bfd_link_hash_warning)
1788     /* When warning symbols are created, they **replace** the "real"
1789        entry in the hash table, thus we never get to see the real
1790        symbol in a hash traversal.  So look at it now.  */
1791     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1792
1793   info = (struct bfd_link_info *) inf;
1794   htab = _bfd_sparc_elf_hash_table (info);
1795
1796   if (htab->elf.dynamic_sections_created
1797       && h->plt.refcount > 0)
1798     {
1799       /* Make sure this symbol is output as a dynamic symbol.
1800          Undefined weak syms won't yet be marked as dynamic.  */
1801       if (h->dynindx == -1
1802           && !h->forced_local)
1803         {
1804           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1805             return FALSE;
1806         }
1807
1808       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1809         {
1810           asection *s = htab->splt;
1811
1812           /* The first four entries in .plt is reserved.  */
1813           if (s->size == 0)
1814             s->size = (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1815                        PLT64_HEADER_SIZE : PLT32_HEADER_SIZE);
1816
1817           /* The procedure linkage table size is bounded by the magnitude
1818              of the offset we can describe in the entry.  */
1819           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1820                           (((bfd_vma)1 << 31) << 1) : 0x400000))
1821             {
1822               bfd_set_error (bfd_error_bad_value);
1823               return FALSE;
1824             }
1825
1826           if (SPARC_ELF_WORD_BYTES(htab) == 8
1827               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1828             {
1829               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1830
1831
1832               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1833
1834               h->plt.offset = (s->size - (off * 8));
1835             }
1836           else
1837             h->plt.offset = s->size;
1838
1839           /* If this symbol is not defined in a regular file, and we are
1840              not generating a shared library, then set the symbol to this
1841              location in the .plt.  This is required to make function
1842              pointers compare as equal between the normal executable and
1843              the shared library.  */
1844           if (! info->shared
1845               && !h->def_regular)
1846             {
1847               h->root.u.def.section = s;
1848               h->root.u.def.value = h->plt.offset;
1849             }
1850
1851           /* Make room for this entry.  */
1852           s->size += (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1853                       PLT64_ENTRY_SIZE : PLT32_ENTRY_SIZE);
1854
1855           /* We also need to make an entry in the .rela.plt section.  */
1856           htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1857         }
1858       else
1859         {
1860           h->plt.offset = (bfd_vma) -1;
1861           h->needs_plt = 0;
1862         }
1863     }
1864   else
1865     {
1866       h->plt.offset = (bfd_vma) -1;
1867       h->needs_plt = 0;
1868     }
1869
1870   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1871      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1872   if (h->got.refcount > 0
1873       && !info->shared
1874       && h->dynindx == -1
1875       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1876     h->got.offset = (bfd_vma) -1;
1877   else if (h->got.refcount > 0)
1878     {
1879       asection *s;
1880       bfd_boolean dyn;
1881       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1882
1883       /* Make sure this symbol is output as a dynamic symbol.
1884          Undefined weak syms won't yet be marked as dynamic.  */
1885       if (h->dynindx == -1
1886           && !h->forced_local)
1887         {
1888           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1889             return FALSE;
1890         }
1891
1892       s = htab->sgot;
1893       h->got.offset = s->size;
1894       s->size += SPARC_ELF_WORD_BYTES (htab);
1895       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1896       if (tls_type == GOT_TLS_GD)
1897         s->size += SPARC_ELF_WORD_BYTES (htab);
1898       dyn = htab->elf.dynamic_sections_created;
1899       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1900          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1901          global.  */
1902       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1903           || tls_type == GOT_TLS_IE)
1904         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1905       else if (tls_type == GOT_TLS_GD)
1906         htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
1907       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1908         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1909     }
1910   else
1911     h->got.offset = (bfd_vma) -1;
1912
1913   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1914   if (eh->dyn_relocs == NULL)
1915     return TRUE;
1916
1917   /* In the shared -Bsymbolic case, discard space allocated for
1918      dynamic pc-relative relocs against symbols which turn out to be
1919      defined in regular objects.  For the normal shared case, discard
1920      space for pc-relative relocs that have become local due to symbol
1921      visibility changes.  */
1922
1923   if (info->shared)
1924     {
1925       if (h->def_regular
1926           && (h->forced_local
1927               || info->symbolic))
1928         {
1929           struct _bfd_sparc_elf_dyn_relocs **pp;
1930
1931           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1932             {
1933               p->count -= p->pc_count;
1934               p->pc_count = 0;
1935               if (p->count == 0)
1936                 *pp = p->next;
1937               else
1938                 pp = &p->next;
1939             }
1940         }
1941     }
1942   else
1943     {
1944       /* For the non-shared case, discard space for relocs against
1945          symbols which turn out to need copy relocs or are not
1946          dynamic.  */
1947
1948       if (!h->non_got_ref
1949           && ((h->def_dynamic
1950                && !h->def_regular)
1951               || (htab->elf.dynamic_sections_created
1952                   && (h->root.type == bfd_link_hash_undefweak
1953                       || h->root.type == bfd_link_hash_undefined))))
1954         {
1955           /* Make sure this symbol is output as a dynamic symbol.
1956              Undefined weak syms won't yet be marked as dynamic.  */
1957           if (h->dynindx == -1
1958               && !h->forced_local)
1959             {
1960               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1961                 return FALSE;
1962             }
1963
1964           /* If that succeeded, we know we'll be keeping all the
1965              relocs.  */
1966           if (h->dynindx != -1)
1967             goto keep;
1968         }
1969
1970       eh->dyn_relocs = NULL;
1971
1972     keep: ;
1973     }
1974
1975   /* Finally, allocate space.  */
1976   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1977     {
1978       asection *sreloc = elf_section_data (p->sec)->sreloc;
1979       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
1980     }
1981
1982   return TRUE;
1983 }
1984
1985 /* Find any dynamic relocs that apply to read-only sections.  */
1986
1987 static bfd_boolean
1988 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1989 {
1990   struct _bfd_sparc_elf_link_hash_entry *eh;
1991   struct _bfd_sparc_elf_dyn_relocs *p;
1992
1993   if (h->root.type == bfd_link_hash_warning)
1994     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1995
1996   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1997   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1998     {
1999       asection *s = p->sec->output_section;
2000
2001       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2002         {
2003           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2004
2005           info->flags |= DF_TEXTREL;
2006
2007           /* Not an error, just cut short the traversal.  */
2008           return FALSE;
2009         }
2010     }
2011   return TRUE;
2012 }
2013
2014 /* Return true if the dynamic symbol for a given section should be
2015    omitted when creating a shared library.  */
2016
2017 bfd_boolean
2018 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2019                                     struct bfd_link_info *info,
2020                                     asection *p)
2021 {
2022   /* We keep the .got section symbol so that explicit relocations
2023      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2024      can be turned into relocations against the .got symbol.  */
2025   if (strcmp (p->name, ".got") == 0)
2026     return FALSE;
2027
2028   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2029 }
2030
2031 /* Set the sizes of the dynamic sections.  */
2032
2033 bfd_boolean
2034 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2035                                       struct bfd_link_info *info)
2036 {
2037   struct _bfd_sparc_elf_link_hash_table *htab;
2038   bfd *dynobj;
2039   asection *s;
2040   bfd *ibfd;
2041
2042   htab = _bfd_sparc_elf_hash_table (info);
2043   dynobj = htab->elf.dynobj;
2044   BFD_ASSERT (dynobj != NULL);
2045
2046   if (elf_hash_table (info)->dynamic_sections_created)
2047     {
2048       /* Set the contents of the .interp section to the interpreter.  */
2049       if (info->executable)
2050         {
2051           s = bfd_get_section_by_name (dynobj, ".interp");
2052           BFD_ASSERT (s != NULL);
2053           s->size = htab->dynamic_interpreter_size;
2054           s->contents = (unsigned char *) htab->dynamic_interpreter;
2055         }
2056     }
2057
2058   /* Set up .got offsets for local syms, and space for local dynamic
2059      relocs.  */
2060   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2061     {
2062       bfd_signed_vma *local_got;
2063       bfd_signed_vma *end_local_got;
2064       char *local_tls_type;
2065       bfd_size_type locsymcount;
2066       Elf_Internal_Shdr *symtab_hdr;
2067       asection *srel;
2068
2069       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2070         continue;
2071
2072       for (s = ibfd->sections; s != NULL; s = s->next)
2073         {
2074           struct _bfd_sparc_elf_dyn_relocs *p;
2075
2076           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2077             {
2078               if (!bfd_is_abs_section (p->sec)
2079                   && bfd_is_abs_section (p->sec->output_section))
2080                 {
2081                   /* Input section has been discarded, either because
2082                      it is a copy of a linkonce section or due to
2083                      linker script /DISCARD/, so we'll be discarding
2084                      the relocs too.  */
2085                 }
2086               else if (p->count != 0)
2087                 {
2088                   srel = elf_section_data (p->sec)->sreloc;
2089                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2090                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2091                     info->flags |= DF_TEXTREL;
2092                 }
2093             }
2094         }
2095
2096       local_got = elf_local_got_refcounts (ibfd);
2097       if (!local_got)
2098         continue;
2099
2100       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2101       locsymcount = symtab_hdr->sh_info;
2102       end_local_got = local_got + locsymcount;
2103       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2104       s = htab->sgot;
2105       srel = htab->srelgot;
2106       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2107         {
2108           if (*local_got > 0)
2109             {
2110               *local_got = s->size;
2111               s->size += SPARC_ELF_WORD_BYTES (htab);
2112               if (*local_tls_type == GOT_TLS_GD)
2113                 s->size += SPARC_ELF_WORD_BYTES (htab);
2114               if (info->shared
2115                   || *local_tls_type == GOT_TLS_GD
2116                   || *local_tls_type == GOT_TLS_IE)
2117                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2118             }
2119           else
2120             *local_got = (bfd_vma) -1;
2121         }
2122     }
2123
2124   if (htab->tls_ldm_got.refcount > 0)
2125     {
2126       /* Allocate 2 got entries and 1 dynamic reloc for
2127          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2128       htab->tls_ldm_got.offset = htab->sgot->size;
2129       htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2130       htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2131     }
2132   else
2133     htab->tls_ldm_got.offset = -1;
2134
2135   /* Allocate global sym .plt and .got entries, and space for global
2136      sym dynamic relocs.  */
2137   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2138
2139   if (! ABI_64_P (output_bfd)
2140       && elf_hash_table (info)->dynamic_sections_created)
2141     {
2142       /* Make space for the trailing nop in .plt.  */
2143       if (htab->splt->size > 0)
2144         htab->splt->size += 1 * SPARC_INSN_BYTES;
2145
2146       /* If the .got section is more than 0x1000 bytes, we add
2147          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2148          bit relocations have a greater chance of working.
2149
2150          FIXME: Make this optimization work for 64-bit too.  */
2151       if (htab->sgot->size >= 0x1000
2152           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2153         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2154     }
2155
2156   /* The check_relocs and adjust_dynamic_symbol entry points have
2157      determined the sizes of the various dynamic sections.  Allocate
2158      memory for them.  */
2159   for (s = dynobj->sections; s != NULL; s = s->next)
2160     {
2161       if ((s->flags & SEC_LINKER_CREATED) == 0)
2162         continue;
2163
2164       if (s == htab->splt
2165           || s == htab->sgot
2166           || s == htab->sdynbss)
2167         {
2168           /* Strip this section if we don't need it; see the
2169              comment below.  */
2170         }
2171       else if (strncmp (s->name, ".rela", 5) == 0)
2172         {
2173           if (s->size != 0)
2174             {
2175               /* We use the reloc_count field as a counter if we need
2176                  to copy relocs into the output file.  */
2177               s->reloc_count = 0;
2178             }
2179         }
2180       else
2181         {
2182           /* It's not one of our sections.  */
2183           continue;
2184         }
2185
2186       if (s->size == 0)
2187         {
2188           /* If we don't need this section, strip it from the
2189              output file.  This is mostly to handle .rela.bss and
2190              .rela.plt.  We must create both sections in
2191              create_dynamic_sections, because they must be created
2192              before the linker maps input sections to output
2193              sections.  The linker does that before
2194              adjust_dynamic_symbol is called, and it is that
2195              function which decides whether anything needs to go
2196              into these sections.  */
2197           s->flags |= SEC_EXCLUDE;
2198           continue;
2199         }
2200
2201       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2202         continue;
2203
2204       /* Allocate memory for the section contents.  Zero the memory
2205          for the benefit of .rela.plt, which has 4 unused entries
2206          at the beginning, and we don't want garbage.  */
2207       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2208       if (s->contents == NULL)
2209         return FALSE;
2210     }
2211
2212   if (elf_hash_table (info)->dynamic_sections_created)
2213     {
2214       /* Add some entries to the .dynamic section.  We fill in the
2215          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2216          must add the entries now so that we get the correct size for
2217          the .dynamic section.  The DT_DEBUG entry is filled in by the
2218          dynamic linker and used by the debugger.  */
2219 #define add_dynamic_entry(TAG, VAL) \
2220   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2221
2222       if (info->executable)
2223         {
2224           if (!add_dynamic_entry (DT_DEBUG, 0))
2225             return FALSE;
2226         }
2227
2228       if (htab->srelplt->size != 0)
2229         {
2230           if (!add_dynamic_entry (DT_PLTGOT, 0)
2231               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2232               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2233               || !add_dynamic_entry (DT_JMPREL, 0))
2234             return FALSE;
2235         }
2236
2237       if (!add_dynamic_entry (DT_RELA, 0)
2238           || !add_dynamic_entry (DT_RELASZ, 0)
2239           || !add_dynamic_entry (DT_RELAENT,
2240                                  SPARC_ELF_RELA_BYTES (htab)))
2241         return FALSE;
2242
2243       /* If any dynamic relocs apply to a read-only section,
2244          then we need a DT_TEXTREL entry.  */
2245       if ((info->flags & DF_TEXTREL) == 0)
2246         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2247                                 (PTR) info);
2248
2249       if (info->flags & DF_TEXTREL)
2250         {
2251           if (!add_dynamic_entry (DT_TEXTREL, 0))
2252             return FALSE;
2253         }
2254
2255       if (ABI_64_P (output_bfd))
2256         {
2257           int reg;
2258           struct _bfd_sparc_elf_app_reg * app_regs;
2259           struct elf_strtab_hash *dynstr;
2260           struct elf_link_hash_table *eht = elf_hash_table (info);
2261
2262           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2263              entries if needed.  */
2264           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2265           dynstr = eht->dynstr;
2266
2267           for (reg = 0; reg < 4; reg++)
2268             if (app_regs [reg].name != NULL)
2269               {
2270                 struct elf_link_local_dynamic_entry *entry, *e;
2271
2272                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2273                   return FALSE;
2274
2275                 entry = (struct elf_link_local_dynamic_entry *)
2276                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2277                 if (entry == NULL)
2278                   return FALSE;
2279
2280                 /* We cheat here a little bit: the symbol will not be local, so we
2281                    put it at the end of the dynlocal linked list.  We will fix it
2282                    later on, as we have to fix other fields anyway.  */
2283                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2284                 entry->isym.st_size = 0;
2285                 if (*app_regs [reg].name != '\0')
2286                   entry->isym.st_name
2287                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2288                 else
2289                   entry->isym.st_name = 0;
2290                 entry->isym.st_other = 0;
2291                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2292                                                    STT_REGISTER);
2293                 entry->isym.st_shndx = app_regs [reg].shndx;
2294                 entry->next = NULL;
2295                 entry->input_bfd = output_bfd;
2296                 entry->input_indx = -1;
2297
2298                 if (eht->dynlocal == NULL)
2299                   eht->dynlocal = entry;
2300                 else
2301                   {
2302                     for (e = eht->dynlocal; e->next; e = e->next)
2303                       ;
2304                     e->next = entry;
2305                   }
2306                 eht->dynsymcount++;
2307               }
2308         }
2309     }
2310 #undef add_dynamic_entry
2311
2312   return TRUE;
2313 }
2314 \f
2315 bfd_boolean
2316 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2317 {
2318   struct _bfd_sparc_elf_section_data *sdata;
2319   bfd_size_type amt = sizeof (*sdata);
2320
2321   sdata = (struct _bfd_sparc_elf_section_data *) bfd_zalloc (abfd, amt);
2322   if (sdata == NULL)
2323     return FALSE;
2324   sec->used_by_bfd = (PTR) sdata;
2325
2326   return _bfd_elf_new_section_hook (abfd, sec);
2327 }
2328
2329 bfd_boolean
2330 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2331                               struct bfd_section *section,
2332                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2333                               bfd_boolean *again)
2334 {
2335   *again = FALSE;
2336   sec_do_relax (section) = 1;
2337   return TRUE;
2338 }
2339 \f
2340 /* Return the base VMA address which should be subtracted from real addresses
2341    when resolving @dtpoff relocation.
2342    This is PT_TLS segment p_vaddr.  */
2343
2344 static bfd_vma
2345 dtpoff_base (struct bfd_link_info *info)
2346 {
2347   /* If tls_sec is NULL, we should have signalled an error already.  */
2348   if (elf_hash_table (info)->tls_sec == NULL)
2349     return 0;
2350   return elf_hash_table (info)->tls_sec->vma;
2351 }
2352
2353 /* Return the relocation value for @tpoff relocation
2354    if STT_TLS virtual address is ADDRESS.  */
2355
2356 static bfd_vma
2357 tpoff (struct bfd_link_info *info, bfd_vma address)
2358 {
2359   struct elf_link_hash_table *htab = elf_hash_table (info);
2360
2361   /* If tls_sec is NULL, we should have signalled an error already.  */
2362   if (htab->tls_sec == NULL)
2363     return 0;
2364   return address - htab->tls_size - htab->tls_sec->vma;
2365 }
2366
2367 /* Relocate a SPARC ELF section.  */
2368
2369 bfd_boolean
2370 _bfd_sparc_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2371                                  bfd *input_bfd, asection *input_section,
2372                                  bfd_byte *contents, Elf_Internal_Rela *relocs,
2373                                  Elf_Internal_Sym *local_syms, asection **local_sections)
2374 {
2375   struct _bfd_sparc_elf_link_hash_table *htab;
2376   Elf_Internal_Shdr *symtab_hdr;
2377   struct elf_link_hash_entry **sym_hashes;
2378   bfd_vma *local_got_offsets;
2379   bfd_vma got_base;
2380   asection *sreloc;
2381   Elf_Internal_Rela *rel;
2382   Elf_Internal_Rela *relend;
2383   int num_relocs;
2384
2385   if (info->relocatable)
2386     return TRUE;
2387
2388   htab = _bfd_sparc_elf_hash_table (info);
2389   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2390   sym_hashes = elf_sym_hashes (input_bfd);
2391   local_got_offsets = elf_local_got_offsets (input_bfd);
2392
2393   if (elf_hash_table (info)->hgot == NULL)
2394     got_base = 0;
2395   else
2396     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2397
2398   sreloc = elf_section_data (input_section)->sreloc;
2399
2400   rel = relocs;
2401   if (ABI_64_P (output_bfd))
2402     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2403   else
2404     num_relocs = input_section->reloc_count;
2405   relend = relocs + num_relocs;
2406   for (; rel < relend; rel++)
2407     {
2408       int r_type, tls_type;
2409       reloc_howto_type *howto;
2410       unsigned long r_symndx;
2411       struct elf_link_hash_entry *h;
2412       Elf_Internal_Sym *sym;
2413       asection *sec;
2414       bfd_vma relocation, off;
2415       bfd_reloc_status_type r;
2416       bfd_boolean is_plt = FALSE;
2417       bfd_boolean unresolved_reloc;
2418
2419       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2420       if (r_type == R_SPARC_GNU_VTINHERIT
2421           || r_type == R_SPARC_GNU_VTENTRY)
2422         continue;
2423
2424       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2425         {
2426           bfd_set_error (bfd_error_bad_value);
2427           return FALSE;
2428         }
2429       howto = _bfd_sparc_elf_howto_table + r_type;
2430
2431       /* This is a final link.  */
2432       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2433       h = NULL;
2434       sym = NULL;
2435       sec = NULL;
2436       unresolved_reloc = FALSE;
2437       if (r_symndx < symtab_hdr->sh_info)
2438         {
2439           sym = local_syms + r_symndx;
2440           sec = local_sections[r_symndx];
2441           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2442         }
2443       else
2444         {
2445           bfd_boolean warned;
2446
2447           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2448                                    r_symndx, symtab_hdr, sym_hashes,
2449                                    h, sec, relocation,
2450                                    unresolved_reloc, warned);
2451           if (warned)
2452             {
2453               /* To avoid generating warning messages about truncated
2454                  relocations, set the relocation's address to be the same as
2455                  the start of this section.  */
2456               if (input_section->output_section != NULL)
2457                 relocation = input_section->output_section->vma;
2458               else
2459                 relocation = 0;
2460             }
2461         }
2462
2463       switch (r_type)
2464         {
2465         case R_SPARC_GOT10:
2466         case R_SPARC_GOT13:
2467         case R_SPARC_GOT22:
2468           /* Relocation is to the entry for this symbol in the global
2469              offset table.  */
2470           if (htab->sgot == NULL)
2471             abort ();
2472
2473           if (h != NULL)
2474             {
2475               bfd_boolean dyn;
2476
2477               off = h->got.offset;
2478               BFD_ASSERT (off != (bfd_vma) -1);
2479               dyn = elf_hash_table (info)->dynamic_sections_created;
2480
2481               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2482                   || (info->shared
2483                       && (info->symbolic
2484                           || h->dynindx == -1
2485                           || h->forced_local)
2486                       && h->def_regular))
2487                 {
2488                   /* This is actually a static link, or it is a
2489                      -Bsymbolic link and the symbol is defined
2490                      locally, or the symbol was forced to be local
2491                      because of a version file.  We must initialize
2492                      this entry in the global offset table.  Since the
2493                      offset must always be a multiple of 8 for 64-bit
2494                      and 4 for 32-bit, we use the least significant bit
2495                      to record whether we have initialized it already.
2496
2497                      When doing a dynamic link, we create a .rela.got
2498                      relocation entry to initialize the value.  This
2499                      is done in the finish_dynamic_symbol routine.  */
2500                   if ((off & 1) != 0)
2501                     off &= ~1;
2502                   else
2503                     {
2504                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2505                                           htab->sgot->contents + off);
2506                       h->got.offset |= 1;
2507                     }
2508                 }
2509               else
2510                 unresolved_reloc = FALSE;
2511             }
2512           else
2513             {
2514               BFD_ASSERT (local_got_offsets != NULL
2515                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2516
2517               off = local_got_offsets[r_symndx];
2518
2519               /* The offset must always be a multiple of 8 on 64-bit and
2520                  4 on 32-bit.  We use the least significant bit to record
2521                  whether we have already processed this entry.  */
2522               if ((off & 1) != 0)
2523                 off &= ~1;
2524               else
2525                 {
2526
2527                   if (info->shared)
2528                     {
2529                       asection *s;
2530                       Elf_Internal_Rela outrel;
2531
2532                       /* We need to generate a R_SPARC_RELATIVE reloc
2533                          for the dynamic linker.  */
2534                       s = htab->srelgot;
2535                       BFD_ASSERT (s != NULL);
2536
2537                       outrel.r_offset = (htab->sgot->output_section->vma
2538                                          + htab->sgot->output_offset
2539                                          + off);
2540                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2541                                                         0, R_SPARC_RELATIVE);
2542                       outrel.r_addend = relocation;
2543                       relocation = 0;
2544                       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &outrel);
2545                     }
2546
2547                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2548                                       htab->sgot->contents + off);
2549                   local_got_offsets[r_symndx] |= 1;
2550                 }
2551             }
2552           relocation = htab->sgot->output_offset + off - got_base;
2553           break;
2554
2555         case R_SPARC_PLT32:
2556         case R_SPARC_PLT64:
2557           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2558             {
2559               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2560               goto r_sparc_plt32;
2561             }
2562           /* Fall through.  */
2563
2564         case R_SPARC_WPLT30:
2565         case R_SPARC_HIPLT22:
2566         case R_SPARC_LOPLT10:
2567         case R_SPARC_PCPLT32:
2568         case R_SPARC_PCPLT22:
2569         case R_SPARC_PCPLT10:
2570         r_sparc_wplt30:
2571           /* Relocation is to the entry for this symbol in the
2572              procedure linkage table.  */
2573
2574           if (! ABI_64_P (output_bfd))
2575             {
2576               /* The Solaris native assembler will generate a WPLT30 reloc
2577                  for a local symbol if you assemble a call from one
2578                  section to another when using -K pic.  We treat it as
2579                  WDISP30.  */
2580               if (h == NULL)
2581                 break;
2582             }
2583           else
2584             {
2585               BFD_ASSERT (h != NULL);
2586             }
2587
2588           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2589             {
2590               /* We didn't make a PLT entry for this symbol.  This
2591                  happens when statically linking PIC code, or when
2592                  using -Bsymbolic.  */
2593               break;
2594             }
2595
2596           relocation = (htab->splt->output_section->vma
2597                         + htab->splt->output_offset
2598                         + h->plt.offset);
2599           unresolved_reloc = FALSE;
2600           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2601             {
2602               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2603               is_plt = TRUE;
2604               goto r_sparc_plt32;
2605             }
2606           break;
2607
2608         case R_SPARC_PC10:
2609         case R_SPARC_PC22:
2610         case R_SPARC_PC_HH22:
2611         case R_SPARC_PC_HM10:
2612         case R_SPARC_PC_LM22:
2613           if (h != NULL
2614               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2615             break;
2616           /* Fall through.  */
2617         case R_SPARC_DISP8:
2618         case R_SPARC_DISP16:
2619         case R_SPARC_DISP32:
2620         case R_SPARC_DISP64:
2621         case R_SPARC_WDISP30:
2622         case R_SPARC_WDISP22:
2623         case R_SPARC_WDISP19:
2624         case R_SPARC_WDISP16:
2625         case R_SPARC_8:
2626         case R_SPARC_16:
2627         case R_SPARC_32:
2628         case R_SPARC_HI22:
2629         case R_SPARC_22:
2630         case R_SPARC_13:
2631         case R_SPARC_LO10:
2632         case R_SPARC_UA16:
2633         case R_SPARC_UA32:
2634         case R_SPARC_10:
2635         case R_SPARC_11:
2636         case R_SPARC_64:
2637         case R_SPARC_OLO10:
2638         case R_SPARC_HH22:
2639         case R_SPARC_HM10:
2640         case R_SPARC_LM22:
2641         case R_SPARC_7:
2642         case R_SPARC_5:
2643         case R_SPARC_6:
2644         case R_SPARC_HIX22:
2645         case R_SPARC_LOX10:
2646         case R_SPARC_H44:
2647         case R_SPARC_M44:
2648         case R_SPARC_L44:
2649         case R_SPARC_UA64:
2650         r_sparc_plt32:
2651           /* r_symndx will be zero only for relocs against symbols
2652              from removed linkonce sections, or sections discarded by
2653              a linker script.  */
2654           if (r_symndx == 0
2655               || (input_section->flags & SEC_ALLOC) == 0)
2656             break;
2657
2658           if ((info->shared
2659                && (h == NULL
2660                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2661                    || h->root.type != bfd_link_hash_undefweak)
2662                && (! howto->pc_relative
2663                    || (h != NULL
2664                        && h->dynindx != -1
2665                        && (! info->symbolic
2666                            || !h->def_regular))))
2667               || (!info->shared
2668                   && h != NULL
2669                   && h->dynindx != -1
2670                   && !h->non_got_ref
2671                   && ((h->def_dynamic
2672                        && !h->def_regular)
2673                       || h->root.type == bfd_link_hash_undefweak
2674                       || h->root.type == bfd_link_hash_undefined)))
2675             {
2676               Elf_Internal_Rela outrel;
2677               bfd_boolean skip, relocate = FALSE;
2678
2679               /* When generating a shared object, these relocations
2680                  are copied into the output file to be resolved at run
2681                  time.  */
2682
2683               BFD_ASSERT (sreloc != NULL);
2684
2685               skip = FALSE;
2686
2687               outrel.r_offset =
2688                 _bfd_elf_section_offset (output_bfd, info, input_section,
2689                                          rel->r_offset);
2690               if (outrel.r_offset == (bfd_vma) -1)
2691                 skip = TRUE;
2692               else if (outrel.r_offset == (bfd_vma) -2)
2693                 skip = TRUE, relocate = TRUE;
2694               outrel.r_offset += (input_section->output_section->vma
2695                                   + input_section->output_offset);
2696
2697               /* Optimize unaligned reloc usage now that we know where
2698                  it finally resides.  */
2699               switch (r_type)
2700                 {
2701                 case R_SPARC_16:
2702                   if (outrel.r_offset & 1)
2703                     r_type = R_SPARC_UA16;
2704                   break;
2705                 case R_SPARC_UA16:
2706                   if (!(outrel.r_offset & 1))
2707                     r_type = R_SPARC_16;
2708                   break;
2709                 case R_SPARC_32:
2710                   if (outrel.r_offset & 3)
2711                     r_type = R_SPARC_UA32;
2712                   break;
2713                 case R_SPARC_UA32:
2714                   if (!(outrel.r_offset & 3))
2715                     r_type = R_SPARC_32;
2716                   break;
2717                 case R_SPARC_64:
2718                   if (outrel.r_offset & 7)
2719                     r_type = R_SPARC_UA64;
2720                   break;
2721                 case R_SPARC_UA64:
2722                   if (!(outrel.r_offset & 7))
2723                     r_type = R_SPARC_64;
2724                   break;
2725                 case R_SPARC_DISP8:
2726                 case R_SPARC_DISP16:
2727                 case R_SPARC_DISP32:
2728                 case R_SPARC_DISP64:
2729                   /* If the symbol is not dynamic, we should not keep
2730                      a dynamic relocation.  But an .rela.* slot has been
2731                      allocated for it, output R_SPARC_NONE.
2732                      FIXME: Add code tracking needed dynamic relocs as
2733                      e.g. i386 has.  */
2734                   if (h->dynindx == -1)
2735                     skip = TRUE, relocate = TRUE;
2736                   break;
2737                 }
2738
2739               if (skip)
2740                 memset (&outrel, 0, sizeof outrel);
2741               /* h->dynindx may be -1 if the symbol was marked to
2742                  become local.  */
2743               else if (h != NULL && ! is_plt
2744                        && ((! info->symbolic && h->dynindx != -1)
2745                            || !h->def_regular))
2746                 {
2747                   BFD_ASSERT (h->dynindx != -1);
2748                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2749                   outrel.r_addend = rel->r_addend;
2750                 }
2751               else
2752                 {
2753                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2754                     {
2755                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2756                                                         0, R_SPARC_RELATIVE);
2757                       outrel.r_addend = relocation + rel->r_addend;
2758                     }
2759                   else
2760                     {
2761                       long indx;
2762
2763                       if (is_plt)
2764                         sec = htab->splt;
2765
2766                       if (bfd_is_abs_section (sec))
2767                         indx = 0;
2768                       else if (sec == NULL || sec->owner == NULL)
2769                         {
2770                           bfd_set_error (bfd_error_bad_value);
2771                           return FALSE;
2772                         }
2773                       else
2774                         {
2775                           asection *osec;
2776
2777                           osec = sec->output_section;
2778                           indx = elf_section_data (osec)->dynindx;
2779
2780                           /* FIXME: we really should be able to link non-pic
2781                              shared libraries.  */
2782                           if (indx == 0)
2783                             {
2784                               BFD_FAIL ();
2785                               (*_bfd_error_handler)
2786                                 (_("%B: probably compiled without -fPIC?"),
2787                                  input_bfd);
2788                               bfd_set_error (bfd_error_bad_value);
2789                               return FALSE;
2790                             }
2791                         }
2792
2793                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, r_type);
2794                       outrel.r_addend = relocation + rel->r_addend;
2795                     }
2796                 }
2797
2798               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2799
2800               /* This reloc will be computed at runtime, so there's no
2801                  need to do anything now.  */
2802               if (! relocate)
2803                 continue;
2804             }
2805           break;
2806
2807         case R_SPARC_TLS_GD_HI22:
2808           if (! ABI_64_P (input_bfd)
2809               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2810             {
2811               /* R_SPARC_REV32 used the same reloc number as
2812                  R_SPARC_TLS_GD_HI22.  */
2813               r_type = R_SPARC_REV32;
2814               break;
2815             }
2816           /* Fall through */
2817
2818         case R_SPARC_TLS_GD_LO10:
2819         case R_SPARC_TLS_IE_HI22:
2820         case R_SPARC_TLS_IE_LO10:
2821           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2822           tls_type = GOT_UNKNOWN;
2823           if (h == NULL && local_got_offsets)
2824             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2825           else if (h != NULL)
2826             {
2827               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2828               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2829                 switch (SPARC_ELF_R_TYPE (rel->r_info))
2830                   {
2831                   case R_SPARC_TLS_GD_HI22:
2832                   case R_SPARC_TLS_IE_HI22:
2833                     r_type = R_SPARC_TLS_LE_HIX22;
2834                     break;
2835                   default:
2836                     r_type = R_SPARC_TLS_LE_LOX10;
2837                     break;
2838                   }
2839             }
2840           if (tls_type == GOT_TLS_IE)
2841             switch (r_type)
2842               {
2843               case R_SPARC_TLS_GD_HI22:
2844                 r_type = R_SPARC_TLS_IE_HI22;
2845                 break;
2846               case R_SPARC_TLS_GD_LO10:
2847                 r_type = R_SPARC_TLS_IE_LO10;
2848                 break;
2849               }
2850
2851           if (r_type == R_SPARC_TLS_LE_HIX22)
2852             {
2853               relocation = tpoff (info, relocation);
2854               break;
2855             }
2856           if (r_type == R_SPARC_TLS_LE_LOX10)
2857             {
2858               /* Change add into xor.  */
2859               relocation = tpoff (info, relocation);
2860               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2861                                                    contents + rel->r_offset)
2862                                        | 0x80182000), contents + rel->r_offset);
2863               break;
2864             }
2865
2866           if (h != NULL)
2867             {
2868               off = h->got.offset;
2869               h->got.offset |= 1;
2870             }
2871           else
2872             {
2873               BFD_ASSERT (local_got_offsets != NULL);
2874               off = local_got_offsets[r_symndx];
2875               local_got_offsets[r_symndx] |= 1;
2876             }
2877
2878         r_sparc_tlsldm:
2879           if (htab->sgot == NULL)
2880             abort ();
2881
2882           if ((off & 1) != 0)
2883             off &= ~1;
2884           else
2885             {
2886               Elf_Internal_Rela outrel;
2887               int dr_type, indx;
2888
2889               if (htab->srelgot == NULL)
2890                 abort ();
2891
2892               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
2893               outrel.r_offset = (htab->sgot->output_section->vma
2894                                  + htab->sgot->output_offset + off);
2895               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2896               if (r_type == R_SPARC_TLS_IE_HI22
2897                   || r_type == R_SPARC_TLS_IE_LO10)
2898                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
2899               else
2900                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
2901               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
2902                 outrel.r_addend = relocation - dtpoff_base (info);
2903               else
2904                 outrel.r_addend = 0;
2905               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
2906               SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
2907
2908               if (r_type == R_SPARC_TLS_GD_HI22
2909                   || r_type == R_SPARC_TLS_GD_LO10)
2910                 {
2911                   if (indx == 0)
2912                     {
2913                       BFD_ASSERT (! unresolved_reloc);
2914                       SPARC_ELF_PUT_WORD (htab, output_bfd,
2915                                           relocation - dtpoff_base (info),
2916                                           (htab->sgot->contents + off
2917                                            + SPARC_ELF_WORD_BYTES (htab)));
2918                     }
2919                   else
2920                     {
2921                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
2922                                           (htab->sgot->contents + off
2923                                            + SPARC_ELF_WORD_BYTES (htab)));
2924                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
2925                                                         SPARC_ELF_DTPOFF_RELOC (htab));
2926                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
2927                       SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
2928                     }
2929                 }
2930               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
2931                 {
2932                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
2933                                       (htab->sgot->contents + off
2934                                        + SPARC_ELF_WORD_BYTES (htab)));
2935                 }
2936             }
2937
2938           if (off >= (bfd_vma) -2)
2939             abort ();
2940
2941           relocation = htab->sgot->output_offset + off - got_base;
2942           unresolved_reloc = FALSE;
2943           howto = _bfd_sparc_elf_howto_table + r_type;
2944           break;
2945
2946         case R_SPARC_TLS_LDM_HI22:
2947         case R_SPARC_TLS_LDM_LO10:
2948           if (! info->shared)
2949             {
2950               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2951               continue;
2952             }
2953           off = htab->tls_ldm_got.offset;
2954           htab->tls_ldm_got.offset |= 1;
2955           goto r_sparc_tlsldm;
2956
2957         case R_SPARC_TLS_LDO_HIX22:
2958         case R_SPARC_TLS_LDO_LOX10:
2959           if (info->shared)
2960             {
2961               relocation -= dtpoff_base (info);
2962               break;
2963             }
2964
2965           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
2966                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
2967           /* Fall through.  */
2968
2969         case R_SPARC_TLS_LE_HIX22:
2970         case R_SPARC_TLS_LE_LOX10:
2971           if (info->shared)
2972             {
2973               Elf_Internal_Rela outrel;
2974               bfd_boolean skip, relocate = FALSE;
2975
2976               BFD_ASSERT (sreloc != NULL);
2977               skip = FALSE;
2978               outrel.r_offset =
2979                 _bfd_elf_section_offset (output_bfd, info, input_section,
2980                                          rel->r_offset);
2981               if (outrel.r_offset == (bfd_vma) -1)
2982                 skip = TRUE;
2983               else if (outrel.r_offset == (bfd_vma) -2)
2984                 skip = TRUE, relocate = TRUE;
2985               outrel.r_offset += (input_section->output_section->vma
2986                                   + input_section->output_offset);
2987               if (skip)
2988                 memset (&outrel, 0, sizeof outrel);
2989               else
2990                 {
2991                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
2992                   outrel.r_addend = relocation - dtpoff_base (info)
2993                                     + rel->r_addend;
2994                 }
2995
2996               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2997               continue;
2998             }
2999           relocation = tpoff (info, relocation);
3000           break;
3001
3002         case R_SPARC_TLS_LDM_CALL:
3003           if (! info->shared)
3004             {
3005               /* mov %g0, %o0 */
3006               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3007               continue;
3008             }
3009           /* Fall through */
3010
3011         case R_SPARC_TLS_GD_CALL:
3012           tls_type = GOT_UNKNOWN;
3013           if (h == NULL && local_got_offsets)
3014             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3015           else if (h != NULL)
3016             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3017           if (! info->shared
3018               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3019             {
3020               bfd_vma insn;
3021
3022               if (!info->shared && (h == NULL || h->dynindx == -1))
3023                 {
3024                   /* GD -> LE */
3025                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3026                   continue;
3027                 }
3028
3029               /* GD -> IE */
3030               if (rel + 1 < relend
3031                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3032                   && rel[1].r_offset == rel->r_offset + 4
3033                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3034                   && (((insn = bfd_get_32 (input_bfd,
3035                                            contents + rel[1].r_offset))
3036                        >> 25) & 0x1f) == 8)
3037                 {
3038                   /* We have
3039                      call __tls_get_addr, %tgd_call(foo)
3040                       add %reg1, %reg2, %o0, %tgd_add(foo)
3041                      and change it into IE:
3042                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3043                      add %g7, %o0, %o0, %tie_add(foo).
3044                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3045                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3046                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3047                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3048                               contents + rel->r_offset);
3049                   bfd_put_32 (output_bfd, 0x9001c008,
3050                               contents + rel->r_offset + 4);
3051                   rel++;
3052                   continue;
3053                 }
3054
3055               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3056               continue;
3057             }
3058
3059           h = (struct elf_link_hash_entry *)
3060               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3061                                     FALSE, TRUE);
3062           BFD_ASSERT (h != NULL);
3063           r_type = R_SPARC_WPLT30;
3064           howto = _bfd_sparc_elf_howto_table + r_type;
3065           goto r_sparc_wplt30;
3066
3067         case R_SPARC_TLS_GD_ADD:
3068           tls_type = GOT_UNKNOWN;
3069           if (h == NULL && local_got_offsets)
3070             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3071           else if (h != NULL)
3072             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3073           if (! info->shared || tls_type == GOT_TLS_IE)
3074             {
3075               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3076                  changed into IE:
3077                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3078                  or LE:
3079                  add %g7, %reg2, %reg3.  */
3080               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3081               if ((h != NULL && h->dynindx != -1) || info->shared)
3082                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3083               else
3084                 relocation = (insn & ~0x7c000) | 0x1c000;
3085               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3086             }
3087           continue;
3088
3089         case R_SPARC_TLS_LDM_ADD:
3090           if (! info->shared)
3091             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3092           continue;
3093
3094         case R_SPARC_TLS_LDO_ADD:
3095           if (! info->shared)
3096             {
3097               /* Change rs1 into %g7.  */
3098               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3099               insn = (insn & ~0x7c000) | 0x1c000;
3100               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3101             }
3102           continue;
3103
3104         case R_SPARC_TLS_IE_LD:
3105         case R_SPARC_TLS_IE_LDX:
3106           if (! info->shared && (h == NULL || h->dynindx == -1))
3107             {
3108               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3109               int rs2 = insn & 0x1f;
3110               int rd = (insn >> 25) & 0x1f;
3111
3112               if (rs2 == rd)
3113                 relocation = SPARC_NOP;
3114               else
3115                 relocation = 0x80100000 | (insn & 0x3e00001f);
3116               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3117             }
3118           continue;
3119
3120         case R_SPARC_TLS_IE_ADD:
3121           /* Totally useless relocation.  */
3122           continue;
3123
3124         case R_SPARC_TLS_DTPOFF32:
3125         case R_SPARC_TLS_DTPOFF64:
3126           relocation -= dtpoff_base (info);
3127           break;
3128
3129         default:
3130           break;
3131         }
3132
3133       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3134          because such sections are not SEC_ALLOC and thus ld.so will
3135          not process them.  */
3136       if (unresolved_reloc
3137           && !((input_section->flags & SEC_DEBUGGING) != 0
3138                && h->def_dynamic))
3139         (*_bfd_error_handler)
3140           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3141            input_bfd,
3142            input_section,
3143            (long) rel->r_offset,
3144            howto->name,
3145            h->root.root.string);
3146
3147       r = bfd_reloc_continue;
3148       if (r_type == R_SPARC_OLO10)
3149         {
3150             bfd_vma x;
3151
3152             if (! ABI_64_P (output_bfd))
3153               abort ();
3154
3155             relocation += rel->r_addend;
3156             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3157
3158             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3159             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3160             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3161
3162             r = bfd_check_overflow (howto->complain_on_overflow,
3163                                     howto->bitsize, howto->rightshift,
3164                                     bfd_arch_bits_per_address (input_bfd),
3165                                     relocation);
3166         }
3167       else if (r_type == R_SPARC_WDISP16)
3168         {
3169           bfd_vma x;
3170
3171           relocation += rel->r_addend;
3172           relocation -= (input_section->output_section->vma
3173                          + input_section->output_offset);
3174           relocation -= rel->r_offset;
3175
3176           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3177           x |= ((((relocation >> 2) & 0xc000) << 6)
3178                 | ((relocation >> 2) & 0x3fff));
3179           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3180
3181           r = bfd_check_overflow (howto->complain_on_overflow,
3182                                   howto->bitsize, howto->rightshift,
3183                                   bfd_arch_bits_per_address (input_bfd),
3184                                   relocation);
3185         }
3186       else if (r_type == R_SPARC_REV32)
3187         {
3188           bfd_vma x;
3189
3190           relocation = relocation + rel->r_addend;
3191
3192           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3193           x = x + relocation;
3194           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3195           r = bfd_reloc_ok;
3196         }
3197       else if (r_type == R_SPARC_TLS_LDO_HIX22
3198                || r_type == R_SPARC_TLS_LE_HIX22)
3199         {
3200           bfd_vma x;
3201
3202           relocation += rel->r_addend;
3203           if (r_type == R_SPARC_TLS_LE_HIX22)
3204             relocation ^= MINUS_ONE;
3205
3206           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3207           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3208           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3209           r = bfd_reloc_ok;
3210         }
3211       else if (r_type == R_SPARC_TLS_LDO_LOX10
3212                || r_type == R_SPARC_TLS_LE_LOX10)
3213         {
3214           bfd_vma x;
3215
3216           relocation += rel->r_addend;
3217           relocation &= 0x3ff;
3218           if (r_type == R_SPARC_TLS_LE_LOX10)
3219             relocation |= 0x1c00;
3220
3221           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3222           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3223           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3224
3225           r = bfd_reloc_ok;
3226         }
3227       else if (r_type == R_SPARC_HIX22)
3228         {
3229           bfd_vma x;
3230
3231           relocation += rel->r_addend;
3232           relocation = relocation ^ MINUS_ONE;
3233
3234           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3235           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3236           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3237
3238           r = bfd_check_overflow (howto->complain_on_overflow,
3239                                   howto->bitsize, howto->rightshift,
3240                                   bfd_arch_bits_per_address (input_bfd),
3241                                   relocation);
3242         }
3243       else if (r_type == R_SPARC_LOX10)
3244         {
3245           bfd_vma x;
3246
3247           relocation += rel->r_addend;
3248           relocation = (relocation & 0x3ff) | 0x1c00;
3249
3250           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3251           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3252           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3253
3254           r = bfd_reloc_ok;
3255         }
3256       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3257                && sec_do_relax (input_section)
3258                && rel->r_offset + 4 < input_section->size)
3259         {
3260 #define G0              0
3261 #define O7              15
3262 #define XCC             (2 << 20)
3263 #define COND(x)         (((x)&0xf)<<25)
3264 #define CONDA           COND(0x8)
3265 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3266 #define INSN_BA         (F2(0,2) | CONDA)
3267 #define INSN_OR         F3(2, 0x2, 0)
3268 #define INSN_NOP        F2(0,4)
3269
3270           bfd_vma x, y;
3271
3272           /* If the instruction is a call with either:
3273              restore
3274              arithmetic instruction with rd == %o7
3275              where rs1 != %o7 and rs2 if it is register != %o7
3276              then we can optimize if the call destination is near
3277              by changing the call into a branch always.  */
3278           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3279           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3280           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3281             {
3282               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3283                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3284                        && (y & RD(~0)) == RD(O7)))
3285                   && (y & RS1(~0)) != RS1(O7)
3286                   && ((y & F3I(~0))
3287                       || (y & RS2(~0)) != RS2(O7)))
3288                 {
3289                   bfd_vma reloc;
3290
3291                   reloc = relocation + rel->r_addend - rel->r_offset;
3292                   reloc -= (input_section->output_section->vma
3293                             + input_section->output_offset);
3294
3295                   /* Ensure the branch fits into simm22.  */
3296                   if ((reloc & 3) == 0
3297                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3298                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3299                     {
3300                       reloc >>= 2;
3301
3302                       /* Check whether it fits into simm19.  */
3303                       if (((reloc & 0x3c0000) == 0
3304                            || (reloc & 0x3c0000) == 0x3c0000)
3305                           && (ABI_64_P (output_bfd)
3306                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3307                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3308                       else
3309                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3310                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3311                       r = bfd_reloc_ok;
3312                       if (rel->r_offset >= 4
3313                           && (y & (0xffffffff ^ RS1(~0)))
3314                              == (INSN_OR | RD(O7) | RS2(G0)))
3315                         {
3316                           bfd_vma z;
3317                           unsigned int reg;
3318
3319                           z = bfd_get_32 (input_bfd,
3320                                           contents + rel->r_offset - 4);
3321                           if ((z & (0xffffffff ^ RD(~0)))
3322                               != (INSN_OR | RS1(O7) | RS2(G0)))
3323                             break;
3324
3325                           /* The sequence was
3326                              or %o7, %g0, %rN
3327                              call foo
3328                              or %rN, %g0, %o7
3329
3330                              If call foo was replaced with ba, replace
3331                              or %rN, %g0, %o7 with nop.  */
3332
3333                           reg = (y & RS1(~0)) >> 14;
3334                           if (reg != ((z & RD(~0)) >> 25)
3335                               || reg == G0 || reg == O7)
3336                             break;
3337
3338                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3339                                       contents + rel->r_offset + 4);
3340                         }
3341
3342                     }
3343                 }
3344             }
3345         }
3346
3347       if (r == bfd_reloc_continue)
3348         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3349                                       contents, rel->r_offset,
3350                                       relocation, rel->r_addend);
3351
3352       if (r != bfd_reloc_ok)
3353         {
3354           switch (r)
3355             {
3356             default:
3357             case bfd_reloc_outofrange:
3358               abort ();
3359             case bfd_reloc_overflow:
3360               {
3361                 const char *name;
3362
3363                 if (h != NULL)
3364                   name = NULL;
3365                 else
3366                   {
3367                     name = bfd_elf_string_from_elf_section (input_bfd,
3368                                                             symtab_hdr->sh_link,
3369                                                             sym->st_name);
3370                     if (name == NULL)
3371                       return FALSE;
3372                     if (*name == '\0')
3373                       name = bfd_section_name (input_bfd, sec);
3374                   }
3375                 if (! ((*info->callbacks->reloc_overflow)
3376                        (info, (h ? &h->root : NULL), name, howto->name,
3377                         (bfd_vma) 0, input_bfd, input_section,
3378                         rel->r_offset)))
3379                   return FALSE;
3380               }
3381               break;
3382             }
3383         }
3384     }
3385
3386   return TRUE;
3387 }
3388
3389 /* Finish up dynamic symbol handling.  We set the contents of various
3390    dynamic sections here.  */
3391
3392 bfd_boolean
3393 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3394                                       struct bfd_link_info *info,
3395                                       struct elf_link_hash_entry *h,
3396                                       Elf_Internal_Sym *sym)
3397 {
3398   bfd *dynobj;
3399   struct _bfd_sparc_elf_link_hash_table *htab;
3400
3401   htab = _bfd_sparc_elf_hash_table (info);
3402   dynobj = htab->elf.dynobj;
3403
3404   if (h->plt.offset != (bfd_vma) -1)
3405     {
3406       asection *splt;
3407       asection *srela;
3408       Elf_Internal_Rela rela;
3409       bfd_byte *loc;
3410       bfd_vma r_offset;
3411       int rela_index;
3412
3413       /* This symbol has an entry in the PLT.  Set it up.  */
3414
3415       BFD_ASSERT (h->dynindx != -1);
3416
3417       splt = htab->splt;
3418       srela = htab->srelplt;
3419       BFD_ASSERT (splt != NULL && srela != NULL);
3420
3421       /* Fill in the entry in the procedure linkage table.  */
3422       rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3423                                               h->plt.offset, splt->size,
3424                                               &r_offset);
3425
3426       /* Fill in the entry in the .rela.plt section.  */
3427       rela.r_offset = r_offset
3428         + (splt->output_section->vma + splt->output_offset);
3429       if (! ABI_64_P (output_bfd)
3430           || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3431         {
3432           rela.r_addend = 0;
3433         }
3434       else
3435         {
3436           rela.r_addend = -(h->plt.offset + 4)
3437                           -(splt->output_section->vma + splt->output_offset);
3438         }
3439       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3440
3441       /* Adjust for the first 4 reserved elements in the .plt section
3442          when setting the offset in the .rela.plt section.
3443          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3444          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3445
3446       loc = srela->contents;
3447 #ifdef BFD64
3448       if (ABI_64_P (output_bfd))
3449         {
3450           loc += rela_index * sizeof (Elf64_External_Rela);
3451           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3452         }
3453       else
3454 #endif
3455         {
3456           loc += rela_index * sizeof (Elf32_External_Rela);
3457           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3458         }
3459
3460       if (!h->def_regular)
3461         {
3462           /* Mark the symbol as undefined, rather than as defined in
3463              the .plt section.  Leave the value alone.  */
3464           sym->st_shndx = SHN_UNDEF;
3465           /* If the symbol is weak, we do need to clear the value.
3466              Otherwise, the PLT entry would provide a definition for
3467              the symbol even if the symbol wasn't defined anywhere,
3468              and so the symbol would never be NULL.  */
3469           if (!h->ref_regular_nonweak)
3470             sym->st_value = 0;
3471         }
3472     }
3473
3474   if (h->got.offset != (bfd_vma) -1
3475       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3476       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3477     {
3478       asection *sgot;
3479       asection *srela;
3480       Elf_Internal_Rela rela;
3481
3482       /* This symbol has an entry in the GOT.  Set it up.  */
3483
3484       sgot = htab->sgot;
3485       srela = htab->srelgot;
3486       BFD_ASSERT (sgot != NULL && srela != NULL);
3487
3488       rela.r_offset = (sgot->output_section->vma
3489                        + sgot->output_offset
3490                        + (h->got.offset &~ (bfd_vma) 1));
3491
3492       /* If this is a -Bsymbolic link, and the symbol is defined
3493          locally, we just want to emit a RELATIVE reloc.  Likewise if
3494          the symbol was forced to be local because of a version file.
3495          The entry in the global offset table will already have been
3496          initialized in the relocate_section function.  */
3497       if (info->shared
3498           && (info->symbolic || h->dynindx == -1)
3499           && h->def_regular)
3500         {
3501           asection *sec = h->root.u.def.section;
3502           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3503           rela.r_addend = (h->root.u.def.value
3504                            + sec->output_section->vma
3505                            + sec->output_offset);
3506         }
3507       else
3508         {
3509           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3510           rela.r_addend = 0;
3511         }
3512
3513       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3514                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3515       SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3516     }
3517
3518   if (h->needs_copy)
3519     {
3520       asection *s;
3521       Elf_Internal_Rela rela;
3522
3523       /* This symbols needs a copy reloc.  Set it up.  */
3524       BFD_ASSERT (h->dynindx != -1);
3525
3526       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3527                                    ".rela.bss");
3528       BFD_ASSERT (s != NULL);
3529
3530       rela.r_offset = (h->root.u.def.value
3531                        + h->root.u.def.section->output_section->vma
3532                        + h->root.u.def.section->output_offset);
3533       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3534       rela.r_addend = 0;
3535       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3536     }
3537
3538   /* Mark some specially defined symbols as absolute.  */
3539   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3540       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3541       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3542     sym->st_shndx = SHN_ABS;
3543
3544   return TRUE;
3545 }
3546
3547 /* Finish up the dynamic sections.  */
3548
3549 #ifdef BFD64
3550 static bfd_boolean
3551 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3552                     bfd *dynobj, asection *sdyn,
3553                     asection *splt ATTRIBUTE_UNUSED)
3554 {
3555   Elf64_External_Dyn *dyncon, *dynconend;
3556   int stt_regidx = -1;
3557
3558   dyncon = (Elf64_External_Dyn *) sdyn->contents;
3559   dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3560   for (; dyncon < dynconend; dyncon++)
3561     {
3562       Elf_Internal_Dyn dyn;
3563       const char *name;
3564       bfd_boolean size;
3565
3566       bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3567
3568       switch (dyn.d_tag)
3569         {
3570         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3571         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3572         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3573         case DT_SPARC_REGISTER:
3574           if (stt_regidx == -1)
3575             {
3576               stt_regidx =
3577                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3578               if (stt_regidx == -1)
3579                 return FALSE;
3580             }
3581           dyn.d_un.d_val = stt_regidx++;
3582           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3583           /* fallthrough */
3584         default:          name = NULL; size = FALSE; break;
3585         }
3586
3587       if (name != NULL)
3588         {
3589           asection *s;
3590
3591           s = bfd_get_section_by_name (output_bfd, name);
3592           if (s == NULL)
3593             dyn.d_un.d_val = 0;
3594           else
3595             {
3596               if (! size)
3597                 dyn.d_un.d_ptr = s->vma;
3598               else
3599                 dyn.d_un.d_val = s->size;
3600             }
3601           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3602         }
3603     }
3604   return TRUE;
3605 }
3606 #endif
3607
3608 static bfd_boolean
3609 sparc32_finish_dyn (bfd *output_bfd,
3610                     struct bfd_link_info *info ATTRIBUTE_UNUSED,
3611                     bfd *dynobj, asection *sdyn,
3612                     asection *splt ATTRIBUTE_UNUSED)
3613 {
3614   Elf32_External_Dyn *dyncon, *dynconend;
3615
3616   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3617   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3618   for (; dyncon < dynconend; dyncon++)
3619     {
3620       Elf_Internal_Dyn dyn;
3621       const char *name;
3622       bfd_boolean size;
3623
3624       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3625
3626       switch (dyn.d_tag)
3627         {
3628         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3629         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3630         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3631         default:          name = NULL; size = FALSE; break;
3632         }
3633
3634       if (name != NULL)
3635         {
3636           asection *s;
3637
3638           s = bfd_get_section_by_name (output_bfd, name);
3639           if (s == NULL)
3640             dyn.d_un.d_val = 0;
3641           else
3642             {
3643               if (! size)
3644                 dyn.d_un.d_ptr = s->vma;
3645               else
3646                 dyn.d_un.d_val = s->size;
3647             }
3648           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3649         }
3650     }
3651   return TRUE;
3652 }
3653
3654 bfd_boolean
3655 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3656 {
3657   bfd *dynobj;
3658   asection *sdyn;
3659   struct _bfd_sparc_elf_link_hash_table *htab;
3660
3661   htab = _bfd_sparc_elf_hash_table (info);
3662   dynobj = htab->elf.dynobj;
3663
3664   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3665
3666   if (elf_hash_table (info)->dynamic_sections_created)
3667     {
3668       asection *splt;
3669       bfd_boolean ret;
3670
3671       splt = bfd_get_section_by_name (dynobj, ".plt");
3672       BFD_ASSERT (splt != NULL && sdyn != NULL);
3673
3674 #ifdef BFD64
3675       if (ABI_64_P (output_bfd))
3676         ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3677       else
3678 #endif
3679         ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3680
3681       if (ret != TRUE)
3682         return ret;
3683
3684       /* Initialize the contents of the .plt section.  */
3685       if (splt->size > 0)
3686         {
3687           if (ABI_64_P (output_bfd))
3688             memset (splt->contents, 0, 4 * PLT64_ENTRY_SIZE);
3689           else
3690             {
3691               memset (splt->contents, 0, 4 * PLT32_ENTRY_SIZE);
3692               bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3693                           splt->contents + splt->size - 4);
3694             }
3695         }
3696
3697       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3698         (ABI_64_P (output_bfd) ? PLT64_ENTRY_SIZE : PLT32_ENTRY_SIZE);
3699     }
3700
3701   /* Set the first entry in the global offset table to the address of
3702      the dynamic section.  */
3703   if (htab->sgot && htab->sgot->size > 0)
3704     {
3705       bfd_vma val = (sdyn ?
3706                      sdyn->output_section->vma + sdyn->output_offset :
3707                      0);
3708
3709       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
3710     }
3711
3712   if (htab->sgot)
3713     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
3714       SPARC_ELF_WORD_BYTES (htab);
3715
3716   return TRUE;
3717 }
3718
3719 \f
3720 /* Set the right machine number for a SPARC ELF file.  */
3721
3722 bfd_boolean
3723 _bfd_sparc_elf_object_p (bfd *abfd)
3724 {
3725   if (ABI_64_P (abfd))
3726     {
3727       unsigned long mach = bfd_mach_sparc_v9;
3728
3729       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3730         mach = bfd_mach_sparc_v9b;
3731       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3732         mach = bfd_mach_sparc_v9a;
3733       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3734     }
3735   else
3736     {
3737       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3738         {
3739           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3740             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3741                                               bfd_mach_sparc_v8plusb);
3742           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3743             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3744                                               bfd_mach_sparc_v8plusa);
3745           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3746             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3747                                               bfd_mach_sparc_v8plus);
3748           else
3749             return FALSE;
3750         }
3751       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3752         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3753                                           bfd_mach_sparc_sparclite_le);
3754       else
3755         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3756     }
3757 }
3758
3759 /* Return address for Ith PLT stub in section PLT, for relocation REL
3760    or (bfd_vma) -1 if it should not be included.  */
3761
3762 bfd_vma
3763 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
3764 {
3765   if (ABI_64_P (plt->owner))
3766     {
3767       bfd_vma j;
3768
3769       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
3770       if (i < PLT64_LARGE_THRESHOLD)
3771         return plt->vma + i * PLT64_ENTRY_SIZE;
3772
3773       j = (i - PLT64_LARGE_THRESHOLD) % 160;
3774       i -= j;
3775       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
3776     }
3777   else
3778     return rel->address;
3779 }