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 /* Update the got entry reference counts for the section being removed.  */
1834 bfd_boolean
1835 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1836                               asection *sec, const Elf_Internal_Rela *relocs)
1837 {
1838   struct _bfd_sparc_elf_link_hash_table *htab;
1839   Elf_Internal_Shdr *symtab_hdr;
1840   struct elf_link_hash_entry **sym_hashes;
1841   bfd_signed_vma *local_got_refcounts;
1842   const Elf_Internal_Rela *rel, *relend;
1843
1844   if (info->relocatable)
1845     return TRUE;
1846
1847   BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1848
1849   elf_section_data (sec)->local_dynrel = NULL;
1850
1851   htab = _bfd_sparc_elf_hash_table (info);
1852   BFD_ASSERT (htab != NULL);
1853   symtab_hdr = &elf_symtab_hdr (abfd);
1854   sym_hashes = elf_sym_hashes (abfd);
1855   local_got_refcounts = elf_local_got_refcounts (abfd);
1856
1857   relend = relocs + sec->reloc_count;
1858   for (rel = relocs; rel < relend; rel++)
1859     {
1860       unsigned long r_symndx;
1861       unsigned int r_type;
1862       struct elf_link_hash_entry *h = NULL;
1863
1864       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1865       if (r_symndx >= symtab_hdr->sh_info)
1866         {
1867           struct _bfd_sparc_elf_link_hash_entry *eh;
1868           struct _bfd_sparc_elf_dyn_relocs **pp;
1869           struct _bfd_sparc_elf_dyn_relocs *p;
1870
1871           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1872           while (h->root.type == bfd_link_hash_indirect
1873                  || h->root.type == bfd_link_hash_warning)
1874             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1875           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1876           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1877             if (p->sec == sec)
1878               {
1879                 /* Everything must go for SEC.  */
1880                 *pp = p->next;
1881                 break;
1882               }
1883         }
1884
1885       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1886       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1887       switch (r_type)
1888         {
1889         case R_SPARC_TLS_LDM_HI22:
1890         case R_SPARC_TLS_LDM_LO10:
1891           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1892             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1893           break;
1894
1895         case R_SPARC_TLS_GD_HI22:
1896         case R_SPARC_TLS_GD_LO10:
1897         case R_SPARC_TLS_IE_HI22:
1898         case R_SPARC_TLS_IE_LO10:
1899         case R_SPARC_GOT10:
1900         case R_SPARC_GOT13:
1901         case R_SPARC_GOT22:
1902         case R_SPARC_GOTDATA_HIX22:
1903         case R_SPARC_GOTDATA_LOX10:
1904         case R_SPARC_GOTDATA_OP_HIX22:
1905         case R_SPARC_GOTDATA_OP_LOX10:
1906           if (h != NULL)
1907             {
1908               if (h->got.refcount > 0)
1909                 h->got.refcount--;
1910             }
1911           else
1912             {
1913               switch (r_type)
1914                 {
1915                 case R_SPARC_GOTDATA_OP_HIX22:
1916                 case R_SPARC_GOTDATA_OP_LOX10:
1917                   break;
1918
1919                 default:
1920                   if (local_got_refcounts[r_symndx] > 0)
1921                     local_got_refcounts[r_symndx]--;
1922                   break;
1923                 }
1924             }
1925           break;
1926
1927         case R_SPARC_PC10:
1928         case R_SPARC_PC22:
1929         case R_SPARC_PC_HH22:
1930         case R_SPARC_PC_HM10:
1931         case R_SPARC_PC_LM22:
1932           if (h != NULL
1933               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1934             break;
1935           /* Fall through.  */
1936
1937         case R_SPARC_DISP8:
1938         case R_SPARC_DISP16:
1939         case R_SPARC_DISP32:
1940         case R_SPARC_DISP64:
1941         case R_SPARC_WDISP30:
1942         case R_SPARC_WDISP22:
1943         case R_SPARC_WDISP19:
1944         case R_SPARC_WDISP16:
1945         case R_SPARC_8:
1946         case R_SPARC_16:
1947         case R_SPARC_32:
1948         case R_SPARC_HI22:
1949         case R_SPARC_22:
1950         case R_SPARC_13:
1951         case R_SPARC_LO10:
1952         case R_SPARC_UA16:
1953         case R_SPARC_UA32:
1954         case R_SPARC_PLT32:
1955         case R_SPARC_10:
1956         case R_SPARC_11:
1957         case R_SPARC_64:
1958         case R_SPARC_OLO10:
1959         case R_SPARC_HH22:
1960         case R_SPARC_HM10:
1961         case R_SPARC_LM22:
1962         case R_SPARC_7:
1963         case R_SPARC_5:
1964         case R_SPARC_6:
1965         case R_SPARC_HIX22:
1966         case R_SPARC_LOX10:
1967         case R_SPARC_H44:
1968         case R_SPARC_M44:
1969         case R_SPARC_L44:
1970         case R_SPARC_UA64:
1971           if (info->shared)
1972             break;
1973           /* Fall through.  */
1974
1975         case R_SPARC_WPLT30:
1976           if (h != NULL)
1977             {
1978               if (h->plt.refcount > 0)
1979                 h->plt.refcount--;
1980             }
1981           break;
1982
1983         default:
1984           break;
1985         }
1986     }
1987
1988   return TRUE;
1989 }
1990
1991 /* Adjust a symbol defined by a dynamic object and referenced by a
1992    regular object.  The current definition is in some section of the
1993    dynamic object, but we're not including those sections.  We have to
1994    change the definition to something the rest of the link can
1995    understand.  */
1996
1997 bfd_boolean
1998 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1999                                      struct elf_link_hash_entry *h)
2000 {
2001   struct _bfd_sparc_elf_link_hash_table *htab;
2002   struct _bfd_sparc_elf_link_hash_entry * eh;
2003   struct _bfd_sparc_elf_dyn_relocs *p;
2004   asection *s;
2005
2006   htab = _bfd_sparc_elf_hash_table (info);
2007   BFD_ASSERT (htab != NULL);
2008
2009   /* Make sure we know what is going on here.  */
2010   BFD_ASSERT (htab->elf.dynobj != NULL
2011               && (h->needs_plt
2012                   || h->type == STT_GNU_IFUNC
2013                   || h->u.weakdef != NULL
2014                   || (h->def_dynamic
2015                       && h->ref_regular
2016                       && !h->def_regular)));
2017
2018   /* If this is a function, put it in the procedure linkage table.  We
2019      will fill in the contents of the procedure linkage table later
2020      (although we could actually do it here).  The STT_NOTYPE
2021      condition is a hack specifically for the Oracle libraries
2022      delivered for Solaris; for some inexplicable reason, they define
2023      some of their functions as STT_NOTYPE when they really should be
2024      STT_FUNC.  */
2025   if (h->type == STT_FUNC
2026       || h->type == STT_GNU_IFUNC
2027       || h->needs_plt
2028       || (h->type == STT_NOTYPE
2029           && (h->root.type == bfd_link_hash_defined
2030               || h->root.type == bfd_link_hash_defweak)
2031           && (h->root.u.def.section->flags & SEC_CODE) != 0))
2032     {
2033       if (h->plt.refcount <= 0
2034           || (h->type != STT_GNU_IFUNC
2035               && (SYMBOL_CALLS_LOCAL (info, h)
2036                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2037                       && h->root.type == bfd_link_hash_undefweak))))
2038         {
2039           /* This case can occur if we saw a WPLT30 reloc in an input
2040              file, but the symbol was never referred to by a dynamic
2041              object, or if all references were garbage collected.  In
2042              such a case, we don't actually need to build a procedure
2043              linkage table, and we can just do a WDISP30 reloc instead.  */
2044           h->plt.offset = (bfd_vma) -1;
2045           h->needs_plt = 0;
2046         }
2047
2048       return TRUE;
2049     }
2050   else
2051     h->plt.offset = (bfd_vma) -1;
2052
2053   /* If this is a weak symbol, and there is a real definition, the
2054      processor independent code will have arranged for us to see the
2055      real definition first, and we can just use the same value.  */
2056   if (h->u.weakdef != NULL)
2057     {
2058       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2059                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2060       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2061       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2062       return TRUE;
2063     }
2064
2065   /* This is a reference to a symbol defined by a dynamic object which
2066      is not a function.  */
2067
2068   /* If we are creating a shared library, we must presume that the
2069      only references to the symbol are via the global offset table.
2070      For such cases we need not do anything here; the relocations will
2071      be handled correctly by relocate_section.  */
2072   if (info->shared)
2073     return TRUE;
2074
2075   /* If there are no references to this symbol that do not use the
2076      GOT, we don't need to generate a copy reloc.  */
2077   if (!h->non_got_ref)
2078     return TRUE;
2079
2080   /* If -z nocopyreloc was given, we won't generate them either.  */
2081   if (info->nocopyreloc)
2082     {
2083       h->non_got_ref = 0;
2084       return TRUE;
2085     }
2086
2087   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2088   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2089     {
2090       s = p->sec->output_section;
2091       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2092         break;
2093     }
2094
2095   /* If we didn't find any dynamic relocs in read-only sections, then
2096      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2097   if (p == NULL)
2098     {
2099       h->non_got_ref = 0;
2100       return TRUE;
2101     }
2102
2103   if (h->size == 0)
2104     {
2105       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2106                              h->root.root.string);
2107       return TRUE;
2108     }
2109
2110   /* We must allocate the symbol in our .dynbss section, which will
2111      become part of the .bss section of the executable.  There will be
2112      an entry for this symbol in the .dynsym section.  The dynamic
2113      object will contain position independent code, so all references
2114      from the dynamic object to this symbol will go through the global
2115      offset table.  The dynamic linker will use the .dynsym entry to
2116      determine the address it must put in the global offset table, so
2117      both the dynamic object and the regular object will refer to the
2118      same memory location for the variable.  */
2119
2120   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2121      to copy the initial value out of the dynamic object and into the
2122      runtime process image.  We need to remember the offset into the
2123      .rel.bss section we are going to use.  */
2124   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2125     {
2126       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2127       h->needs_copy = 1;
2128     }
2129
2130   s = htab->sdynbss;
2131
2132   return _bfd_elf_adjust_dynamic_copy (h, s);
2133 }
2134
2135 /* Allocate space in .plt, .got and associated reloc sections for
2136    dynamic relocs.  */
2137
2138 static bfd_boolean
2139 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2140 {
2141   struct bfd_link_info *info;
2142   struct _bfd_sparc_elf_link_hash_table *htab;
2143   struct _bfd_sparc_elf_link_hash_entry *eh;
2144   struct _bfd_sparc_elf_dyn_relocs *p;
2145
2146   if (h->root.type == bfd_link_hash_indirect)
2147     return TRUE;
2148
2149   info = (struct bfd_link_info *) inf;
2150   htab = _bfd_sparc_elf_hash_table (info);
2151   BFD_ASSERT (htab != NULL);
2152
2153   if ((htab->elf.dynamic_sections_created
2154        && h->plt.refcount > 0)
2155       || (h->type == STT_GNU_IFUNC
2156           && h->def_regular
2157           && h->ref_regular))
2158     {
2159       /* Make sure this symbol is output as a dynamic symbol.
2160          Undefined weak syms won't yet be marked as dynamic.  */
2161       if (h->dynindx == -1
2162           && !h->forced_local)
2163         {
2164           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2165             return FALSE;
2166         }
2167
2168       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2169           || (h->type == STT_GNU_IFUNC
2170               && h->def_regular))
2171         {
2172           asection *s = htab->elf.splt;
2173
2174           if (s == NULL)
2175             s = htab->elf.iplt;
2176
2177           /* Allocate room for the header.  */
2178           if (s->size == 0)
2179             {
2180               s->size = htab->plt_header_size;
2181
2182               /* Allocate space for the .rela.plt.unloaded relocations.  */
2183               if (htab->is_vxworks && !info->shared)
2184                 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2185             }
2186
2187           /* The procedure linkage table size is bounded by the magnitude
2188              of the offset we can describe in the entry.  */
2189           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2190                           (((bfd_vma)1 << 31) << 1) : 0x400000))
2191             {
2192               bfd_set_error (bfd_error_bad_value);
2193               return FALSE;
2194             }
2195
2196           if (SPARC_ELF_WORD_BYTES(htab) == 8
2197               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2198             {
2199               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2200
2201
2202               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2203
2204               h->plt.offset = (s->size - (off * 8));
2205             }
2206           else
2207             h->plt.offset = s->size;
2208
2209           /* If this symbol is not defined in a regular file, and we are
2210              not generating a shared library, then set the symbol to this
2211              location in the .plt.  This is required to make function
2212              pointers compare as equal between the normal executable and
2213              the shared library.  */
2214           if (! info->shared
2215               && !h->def_regular)
2216             {
2217               h->root.u.def.section = s;
2218               h->root.u.def.value = h->plt.offset;
2219             }
2220
2221           /* Make room for this entry.  */
2222           s->size += htab->plt_entry_size;
2223
2224           /* We also need to make an entry in the .rela.plt section.  */
2225           if (s == htab->elf.splt)
2226             htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2227           else
2228             htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2229
2230           if (htab->is_vxworks)
2231             {
2232               /* Allocate space for the .got.plt entry.  */
2233               htab->elf.sgotplt->size += 4;
2234
2235               /* ...and for the .rela.plt.unloaded relocations.  */
2236               if (!info->shared)
2237                 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2238             }
2239         }
2240       else
2241         {
2242           h->plt.offset = (bfd_vma) -1;
2243           h->needs_plt = 0;
2244         }
2245     }
2246   else
2247     {
2248       h->plt.offset = (bfd_vma) -1;
2249       h->needs_plt = 0;
2250     }
2251
2252   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2253      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
2254   if (h->got.refcount > 0
2255       && !info->shared
2256       && h->dynindx == -1
2257       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2258     h->got.offset = (bfd_vma) -1;
2259   else if (h->got.refcount > 0)
2260     {
2261       asection *s;
2262       bfd_boolean dyn;
2263       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2264
2265       /* Make sure this symbol is output as a dynamic symbol.
2266          Undefined weak syms won't yet be marked as dynamic.  */
2267       if (h->dynindx == -1
2268           && !h->forced_local)
2269         {
2270           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2271             return FALSE;
2272         }
2273
2274       s = htab->elf.sgot;
2275       h->got.offset = s->size;
2276       s->size += SPARC_ELF_WORD_BYTES (htab);
2277       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
2278       if (tls_type == GOT_TLS_GD)
2279         s->size += SPARC_ELF_WORD_BYTES (htab);
2280       dyn = htab->elf.dynamic_sections_created;
2281       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2282          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2283          global.  */
2284       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2285           || tls_type == GOT_TLS_IE
2286           || h->type == STT_GNU_IFUNC)
2287         htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2288       else if (tls_type == GOT_TLS_GD)
2289         htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2290       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2291         htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2292     }
2293   else
2294     h->got.offset = (bfd_vma) -1;
2295
2296   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2297   if (eh->dyn_relocs == NULL)
2298     return TRUE;
2299
2300   /* In the shared -Bsymbolic case, discard space allocated for
2301      dynamic pc-relative relocs against symbols which turn out to be
2302      defined in regular objects.  For the normal shared case, discard
2303      space for pc-relative relocs that have become local due to symbol
2304      visibility changes.  */
2305
2306   if (info->shared)
2307     {
2308       if (SYMBOL_CALLS_LOCAL (info, h))
2309         {
2310           struct _bfd_sparc_elf_dyn_relocs **pp;
2311
2312           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2313             {
2314               p->count -= p->pc_count;
2315               p->pc_count = 0;
2316               if (p->count == 0)
2317                 *pp = p->next;
2318               else
2319                 pp = &p->next;
2320             }
2321         }
2322
2323       if (htab->is_vxworks)
2324         {
2325           struct _bfd_sparc_elf_dyn_relocs **pp;
2326
2327           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2328             {
2329               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2330                 *pp = p->next;
2331               else
2332                 pp = &p->next;
2333             }
2334         }
2335
2336       /* Also discard relocs on undefined weak syms with non-default
2337          visibility.  */
2338       if (eh->dyn_relocs != NULL
2339           && h->root.type == bfd_link_hash_undefweak)
2340         {
2341           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2342             eh->dyn_relocs = NULL;
2343
2344           /* Make sure undefined weak symbols are output as a dynamic
2345              symbol in PIEs.  */
2346           else if (h->dynindx == -1
2347                    && !h->forced_local)
2348             {
2349               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2350                 return FALSE;
2351             }
2352         }
2353     }
2354   else
2355     {
2356       /* For the non-shared case, discard space for relocs against
2357          symbols which turn out to need copy relocs or are not
2358          dynamic.  */
2359
2360       if (!h->non_got_ref
2361           && ((h->def_dynamic
2362                && !h->def_regular)
2363               || (htab->elf.dynamic_sections_created
2364                   && (h->root.type == bfd_link_hash_undefweak
2365                       || h->root.type == bfd_link_hash_undefined))))
2366         {
2367           /* Make sure this symbol is output as a dynamic symbol.
2368              Undefined weak syms won't yet be marked as dynamic.  */
2369           if (h->dynindx == -1
2370               && !h->forced_local)
2371             {
2372               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2373                 return FALSE;
2374             }
2375
2376           /* If that succeeded, we know we'll be keeping all the
2377              relocs.  */
2378           if (h->dynindx != -1)
2379             goto keep;
2380         }
2381
2382       eh->dyn_relocs = NULL;
2383
2384     keep: ;
2385     }
2386
2387   /* Finally, allocate space.  */
2388   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2389     {
2390       asection *sreloc = elf_section_data (p->sec)->sreloc;
2391       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2392     }
2393
2394   return TRUE;
2395 }
2396
2397 /* Allocate space in .plt, .got and associated reloc sections for
2398    local dynamic relocs.  */
2399
2400 static bfd_boolean
2401 allocate_local_dynrelocs (void **slot, void *inf)
2402 {
2403   struct elf_link_hash_entry *h
2404     = (struct elf_link_hash_entry *) *slot;
2405
2406   if (h->type != STT_GNU_IFUNC
2407       || !h->def_regular
2408       || !h->ref_regular
2409       || !h->forced_local
2410       || h->root.type != bfd_link_hash_defined)
2411     abort ();
2412
2413   return allocate_dynrelocs (h, inf);
2414 }
2415
2416 /* Find any dynamic relocs that apply to read-only sections.  */
2417
2418 static bfd_boolean
2419 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2420 {
2421   struct _bfd_sparc_elf_link_hash_entry *eh;
2422   struct _bfd_sparc_elf_dyn_relocs *p;
2423
2424   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2425   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2426     {
2427       asection *s = p->sec->output_section;
2428
2429       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2430         {
2431           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2432
2433           info->flags |= DF_TEXTREL;
2434
2435           /* Not an error, just cut short the traversal.  */
2436           return FALSE;
2437         }
2438     }
2439   return TRUE;
2440 }
2441
2442 /* Return true if the dynamic symbol for a given section should be
2443    omitted when creating a shared library.  */
2444
2445 bfd_boolean
2446 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2447                                     struct bfd_link_info *info,
2448                                     asection *p)
2449 {
2450   /* We keep the .got section symbol so that explicit relocations
2451      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2452      can be turned into relocations against the .got symbol.  */
2453   if (strcmp (p->name, ".got") == 0)
2454     return FALSE;
2455
2456   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2457 }
2458
2459 /* Set the sizes of the dynamic sections.  */
2460
2461 bfd_boolean
2462 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2463                                       struct bfd_link_info *info)
2464 {
2465   struct _bfd_sparc_elf_link_hash_table *htab;
2466   bfd *dynobj;
2467   asection *s;
2468   bfd *ibfd;
2469
2470   htab = _bfd_sparc_elf_hash_table (info);
2471   BFD_ASSERT (htab != NULL);
2472   dynobj = htab->elf.dynobj;
2473   BFD_ASSERT (dynobj != NULL);
2474
2475   if (elf_hash_table (info)->dynamic_sections_created)
2476     {
2477       /* Set the contents of the .interp section to the interpreter.  */
2478       if (info->executable)
2479         {
2480           s = bfd_get_section_by_name (dynobj, ".interp");
2481           BFD_ASSERT (s != NULL);
2482           s->size = htab->dynamic_interpreter_size;
2483           s->contents = (unsigned char *) htab->dynamic_interpreter;
2484         }
2485     }
2486
2487   /* Set up .got offsets for local syms, and space for local dynamic
2488      relocs.  */
2489   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2490     {
2491       bfd_signed_vma *local_got;
2492       bfd_signed_vma *end_local_got;
2493       char *local_tls_type;
2494       bfd_size_type locsymcount;
2495       Elf_Internal_Shdr *symtab_hdr;
2496       asection *srel;
2497
2498       if (! is_sparc_elf (ibfd))
2499         continue;
2500
2501       for (s = ibfd->sections; s != NULL; s = s->next)
2502         {
2503           struct _bfd_sparc_elf_dyn_relocs *p;
2504
2505           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2506             {
2507               if (!bfd_is_abs_section (p->sec)
2508                   && bfd_is_abs_section (p->sec->output_section))
2509                 {
2510                   /* Input section has been discarded, either because
2511                      it is a copy of a linkonce section or due to
2512                      linker script /DISCARD/, so we'll be discarding
2513                      the relocs too.  */
2514                 }
2515               else if (htab->is_vxworks
2516                        && strcmp (p->sec->output_section->name,
2517                                   ".tls_vars") == 0)
2518                 {
2519                   /* Relocations in vxworks .tls_vars sections are
2520                      handled specially by the loader.  */
2521                 }
2522               else if (p->count != 0)
2523                 {
2524                   srel = elf_section_data (p->sec)->sreloc;
2525                   if (!htab->elf.dynamic_sections_created)
2526                     srel = htab->elf.irelplt;
2527                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2528                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2529                     info->flags |= DF_TEXTREL;
2530                 }
2531             }
2532         }
2533
2534       local_got = elf_local_got_refcounts (ibfd);
2535       if (!local_got)
2536         continue;
2537
2538       symtab_hdr = &elf_symtab_hdr (ibfd);
2539       locsymcount = symtab_hdr->sh_info;
2540       end_local_got = local_got + locsymcount;
2541       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2542       s = htab->elf.sgot;
2543       srel = htab->elf.srelgot;
2544       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2545         {
2546           if (*local_got > 0)
2547             {
2548               *local_got = s->size;
2549               s->size += SPARC_ELF_WORD_BYTES (htab);
2550               if (*local_tls_type == GOT_TLS_GD)
2551                 s->size += SPARC_ELF_WORD_BYTES (htab);
2552               if (info->shared
2553                   || *local_tls_type == GOT_TLS_GD
2554                   || *local_tls_type == GOT_TLS_IE)
2555                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2556             }
2557           else
2558             *local_got = (bfd_vma) -1;
2559         }
2560     }
2561
2562   if (htab->tls_ldm_got.refcount > 0)
2563     {
2564       /* Allocate 2 got entries and 1 dynamic reloc for
2565          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2566       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2567       htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2568       htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2569     }
2570   else
2571     htab->tls_ldm_got.offset = -1;
2572
2573   /* Allocate global sym .plt and .got entries, and space for global
2574      sym dynamic relocs.  */
2575   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2576
2577   /* Allocate .plt and .got entries, and space for local symbols.  */
2578   htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2579
2580   if (! ABI_64_P (output_bfd)
2581       && !htab->is_vxworks
2582       && elf_hash_table (info)->dynamic_sections_created)
2583     {
2584       /* Make space for the trailing nop in .plt.  */
2585       if (htab->elf.splt->size > 0)
2586         htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2587
2588       /* If the .got section is more than 0x1000 bytes, we add
2589          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2590          bit relocations have a greater chance of working.
2591
2592          FIXME: Make this optimization work for 64-bit too.  */
2593       if (htab->elf.sgot->size >= 0x1000
2594           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2595         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2596     }
2597
2598   /* The check_relocs and adjust_dynamic_symbol entry points have
2599      determined the sizes of the various dynamic sections.  Allocate
2600      memory for them.  */
2601   for (s = dynobj->sections; s != NULL; s = s->next)
2602     {
2603       if ((s->flags & SEC_LINKER_CREATED) == 0)
2604         continue;
2605
2606       if (s == htab->elf.splt
2607           || s == htab->elf.sgot
2608           || s == htab->sdynbss
2609           || s == htab->elf.iplt
2610           || s == htab->elf.sgotplt)
2611         {
2612           /* Strip this section if we don't need it; see the
2613              comment below.  */
2614         }
2615       else if (CONST_STRNEQ (s->name, ".rela"))
2616         {
2617           if (s->size != 0)
2618             {
2619               /* We use the reloc_count field as a counter if we need
2620                  to copy relocs into the output file.  */
2621               s->reloc_count = 0;
2622             }
2623         }
2624       else
2625         {
2626           /* It's not one of our sections.  */
2627           continue;
2628         }
2629
2630       if (s->size == 0)
2631         {
2632           /* If we don't need this section, strip it from the
2633              output file.  This is mostly to handle .rela.bss and
2634              .rela.plt.  We must create both sections in
2635              create_dynamic_sections, because they must be created
2636              before the linker maps input sections to output
2637              sections.  The linker does that before
2638              adjust_dynamic_symbol is called, and it is that
2639              function which decides whether anything needs to go
2640              into these sections.  */
2641           s->flags |= SEC_EXCLUDE;
2642           continue;
2643         }
2644
2645       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2646         continue;
2647
2648       /* Allocate memory for the section contents.  Zero the memory
2649          for the benefit of .rela.plt, which has 4 unused entries
2650          at the beginning, and we don't want garbage.  */
2651       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2652       if (s->contents == NULL)
2653         return FALSE;
2654     }
2655
2656   if (elf_hash_table (info)->dynamic_sections_created)
2657     {
2658       /* Add some entries to the .dynamic section.  We fill in the
2659          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2660          must add the entries now so that we get the correct size for
2661          the .dynamic section.  The DT_DEBUG entry is filled in by the
2662          dynamic linker and used by the debugger.  */
2663 #define add_dynamic_entry(TAG, VAL) \
2664   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2665
2666       if (info->executable)
2667         {
2668           if (!add_dynamic_entry (DT_DEBUG, 0))
2669             return FALSE;
2670         }
2671
2672       if (htab->elf.srelplt->size != 0)
2673         {
2674           if (!add_dynamic_entry (DT_PLTGOT, 0)
2675               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2676               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2677               || !add_dynamic_entry (DT_JMPREL, 0))
2678             return FALSE;
2679         }
2680
2681       if (!add_dynamic_entry (DT_RELA, 0)
2682           || !add_dynamic_entry (DT_RELASZ, 0)
2683           || !add_dynamic_entry (DT_RELAENT,
2684                                  SPARC_ELF_RELA_BYTES (htab)))
2685         return FALSE;
2686
2687       /* If any dynamic relocs apply to a read-only section,
2688          then we need a DT_TEXTREL entry.  */
2689       if ((info->flags & DF_TEXTREL) == 0)
2690         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2691                                 (PTR) info);
2692
2693       if (info->flags & DF_TEXTREL)
2694         {
2695           if (!add_dynamic_entry (DT_TEXTREL, 0))
2696             return FALSE;
2697         }
2698
2699       if (ABI_64_P (output_bfd))
2700         {
2701           int reg;
2702           struct _bfd_sparc_elf_app_reg * app_regs;
2703           struct elf_strtab_hash *dynstr;
2704           struct elf_link_hash_table *eht = elf_hash_table (info);
2705
2706           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2707              entries if needed.  */
2708           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2709           dynstr = eht->dynstr;
2710
2711           for (reg = 0; reg < 4; reg++)
2712             if (app_regs [reg].name != NULL)
2713               {
2714                 struct elf_link_local_dynamic_entry *entry, *e;
2715
2716                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2717                   return FALSE;
2718
2719                 entry = (struct elf_link_local_dynamic_entry *)
2720                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2721                 if (entry == NULL)
2722                   return FALSE;
2723
2724                 /* We cheat here a little bit: the symbol will not be local, so we
2725                    put it at the end of the dynlocal linked list.  We will fix it
2726                    later on, as we have to fix other fields anyway.  */
2727                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2728                 entry->isym.st_size = 0;
2729                 if (*app_regs [reg].name != '\0')
2730                   entry->isym.st_name
2731                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2732                 else
2733                   entry->isym.st_name = 0;
2734                 entry->isym.st_other = 0;
2735                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2736                                                    STT_REGISTER);
2737                 entry->isym.st_shndx = app_regs [reg].shndx;
2738                 entry->isym.st_target_internal = 0;
2739                 entry->next = NULL;
2740                 entry->input_bfd = output_bfd;
2741                 entry->input_indx = -1;
2742
2743                 if (eht->dynlocal == NULL)
2744                   eht->dynlocal = entry;
2745                 else
2746                   {
2747                     for (e = eht->dynlocal; e->next; e = e->next)
2748                       ;
2749                     e->next = entry;
2750                   }
2751                 eht->dynsymcount++;
2752               }
2753         }
2754       if (htab->is_vxworks
2755           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2756         return FALSE;
2757     }
2758 #undef add_dynamic_entry
2759
2760   return TRUE;
2761 }
2762 \f
2763 bfd_boolean
2764 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2765 {
2766   if (!sec->used_by_bfd)
2767     {
2768       struct _bfd_sparc_elf_section_data *sdata;
2769       bfd_size_type amt = sizeof (*sdata);
2770
2771       sdata = bfd_zalloc (abfd, amt);
2772       if (sdata == NULL)
2773         return FALSE;
2774       sec->used_by_bfd = sdata;
2775     }
2776
2777   return _bfd_elf_new_section_hook (abfd, sec);
2778 }
2779
2780 bfd_boolean
2781 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2782                               struct bfd_section *section,
2783                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2784                               bfd_boolean *again)
2785 {
2786   if (link_info->relocatable)
2787     (*link_info->callbacks->einfo)
2788       (_("%P%F: --relax and -r may not be used together\n"));
2789
2790   *again = FALSE;
2791   sec_do_relax (section) = 1;
2792   return TRUE;
2793 }
2794 \f
2795 /* Return the base VMA address which should be subtracted from real addresses
2796    when resolving @dtpoff relocation.
2797    This is PT_TLS segment p_vaddr.  */
2798
2799 static bfd_vma
2800 dtpoff_base (struct bfd_link_info *info)
2801 {
2802   /* If tls_sec is NULL, we should have signalled an error already.  */
2803   if (elf_hash_table (info)->tls_sec == NULL)
2804     return 0;
2805   return elf_hash_table (info)->tls_sec->vma;
2806 }
2807
2808 /* Return the relocation value for @tpoff relocation
2809    if STT_TLS virtual address is ADDRESS.  */
2810
2811 static bfd_vma
2812 tpoff (struct bfd_link_info *info, bfd_vma address)
2813 {
2814   struct elf_link_hash_table *htab = elf_hash_table (info);
2815   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2816   bfd_vma static_tls_size;
2817
2818   /* If tls_sec is NULL, we should have signalled an error already.  */
2819   if (htab->tls_sec == NULL)
2820     return 0;
2821
2822   /* Consider special static TLS alignment requirements.  */
2823   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2824   return address - static_tls_size - htab->tls_sec->vma;
2825 }
2826
2827 /* Return the relocation value for a %gdop relocation.  */
2828
2829 static bfd_vma
2830 gdopoff (struct bfd_link_info *info, bfd_vma address)
2831 {
2832   struct elf_link_hash_table *htab = elf_hash_table (info);
2833   bfd_vma got_base;
2834
2835   got_base = (htab->hgot->root.u.def.value
2836               + htab->hgot->root.u.def.section->output_offset
2837               + htab->hgot->root.u.def.section->output_section->vma);
2838
2839   return address - got_base;
2840 }
2841
2842 /* Relocate a SPARC ELF section.  */
2843
2844 bfd_boolean
2845 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2846                                  struct bfd_link_info *info,
2847                                  bfd *input_bfd,
2848                                  asection *input_section,
2849                                  bfd_byte *contents,
2850                                  Elf_Internal_Rela *relocs,
2851                                  Elf_Internal_Sym *local_syms,
2852                                  asection **local_sections)
2853 {
2854   struct _bfd_sparc_elf_link_hash_table *htab;
2855   Elf_Internal_Shdr *symtab_hdr;
2856   struct elf_link_hash_entry **sym_hashes;
2857   bfd_vma *local_got_offsets;
2858   bfd_vma got_base;
2859   asection *sreloc;
2860   Elf_Internal_Rela *rel;
2861   Elf_Internal_Rela *relend;
2862   int num_relocs;
2863   bfd_boolean is_vxworks_tls;
2864
2865   htab = _bfd_sparc_elf_hash_table (info);
2866   BFD_ASSERT (htab != NULL);
2867   symtab_hdr = &elf_symtab_hdr (input_bfd);
2868   sym_hashes = elf_sym_hashes (input_bfd);
2869   local_got_offsets = elf_local_got_offsets (input_bfd);
2870
2871   if (elf_hash_table (info)->hgot == NULL)
2872     got_base = 0;
2873   else
2874     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2875
2876   sreloc = elf_section_data (input_section)->sreloc;
2877   /* We have to handle relocations in vxworks .tls_vars sections
2878      specially, because the dynamic loader is 'weird'.  */
2879   is_vxworks_tls = (htab->is_vxworks && info->shared
2880                     && !strcmp (input_section->output_section->name,
2881                                 ".tls_vars"));
2882
2883   rel = relocs;
2884   if (ABI_64_P (output_bfd))
2885     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2886   else
2887     num_relocs = input_section->reloc_count;
2888   relend = relocs + num_relocs;
2889   for (; rel < relend; rel++)
2890     {
2891       int r_type, tls_type;
2892       reloc_howto_type *howto;
2893       unsigned long r_symndx;
2894       struct elf_link_hash_entry *h;
2895       Elf_Internal_Sym *sym;
2896       asection *sec;
2897       bfd_vma relocation, off;
2898       bfd_reloc_status_type r;
2899       bfd_boolean is_plt = FALSE;
2900       bfd_boolean unresolved_reloc;
2901
2902       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2903       if (r_type == R_SPARC_GNU_VTINHERIT
2904           || r_type == R_SPARC_GNU_VTENTRY)
2905         continue;
2906
2907       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2908         {
2909           bfd_set_error (bfd_error_bad_value);
2910           return FALSE;
2911         }
2912       howto = _bfd_sparc_elf_howto_table + r_type;
2913
2914       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2915       h = NULL;
2916       sym = NULL;
2917       sec = NULL;
2918       unresolved_reloc = FALSE;
2919       if (r_symndx < symtab_hdr->sh_info)
2920         {
2921           sym = local_syms + r_symndx;
2922           sec = local_sections[r_symndx];
2923           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2924
2925           if (!info->relocatable
2926               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2927             {
2928               /* Relocate against local STT_GNU_IFUNC symbol.  */
2929               h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2930                                                 rel, FALSE);
2931               if (h == NULL)
2932                 abort ();
2933
2934               /* Set STT_GNU_IFUNC symbol value.  */
2935               h->root.u.def.value = sym->st_value;
2936               h->root.u.def.section = sec;
2937             }
2938         }
2939       else
2940         {
2941           bfd_boolean warned;
2942
2943           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2944                                    r_symndx, symtab_hdr, sym_hashes,
2945                                    h, sec, relocation,
2946                                    unresolved_reloc, warned);
2947           if (warned)
2948             {
2949               /* To avoid generating warning messages about truncated
2950                  relocations, set the relocation's address to be the same as
2951                  the start of this section.  */
2952               if (input_section->output_section != NULL)
2953                 relocation = input_section->output_section->vma;
2954               else
2955                 relocation = 0;
2956             }
2957         }
2958
2959       if (sec != NULL && elf_discarded_section (sec))
2960         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2961                                          rel, relend, howto, contents);
2962
2963       if (info->relocatable)
2964         continue;
2965
2966       if (h != NULL
2967           && h->type == STT_GNU_IFUNC
2968           && h->def_regular)
2969         {
2970           asection *plt_sec;
2971           const char *name;
2972
2973           if ((input_section->flags & SEC_ALLOC) == 0
2974               || h->plt.offset == (bfd_vma) -1)
2975             abort ();
2976
2977           plt_sec = htab->elf.splt;
2978           if (! plt_sec)
2979             plt_sec =htab->elf.iplt;
2980
2981           switch (r_type)
2982             {
2983             case R_SPARC_GOTDATA_OP:
2984               continue;
2985
2986             case R_SPARC_GOTDATA_OP_HIX22:
2987             case R_SPARC_GOTDATA_OP_LOX10:
2988               r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
2989                         ? R_SPARC_GOT22
2990                         : R_SPARC_GOT10);
2991               howto = _bfd_sparc_elf_howto_table + r_type;
2992               /* Fall through.  */
2993
2994             case R_SPARC_GOT10:
2995             case R_SPARC_GOT13:
2996             case R_SPARC_GOT22:
2997               if (htab->elf.sgot == NULL)
2998                 abort ();
2999               off = h->got.offset;
3000               if (off == (bfd_vma) -1)
3001                 abort();
3002               relocation = htab->elf.sgot->output_offset + off - got_base;
3003               goto do_relocation;
3004
3005             case R_SPARC_WPLT30:
3006             case R_SPARC_WDISP30:
3007               relocation = (plt_sec->output_section->vma
3008                             + plt_sec->output_offset + h->plt.offset);
3009               goto do_relocation;
3010
3011             case R_SPARC_32:
3012             case R_SPARC_64:
3013               if (info->shared && h->non_got_ref)
3014                 {
3015                   Elf_Internal_Rela outrel;
3016                   bfd_vma offset;
3017
3018                   offset = _bfd_elf_section_offset (output_bfd, info,
3019                                                     input_section,
3020                                                     rel->r_offset);
3021                   if (offset == (bfd_vma) -1
3022                       || offset == (bfd_vma) -2)
3023                     abort();
3024
3025                   outrel.r_offset = (input_section->output_section->vma
3026                                      + input_section->output_offset
3027                                      + offset);
3028
3029                   if (h->dynindx == -1
3030                       || h->forced_local
3031                       || info->executable)
3032                     {
3033                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3034                                                         0, R_SPARC_IRELATIVE);
3035                       outrel.r_addend = relocation + rel->r_addend;
3036                     }
3037                   else
3038                     {
3039                       if (h->dynindx == -1)
3040                         abort();
3041                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3042                       outrel.r_addend = rel->r_addend;
3043                     }
3044
3045                   sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3046                   continue;
3047                 }
3048
3049               relocation = (plt_sec->output_section->vma
3050                             + plt_sec->output_offset + h->plt.offset);
3051               goto do_relocation;
3052
3053             case R_SPARC_HI22:
3054             case R_SPARC_LO10:
3055               /* We should only see such relocs in static links.  */
3056               if (info->shared)
3057                 abort();
3058               relocation = (plt_sec->output_section->vma
3059                             + plt_sec->output_offset + h->plt.offset);
3060               goto do_relocation;
3061
3062             default:
3063               if (h->root.root.string)
3064                 name = h->root.root.string;
3065               else
3066                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3067                                          NULL);
3068               (*_bfd_error_handler)
3069                 (_("%B: relocation %s against STT_GNU_IFUNC "
3070                    "symbol `%s' isn't handled by %s"), input_bfd,
3071                  _bfd_sparc_elf_howto_table[r_type].name,
3072                  name, __FUNCTION__);
3073               bfd_set_error (bfd_error_bad_value);
3074               return FALSE;
3075             }
3076         }
3077
3078       switch (r_type)
3079         {
3080         case R_SPARC_GOTDATA_OP_HIX22:
3081         case R_SPARC_GOTDATA_OP_LOX10:
3082           if (SYMBOL_REFERENCES_LOCAL (info, h))
3083             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3084                       ? R_SPARC_GOTDATA_HIX22
3085                       : R_SPARC_GOTDATA_LOX10);
3086           else
3087             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3088                       ? R_SPARC_GOT22
3089                       : R_SPARC_GOT10);
3090           howto = _bfd_sparc_elf_howto_table + r_type;
3091           break;
3092
3093         case R_SPARC_GOTDATA_OP:
3094           if (SYMBOL_REFERENCES_LOCAL (info, h))
3095             {
3096               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3097
3098               /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3099               relocation = 0x80000000 | (insn & 0x3e07c01f);
3100               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3101             }
3102           continue;
3103         }
3104
3105       switch (r_type)
3106         {
3107         case R_SPARC_GOTDATA_HIX22:
3108         case R_SPARC_GOTDATA_LOX10:
3109           relocation = gdopoff (info, relocation);
3110           break;
3111
3112         case R_SPARC_GOT10:
3113         case R_SPARC_GOT13:
3114         case R_SPARC_GOT22:
3115           /* Relocation is to the entry for this symbol in the global
3116              offset table.  */
3117           if (htab->elf.sgot == NULL)
3118             abort ();
3119
3120           if (h != NULL)
3121             {
3122               bfd_boolean dyn;
3123
3124               off = h->got.offset;
3125               BFD_ASSERT (off != (bfd_vma) -1);
3126               dyn = elf_hash_table (info)->dynamic_sections_created;
3127
3128               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3129                   || (info->shared
3130                       && SYMBOL_REFERENCES_LOCAL (info, h)))
3131                 {
3132                   /* This is actually a static link, or it is a
3133                      -Bsymbolic link and the symbol is defined
3134                      locally, or the symbol was forced to be local
3135                      because of a version file.  We must initialize
3136                      this entry in the global offset table.  Since the
3137                      offset must always be a multiple of 8 for 64-bit
3138                      and 4 for 32-bit, we use the least significant bit
3139                      to record whether we have initialized it already.
3140
3141                      When doing a dynamic link, we create a .rela.got
3142                      relocation entry to initialize the value.  This
3143                      is done in the finish_dynamic_symbol routine.  */
3144                   if ((off & 1) != 0)
3145                     off &= ~1;
3146                   else
3147                     {
3148                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3149                                           htab->elf.sgot->contents + off);
3150                       h->got.offset |= 1;
3151                     }
3152                 }
3153               else
3154                 unresolved_reloc = FALSE;
3155             }
3156           else
3157             {
3158               BFD_ASSERT (local_got_offsets != NULL
3159                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3160
3161               off = local_got_offsets[r_symndx];
3162
3163               /* The offset must always be a multiple of 8 on 64-bit and
3164                  4 on 32-bit.  We use the least significant bit to record
3165                  whether we have already processed this entry.  */
3166               if ((off & 1) != 0)
3167                 off &= ~1;
3168               else
3169                 {
3170
3171                   if (info->shared)
3172                     {
3173                       asection *s;
3174                       Elf_Internal_Rela outrel;
3175
3176                       /* We need to generate a R_SPARC_RELATIVE reloc
3177                          for the dynamic linker.  */
3178                       s = htab->elf.srelgot;
3179                       BFD_ASSERT (s != NULL);
3180
3181                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3182                                          + htab->elf.sgot->output_offset
3183                                          + off);
3184                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3185                                                         0, R_SPARC_RELATIVE);
3186                       outrel.r_addend = relocation;
3187                       relocation = 0;
3188                       sparc_elf_append_rela (output_bfd, s, &outrel);
3189                     }
3190
3191                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3192                                       htab->elf.sgot->contents + off);
3193                   local_got_offsets[r_symndx] |= 1;
3194                 }
3195             }
3196           relocation = htab->elf.sgot->output_offset + off - got_base;
3197           break;
3198
3199         case R_SPARC_PLT32:
3200         case R_SPARC_PLT64:
3201           if (h == NULL || h->plt.offset == (bfd_vma) -1)
3202             {
3203               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3204               goto r_sparc_plt32;
3205             }
3206           /* Fall through.  */
3207
3208         case R_SPARC_WPLT30:
3209         case R_SPARC_HIPLT22:
3210         case R_SPARC_LOPLT10:
3211         case R_SPARC_PCPLT32:
3212         case R_SPARC_PCPLT22:
3213         case R_SPARC_PCPLT10:
3214         r_sparc_wplt30:
3215           /* Relocation is to the entry for this symbol in the
3216              procedure linkage table.  */
3217
3218           if (! ABI_64_P (output_bfd))
3219             {
3220               /* The Solaris native assembler will generate a WPLT30 reloc
3221                  for a local symbol if you assemble a call from one
3222                  section to another when using -K pic.  We treat it as
3223                  WDISP30.  */
3224               if (h == NULL)
3225                 break;
3226             }
3227           /* PR 7027: We need similar behaviour for 64-bit binaries.  */
3228           else if (r_type == R_SPARC_WPLT30 && h == NULL)
3229             break;
3230           else
3231             {
3232               BFD_ASSERT (h != NULL);
3233             }
3234
3235           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3236             {
3237               /* We didn't make a PLT entry for this symbol.  This
3238                  happens when statically linking PIC code, or when
3239                  using -Bsymbolic.  */
3240               break;
3241             }
3242
3243           relocation = (htab->elf.splt->output_section->vma
3244                         + htab->elf.splt->output_offset
3245                         + h->plt.offset);
3246           unresolved_reloc = FALSE;
3247           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3248             {
3249               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3250               is_plt = TRUE;
3251               goto r_sparc_plt32;
3252             }
3253           break;
3254
3255         case R_SPARC_PC10:
3256         case R_SPARC_PC22:
3257         case R_SPARC_PC_HH22:
3258         case R_SPARC_PC_HM10:
3259         case R_SPARC_PC_LM22:
3260           if (h != NULL
3261               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3262             break;
3263           /* Fall through.  */
3264         case R_SPARC_DISP8:
3265         case R_SPARC_DISP16:
3266         case R_SPARC_DISP32:
3267         case R_SPARC_DISP64:
3268         case R_SPARC_WDISP30:
3269         case R_SPARC_WDISP22:
3270         case R_SPARC_WDISP19:
3271         case R_SPARC_WDISP16:
3272         case R_SPARC_8:
3273         case R_SPARC_16:
3274         case R_SPARC_32:
3275         case R_SPARC_HI22:
3276         case R_SPARC_22:
3277         case R_SPARC_13:
3278         case R_SPARC_LO10:
3279         case R_SPARC_UA16:
3280         case R_SPARC_UA32:
3281         case R_SPARC_10:
3282         case R_SPARC_11:
3283         case R_SPARC_64:
3284         case R_SPARC_OLO10:
3285         case R_SPARC_HH22:
3286         case R_SPARC_HM10:
3287         case R_SPARC_LM22:
3288         case R_SPARC_7:
3289         case R_SPARC_5:
3290         case R_SPARC_6:
3291         case R_SPARC_HIX22:
3292         case R_SPARC_LOX10:
3293         case R_SPARC_H44:
3294         case R_SPARC_M44:
3295         case R_SPARC_L44:
3296         case R_SPARC_UA64:
3297         r_sparc_plt32:
3298           if ((input_section->flags & SEC_ALLOC) == 0
3299               || is_vxworks_tls)
3300             break;
3301
3302           if ((info->shared
3303                && (h == NULL
3304                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3305                    || h->root.type != bfd_link_hash_undefweak)
3306                && (! howto->pc_relative
3307                    || !SYMBOL_CALLS_LOCAL (info, h)))
3308               || (!info->shared
3309                   && h != NULL
3310                   && h->dynindx != -1
3311                   && !h->non_got_ref
3312                   && ((h->def_dynamic
3313                        && !h->def_regular)
3314                       || h->root.type == bfd_link_hash_undefweak
3315                       || h->root.type == bfd_link_hash_undefined)))
3316             {
3317               Elf_Internal_Rela outrel;
3318               bfd_boolean skip, relocate = FALSE;
3319
3320               /* When generating a shared object, these relocations
3321                  are copied into the output file to be resolved at run
3322                  time.  */
3323
3324               BFD_ASSERT (sreloc != NULL);
3325
3326               skip = FALSE;
3327
3328               outrel.r_offset =
3329                 _bfd_elf_section_offset (output_bfd, info, input_section,
3330                                          rel->r_offset);
3331               if (outrel.r_offset == (bfd_vma) -1)
3332                 skip = TRUE;
3333               else if (outrel.r_offset == (bfd_vma) -2)
3334                 skip = TRUE, relocate = TRUE;
3335               outrel.r_offset += (input_section->output_section->vma
3336                                   + input_section->output_offset);
3337
3338               /* Optimize unaligned reloc usage now that we know where
3339                  it finally resides.  */
3340               switch (r_type)
3341                 {
3342                 case R_SPARC_16:
3343                   if (outrel.r_offset & 1)
3344                     r_type = R_SPARC_UA16;
3345                   break;
3346                 case R_SPARC_UA16:
3347                   if (!(outrel.r_offset & 1))
3348                     r_type = R_SPARC_16;
3349                   break;
3350                 case R_SPARC_32:
3351                   if (outrel.r_offset & 3)
3352                     r_type = R_SPARC_UA32;
3353                   break;
3354                 case R_SPARC_UA32:
3355                   if (!(outrel.r_offset & 3))
3356                     r_type = R_SPARC_32;
3357                   break;
3358                 case R_SPARC_64:
3359                   if (outrel.r_offset & 7)
3360                     r_type = R_SPARC_UA64;
3361                   break;
3362                 case R_SPARC_UA64:
3363                   if (!(outrel.r_offset & 7))
3364                     r_type = R_SPARC_64;
3365                   break;
3366                 case R_SPARC_DISP8:
3367                 case R_SPARC_DISP16:
3368                 case R_SPARC_DISP32:
3369                 case R_SPARC_DISP64:
3370                   /* If the symbol is not dynamic, we should not keep
3371                      a dynamic relocation.  But an .rela.* slot has been
3372                      allocated for it, output R_SPARC_NONE.
3373                      FIXME: Add code tracking needed dynamic relocs as
3374                      e.g. i386 has.  */
3375                   if (h->dynindx == -1)
3376                     skip = TRUE, relocate = TRUE;
3377                   break;
3378                 }
3379
3380               if (skip)
3381                 memset (&outrel, 0, sizeof outrel);
3382               /* h->dynindx may be -1 if the symbol was marked to
3383                  become local.  */
3384               else if (h != NULL &&
3385                        h->dynindx != -1
3386                        && (! is_plt
3387                            || !info->shared
3388                            || !SYMBOLIC_BIND (info, h)
3389                            || !h->def_regular))
3390                 {
3391                   BFD_ASSERT (h->dynindx != -1);
3392                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3393                   outrel.r_addend = rel->r_addend;
3394                 }
3395               else
3396                 {
3397                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3398                     {
3399                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3400                                                         0, R_SPARC_RELATIVE);
3401                       outrel.r_addend = relocation + rel->r_addend;
3402                     }
3403                   else
3404                     {
3405                       long indx;
3406
3407                       outrel.r_addend = relocation + rel->r_addend;
3408
3409                       if (is_plt)
3410                         sec = htab->elf.splt;
3411
3412                       if (bfd_is_abs_section (sec))
3413                         indx = 0;
3414                       else if (sec == NULL || sec->owner == NULL)
3415                         {
3416                           bfd_set_error (bfd_error_bad_value);
3417                           return FALSE;
3418                         }
3419                       else
3420                         {
3421                           asection *osec;
3422
3423                           /* We are turning this relocation into one
3424                              against a section symbol.  It would be
3425                              proper to subtract the symbol's value,
3426                              osec->vma, from the emitted reloc addend,
3427                              but ld.so expects buggy relocs.  */
3428                           osec = sec->output_section;
3429                           indx = elf_section_data (osec)->dynindx;
3430
3431                           if (indx == 0)
3432                             {
3433                               osec = htab->elf.text_index_section;
3434                               indx = elf_section_data (osec)->dynindx;
3435                             }
3436
3437                           /* FIXME: we really should be able to link non-pic
3438                              shared libraries.  */
3439                           if (indx == 0)
3440                             {
3441                               BFD_FAIL ();
3442                               (*_bfd_error_handler)
3443                                 (_("%B: probably compiled without -fPIC?"),
3444                                  input_bfd);
3445                               bfd_set_error (bfd_error_bad_value);
3446                               return FALSE;
3447                             }
3448                         }
3449
3450                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3451                                                         r_type);
3452                     }
3453                 }
3454
3455               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3456
3457               /* This reloc will be computed at runtime, so there's no
3458                  need to do anything now.  */
3459               if (! relocate)
3460                 continue;
3461             }
3462           break;
3463
3464         case R_SPARC_TLS_GD_HI22:
3465           if (! ABI_64_P (input_bfd)
3466               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3467             {
3468               /* R_SPARC_REV32 used the same reloc number as
3469                  R_SPARC_TLS_GD_HI22.  */
3470               r_type = R_SPARC_REV32;
3471               break;
3472             }
3473           /* Fall through */
3474
3475         case R_SPARC_TLS_GD_LO10:
3476         case R_SPARC_TLS_IE_HI22:
3477         case R_SPARC_TLS_IE_LO10:
3478           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3479           tls_type = GOT_UNKNOWN;
3480           if (h == NULL && local_got_offsets)
3481             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3482           else if (h != NULL)
3483             {
3484               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3485               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3486                 switch (SPARC_ELF_R_TYPE (rel->r_info))
3487                   {
3488                   case R_SPARC_TLS_GD_HI22:
3489                   case R_SPARC_TLS_IE_HI22:
3490                     r_type = R_SPARC_TLS_LE_HIX22;
3491                     break;
3492                   default:
3493                     r_type = R_SPARC_TLS_LE_LOX10;
3494                     break;
3495                   }
3496             }
3497           if (tls_type == GOT_TLS_IE)
3498             switch (r_type)
3499               {
3500               case R_SPARC_TLS_GD_HI22:
3501                 r_type = R_SPARC_TLS_IE_HI22;
3502                 break;
3503               case R_SPARC_TLS_GD_LO10:
3504                 r_type = R_SPARC_TLS_IE_LO10;
3505                 break;
3506               }
3507
3508           if (r_type == R_SPARC_TLS_LE_HIX22)
3509             {
3510               relocation = tpoff (info, relocation);
3511               break;
3512             }
3513           if (r_type == R_SPARC_TLS_LE_LOX10)
3514             {
3515               /* Change add into xor.  */
3516               relocation = tpoff (info, relocation);
3517               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3518                                                    contents + rel->r_offset)
3519                                        | 0x80182000), contents + rel->r_offset);
3520               break;
3521             }
3522
3523           if (h != NULL)
3524             {
3525               off = h->got.offset;
3526               h->got.offset |= 1;
3527             }
3528           else
3529             {
3530               BFD_ASSERT (local_got_offsets != NULL);
3531               off = local_got_offsets[r_symndx];
3532               local_got_offsets[r_symndx] |= 1;
3533             }
3534
3535         r_sparc_tlsldm:
3536           if (htab->elf.sgot == NULL)
3537             abort ();
3538
3539           if ((off & 1) != 0)
3540             off &= ~1;
3541           else
3542             {
3543               Elf_Internal_Rela outrel;
3544               int dr_type, indx;
3545
3546               if (htab->elf.srelgot == NULL)
3547                 abort ();
3548
3549               SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3550                                   htab->elf.sgot->contents + off);
3551               outrel.r_offset = (htab->elf.sgot->output_section->vma
3552                                  + htab->elf.sgot->output_offset + off);
3553               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3554               if (r_type == R_SPARC_TLS_IE_HI22
3555                   || r_type == R_SPARC_TLS_IE_LO10)
3556                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3557               else
3558                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3559               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3560                 outrel.r_addend = relocation - dtpoff_base (info);
3561               else
3562                 outrel.r_addend = 0;
3563               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3564               sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3565
3566               if (r_type == R_SPARC_TLS_GD_HI22
3567                   || r_type == R_SPARC_TLS_GD_LO10)
3568                 {
3569                   if (indx == 0)
3570                     {
3571                       BFD_ASSERT (! unresolved_reloc);
3572                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3573                                           relocation - dtpoff_base (info),
3574                                           (htab->elf.sgot->contents + off
3575                                            + SPARC_ELF_WORD_BYTES (htab)));
3576                     }
3577                   else
3578                     {
3579                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3580                                           (htab->elf.sgot->contents + off
3581                                            + SPARC_ELF_WORD_BYTES (htab)));
3582                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3583                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3584                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3585                       sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3586                                              &outrel);
3587                     }
3588                 }
3589               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3590                 {
3591                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3592                                       (htab->elf.sgot->contents + off
3593                                        + SPARC_ELF_WORD_BYTES (htab)));
3594                 }
3595             }
3596
3597           if (off >= (bfd_vma) -2)
3598             abort ();
3599
3600           relocation = htab->elf.sgot->output_offset + off - got_base;
3601           unresolved_reloc = FALSE;
3602           howto = _bfd_sparc_elf_howto_table + r_type;
3603           break;
3604
3605         case R_SPARC_TLS_LDM_HI22:
3606         case R_SPARC_TLS_LDM_LO10:
3607           if (! info->shared)
3608             {
3609               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3610               continue;
3611             }
3612           off = htab->tls_ldm_got.offset;
3613           htab->tls_ldm_got.offset |= 1;
3614           goto r_sparc_tlsldm;
3615
3616         case R_SPARC_TLS_LDO_HIX22:
3617         case R_SPARC_TLS_LDO_LOX10:
3618           if (info->shared)
3619             {
3620               relocation -= dtpoff_base (info);
3621               break;
3622             }
3623
3624           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3625                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3626           /* Fall through.  */
3627
3628         case R_SPARC_TLS_LE_HIX22:
3629         case R_SPARC_TLS_LE_LOX10:
3630           if (info->shared)
3631             {
3632               Elf_Internal_Rela outrel;
3633               bfd_boolean skip;
3634
3635               BFD_ASSERT (sreloc != NULL);
3636               skip = FALSE;
3637               outrel.r_offset =
3638                 _bfd_elf_section_offset (output_bfd, info, input_section,
3639                                          rel->r_offset);
3640               if (outrel.r_offset == (bfd_vma) -1)
3641                 skip = TRUE;
3642               else if (outrel.r_offset == (bfd_vma) -2)
3643                 skip = TRUE;
3644               outrel.r_offset += (input_section->output_section->vma
3645                                   + input_section->output_offset);
3646               if (skip)
3647                 memset (&outrel, 0, sizeof outrel);
3648               else
3649                 {
3650                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3651                   outrel.r_addend = relocation - dtpoff_base (info)
3652                                     + rel->r_addend;
3653                 }
3654
3655               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3656               continue;
3657             }
3658           relocation = tpoff (info, relocation);
3659           break;
3660
3661         case R_SPARC_TLS_LDM_CALL:
3662           if (! info->shared)
3663             {
3664               /* mov %g0, %o0 */
3665               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3666               continue;
3667             }
3668           /* Fall through */
3669
3670         case R_SPARC_TLS_GD_CALL:
3671           tls_type = GOT_UNKNOWN;
3672           if (h == NULL && local_got_offsets)
3673             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3674           else if (h != NULL)
3675             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3676           if (! info->shared
3677               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3678             {
3679               bfd_vma insn;
3680
3681               if (!info->shared && (h == NULL || h->dynindx == -1))
3682                 {
3683                   /* GD -> LE */
3684                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3685                   continue;
3686                 }
3687
3688               /* GD -> IE */
3689               if (rel + 1 < relend
3690                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3691                   && rel[1].r_offset == rel->r_offset + 4
3692                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3693                   && (((insn = bfd_get_32 (input_bfd,
3694                                            contents + rel[1].r_offset))
3695                        >> 25) & 0x1f) == 8)
3696                 {
3697                   /* We have
3698                      call __tls_get_addr, %tgd_call(foo)
3699                       add %reg1, %reg2, %o0, %tgd_add(foo)
3700                      and change it into IE:
3701                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3702                      add %g7, %o0, %o0, %tie_add(foo).
3703                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3704                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3705                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3706                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3707                               contents + rel->r_offset);
3708                   bfd_put_32 (output_bfd, 0x9001c008,
3709                               contents + rel->r_offset + 4);
3710                   rel++;
3711                   continue;
3712                 }
3713
3714               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3715               continue;
3716             }
3717
3718           h = (struct elf_link_hash_entry *)
3719               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3720                                     FALSE, TRUE);
3721           BFD_ASSERT (h != NULL);
3722           r_type = R_SPARC_WPLT30;
3723           howto = _bfd_sparc_elf_howto_table + r_type;
3724           goto r_sparc_wplt30;
3725
3726         case R_SPARC_TLS_GD_ADD:
3727           tls_type = GOT_UNKNOWN;
3728           if (h == NULL && local_got_offsets)
3729             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3730           else if (h != NULL)
3731             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3732           if (! info->shared || tls_type == GOT_TLS_IE)
3733             {
3734               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3735                  changed into IE:
3736                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3737                  or LE:
3738                  add %g7, %reg2, %reg3.  */
3739               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3740               if ((h != NULL && h->dynindx != -1) || info->shared)
3741                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3742               else
3743                 relocation = (insn & ~0x7c000) | 0x1c000;
3744               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3745             }
3746           continue;
3747
3748         case R_SPARC_TLS_LDM_ADD:
3749           if (! info->shared)
3750             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3751           continue;
3752
3753         case R_SPARC_TLS_LDO_ADD:
3754           if (! info->shared)
3755             {
3756               /* Change rs1 into %g7.  */
3757               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3758               insn = (insn & ~0x7c000) | 0x1c000;
3759               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3760             }
3761           continue;
3762
3763         case R_SPARC_TLS_IE_LD:
3764         case R_SPARC_TLS_IE_LDX:
3765           if (! info->shared && (h == NULL || h->dynindx == -1))
3766             {
3767               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3768               int rs2 = insn & 0x1f;
3769               int rd = (insn >> 25) & 0x1f;
3770
3771               if (rs2 == rd)
3772                 relocation = SPARC_NOP;
3773               else
3774                 relocation = 0x80100000 | (insn & 0x3e00001f);
3775               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3776             }
3777           continue;
3778
3779         case R_SPARC_TLS_IE_ADD:
3780           /* Totally useless relocation.  */
3781           continue;
3782
3783         case R_SPARC_TLS_DTPOFF32:
3784         case R_SPARC_TLS_DTPOFF64:
3785           relocation -= dtpoff_base (info);
3786           break;
3787
3788         default:
3789           break;
3790         }
3791
3792       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3793          because such sections are not SEC_ALLOC and thus ld.so will
3794          not process them.  */
3795       if (unresolved_reloc
3796           && !((input_section->flags & SEC_DEBUGGING) != 0
3797                && h->def_dynamic))
3798         (*_bfd_error_handler)
3799           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3800            input_bfd,
3801            input_section,
3802            (long) rel->r_offset,
3803            howto->name,
3804            h->root.root.string);
3805
3806       r = bfd_reloc_continue;
3807       if (r_type == R_SPARC_OLO10)
3808         {
3809             bfd_vma x;
3810
3811             if (! ABI_64_P (output_bfd))
3812               abort ();
3813
3814             relocation += rel->r_addend;
3815             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3816
3817             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3818             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3819             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3820
3821             r = bfd_check_overflow (howto->complain_on_overflow,
3822                                     howto->bitsize, howto->rightshift,
3823                                     bfd_arch_bits_per_address (input_bfd),
3824                                     relocation);
3825         }
3826       else if (r_type == R_SPARC_WDISP16)
3827         {
3828           bfd_vma x;
3829
3830           relocation += rel->r_addend;
3831           relocation -= (input_section->output_section->vma
3832                          + input_section->output_offset);
3833           relocation -= rel->r_offset;
3834
3835           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3836           x |= ((((relocation >> 2) & 0xc000) << 6)
3837                 | ((relocation >> 2) & 0x3fff));
3838           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3839
3840           r = bfd_check_overflow (howto->complain_on_overflow,
3841                                   howto->bitsize, howto->rightshift,
3842                                   bfd_arch_bits_per_address (input_bfd),
3843                                   relocation);
3844         }
3845       else if (r_type == R_SPARC_REV32)
3846         {
3847           bfd_vma x;
3848
3849           relocation = relocation + rel->r_addend;
3850
3851           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3852           x = x + relocation;
3853           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3854           r = bfd_reloc_ok;
3855         }
3856       else if (r_type == R_SPARC_TLS_LDO_HIX22
3857                || r_type == R_SPARC_TLS_LE_HIX22)
3858         {
3859           bfd_vma x;
3860
3861           relocation += rel->r_addend;
3862           if (r_type == R_SPARC_TLS_LE_HIX22)
3863             relocation ^= MINUS_ONE;
3864
3865           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3866           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3867           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3868           r = bfd_reloc_ok;
3869         }
3870       else if (r_type == R_SPARC_TLS_LDO_LOX10
3871                || r_type == R_SPARC_TLS_LE_LOX10)
3872         {
3873           bfd_vma x;
3874
3875           relocation += rel->r_addend;
3876           relocation &= 0x3ff;
3877           if (r_type == R_SPARC_TLS_LE_LOX10)
3878             relocation |= 0x1c00;
3879
3880           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3881           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3882           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3883
3884           r = bfd_reloc_ok;
3885         }
3886       else if (r_type == R_SPARC_HIX22
3887                || r_type == R_SPARC_GOTDATA_HIX22)
3888         {
3889           bfd_vma x;
3890
3891           relocation += rel->r_addend;
3892           if (r_type == R_SPARC_HIX22
3893               || (bfd_signed_vma) relocation < 0)
3894             relocation = relocation ^ MINUS_ONE;
3895
3896           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3897           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3898           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3899
3900           r = bfd_check_overflow (howto->complain_on_overflow,
3901                                   howto->bitsize, howto->rightshift,
3902                                   bfd_arch_bits_per_address (input_bfd),
3903                                   relocation);
3904         }
3905       else if (r_type == R_SPARC_LOX10
3906                || r_type == R_SPARC_GOTDATA_LOX10)
3907         {
3908           bfd_vma x;
3909
3910           relocation += rel->r_addend;
3911           if (r_type == R_SPARC_LOX10
3912               || (bfd_signed_vma) relocation < 0)
3913             relocation = (relocation & 0x3ff) | 0x1c00;
3914           else
3915             relocation = (relocation & 0x3ff);
3916
3917           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3918           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3919           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3920
3921           r = bfd_reloc_ok;
3922         }
3923       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3924                && sec_do_relax (input_section)
3925                && rel->r_offset + 4 < input_section->size)
3926         {
3927 #define G0              0
3928 #define O7              15
3929 #define XCC             (2 << 20)
3930 #define COND(x)         (((x)&0xf)<<25)
3931 #define CONDA           COND(0x8)
3932 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3933 #define INSN_BA         (F2(0,2) | CONDA)
3934 #define INSN_OR         F3(2, 0x2, 0)
3935 #define INSN_NOP        F2(0,4)
3936
3937           bfd_vma x, y;
3938
3939           /* If the instruction is a call with either:
3940              restore
3941              arithmetic instruction with rd == %o7
3942              where rs1 != %o7 and rs2 if it is register != %o7
3943              then we can optimize if the call destination is near
3944              by changing the call into a branch always.  */
3945           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3946           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3947           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3948             {
3949               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3950                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3951                        && (y & RD(~0)) == RD(O7)))
3952                   && (y & RS1(~0)) != RS1(O7)
3953                   && ((y & F3I(~0))
3954                       || (y & RS2(~0)) != RS2(O7)))
3955                 {
3956                   bfd_vma reloc;
3957
3958                   reloc = relocation + rel->r_addend - rel->r_offset;
3959                   reloc -= (input_section->output_section->vma
3960                             + input_section->output_offset);
3961
3962                   /* Ensure the branch fits into simm22.  */
3963                   if ((reloc & 3) == 0
3964                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3965                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3966                     {
3967                       reloc >>= 2;
3968
3969                       /* Check whether it fits into simm19.  */
3970                       if (((reloc & 0x3c0000) == 0
3971                            || (reloc & 0x3c0000) == 0x3c0000)
3972                           && (ABI_64_P (output_bfd)
3973                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3974                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3975                       else
3976                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3977                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3978                       r = bfd_reloc_ok;
3979                       if (rel->r_offset >= 4
3980                           && (y & (0xffffffff ^ RS1(~0)))
3981                              == (INSN_OR | RD(O7) | RS2(G0)))
3982                         {
3983                           bfd_vma z;
3984                           unsigned int reg;
3985
3986                           z = bfd_get_32 (input_bfd,
3987                                           contents + rel->r_offset - 4);
3988                           if ((z & (0xffffffff ^ RD(~0)))
3989                               != (INSN_OR | RS1(O7) | RS2(G0)))
3990                             break;
3991
3992                           /* The sequence was
3993                              or %o7, %g0, %rN
3994                              call foo
3995                              or %rN, %g0, %o7
3996
3997                              If call foo was replaced with ba, replace
3998                              or %rN, %g0, %o7 with nop.  */
3999
4000                           reg = (y & RS1(~0)) >> 14;
4001                           if (reg != ((z & RD(~0)) >> 25)
4002                               || reg == G0 || reg == O7)
4003                             break;
4004
4005                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4006                                       contents + rel->r_offset + 4);
4007                         }
4008
4009                     }
4010                 }
4011             }
4012         }
4013
4014       if (r == bfd_reloc_continue)
4015         {
4016 do_relocation:
4017           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4018                                         contents, rel->r_offset,
4019                                         relocation, rel->r_addend);
4020         }
4021       if (r != bfd_reloc_ok)
4022         {
4023           switch (r)
4024             {
4025             default:
4026             case bfd_reloc_outofrange:
4027               abort ();
4028             case bfd_reloc_overflow:
4029               {
4030                 const char *name;
4031
4032                 /* The Solaris native linker silently disregards overflows.
4033                    We don't, but this breaks stabs debugging info, whose
4034                    relocations are only 32-bits wide.  Ignore overflows in
4035                    this case and also for discarded entries.  */
4036                 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
4037                     && (((input_section->flags & SEC_DEBUGGING) != 0
4038                          && strcmp (bfd_section_name (input_bfd,
4039                                                       input_section),
4040                                     ".stab") == 0)
4041                         || _bfd_elf_section_offset (output_bfd, info,
4042                                                     input_section,
4043                                                     rel->r_offset)
4044                              == (bfd_vma)-1))
4045                   break;
4046
4047                 if (h != NULL)
4048                   {
4049                     /* Assume this is a call protected by other code that
4050                        detect the symbol is undefined.  If this is the case,
4051                        we can safely ignore the overflow.  If not, the
4052                        program is hosed anyway, and a little warning isn't
4053                        going to help.  */
4054                     if (h->root.type == bfd_link_hash_undefweak
4055                         && howto->pc_relative)
4056                       break;
4057
4058                     name = NULL;
4059                   }
4060                 else
4061                   {
4062                     name = bfd_elf_string_from_elf_section (input_bfd,
4063                                                             symtab_hdr->sh_link,
4064                                                             sym->st_name);
4065                     if (name == NULL)
4066                       return FALSE;
4067                     if (*name == '\0')
4068                       name = bfd_section_name (input_bfd, sec);
4069                   }
4070                 if (! ((*info->callbacks->reloc_overflow)
4071                        (info, (h ? &h->root : NULL), name, howto->name,
4072                         (bfd_vma) 0, input_bfd, input_section,
4073                         rel->r_offset)))
4074                   return FALSE;
4075               }
4076               break;
4077             }
4078         }
4079     }
4080
4081   return TRUE;
4082 }
4083
4084 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
4085    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
4086    is the offset of the associated .got.plt entry from
4087    _GLOBAL_OFFSET_TABLE_.  */
4088
4089 static void
4090 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4091                                bfd_vma plt_offset, bfd_vma plt_index,
4092                                bfd_vma got_offset)
4093 {
4094   bfd_vma got_base;
4095   const bfd_vma *plt_entry;
4096   struct _bfd_sparc_elf_link_hash_table *htab;
4097   bfd_byte *loc;
4098   Elf_Internal_Rela rela;
4099
4100   htab = _bfd_sparc_elf_hash_table (info);
4101   BFD_ASSERT (htab != NULL);
4102
4103   if (info->shared)
4104     {
4105       plt_entry = sparc_vxworks_shared_plt_entry;
4106       got_base = 0;
4107     }
4108   else
4109     {
4110       plt_entry = sparc_vxworks_exec_plt_entry;
4111       got_base = (htab->elf.hgot->root.u.def.value
4112                   + htab->elf.hgot->root.u.def.section->output_offset
4113                   + htab->elf.hgot->root.u.def.section->output_section->vma);
4114     }
4115
4116   /* Fill in the entry in the procedure linkage table.  */
4117   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4118               htab->elf.splt->contents + plt_offset);
4119   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4120               htab->elf.splt->contents + plt_offset + 4);
4121   bfd_put_32 (output_bfd, plt_entry[2],
4122               htab->elf.splt->contents + plt_offset + 8);
4123   bfd_put_32 (output_bfd, plt_entry[3],
4124               htab->elf.splt->contents + plt_offset + 12);
4125   bfd_put_32 (output_bfd, plt_entry[4],
4126               htab->elf.splt->contents + plt_offset + 16);
4127   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4128               htab->elf.splt->contents + plt_offset + 20);
4129   /* PC-relative displacement for a branch to the start of
4130      the PLT section.  */
4131   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4132                                           & 0x003fffff),
4133               htab->elf.splt->contents + plt_offset + 24);
4134   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4135               htab->elf.splt->contents + plt_offset + 28);
4136
4137   /* Fill in the .got.plt entry, pointing initially at the
4138      second half of the PLT entry.  */
4139   BFD_ASSERT (htab->elf.sgotplt != NULL);
4140   bfd_put_32 (output_bfd,
4141               htab->elf.splt->output_section->vma
4142               + htab->elf.splt->output_offset
4143               + plt_offset + 20,
4144               htab->elf.sgotplt->contents + got_offset);
4145
4146   /* Add relocations to .rela.plt.unloaded.  */
4147   if (!info->shared)
4148     {
4149       loc = (htab->srelplt2->contents
4150              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4151
4152       /* Relocate the initial sethi.  */
4153       rela.r_offset = (htab->elf.splt->output_section->vma
4154                        + htab->elf.splt->output_offset
4155                        + plt_offset);
4156       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4157       rela.r_addend = got_offset;
4158       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4159       loc += sizeof (Elf32_External_Rela);
4160
4161       /* Likewise the following or.  */
4162       rela.r_offset += 4;
4163       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4164       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4165       loc += sizeof (Elf32_External_Rela);
4166
4167       /* Relocate the .got.plt entry.  */
4168       rela.r_offset = (htab->elf.sgotplt->output_section->vma
4169                        + htab->elf.sgotplt->output_offset
4170                        + got_offset);
4171       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4172       rela.r_addend = plt_offset + 20;
4173       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4174     }
4175 }
4176
4177 /* Finish up dynamic symbol handling.  We set the contents of various
4178    dynamic sections here.  */
4179
4180 bfd_boolean
4181 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4182                                       struct bfd_link_info *info,
4183                                       struct elf_link_hash_entry *h,
4184                                       Elf_Internal_Sym *sym)
4185 {
4186   struct _bfd_sparc_elf_link_hash_table *htab;
4187   const struct elf_backend_data *bed;
4188
4189   htab = _bfd_sparc_elf_hash_table (info);
4190   BFD_ASSERT (htab != NULL);
4191   bed = get_elf_backend_data (output_bfd);
4192
4193   if (h->plt.offset != (bfd_vma) -1)
4194     {
4195       asection *splt;
4196       asection *srela;
4197       Elf_Internal_Rela rela;
4198       bfd_byte *loc;
4199       bfd_vma r_offset, got_offset;
4200       int rela_index;
4201
4202       /* When building a static executable, use .iplt and
4203          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4204       if (htab->elf.splt != NULL)
4205         {
4206           splt = htab->elf.splt;
4207           srela = htab->elf.srelplt;
4208         }
4209       else
4210         {
4211           splt = htab->elf.iplt;
4212           srela = htab->elf.irelplt;
4213         }
4214
4215       if (splt == NULL || srela == NULL)
4216         abort ();
4217
4218       /* Fill in the entry in the .rela.plt section.  */
4219       if (htab->is_vxworks)
4220         {
4221           /* Work out the index of this PLT entry.  */
4222           rela_index = ((h->plt.offset - htab->plt_header_size)
4223                         / htab->plt_entry_size);
4224
4225           /* Calculate the offset of the associated .got.plt entry.
4226              The first three entries are reserved.  */
4227           got_offset = (rela_index + 3) * 4;
4228
4229           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4230                                          rela_index, got_offset);
4231
4232
4233           /* On VxWorks, the relocation points to the .got.plt entry,
4234              not the .plt entry.  */
4235           rela.r_offset = (htab->elf.sgotplt->output_section->vma
4236                            + htab->elf.sgotplt->output_offset
4237                            + got_offset);
4238           rela.r_addend = 0;
4239           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4240                                           R_SPARC_JMP_SLOT);
4241         }
4242       else
4243         {
4244           bfd_boolean ifunc = FALSE;
4245
4246           /* Fill in the entry in the procedure linkage table.  */
4247           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4248                                                   h->plt.offset, splt->size,
4249                                                   &r_offset);
4250
4251           if (h == NULL
4252               || h->dynindx == -1
4253               || ((info->executable
4254                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4255                   && h->def_regular
4256                   && h->type == STT_GNU_IFUNC))
4257             {
4258               ifunc = TRUE;
4259               BFD_ASSERT (h == NULL
4260                           || (h->type == STT_GNU_IFUNC
4261                               && h->def_regular
4262                               && (h->root.type == bfd_link_hash_defined
4263                                   || h->root.type == bfd_link_hash_defweak)));
4264             }
4265
4266           rela.r_offset = r_offset
4267             + (splt->output_section->vma + splt->output_offset);
4268           if (ABI_64_P (output_bfd)
4269               && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4270             {
4271               if (ifunc)
4272                 {
4273                   rela.r_addend = (h->root.u.def.section->output_section->vma
4274                                    + h->root.u.def.section->output_offset
4275                                    + h->root.u.def.value);
4276                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4277                                                   R_SPARC_IRELATIVE);
4278                 }
4279               else
4280                 {
4281                   rela.r_addend = (-(h->plt.offset + 4)
4282                                    - splt->output_section->vma
4283                                    - splt->output_offset);
4284                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4285                                                   R_SPARC_JMP_SLOT);
4286                 }
4287             }
4288           else
4289             {
4290               if (ifunc)
4291                 {
4292                   rela.r_addend = (h->root.u.def.section->output_section->vma
4293                                    + h->root.u.def.section->output_offset
4294                                    + h->root.u.def.value);
4295                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4296                                                   R_SPARC_JMP_IREL);
4297                 }
4298               else
4299                 {
4300                   rela.r_addend = 0;
4301                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4302                                                   R_SPARC_JMP_SLOT);
4303                 }
4304             }
4305         }
4306
4307       /* Adjust for the first 4 reserved elements in the .plt section
4308          when setting the offset in the .rela.plt section.
4309          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4310          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
4311
4312       loc = srela->contents;
4313       loc += rela_index * bed->s->sizeof_rela;
4314       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4315
4316       if (!h->def_regular)
4317         {
4318           /* Mark the symbol as undefined, rather than as defined in
4319              the .plt section.  Leave the value alone.  */
4320           sym->st_shndx = SHN_UNDEF;
4321           /* If the symbol is weak, we do need to clear the value.
4322              Otherwise, the PLT entry would provide a definition for
4323              the symbol even if the symbol wasn't defined anywhere,
4324              and so the symbol would never be NULL.  */
4325           if (!h->ref_regular_nonweak)
4326             sym->st_value = 0;
4327         }
4328     }
4329
4330   if (h->got.offset != (bfd_vma) -1
4331       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4332       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4333     {
4334       asection *sgot;
4335       asection *srela;
4336       Elf_Internal_Rela rela;
4337
4338       /* This symbol has an entry in the GOT.  Set it up.  */
4339
4340       sgot = htab->elf.sgot;
4341       srela = htab->elf.srelgot;
4342       BFD_ASSERT (sgot != NULL && srela != NULL);
4343
4344       rela.r_offset = (sgot->output_section->vma
4345                        + sgot->output_offset
4346                        + (h->got.offset &~ (bfd_vma) 1));
4347
4348       /* If this is a -Bsymbolic link, and the symbol is defined
4349          locally, we just want to emit a RELATIVE reloc.  Likewise if
4350          the symbol was forced to be local because of a version file.
4351          The entry in the global offset table will already have been
4352          initialized in the relocate_section function.  */
4353       if (! info->shared
4354           && h->type == STT_GNU_IFUNC
4355           && h->def_regular)
4356         {
4357           asection *plt;
4358
4359           /* We load the GOT entry with the PLT entry.  */
4360           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4361           SPARC_ELF_PUT_WORD (htab, output_bfd,
4362                               (plt->output_section->vma
4363                                + plt->output_offset + h->plt.offset),
4364                               htab->elf.sgot->contents
4365                               + (h->got.offset & ~(bfd_vma) 1));
4366           return TRUE;
4367         }
4368       else if (info->shared
4369                && SYMBOL_REFERENCES_LOCAL (info, h))
4370         {
4371           asection *sec = h->root.u.def.section;
4372           if (h->type == STT_GNU_IFUNC)
4373             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4374           else
4375             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4376           rela.r_addend = (h->root.u.def.value
4377                            + sec->output_section->vma
4378                            + sec->output_offset);
4379         }
4380       else
4381         {
4382           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4383           rela.r_addend = 0;
4384         }
4385
4386       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4387                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4388       sparc_elf_append_rela (output_bfd, srela, &rela);
4389     }
4390
4391   if (h->needs_copy)
4392     {
4393       asection *s;
4394       Elf_Internal_Rela rela;
4395
4396       /* This symbols needs a copy reloc.  Set it up.  */
4397       BFD_ASSERT (h->dynindx != -1);
4398
4399       s = bfd_get_section_by_name (h->root.u.def.section->owner,
4400                                    ".rela.bss");
4401       BFD_ASSERT (s != NULL);
4402
4403       rela.r_offset = (h->root.u.def.value
4404                        + h->root.u.def.section->output_section->vma
4405                        + h->root.u.def.section->output_offset);
4406       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4407       rela.r_addend = 0;
4408       sparc_elf_append_rela (output_bfd, s, &rela);
4409     }
4410
4411   /* Mark some specially defined symbols as absolute.  On VxWorks,
4412      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4413      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
4414   if (sym != NULL
4415       && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4416           || (!htab->is_vxworks
4417               && (h == htab->elf.hgot || h == htab->elf.hplt))))
4418     sym->st_shndx = SHN_ABS;
4419
4420   return TRUE;
4421 }
4422
4423 /* Finish up the dynamic sections.  */
4424
4425 static bfd_boolean
4426 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4427                   bfd *dynobj, asection *sdyn,
4428                   asection *splt ATTRIBUTE_UNUSED)
4429 {
4430   struct _bfd_sparc_elf_link_hash_table *htab;
4431   const struct elf_backend_data *bed;
4432   bfd_byte *dyncon, *dynconend;
4433   size_t dynsize;
4434   int stt_regidx = -1;
4435   bfd_boolean abi_64_p;
4436
4437   htab = _bfd_sparc_elf_hash_table (info);
4438   BFD_ASSERT (htab != NULL);
4439   bed = get_elf_backend_data (output_bfd);
4440   dynsize = bed->s->sizeof_dyn;
4441   dynconend = sdyn->contents + sdyn->size;
4442   abi_64_p = ABI_64_P (output_bfd);
4443   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4444     {
4445       Elf_Internal_Dyn dyn;
4446       const char *name;
4447       bfd_boolean size;
4448
4449       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4450
4451       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4452         {
4453           /* On VxWorks, DT_RELASZ should not include the relocations
4454              in .rela.plt.  */
4455           if (htab->elf.srelplt)
4456             {
4457               dyn.d_un.d_val -= htab->elf.srelplt->size;
4458               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4459             }
4460         }
4461       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4462         {
4463           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4464              not to the start of the PLT.  */
4465           if (htab->elf.sgotplt)
4466             {
4467               dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4468                                 + htab->elf.sgotplt->output_offset);
4469               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4470             }
4471         }
4472       else if (htab->is_vxworks
4473                && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4474         bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4475       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4476         {
4477           if (stt_regidx == -1)
4478             {
4479               stt_regidx =
4480                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4481               if (stt_regidx == -1)
4482                 return FALSE;
4483             }
4484           dyn.d_un.d_val = stt_regidx++;
4485           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4486         }
4487       else
4488         {
4489           switch (dyn.d_tag)
4490             {
4491             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
4492             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4493             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
4494             default:          name = NULL; size = FALSE; break;
4495             }
4496
4497           if (name != NULL)
4498             {
4499               asection *s;
4500
4501               s = bfd_get_section_by_name (output_bfd, name);
4502               if (s == NULL)
4503                 dyn.d_un.d_val = 0;
4504               else
4505                 {
4506                   if (! size)
4507                     dyn.d_un.d_ptr = s->vma;
4508                   else
4509                     dyn.d_un.d_val = s->size;
4510                 }
4511               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4512             }
4513         }
4514     }
4515   return TRUE;
4516 }
4517
4518 /* Install the first PLT entry in a VxWorks executable and make sure that
4519    .rela.plt.unloaded relocations have the correct symbol indexes.  */
4520
4521 static void
4522 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4523 {
4524   struct _bfd_sparc_elf_link_hash_table *htab;
4525   Elf_Internal_Rela rela;
4526   bfd_vma got_base;
4527   bfd_byte *loc;
4528
4529   htab = _bfd_sparc_elf_hash_table (info);
4530   BFD_ASSERT (htab != NULL);
4531
4532   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
4533   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4534               + htab->elf.hgot->root.u.def.section->output_offset
4535               + htab->elf.hgot->root.u.def.value);
4536
4537   /* Install the initial PLT entry.  */
4538   bfd_put_32 (output_bfd,
4539               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4540               htab->elf.splt->contents);
4541   bfd_put_32 (output_bfd,
4542               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4543               htab->elf.splt->contents + 4);
4544   bfd_put_32 (output_bfd,
4545               sparc_vxworks_exec_plt0_entry[2],
4546               htab->elf.splt->contents + 8);
4547   bfd_put_32 (output_bfd,
4548               sparc_vxworks_exec_plt0_entry[3],
4549               htab->elf.splt->contents + 12);
4550   bfd_put_32 (output_bfd,
4551               sparc_vxworks_exec_plt0_entry[4],
4552               htab->elf.splt->contents + 16);
4553
4554   loc = htab->srelplt2->contents;
4555
4556   /* Add an unloaded relocation for the initial entry's "sethi".  */
4557   rela.r_offset = (htab->elf.splt->output_section->vma
4558                    + htab->elf.splt->output_offset);
4559   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4560   rela.r_addend = 8;
4561   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4562   loc += sizeof (Elf32_External_Rela);
4563
4564   /* Likewise the following "or".  */
4565   rela.r_offset += 4;
4566   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4567   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4568   loc += sizeof (Elf32_External_Rela);
4569
4570   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4571      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4572      in which symbols were output.  */
4573   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4574     {
4575       Elf_Internal_Rela rel;
4576
4577       /* The entry's initial "sethi" (against _G_O_T_).  */
4578       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4579       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4580       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4581       loc += sizeof (Elf32_External_Rela);
4582
4583       /* The following "or" (also against _G_O_T_).  */
4584       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4585       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4586       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4587       loc += sizeof (Elf32_External_Rela);
4588
4589       /* The .got.plt entry (against _P_L_T_).  */
4590       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4591       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4592       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4593       loc += sizeof (Elf32_External_Rela);
4594     }
4595 }
4596
4597 /* Install the first PLT entry in a VxWorks shared object.  */
4598
4599 static void
4600 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4601 {
4602   struct _bfd_sparc_elf_link_hash_table *htab;
4603   unsigned int i;
4604
4605   htab = _bfd_sparc_elf_hash_table (info);
4606   BFD_ASSERT (htab != NULL);
4607
4608   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4609     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4610                 htab->elf.splt->contents + i * 4);
4611 }
4612
4613 /* Finish up local dynamic symbol handling.  We set the contents of
4614    various dynamic sections here.  */
4615
4616 static bfd_boolean
4617 finish_local_dynamic_symbol (void **slot, void *inf)
4618 {
4619   struct elf_link_hash_entry *h
4620     = (struct elf_link_hash_entry *) *slot;
4621   struct bfd_link_info *info
4622     = (struct bfd_link_info *) inf;
4623
4624   return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4625                                                h, NULL);
4626 }
4627
4628 bfd_boolean
4629 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4630 {
4631   bfd *dynobj;
4632   asection *sdyn;
4633   struct _bfd_sparc_elf_link_hash_table *htab;
4634
4635   htab = _bfd_sparc_elf_hash_table (info);
4636   BFD_ASSERT (htab != NULL);
4637   dynobj = htab->elf.dynobj;
4638
4639   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4640
4641   if (elf_hash_table (info)->dynamic_sections_created)
4642     {
4643       asection *splt;
4644
4645       splt = bfd_get_section_by_name (dynobj, ".plt");
4646       BFD_ASSERT (splt != NULL && sdyn != NULL);
4647
4648       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4649         return FALSE;
4650
4651       /* Initialize the contents of the .plt section.  */
4652       if (splt->size > 0)
4653         {
4654           if (htab->is_vxworks)
4655             {
4656               if (info->shared)
4657                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4658               else
4659                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4660             }
4661           else
4662             {
4663               memset (splt->contents, 0, htab->plt_header_size);
4664               if (!ABI_64_P (output_bfd))
4665                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4666                             splt->contents + splt->size - 4);
4667             }
4668         }
4669
4670       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4671         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4672           ? 0 : htab->plt_entry_size;
4673     }
4674
4675   /* Set the first entry in the global offset table to the address of
4676      the dynamic section.  */
4677   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4678     {
4679       bfd_vma val = (sdyn ?
4680                      sdyn->output_section->vma + sdyn->output_offset :
4681                      0);
4682
4683       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4684     }
4685
4686   if (htab->elf.sgot)
4687     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4688       SPARC_ELF_WORD_BYTES (htab);
4689
4690   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4691   htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4692
4693   return TRUE;
4694 }
4695
4696 \f
4697 /* Set the right machine number for a SPARC ELF file.  */
4698
4699 bfd_boolean
4700 _bfd_sparc_elf_object_p (bfd *abfd)
4701 {
4702   if (ABI_64_P (abfd))
4703     {
4704       unsigned long mach = bfd_mach_sparc_v9;
4705
4706       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4707         mach = bfd_mach_sparc_v9b;
4708       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4709         mach = bfd_mach_sparc_v9a;
4710       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4711     }
4712   else
4713     {
4714       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4715         {
4716           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4717             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4718                                               bfd_mach_sparc_v8plusb);
4719           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4720             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4721                                               bfd_mach_sparc_v8plusa);
4722           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4723             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4724                                               bfd_mach_sparc_v8plus);
4725           else
4726             return FALSE;
4727         }
4728       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4729         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4730                                           bfd_mach_sparc_sparclite_le);
4731       else
4732         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4733     }
4734 }
4735
4736 /* Return address for Ith PLT stub in section PLT, for relocation REL
4737    or (bfd_vma) -1 if it should not be included.  */
4738
4739 bfd_vma
4740 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4741 {
4742   if (ABI_64_P (plt->owner))
4743     {
4744       bfd_vma j;
4745
4746       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4747       if (i < PLT64_LARGE_THRESHOLD)
4748         return plt->vma + i * PLT64_ENTRY_SIZE;
4749
4750       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4751       i -= j;
4752       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4753     }
4754   else
4755     return rel->address;
4756 }