bfd/elfxx-sparc.c

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