bfd/elfxx-sparc.c

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