bfd/elfxx-sparc.c

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