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 /* Return whether H is local and its ADDRESS is within 4G of
2931    _GLOBAL_OFFSET_TABLE_ and thus the offset may be calculated by a
2932    sethi, xor sequence.  */
2933
2934 static bfd_boolean
2935 gdop_relative_offset_ok (struct bfd_link_info *info,
2936                          struct elf_link_hash_entry *h,
2937                          bfd_vma address ATTRIBUTE_UNUSED)
2938 {
2939   if (!SYMBOL_REFERENCES_LOCAL (info, h))
2940     return FALSE;
2941   /* If H is undefined, ADDRESS will be zero.  We can't allow a
2942      relative offset to "zero" when producing PIEs or shared libs.
2943      Note that to get here with an undefined symbol it must also be
2944      hidden or internal visibility.  */
2945   if (bfd_link_pic (info)
2946       && h != NULL
2947       && (h->root.type == bfd_link_hash_undefweak
2948           || h->root.type == bfd_link_hash_undefined))
2949     return FALSE;
2950 #ifdef BFD64
2951   return gdopoff (info, address) + ((bfd_vma) 1 << 32) < (bfd_vma) 2 << 32;
2952 #else
2953   return TRUE;
2954 #endif
2955 }
2956
2957 /* Relocate a SPARC ELF section.  */
2958
2959 bfd_boolean
2960 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2961                                  struct bfd_link_info *info,
2962                                  bfd *input_bfd,
2963                                  asection *input_section,
2964                                  bfd_byte *contents,
2965                                  Elf_Internal_Rela *relocs,
2966                                  Elf_Internal_Sym *local_syms,
2967                                  asection **local_sections)
2968 {
2969   struct _bfd_sparc_elf_link_hash_table *htab;
2970   Elf_Internal_Shdr *symtab_hdr;
2971   struct elf_link_hash_entry **sym_hashes;
2972   bfd_vma *local_got_offsets;
2973   bfd_vma got_base;
2974   asection *sreloc;
2975   Elf_Internal_Rela *rel;
2976   Elf_Internal_Rela *relend;
2977   int num_relocs;
2978   bfd_boolean is_vxworks_tls;
2979
2980   htab = _bfd_sparc_elf_hash_table (info);
2981   BFD_ASSERT (htab != NULL);
2982   symtab_hdr = &elf_symtab_hdr (input_bfd);
2983   sym_hashes = elf_sym_hashes (input_bfd);
2984   local_got_offsets = elf_local_got_offsets (input_bfd);
2985
2986   if (elf_hash_table (info)->hgot == NULL)
2987     got_base = 0;
2988   else
2989     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2990
2991   sreloc = elf_section_data (input_section)->sreloc;
2992   /* We have to handle relocations in vxworks .tls_vars sections
2993      specially, because the dynamic loader is 'weird'.  */
2994   is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info)
2995                     && !strcmp (input_section->output_section->name,
2996                                 ".tls_vars"));
2997
2998   rel = relocs;
2999   if (ABI_64_P (output_bfd))
3000     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
3001   else
3002     num_relocs = input_section->reloc_count;
3003   relend = relocs + num_relocs;
3004   for (; rel < relend; rel++)
3005     {
3006       int r_type, tls_type;
3007       reloc_howto_type *howto;
3008       unsigned long r_symndx;
3009       struct elf_link_hash_entry *h;
3010       Elf_Internal_Sym *sym;
3011       asection *sec;
3012       bfd_vma relocation, off;
3013       bfd_reloc_status_type r;
3014       bfd_boolean is_plt = FALSE;
3015       bfd_boolean unresolved_reloc;
3016
3017       r_type = SPARC_ELF_R_TYPE (rel->r_info);
3018       if (r_type == R_SPARC_GNU_VTINHERIT
3019           || r_type == R_SPARC_GNU_VTENTRY)
3020         continue;
3021
3022       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
3023         {
3024           bfd_set_error (bfd_error_bad_value);
3025           return FALSE;
3026         }
3027       howto = _bfd_sparc_elf_howto_table + r_type;
3028
3029       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
3030       h = NULL;
3031       sym = NULL;
3032       sec = NULL;
3033       unresolved_reloc = FALSE;
3034       if (r_symndx < symtab_hdr->sh_info)
3035         {
3036           sym = local_syms + r_symndx;
3037           sec = local_sections[r_symndx];
3038           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3039
3040           if (!bfd_link_relocatable (info)
3041               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3042             {
3043               /* Relocate against local STT_GNU_IFUNC symbol.  */
3044               h = elf_sparc_get_local_sym_hash (htab, input_bfd,
3045                                                 rel, FALSE);
3046               if (h == NULL)
3047                 abort ();
3048
3049               /* Set STT_GNU_IFUNC symbol value.  */
3050               h->root.u.def.value = sym->st_value;
3051               h->root.u.def.section = sec;
3052             }
3053         }
3054       else
3055         {
3056           bfd_boolean warned, ignored;
3057
3058           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3059                                    r_symndx, symtab_hdr, sym_hashes,
3060                                    h, sec, relocation,
3061                                    unresolved_reloc, warned, ignored);
3062           if (warned)
3063             {
3064               /* To avoid generating warning messages about truncated
3065                  relocations, set the relocation's address to be the same as
3066                  the start of this section.  */
3067               if (input_section->output_section != NULL)
3068                 relocation = input_section->output_section->vma;
3069               else
3070                 relocation = 0;
3071             }
3072         }
3073
3074       if (sec != NULL && discarded_section (sec))
3075         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3076                                          rel, 1, relend, howto, 0, contents);
3077
3078       if (bfd_link_relocatable (info))
3079         continue;
3080
3081       if (h != NULL
3082           && h->type == STT_GNU_IFUNC
3083           && h->def_regular)
3084         {
3085           asection *plt_sec;
3086           const char *name;
3087
3088           if ((input_section->flags & SEC_ALLOC) == 0
3089               || h->plt.offset == (bfd_vma) -1)
3090             abort ();
3091
3092           plt_sec = htab->elf.splt;
3093           if (! plt_sec)
3094             plt_sec =htab->elf.iplt;
3095
3096           switch (r_type)
3097             {
3098             case R_SPARC_GOTDATA_OP:
3099               continue;
3100
3101             case R_SPARC_GOTDATA_OP_HIX22:
3102             case R_SPARC_GOTDATA_OP_LOX10:
3103               r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3104                         ? R_SPARC_GOT22
3105                         : R_SPARC_GOT10);
3106               howto = _bfd_sparc_elf_howto_table + r_type;
3107               /* Fall through.  */
3108
3109             case R_SPARC_GOT10:
3110             case R_SPARC_GOT13:
3111             case R_SPARC_GOT22:
3112               if (htab->elf.sgot == NULL)
3113                 abort ();
3114               off = h->got.offset;
3115               if (off == (bfd_vma) -1)
3116                 abort();
3117               relocation = htab->elf.sgot->output_offset + off - got_base;
3118               goto do_relocation;
3119
3120             case R_SPARC_WPLT30:
3121             case R_SPARC_WDISP30:
3122               relocation = (plt_sec->output_section->vma
3123                             + plt_sec->output_offset + h->plt.offset);
3124               goto do_relocation;
3125
3126             case R_SPARC_32:
3127             case R_SPARC_64:
3128               if (bfd_link_pic (info) && h->non_got_ref)
3129                 {
3130                   Elf_Internal_Rela outrel;
3131                   bfd_vma offset;
3132
3133                   offset = _bfd_elf_section_offset (output_bfd, info,
3134                                                     input_section,
3135                                                     rel->r_offset);
3136                   if (offset == (bfd_vma) -1
3137                       || offset == (bfd_vma) -2)
3138                     abort();
3139
3140                   outrel.r_offset = (input_section->output_section->vma
3141                                      + input_section->output_offset
3142                                      + offset);
3143
3144                   if (h->dynindx == -1
3145                       || h->forced_local
3146                       || bfd_link_executable (info))
3147                     {
3148                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3149                                                         0, R_SPARC_IRELATIVE);
3150                       outrel.r_addend = relocation + rel->r_addend;
3151                     }
3152                   else
3153                     {
3154                       if (h->dynindx == -1)
3155                         abort();
3156                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3157                       outrel.r_addend = rel->r_addend;
3158                     }
3159
3160                   sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3161                   continue;
3162                 }
3163
3164               relocation = (plt_sec->output_section->vma
3165                             + plt_sec->output_offset + h->plt.offset);
3166               goto do_relocation;
3167
3168             case R_SPARC_HI22:
3169             case R_SPARC_LO10:
3170               /* We should only see such relocs in static links.  */
3171               if (bfd_link_pic (info))
3172                 abort();
3173               relocation = (plt_sec->output_section->vma
3174                             + plt_sec->output_offset + h->plt.offset);
3175               goto do_relocation;
3176
3177             default:
3178               if (h->root.root.string)
3179                 name = h->root.root.string;
3180               else
3181                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3182                                          NULL);
3183               _bfd_error_handler
3184                 /* xgettext:c-format */
3185                 (_("%B: relocation %s against STT_GNU_IFUNC "
3186                    "symbol `%s' isn't handled by %s"), input_bfd,
3187                  _bfd_sparc_elf_howto_table[r_type].name,
3188                  name, __FUNCTION__);
3189               bfd_set_error (bfd_error_bad_value);
3190               return FALSE;
3191             }
3192         }
3193
3194       switch (r_type)
3195         {
3196         case R_SPARC_GOTDATA_OP_HIX22:
3197         case R_SPARC_GOTDATA_OP_LOX10:
3198           if (gdop_relative_offset_ok (info, h, relocation))
3199             {
3200               r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3201                         ? R_SPARC_GOTDATA_HIX22
3202                         : R_SPARC_GOTDATA_LOX10);
3203               howto = _bfd_sparc_elf_howto_table + r_type;
3204             }
3205           break;
3206
3207         case R_SPARC_GOTDATA_OP:
3208           if (gdop_relative_offset_ok (info, h, relocation))
3209             {
3210               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3211
3212               /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3213               relocation = 0x80000000 | (insn & 0x3e07c01f);
3214               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3215             }
3216           continue;
3217         }
3218
3219       switch (r_type)
3220         {
3221         case R_SPARC_GOTDATA_HIX22:
3222         case R_SPARC_GOTDATA_LOX10:
3223           relocation = gdopoff (info, relocation);
3224           break;
3225
3226         case R_SPARC_GOTDATA_OP_HIX22:
3227         case R_SPARC_GOTDATA_OP_LOX10:
3228         case R_SPARC_GOT10:
3229         case R_SPARC_GOT13:
3230         case R_SPARC_GOT22:
3231           /* Relocation is to the entry for this symbol in the global
3232              offset table.  */
3233           if (htab->elf.sgot == NULL)
3234             abort ();
3235
3236           if (h != NULL)
3237             {
3238               bfd_boolean dyn;
3239
3240               off = h->got.offset;
3241               BFD_ASSERT (off != (bfd_vma) -1);
3242               dyn = elf_hash_table (info)->dynamic_sections_created;
3243
3244               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3245                                                      bfd_link_pic (info),
3246                                                      h)
3247                   || (bfd_link_pic (info)
3248                       && SYMBOL_REFERENCES_LOCAL (info, h)))
3249                 {
3250                   /* This is actually a static link, or it is a
3251                      -Bsymbolic link and the symbol is defined
3252                      locally, or the symbol was forced to be local
3253                      because of a version file.  We must initialize
3254                      this entry in the global offset table.  Since the
3255                      offset must always be a multiple of 8 for 64-bit
3256                      and 4 for 32-bit, we use the least significant bit
3257                      to record whether we have initialized it already.
3258
3259                      When doing a dynamic link, we create a .rela.got
3260                      relocation entry to initialize the value.  This
3261                      is done in the finish_dynamic_symbol routine.  */
3262                   if ((off & 1) != 0)
3263                     off &= ~1;
3264                   else
3265                     {
3266                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3267                                           htab->elf.sgot->contents + off);
3268                       h->got.offset |= 1;
3269                     }
3270                 }
3271               else
3272                 unresolved_reloc = FALSE;
3273             }
3274           else
3275             {
3276               BFD_ASSERT (local_got_offsets != NULL
3277                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3278
3279               off = local_got_offsets[r_symndx];
3280
3281               /* The offset must always be a multiple of 8 on 64-bit and
3282                  4 on 32-bit.  We use the least significant bit to record
3283                  whether we have already processed this entry.  */
3284               if ((off & 1) != 0)
3285                 off &= ~1;
3286               else
3287                 {
3288
3289                   if (bfd_link_pic (info))
3290                     {
3291                       asection *s;
3292                       Elf_Internal_Rela outrel;
3293
3294                       /* We need to generate a R_SPARC_RELATIVE reloc
3295                          for the dynamic linker.  */
3296                       s = htab->elf.srelgot;
3297                       BFD_ASSERT (s != NULL);
3298
3299                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3300                                          + htab->elf.sgot->output_offset
3301                                          + off);
3302                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3303                                                         0, R_SPARC_RELATIVE);
3304                       outrel.r_addend = relocation;
3305                       relocation = 0;
3306                       sparc_elf_append_rela (output_bfd, s, &outrel);
3307                     }
3308
3309                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3310                                       htab->elf.sgot->contents + off);
3311                   local_got_offsets[r_symndx] |= 1;
3312                 }
3313             }
3314           relocation = htab->elf.sgot->output_offset + off - got_base;
3315           break;
3316
3317         case R_SPARC_PLT32:
3318         case R_SPARC_PLT64:
3319           if (h == NULL || h->plt.offset == (bfd_vma) -1)
3320             {
3321               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3322               goto r_sparc_plt32;
3323             }
3324           /* Fall through.  */
3325
3326         case R_SPARC_WPLT30:
3327         case R_SPARC_HIPLT22:
3328         case R_SPARC_LOPLT10:
3329         case R_SPARC_PCPLT32:
3330         case R_SPARC_PCPLT22:
3331         case R_SPARC_PCPLT10:
3332         r_sparc_wplt30:
3333           /* Relocation is to the entry for this symbol in the
3334              procedure linkage table.  */
3335
3336           if (! ABI_64_P (output_bfd))
3337             {
3338               /* The Solaris native assembler will generate a WPLT30 reloc
3339                  for a local symbol if you assemble a call from one
3340                  section to another when using -K pic.  We treat it as
3341                  WDISP30.  */
3342               if (h == NULL)
3343                 break;
3344             }
3345           /* PR 7027: We need similar behaviour for 64-bit binaries.  */
3346           else if (r_type == R_SPARC_WPLT30 && h == NULL)
3347             break;
3348           else
3349             {
3350               BFD_ASSERT (h != NULL);
3351             }
3352
3353           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3354             {
3355               /* We didn't make a PLT entry for this symbol.  This
3356                  happens when statically linking PIC code, or when
3357                  using -Bsymbolic.  */
3358               break;
3359             }
3360
3361           relocation = (htab->elf.splt->output_section->vma
3362                         + htab->elf.splt->output_offset
3363                         + h->plt.offset);
3364           unresolved_reloc = FALSE;
3365           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3366             {
3367               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3368               is_plt = TRUE;
3369               goto r_sparc_plt32;
3370             }
3371           break;
3372
3373         case R_SPARC_PC10:
3374         case R_SPARC_PC22:
3375         case R_SPARC_PC_HH22:
3376         case R_SPARC_PC_HM10:
3377         case R_SPARC_PC_LM22:
3378           if (h != NULL
3379               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3380             break;
3381           /* Fall through.  */
3382         case R_SPARC_DISP8:
3383         case R_SPARC_DISP16:
3384         case R_SPARC_DISP32:
3385         case R_SPARC_DISP64:
3386         case R_SPARC_WDISP30:
3387         case R_SPARC_WDISP22:
3388         case R_SPARC_WDISP19:
3389         case R_SPARC_WDISP16:
3390         case R_SPARC_WDISP10:
3391         case R_SPARC_8:
3392         case R_SPARC_16:
3393         case R_SPARC_32:
3394         case R_SPARC_HI22:
3395         case R_SPARC_22:
3396         case R_SPARC_13:
3397         case R_SPARC_LO10:
3398         case R_SPARC_UA16:
3399         case R_SPARC_UA32:
3400         case R_SPARC_10:
3401         case R_SPARC_11:
3402         case R_SPARC_64:
3403         case R_SPARC_OLO10:
3404         case R_SPARC_HH22:
3405         case R_SPARC_HM10:
3406         case R_SPARC_LM22:
3407         case R_SPARC_7:
3408         case R_SPARC_5:
3409         case R_SPARC_6:
3410         case R_SPARC_HIX22:
3411         case R_SPARC_LOX10:
3412         case R_SPARC_H44:
3413         case R_SPARC_M44:
3414         case R_SPARC_L44:
3415         case R_SPARC_H34:
3416         case R_SPARC_UA64:
3417         r_sparc_plt32:
3418           if ((input_section->flags & SEC_ALLOC) == 0
3419               || is_vxworks_tls)
3420             break;
3421
3422           if ((bfd_link_pic (info)
3423                && (h == NULL
3424                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3425                    || h->root.type != bfd_link_hash_undefweak)
3426                && (! howto->pc_relative
3427                    || !SYMBOL_CALLS_LOCAL (info, h)))
3428               || (!bfd_link_pic (info)
3429                   && h != NULL
3430                   && h->dynindx != -1
3431                   && !h->non_got_ref
3432                   && ((h->def_dynamic
3433                        && !h->def_regular)
3434                       || h->root.type == bfd_link_hash_undefweak
3435                       || h->root.type == bfd_link_hash_undefined)))
3436             {
3437               Elf_Internal_Rela outrel;
3438               bfd_boolean skip, relocate = FALSE;
3439
3440               /* When generating a shared object, these relocations
3441                  are copied into the output file to be resolved at run
3442                  time.  */
3443
3444               BFD_ASSERT (sreloc != NULL);
3445
3446               skip = FALSE;
3447
3448               outrel.r_offset =
3449                 _bfd_elf_section_offset (output_bfd, info, input_section,
3450                                          rel->r_offset);
3451               if (outrel.r_offset == (bfd_vma) -1)
3452                 skip = TRUE;
3453               else if (outrel.r_offset == (bfd_vma) -2)
3454                 skip = TRUE, relocate = TRUE;
3455               outrel.r_offset += (input_section->output_section->vma
3456                                   + input_section->output_offset);
3457
3458               /* Optimize unaligned reloc usage now that we know where
3459                  it finally resides.  */
3460               switch (r_type)
3461                 {
3462                 case R_SPARC_16:
3463                   if (outrel.r_offset & 1)
3464                     r_type = R_SPARC_UA16;
3465                   break;
3466                 case R_SPARC_UA16:
3467                   if (!(outrel.r_offset & 1))
3468                     r_type = R_SPARC_16;
3469                   break;
3470                 case R_SPARC_32:
3471                   if (outrel.r_offset & 3)
3472                     r_type = R_SPARC_UA32;
3473                   break;
3474                 case R_SPARC_UA32:
3475                   if (!(outrel.r_offset & 3))
3476                     r_type = R_SPARC_32;
3477                   break;
3478                 case R_SPARC_64:
3479                   if (outrel.r_offset & 7)
3480                     r_type = R_SPARC_UA64;
3481                   break;
3482                 case R_SPARC_UA64:
3483                   if (!(outrel.r_offset & 7))
3484                     r_type = R_SPARC_64;
3485                   break;
3486                 case R_SPARC_DISP8:
3487                 case R_SPARC_DISP16:
3488                 case R_SPARC_DISP32:
3489                 case R_SPARC_DISP64:
3490                   /* If the symbol is not dynamic, we should not keep
3491                      a dynamic relocation.  But an .rela.* slot has been
3492                      allocated for it, output R_SPARC_NONE.
3493                      FIXME: Add code tracking needed dynamic relocs as
3494                      e.g. i386 has.  */
3495                   if (h->dynindx == -1)
3496                     skip = TRUE, relocate = TRUE;
3497                   break;
3498                 }
3499
3500               if (skip)
3501                 memset (&outrel, 0, sizeof outrel);
3502               /* h->dynindx may be -1 if the symbol was marked to
3503                  become local.  */
3504               else if (h != NULL
3505                        && h->dynindx != -1
3506                        && (_bfd_sparc_elf_howto_table[r_type].pc_relative
3507                            || !bfd_link_pic (info)
3508                            || !SYMBOLIC_BIND (info, h)
3509                            || !h->def_regular))
3510                 {
3511                   BFD_ASSERT (h->dynindx != -1);
3512                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3513                   outrel.r_addend = rel->r_addend;
3514                 }
3515               else
3516                 {
3517                   if (  (!ABI_64_P (output_bfd) && r_type == R_SPARC_32)
3518                       || (ABI_64_P (output_bfd) && r_type == R_SPARC_64))
3519                     {
3520                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3521                                                         0, R_SPARC_RELATIVE);
3522                       outrel.r_addend = relocation + rel->r_addend;
3523                     }
3524                   else
3525                     {
3526                       long indx;
3527
3528                       outrel.r_addend = relocation + rel->r_addend;
3529
3530                       if (is_plt)
3531                         sec = htab->elf.splt;
3532
3533                       if (bfd_is_abs_section (sec))
3534                         indx = 0;
3535                       else if (sec == NULL || sec->owner == NULL)
3536                         {
3537                           bfd_set_error (bfd_error_bad_value);
3538                           return FALSE;
3539                         }
3540                       else
3541                         {
3542                           asection *osec;
3543
3544                           /* We are turning this relocation into one
3545                              against a section symbol.  It would be
3546                              proper to subtract the symbol's value,
3547                              osec->vma, from the emitted reloc addend,
3548                              but ld.so expects buggy relocs.  */
3549                           osec = sec->output_section;
3550                           indx = elf_section_data (osec)->dynindx;
3551
3552                           if (indx == 0)
3553                             {
3554                               osec = htab->elf.text_index_section;
3555                               indx = elf_section_data (osec)->dynindx;
3556                             }
3557
3558                           /* FIXME: we really should be able to link non-pic
3559                              shared libraries.  */
3560                           if (indx == 0)
3561                             {
3562                               BFD_FAIL ();
3563                               _bfd_error_handler
3564                                 (_("%B: probably compiled without -fPIC?"),
3565                                  input_bfd);
3566                               bfd_set_error (bfd_error_bad_value);
3567                               return FALSE;
3568                             }
3569                         }
3570
3571                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3572                                                         r_type);
3573                     }
3574                 }
3575
3576               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3577
3578               /* This reloc will be computed at runtime, so there's no
3579                  need to do anything now.  */
3580               if (! relocate)
3581                 continue;
3582             }
3583           break;
3584
3585         case R_SPARC_TLS_GD_HI22:
3586           if (! ABI_64_P (input_bfd)
3587               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3588             {
3589               /* R_SPARC_REV32 used the same reloc number as
3590                  R_SPARC_TLS_GD_HI22.  */
3591               r_type = R_SPARC_REV32;
3592               break;
3593             }
3594           /* Fall through */
3595
3596         case R_SPARC_TLS_GD_LO10:
3597         case R_SPARC_TLS_IE_HI22:
3598         case R_SPARC_TLS_IE_LO10:
3599           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3600           tls_type = GOT_UNKNOWN;
3601           if (h == NULL && local_got_offsets)
3602             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3603           else if (h != NULL)
3604             {
3605               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3606               if (!bfd_link_pic (info)
3607                   && h->dynindx == -1
3608                   && tls_type == GOT_TLS_IE)
3609                 switch (SPARC_ELF_R_TYPE (rel->r_info))
3610                   {
3611                   case R_SPARC_TLS_GD_HI22:
3612                   case R_SPARC_TLS_IE_HI22:
3613                     r_type = R_SPARC_TLS_LE_HIX22;
3614                     break;
3615                   default:
3616                     r_type = R_SPARC_TLS_LE_LOX10;
3617                     break;
3618                   }
3619             }
3620           if (tls_type == GOT_TLS_IE)
3621             switch (r_type)
3622               {
3623               case R_SPARC_TLS_GD_HI22:
3624                 r_type = R_SPARC_TLS_IE_HI22;
3625                 break;
3626               case R_SPARC_TLS_GD_LO10:
3627                 r_type = R_SPARC_TLS_IE_LO10;
3628                 break;
3629               }
3630
3631           if (r_type == R_SPARC_TLS_LE_HIX22)
3632             {
3633               relocation = tpoff (info, relocation);
3634               break;
3635             }
3636           if (r_type == R_SPARC_TLS_LE_LOX10)
3637             {
3638               /* Change add into xor.  */
3639               relocation = tpoff (info, relocation);
3640               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3641                                                    contents + rel->r_offset)
3642                                        | 0x80182000), contents + rel->r_offset);
3643               break;
3644             }
3645
3646           if (h != NULL)
3647             {
3648               off = h->got.offset;
3649               h->got.offset |= 1;
3650             }
3651           else
3652             {
3653               BFD_ASSERT (local_got_offsets != NULL);
3654               off = local_got_offsets[r_symndx];
3655               local_got_offsets[r_symndx] |= 1;
3656             }
3657
3658         r_sparc_tlsldm:
3659           if (htab->elf.sgot == NULL)
3660             abort ();
3661
3662           if ((off & 1) != 0)
3663             off &= ~1;
3664           else
3665             {
3666               Elf_Internal_Rela outrel;
3667               int dr_type, indx;
3668
3669               if (htab->elf.srelgot == NULL)
3670                 abort ();
3671
3672               SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3673                                   htab->elf.sgot->contents + off);
3674               outrel.r_offset = (htab->elf.sgot->output_section->vma
3675                                  + htab->elf.sgot->output_offset + off);
3676               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3677               if (r_type == R_SPARC_TLS_IE_HI22
3678                   || r_type == R_SPARC_TLS_IE_LO10)
3679                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3680               else
3681                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3682               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3683                 outrel.r_addend = relocation - dtpoff_base (info);
3684               else
3685                 outrel.r_addend = 0;
3686               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3687               sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3688
3689               if (r_type == R_SPARC_TLS_GD_HI22
3690                   || r_type == R_SPARC_TLS_GD_LO10)
3691                 {
3692                   if (indx == 0)
3693                     {
3694                       BFD_ASSERT (! unresolved_reloc);
3695                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3696                                           relocation - dtpoff_base (info),
3697                                           (htab->elf.sgot->contents + off
3698                                            + SPARC_ELF_WORD_BYTES (htab)));
3699                     }
3700                   else
3701                     {
3702                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3703                                           (htab->elf.sgot->contents + off
3704                                            + SPARC_ELF_WORD_BYTES (htab)));
3705                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3706                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3707                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3708                       sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3709                                              &outrel);
3710                     }
3711                 }
3712               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3713                 {
3714                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3715                                       (htab->elf.sgot->contents + off
3716                                        + SPARC_ELF_WORD_BYTES (htab)));
3717                 }
3718             }
3719
3720           if (off >= (bfd_vma) -2)
3721             abort ();
3722
3723           relocation = htab->elf.sgot->output_offset + off - got_base;
3724           unresolved_reloc = FALSE;
3725           howto = _bfd_sparc_elf_howto_table + r_type;
3726           break;
3727
3728         case R_SPARC_TLS_LDM_HI22:
3729         case R_SPARC_TLS_LDM_LO10:
3730           if (! bfd_link_pic (info))
3731             {
3732               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3733               continue;
3734             }
3735           off = htab->tls_ldm_got.offset;
3736           htab->tls_ldm_got.offset |= 1;
3737           goto r_sparc_tlsldm;
3738
3739         case R_SPARC_TLS_LDO_HIX22:
3740         case R_SPARC_TLS_LDO_LOX10:
3741           if (bfd_link_pic (info))
3742             {
3743               relocation -= dtpoff_base (info);
3744               break;
3745             }
3746
3747           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3748                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3749           /* Fall through.  */
3750
3751         case R_SPARC_TLS_LE_HIX22:
3752         case R_SPARC_TLS_LE_LOX10:
3753           if (bfd_link_pic (info))
3754             {
3755               Elf_Internal_Rela outrel;
3756               bfd_boolean skip;
3757
3758               BFD_ASSERT (sreloc != NULL);
3759               skip = FALSE;
3760               outrel.r_offset =
3761                 _bfd_elf_section_offset (output_bfd, info, input_section,
3762                                          rel->r_offset);
3763               if (outrel.r_offset == (bfd_vma) -1)
3764                 skip = TRUE;
3765               else if (outrel.r_offset == (bfd_vma) -2)
3766                 skip = TRUE;
3767               outrel.r_offset += (input_section->output_section->vma
3768                                   + input_section->output_offset);
3769               if (skip)
3770                 memset (&outrel, 0, sizeof outrel);
3771               else
3772                 {
3773                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3774                   outrel.r_addend = relocation - dtpoff_base (info)
3775                                     + rel->r_addend;
3776                 }
3777
3778               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3779               continue;
3780             }
3781           relocation = tpoff (info, relocation);
3782           break;
3783
3784         case R_SPARC_TLS_LDM_CALL:
3785           if (! bfd_link_pic (info))
3786             {
3787               /* mov %g0, %o0 */
3788               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3789               continue;
3790             }
3791           /* Fall through */
3792
3793         case R_SPARC_TLS_GD_CALL:
3794           tls_type = GOT_UNKNOWN;
3795           if (h == NULL && local_got_offsets)
3796             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3797           else if (h != NULL)
3798             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3799           if (! bfd_link_pic (info)
3800               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3801             {
3802               Elf_Internal_Rela *rel2;
3803               bfd_vma insn;
3804
3805               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3806                 {
3807                   /* GD -> LE */
3808                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3809                   continue;
3810                 }
3811
3812               /* GD -> IE */
3813               if (rel + 1 < relend
3814                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3815                   && rel[1].r_offset == rel->r_offset + 4
3816                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3817                   && (((insn = bfd_get_32 (input_bfd,
3818                                            contents + rel[1].r_offset))
3819                        >> 25) & 0x1f) == 8)
3820                 {
3821                   /* We have
3822                      call __tls_get_addr, %tgd_call(foo)
3823                       add %reg1, %reg2, %o0, %tgd_add(foo)
3824                      and change it into IE:
3825                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3826                      add %g7, %o0, %o0, %tie_add(foo).
3827                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3828                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3829                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3830                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3831                               contents + rel->r_offset);
3832                   bfd_put_32 (output_bfd, 0x9001c008,
3833                               contents + rel->r_offset + 4);
3834                   rel++;
3835                   continue;
3836                 }
3837
3838               /* We cannot just overwrite the delay slot instruction,
3839                  as it might be what puts the %o0 argument to
3840                  __tls_get_addr into place.  So we have to transpose
3841                  the delay slot with the add we patch in.  */
3842               insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3843               bfd_put_32 (output_bfd, insn,
3844                           contents + rel->r_offset);
3845               bfd_put_32 (output_bfd, 0x9001c008,
3846                           contents + rel->r_offset + 4);
3847
3848               rel2 = rel;
3849               while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3850                                                           rel->r_offset + 4))
3851                      != NULL)
3852                 {
3853                   /* If the instruction we moved has a relocation attached to
3854                      it, adjust the offset so that it will apply to the correct
3855                      instruction.  */
3856                   rel2->r_offset -= 4;
3857                 }
3858               continue;
3859             }
3860
3861           h = (struct elf_link_hash_entry *)
3862               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3863                                     FALSE, TRUE);
3864           BFD_ASSERT (h != NULL);
3865           r_type = R_SPARC_WPLT30;
3866           howto = _bfd_sparc_elf_howto_table + r_type;
3867           goto r_sparc_wplt30;
3868
3869         case R_SPARC_TLS_GD_ADD:
3870           tls_type = GOT_UNKNOWN;
3871           if (h == NULL && local_got_offsets)
3872             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3873           else if (h != NULL)
3874             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3875           if (! bfd_link_pic (info) || tls_type == GOT_TLS_IE)
3876             {
3877               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3878                  changed into IE:
3879                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3880                  or LE:
3881                  add %g7, %reg2, %reg3.  */
3882               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3883               if ((h != NULL && h->dynindx != -1) || bfd_link_pic (info))
3884                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3885               else
3886                 relocation = (insn & ~0x7c000) | 0x1c000;
3887               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3888             }
3889           continue;
3890
3891         case R_SPARC_TLS_LDM_ADD:
3892           if (! bfd_link_pic (info))
3893             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3894           continue;
3895
3896         case R_SPARC_TLS_LDO_ADD:
3897           if (! bfd_link_pic (info))
3898             {
3899               /* Change rs1 into %g7.  */
3900               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3901               insn = (insn & ~0x7c000) | 0x1c000;
3902               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3903             }
3904           continue;
3905
3906         case R_SPARC_TLS_IE_LD:
3907         case R_SPARC_TLS_IE_LDX:
3908           if (! bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3909             {
3910               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3911               int rs2 = insn & 0x1f;
3912               int rd = (insn >> 25) & 0x1f;
3913
3914               if (rs2 == rd)
3915                 relocation = SPARC_NOP;
3916               else
3917                 relocation = 0x80100000 | (insn & 0x3e00001f);
3918               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3919             }
3920           continue;
3921
3922         case R_SPARC_TLS_IE_ADD:
3923           /* Totally useless relocation.  */
3924           continue;
3925
3926         case R_SPARC_TLS_DTPOFF32:
3927         case R_SPARC_TLS_DTPOFF64:
3928           relocation -= dtpoff_base (info);
3929           break;
3930
3931         default:
3932           break;
3933         }
3934
3935       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3936          because such sections are not SEC_ALLOC and thus ld.so will
3937          not process them.  */
3938       if (unresolved_reloc
3939           && !((input_section->flags & SEC_DEBUGGING) != 0
3940                && h->def_dynamic)
3941           && _bfd_elf_section_offset (output_bfd, info, input_section,
3942                                       rel->r_offset) != (bfd_vma) -1)
3943         _bfd_error_handler
3944           /* xgettext:c-format */
3945           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3946            input_bfd,
3947            input_section,
3948            (long) rel->r_offset,
3949            howto->name,
3950            h->root.root.string);
3951
3952       r = bfd_reloc_continue;
3953       if (r_type == R_SPARC_OLO10)
3954         {
3955             bfd_vma x;
3956
3957             if (! ABI_64_P (output_bfd))
3958               abort ();
3959
3960             relocation += rel->r_addend;
3961             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3962
3963             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3964             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3965             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3966
3967             r = bfd_check_overflow (howto->complain_on_overflow,
3968                                     howto->bitsize, howto->rightshift,
3969                                     bfd_arch_bits_per_address (input_bfd),
3970                                     relocation);
3971         }
3972       else if (r_type == R_SPARC_WDISP16)
3973         {
3974           bfd_vma x;
3975
3976           relocation += rel->r_addend;
3977           relocation -= (input_section->output_section->vma
3978                          + input_section->output_offset);
3979           relocation -= rel->r_offset;
3980
3981           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3982           x |= ((((relocation >> 2) & 0xc000) << 6)
3983                 | ((relocation >> 2) & 0x3fff));
3984           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3985
3986           r = bfd_check_overflow (howto->complain_on_overflow,
3987                                   howto->bitsize, howto->rightshift,
3988                                   bfd_arch_bits_per_address (input_bfd),
3989                                   relocation);
3990         }
3991       else if (r_type == R_SPARC_WDISP10)
3992         {
3993           bfd_vma x;
3994
3995           relocation += rel->r_addend;
3996           relocation -= (input_section->output_section->vma
3997                          + input_section->output_offset);
3998           relocation -= rel->r_offset;
3999
4000           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4001           x |= ((((relocation >> 2) & 0x300) << 11)
4002                 | (((relocation >> 2) & 0xff) << 5));
4003           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4004
4005           r = bfd_check_overflow (howto->complain_on_overflow,
4006                                   howto->bitsize, howto->rightshift,
4007                                   bfd_arch_bits_per_address (input_bfd),
4008                                   relocation);
4009         }
4010       else if (r_type == R_SPARC_REV32)
4011         {
4012           bfd_vma x;
4013
4014           relocation = relocation + rel->r_addend;
4015
4016           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4017           x = x + relocation;
4018           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
4019           r = bfd_reloc_ok;
4020         }
4021       else if (r_type == R_SPARC_TLS_LDO_HIX22
4022                || r_type == R_SPARC_TLS_LE_HIX22)
4023         {
4024           bfd_vma x;
4025
4026           relocation += rel->r_addend;
4027           if (r_type == R_SPARC_TLS_LE_HIX22)
4028             relocation ^= MINUS_ONE;
4029
4030           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4031           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
4032           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4033           r = bfd_reloc_ok;
4034         }
4035       else if (r_type == R_SPARC_TLS_LDO_LOX10
4036                || r_type == R_SPARC_TLS_LE_LOX10)
4037         {
4038           bfd_vma x;
4039
4040           relocation += rel->r_addend;
4041           relocation &= 0x3ff;
4042           if (r_type == R_SPARC_TLS_LE_LOX10)
4043             relocation |= 0x1c00;
4044
4045           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4046           x = (x & ~(bfd_vma) 0x1fff) | relocation;
4047           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4048
4049           r = bfd_reloc_ok;
4050         }
4051       else if (r_type == R_SPARC_HIX22
4052                || r_type == R_SPARC_GOTDATA_HIX22
4053                || r_type == R_SPARC_GOTDATA_OP_HIX22)
4054         {
4055           bfd_vma x;
4056
4057           relocation += rel->r_addend;
4058           if (r_type == R_SPARC_HIX22
4059               || (bfd_signed_vma) relocation < 0)
4060             relocation = relocation ^ MINUS_ONE;
4061
4062           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4063           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
4064           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4065
4066           r = bfd_check_overflow (howto->complain_on_overflow,
4067                                   howto->bitsize, howto->rightshift,
4068                                   bfd_arch_bits_per_address (input_bfd),
4069                                   relocation);
4070         }
4071       else if (r_type == R_SPARC_LOX10
4072                || r_type == R_SPARC_GOTDATA_LOX10
4073                || r_type == R_SPARC_GOTDATA_OP_LOX10)
4074         {
4075           bfd_vma x;
4076
4077           relocation += rel->r_addend;
4078           if (r_type == R_SPARC_LOX10
4079               || (bfd_signed_vma) relocation < 0)
4080             relocation = (relocation & 0x3ff) | 0x1c00;
4081           else
4082             relocation = (relocation & 0x3ff);
4083
4084           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4085           x = (x & ~(bfd_vma) 0x1fff) | relocation;
4086           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4087
4088           r = bfd_reloc_ok;
4089         }
4090       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4091                && sec_do_relax (input_section)
4092                && rel->r_offset + 4 < input_section->size)
4093         {
4094 #define G0              0
4095 #define O7              15
4096 #define XCC             (2 << 20)
4097 #define COND(x)         (((x)&0xf)<<25)
4098 #define CONDA           COND(0x8)
4099 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
4100 #define INSN_BA         (F2(0,2) | CONDA)
4101 #define INSN_OR         F3(2, 0x2, 0)
4102 #define INSN_NOP        F2(0,4)
4103
4104           bfd_vma x, y;
4105
4106           /* If the instruction is a call with either:
4107              restore
4108              arithmetic instruction with rd == %o7
4109              where rs1 != %o7 and rs2 if it is register != %o7
4110              then we can optimize if the call destination is near
4111              by changing the call into a branch always.  */
4112           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4113           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4114           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4115             {
4116               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4117                    || ((y & OP3(0x28)) == 0 /* arithmetic */
4118                        && (y & RD(~0)) == RD(O7)))
4119                   && (y & RS1(~0)) != RS1(O7)
4120                   && ((y & F3I(~0))
4121                       || (y & RS2(~0)) != RS2(O7)))
4122                 {
4123                   bfd_vma reloc;
4124
4125                   reloc = relocation + rel->r_addend - rel->r_offset;
4126                   reloc -= (input_section->output_section->vma
4127                             + input_section->output_offset);
4128
4129                   /* Ensure the branch fits into simm22.  */
4130                   if ((reloc & 3) == 0
4131                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
4132                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4133                     {
4134                       reloc >>= 2;
4135
4136                       /* Check whether it fits into simm19.  */
4137                       if (((reloc & 0x3c0000) == 0
4138                            || (reloc & 0x3c0000) == 0x3c0000)
4139                           && (ABI_64_P (output_bfd)
4140                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4141                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4142                       else
4143                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
4144                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4145                       r = bfd_reloc_ok;
4146                       if (rel->r_offset >= 4
4147                           && (y & (0xffffffff ^ RS1(~0)))
4148                              == (INSN_OR | RD(O7) | RS2(G0)))
4149                         {
4150                           bfd_vma z;
4151                           unsigned int reg;
4152
4153                           z = bfd_get_32 (input_bfd,
4154                                           contents + rel->r_offset - 4);
4155                           if ((z & (0xffffffff ^ RD(~0)))
4156                               != (INSN_OR | RS1(O7) | RS2(G0)))
4157                             continue;
4158
4159                           /* The sequence was
4160                              or %o7, %g0, %rN
4161                              call foo
4162                              or %rN, %g0, %o7
4163
4164                              If call foo was replaced with ba, replace
4165                              or %rN, %g0, %o7 with nop.  */
4166
4167                           reg = (y & RS1(~0)) >> 14;
4168                           if (reg != ((z & RD(~0)) >> 25)
4169                               || reg == G0 || reg == O7)
4170                             continue;
4171
4172                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4173                                       contents + rel->r_offset + 4);
4174                         }
4175
4176                     }
4177                 }
4178             }
4179         }
4180
4181       if (r == bfd_reloc_continue)
4182         {
4183 do_relocation:
4184           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4185                                         contents, rel->r_offset,
4186                                         relocation, rel->r_addend);
4187         }
4188       if (r != bfd_reloc_ok)
4189         {
4190           switch (r)
4191             {
4192             default:
4193             case bfd_reloc_outofrange:
4194               abort ();
4195             case bfd_reloc_overflow:
4196               {
4197                 const char *name;
4198
4199                 /* The Solaris native linker silently disregards overflows.
4200                    We don't, but this breaks stabs debugging info, whose
4201                    relocations are only 32-bits wide.  Ignore overflows in
4202                    this case and also for discarded entries.  */
4203                 if ((r_type == R_SPARC_32
4204                      || r_type == R_SPARC_UA32
4205                      || r_type == R_SPARC_DISP32)
4206                     && (((input_section->flags & SEC_DEBUGGING) != 0
4207                          && strcmp (bfd_section_name (input_bfd,
4208                                                       input_section),
4209                                     ".stab") == 0)
4210                         || _bfd_elf_section_offset (output_bfd, info,
4211                                                     input_section,
4212                                                     rel->r_offset)
4213                              == (bfd_vma)-1))
4214                   break;
4215
4216                 if (h != NULL)
4217                   {
4218                     /* Assume this is a call protected by other code that
4219                        detect the symbol is undefined.  If this is the case,
4220                        we can safely ignore the overflow.  If not, the
4221                        program is hosed anyway, and a little warning isn't
4222                        going to help.  */
4223                     if (h->root.type == bfd_link_hash_undefweak
4224                         && howto->pc_relative)
4225                       break;
4226
4227                     name = NULL;
4228                   }
4229                 else
4230                   {
4231                     name = bfd_elf_string_from_elf_section (input_bfd,
4232                                                             symtab_hdr->sh_link,
4233                                                             sym->st_name);
4234                     if (name == NULL)
4235                       return FALSE;
4236                     if (*name == '\0')
4237                       name = bfd_section_name (input_bfd, sec);
4238                   }
4239                 (*info->callbacks->reloc_overflow)
4240                   (info, (h ? &h->root : NULL), name, howto->name,
4241                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4242               }
4243               break;
4244             }
4245         }
4246     }
4247
4248   return TRUE;
4249 }
4250
4251 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
4252    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
4253    is the offset of the associated .got.plt entry from
4254    _GLOBAL_OFFSET_TABLE_.  */
4255
4256 static void
4257 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4258                                bfd_vma plt_offset, bfd_vma plt_index,
4259                                bfd_vma got_offset)
4260 {
4261   bfd_vma got_base;
4262   const bfd_vma *plt_entry;
4263   struct _bfd_sparc_elf_link_hash_table *htab;
4264   bfd_byte *loc;
4265   Elf_Internal_Rela rela;
4266
4267   htab = _bfd_sparc_elf_hash_table (info);
4268   BFD_ASSERT (htab != NULL);
4269
4270   if (bfd_link_pic (info))
4271     {
4272       plt_entry = sparc_vxworks_shared_plt_entry;
4273       got_base = 0;
4274     }
4275   else
4276     {
4277       plt_entry = sparc_vxworks_exec_plt_entry;
4278       got_base = (htab->elf.hgot->root.u.def.value
4279                   + htab->elf.hgot->root.u.def.section->output_offset
4280                   + htab->elf.hgot->root.u.def.section->output_section->vma);
4281     }
4282
4283   /* Fill in the entry in the procedure linkage table.  */
4284   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4285               htab->elf.splt->contents + plt_offset);
4286   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4287               htab->elf.splt->contents + plt_offset + 4);
4288   bfd_put_32 (output_bfd, plt_entry[2],
4289               htab->elf.splt->contents + plt_offset + 8);
4290   bfd_put_32 (output_bfd, plt_entry[3],
4291               htab->elf.splt->contents + plt_offset + 12);
4292   bfd_put_32 (output_bfd, plt_entry[4],
4293               htab->elf.splt->contents + plt_offset + 16);
4294   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4295               htab->elf.splt->contents + plt_offset + 20);
4296   /* PC-relative displacement for a branch to the start of
4297      the PLT section.  */
4298   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4299                                           & 0x003fffff),
4300               htab->elf.splt->contents + plt_offset + 24);
4301   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4302               htab->elf.splt->contents + plt_offset + 28);
4303
4304   /* Fill in the .got.plt entry, pointing initially at the
4305      second half of the PLT entry.  */
4306   BFD_ASSERT (htab->elf.sgotplt != NULL);
4307   bfd_put_32 (output_bfd,
4308               htab->elf.splt->output_section->vma
4309               + htab->elf.splt->output_offset
4310               + plt_offset + 20,
4311               htab->elf.sgotplt->contents + got_offset);
4312
4313   /* Add relocations to .rela.plt.unloaded.  */
4314   if (!bfd_link_pic (info))
4315     {
4316       loc = (htab->srelplt2->contents
4317              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4318
4319       /* Relocate the initial sethi.  */
4320       rela.r_offset = (htab->elf.splt->output_section->vma
4321                        + htab->elf.splt->output_offset
4322                        + plt_offset);
4323       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4324       rela.r_addend = got_offset;
4325       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4326       loc += sizeof (Elf32_External_Rela);
4327
4328       /* Likewise the following or.  */
4329       rela.r_offset += 4;
4330       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4331       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4332       loc += sizeof (Elf32_External_Rela);
4333
4334       /* Relocate the .got.plt entry.  */
4335       rela.r_offset = (htab->elf.sgotplt->output_section->vma
4336                        + htab->elf.sgotplt->output_offset
4337                        + got_offset);
4338       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4339       rela.r_addend = plt_offset + 20;
4340       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4341     }
4342 }
4343
4344 /* Finish up dynamic symbol handling.  We set the contents of various
4345    dynamic sections here.  */
4346
4347 bfd_boolean
4348 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4349                                       struct bfd_link_info *info,
4350                                       struct elf_link_hash_entry *h,
4351                                       Elf_Internal_Sym *sym)
4352 {
4353   struct _bfd_sparc_elf_link_hash_table *htab;
4354   const struct elf_backend_data *bed;
4355
4356   htab = _bfd_sparc_elf_hash_table (info);
4357   BFD_ASSERT (htab != NULL);
4358   bed = get_elf_backend_data (output_bfd);
4359
4360   if (h->plt.offset != (bfd_vma) -1)
4361     {
4362       asection *splt;
4363       asection *srela;
4364       Elf_Internal_Rela rela;
4365       bfd_byte *loc;
4366       bfd_vma r_offset, got_offset;
4367       int rela_index;
4368
4369       /* When building a static executable, use .iplt and
4370          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4371       if (htab->elf.splt != NULL)
4372         {
4373           splt = htab->elf.splt;
4374           srela = htab->elf.srelplt;
4375         }
4376       else
4377         {
4378           splt = htab->elf.iplt;
4379           srela = htab->elf.irelplt;
4380         }
4381
4382       if (splt == NULL || srela == NULL)
4383         abort ();
4384
4385       /* Fill in the entry in the .rela.plt section.  */
4386       if (htab->is_vxworks)
4387         {
4388           /* Work out the index of this PLT entry.  */
4389           rela_index = ((h->plt.offset - htab->plt_header_size)
4390                         / htab->plt_entry_size);
4391
4392           /* Calculate the offset of the associated .got.plt entry.
4393              The first three entries are reserved.  */
4394           got_offset = (rela_index + 3) * 4;
4395
4396           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4397                                          rela_index, got_offset);
4398
4399
4400           /* On VxWorks, the relocation points to the .got.plt entry,
4401              not the .plt entry.  */
4402           rela.r_offset = (htab->elf.sgotplt->output_section->vma
4403                            + htab->elf.sgotplt->output_offset
4404                            + got_offset);
4405           rela.r_addend = 0;
4406           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4407                                           R_SPARC_JMP_SLOT);
4408         }
4409       else
4410         {
4411           bfd_boolean ifunc = FALSE;
4412
4413           /* Fill in the entry in the procedure linkage table.  */
4414           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4415                                                   h->plt.offset, splt->size,
4416                                                   &r_offset);
4417
4418           if (h == NULL
4419               || h->dynindx == -1
4420               || ((bfd_link_executable (info)
4421                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4422                   && h->def_regular
4423                   && h->type == STT_GNU_IFUNC))
4424             {
4425               ifunc = TRUE;
4426               BFD_ASSERT (h == NULL
4427                           || (h->type == STT_GNU_IFUNC
4428                               && h->def_regular
4429                               && (h->root.type == bfd_link_hash_defined
4430                                   || h->root.type == bfd_link_hash_defweak)));
4431             }
4432
4433           rela.r_offset = r_offset
4434             + (splt->output_section->vma + splt->output_offset);
4435           if (ABI_64_P (output_bfd)
4436               && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4437             {
4438               if (ifunc)
4439                 {
4440                   rela.r_addend = (h->root.u.def.section->output_section->vma
4441                                    + h->root.u.def.section->output_offset
4442                                    + h->root.u.def.value);
4443                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4444                                                   R_SPARC_IRELATIVE);
4445                 }
4446               else
4447                 {
4448                   rela.r_addend = (-(h->plt.offset + 4)
4449                                    - splt->output_section->vma
4450                                    - splt->output_offset);
4451                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4452                                                   R_SPARC_JMP_SLOT);
4453                 }
4454             }
4455           else
4456             {
4457               if (ifunc)
4458                 {
4459                   rela.r_addend = (h->root.u.def.section->output_section->vma
4460                                    + h->root.u.def.section->output_offset
4461                                    + h->root.u.def.value);
4462                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4463                                                   R_SPARC_JMP_IREL);
4464                 }
4465               else
4466                 {
4467                   rela.r_addend = 0;
4468                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4469                                                   R_SPARC_JMP_SLOT);
4470                 }
4471             }
4472         }
4473
4474       /* Adjust for the first 4 reserved elements in the .plt section
4475          when setting the offset in the .rela.plt section.
4476          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4477          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
4478
4479       loc = srela->contents;
4480       loc += rela_index * bed->s->sizeof_rela;
4481       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4482
4483       if (!h->def_regular)
4484         {
4485           /* Mark the symbol as undefined, rather than as defined in
4486              the .plt section.  Leave the value alone.  */
4487           sym->st_shndx = SHN_UNDEF;
4488           /* If the symbol is weak, we do need to clear the value.
4489              Otherwise, the PLT entry would provide a definition for
4490              the symbol even if the symbol wasn't defined anywhere,
4491              and so the symbol would never be NULL.  */
4492           if (!h->ref_regular_nonweak)
4493             sym->st_value = 0;
4494         }
4495     }
4496
4497   if (h->got.offset != (bfd_vma) -1
4498       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4499       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4500     {
4501       asection *sgot;
4502       asection *srela;
4503       Elf_Internal_Rela rela;
4504
4505       /* This symbol has an entry in the GOT.  Set it up.  */
4506
4507       sgot = htab->elf.sgot;
4508       srela = htab->elf.srelgot;
4509       BFD_ASSERT (sgot != NULL && srela != NULL);
4510
4511       rela.r_offset = (sgot->output_section->vma
4512                        + sgot->output_offset
4513                        + (h->got.offset &~ (bfd_vma) 1));
4514
4515       /* If this is a -Bsymbolic link, and the symbol is defined
4516          locally, we just want to emit a RELATIVE reloc.  Likewise if
4517          the symbol was forced to be local because of a version file.
4518          The entry in the global offset table will already have been
4519          initialized in the relocate_section function.  */
4520       if (! bfd_link_pic (info)
4521           && h->type == STT_GNU_IFUNC
4522           && h->def_regular)
4523         {
4524           asection *plt;
4525
4526           /* We load the GOT entry with the PLT entry.  */
4527           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4528           SPARC_ELF_PUT_WORD (htab, output_bfd,
4529                               (plt->output_section->vma
4530                                + plt->output_offset + h->plt.offset),
4531                               htab->elf.sgot->contents
4532                               + (h->got.offset & ~(bfd_vma) 1));
4533           return TRUE;
4534         }
4535       else if (bfd_link_pic (info)
4536                && SYMBOL_REFERENCES_LOCAL (info, h))
4537         {
4538           asection *sec = h->root.u.def.section;
4539           if (h->type == STT_GNU_IFUNC)
4540             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4541           else
4542             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4543           rela.r_addend = (h->root.u.def.value
4544                            + sec->output_section->vma
4545                            + sec->output_offset);
4546         }
4547       else
4548         {
4549           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4550           rela.r_addend = 0;
4551         }
4552
4553       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4554                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4555       sparc_elf_append_rela (output_bfd, srela, &rela);
4556     }
4557
4558   if (h->needs_copy)
4559     {
4560       asection *s;
4561       Elf_Internal_Rela rela;
4562
4563       /* This symbols needs a copy reloc.  Set it up.  */
4564       BFD_ASSERT (h->dynindx != -1);
4565
4566       rela.r_offset = (h->root.u.def.value
4567                        + h->root.u.def.section->output_section->vma
4568                        + h->root.u.def.section->output_offset);
4569       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4570       rela.r_addend = 0;
4571       if (h->root.u.def.section == htab->elf.sdynrelro)
4572         s = htab->elf.sreldynrelro;
4573       else
4574         s = htab->elf.srelbss;
4575       sparc_elf_append_rela (output_bfd, s, &rela);
4576     }
4577
4578   /* Mark some specially defined symbols as absolute.  On VxWorks,
4579      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4580      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
4581   if (sym != NULL
4582       && (h == htab->elf.hdynamic
4583           || (!htab->is_vxworks
4584               && (h == htab->elf.hgot || h == htab->elf.hplt))))
4585     sym->st_shndx = SHN_ABS;
4586
4587   return TRUE;
4588 }
4589
4590 /* Finish up the dynamic sections.  */
4591
4592 static bfd_boolean
4593 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4594                   bfd *dynobj, asection *sdyn,
4595                   asection *splt ATTRIBUTE_UNUSED)
4596 {
4597   struct _bfd_sparc_elf_link_hash_table *htab;
4598   const struct elf_backend_data *bed;
4599   bfd_byte *dyncon, *dynconend;
4600   size_t dynsize;
4601   int stt_regidx = -1;
4602   bfd_boolean abi_64_p;
4603
4604   htab = _bfd_sparc_elf_hash_table (info);
4605   BFD_ASSERT (htab != NULL);
4606   bed = get_elf_backend_data (output_bfd);
4607   dynsize = bed->s->sizeof_dyn;
4608   dynconend = sdyn->contents + sdyn->size;
4609   abi_64_p = ABI_64_P (output_bfd);
4610   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4611     {
4612       Elf_Internal_Dyn dyn;
4613       bfd_boolean size;
4614
4615       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4616
4617       if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4618         {
4619           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4620              not to the start of the PLT.  */
4621           if (htab->elf.sgotplt)
4622             {
4623               dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4624                                 + htab->elf.sgotplt->output_offset);
4625               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4626             }
4627         }
4628       else if (htab->is_vxworks
4629                && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4630         bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4631       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4632         {
4633           if (stt_regidx == -1)
4634             {
4635               stt_regidx =
4636                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4637               if (stt_regidx == -1)
4638                 return FALSE;
4639             }
4640           dyn.d_un.d_val = stt_regidx++;
4641           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4642         }
4643       else
4644         {
4645           asection *s;
4646
4647           switch (dyn.d_tag)
4648             {
4649             case DT_PLTGOT:
4650               s = htab->elf.splt;
4651               size = FALSE;
4652               break;
4653             case DT_PLTRELSZ:
4654               s = htab->elf.srelplt;
4655               size = TRUE;
4656               break;
4657             case DT_JMPREL:
4658               s = htab->elf.srelplt;
4659               size = FALSE;
4660               break;
4661             default:
4662               continue;
4663             }
4664
4665           if (s == NULL)
4666             dyn.d_un.d_val = 0;
4667           else
4668             {
4669               if (!size)
4670                 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4671               else
4672                 dyn.d_un.d_val = s->size;
4673             }
4674           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4675         }
4676     }
4677   return TRUE;
4678 }
4679
4680 /* Install the first PLT entry in a VxWorks executable and make sure that
4681    .rela.plt.unloaded relocations have the correct symbol indexes.  */
4682
4683 static void
4684 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4685 {
4686   struct _bfd_sparc_elf_link_hash_table *htab;
4687   Elf_Internal_Rela rela;
4688   bfd_vma got_base;
4689   bfd_byte *loc;
4690
4691   htab = _bfd_sparc_elf_hash_table (info);
4692   BFD_ASSERT (htab != NULL);
4693
4694   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
4695   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4696               + htab->elf.hgot->root.u.def.section->output_offset
4697               + htab->elf.hgot->root.u.def.value);
4698
4699   /* Install the initial PLT entry.  */
4700   bfd_put_32 (output_bfd,
4701               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4702               htab->elf.splt->contents);
4703   bfd_put_32 (output_bfd,
4704               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4705               htab->elf.splt->contents + 4);
4706   bfd_put_32 (output_bfd,
4707               sparc_vxworks_exec_plt0_entry[2],
4708               htab->elf.splt->contents + 8);
4709   bfd_put_32 (output_bfd,
4710               sparc_vxworks_exec_plt0_entry[3],
4711               htab->elf.splt->contents + 12);
4712   bfd_put_32 (output_bfd,
4713               sparc_vxworks_exec_plt0_entry[4],
4714               htab->elf.splt->contents + 16);
4715
4716   loc = htab->srelplt2->contents;
4717
4718   /* Add an unloaded relocation for the initial entry's "sethi".  */
4719   rela.r_offset = (htab->elf.splt->output_section->vma
4720                    + htab->elf.splt->output_offset);
4721   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4722   rela.r_addend = 8;
4723   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4724   loc += sizeof (Elf32_External_Rela);
4725
4726   /* Likewise the following "or".  */
4727   rela.r_offset += 4;
4728   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4729   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4730   loc += sizeof (Elf32_External_Rela);
4731
4732   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4733      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4734      in which symbols were output.  */
4735   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4736     {
4737       Elf_Internal_Rela rel;
4738
4739       /* The entry's initial "sethi" (against _G_O_T_).  */
4740       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4741       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4742       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4743       loc += sizeof (Elf32_External_Rela);
4744
4745       /* The following "or" (also against _G_O_T_).  */
4746       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4747       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4748       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4749       loc += sizeof (Elf32_External_Rela);
4750
4751       /* The .got.plt entry (against _P_L_T_).  */
4752       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4753       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4754       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4755       loc += sizeof (Elf32_External_Rela);
4756     }
4757 }
4758
4759 /* Install the first PLT entry in a VxWorks shared object.  */
4760
4761 static void
4762 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4763 {
4764   struct _bfd_sparc_elf_link_hash_table *htab;
4765   unsigned int i;
4766
4767   htab = _bfd_sparc_elf_hash_table (info);
4768   BFD_ASSERT (htab != NULL);
4769
4770   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4771     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4772                 htab->elf.splt->contents + i * 4);
4773 }
4774
4775 /* Finish up local dynamic symbol handling.  We set the contents of
4776    various dynamic sections here.  */
4777
4778 static bfd_boolean
4779 finish_local_dynamic_symbol (void **slot, void *inf)
4780 {
4781   struct elf_link_hash_entry *h
4782     = (struct elf_link_hash_entry *) *slot;
4783   struct bfd_link_info *info
4784     = (struct bfd_link_info *) inf;
4785
4786   return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4787                                                h, NULL);
4788 }
4789
4790 bfd_boolean
4791 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4792 {
4793   bfd *dynobj;
4794   asection *sdyn;
4795   struct _bfd_sparc_elf_link_hash_table *htab;
4796
4797   htab = _bfd_sparc_elf_hash_table (info);
4798   BFD_ASSERT (htab != NULL);
4799   dynobj = htab->elf.dynobj;
4800
4801   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4802
4803   if (elf_hash_table (info)->dynamic_sections_created)
4804     {
4805       asection *splt;
4806
4807       splt = htab->elf.splt;
4808       BFD_ASSERT (splt != NULL && sdyn != NULL);
4809
4810       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4811         return FALSE;
4812
4813       /* Initialize the contents of the .plt section.  */
4814       if (splt->size > 0)
4815         {
4816           if (htab->is_vxworks)
4817             {
4818               if (bfd_link_pic (info))
4819                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4820               else
4821                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4822             }
4823           else
4824             {
4825               memset (splt->contents, 0, htab->plt_header_size);
4826               if (!ABI_64_P (output_bfd))
4827                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4828                             splt->contents + splt->size - 4);
4829             }
4830         }
4831
4832       if (elf_section_data (splt->output_section) != NULL)
4833         elf_section_data (splt->output_section)->this_hdr.sh_entsize
4834           = ((htab->is_vxworks || !ABI_64_P (output_bfd))
4835              ? 0 : htab->plt_entry_size);
4836     }
4837
4838   /* Set the first entry in the global offset table to the address of
4839      the dynamic section.  */
4840   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4841     {
4842       bfd_vma val = (sdyn ?
4843                      sdyn->output_section->vma + sdyn->output_offset :
4844                      0);
4845
4846       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4847     }
4848
4849   if (htab->elf.sgot)
4850     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4851       SPARC_ELF_WORD_BYTES (htab);
4852
4853   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4854   htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4855
4856   return TRUE;
4857 }
4858
4859 \f
4860 /* Set the right machine number for a SPARC ELF file.  */
4861
4862 bfd_boolean
4863 _bfd_sparc_elf_object_p (bfd *abfd)
4864 {
4865   obj_attribute *attrs = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
4866   obj_attribute *hwcaps = &attrs[Tag_GNU_Sparc_HWCAPS];
4867   obj_attribute *hwcaps2 = &attrs[Tag_GNU_Sparc_HWCAPS2];
4868
4869   unsigned int v9c_hwcaps_mask = ELF_SPARC_HWCAP_ASI_BLK_INIT;
4870   unsigned int v9d_hwcaps_mask = (ELF_SPARC_HWCAP_FMAF
4871                                   | ELF_SPARC_HWCAP_VIS3
4872                                   | ELF_SPARC_HWCAP_HPC);
4873   unsigned int v9e_hwcaps_mask = (ELF_SPARC_HWCAP_AES
4874                                   | ELF_SPARC_HWCAP_DES
4875                                   | ELF_SPARC_HWCAP_KASUMI
4876                                   | ELF_SPARC_HWCAP_CAMELLIA
4877                                   | ELF_SPARC_HWCAP_MD5
4878                                   | ELF_SPARC_HWCAP_SHA1
4879                                   | ELF_SPARC_HWCAP_SHA256
4880                                   | ELF_SPARC_HWCAP_SHA512
4881                                   | ELF_SPARC_HWCAP_MPMUL
4882                                   | ELF_SPARC_HWCAP_MONT
4883                                   | ELF_SPARC_HWCAP_CRC32C
4884                                   | ELF_SPARC_HWCAP_CBCOND
4885                                   | ELF_SPARC_HWCAP_PAUSE);
4886   unsigned int v9v_hwcaps_mask = (ELF_SPARC_HWCAP_FJFMAU
4887                                  | ELF_SPARC_HWCAP_IMA);
4888   unsigned int v9m_hwcaps2_mask = (ELF_SPARC_HWCAP2_SPARC5
4889                                    | ELF_SPARC_HWCAP2_MWAIT
4890                                    | ELF_SPARC_HWCAP2_XMPMUL
4891                                    | ELF_SPARC_HWCAP2_XMONT);
4892
4893   if (ABI_64_P (abfd))
4894     {
4895       unsigned long mach = bfd_mach_sparc_v9;
4896
4897       if (hwcaps2->i & v9m_hwcaps2_mask)
4898         mach = bfd_mach_sparc_v9m;
4899       else if (hwcaps->i & v9v_hwcaps_mask)
4900         mach = bfd_mach_sparc_v9v;
4901       else if (hwcaps->i & v9e_hwcaps_mask)
4902         mach = bfd_mach_sparc_v9e;
4903       else if (hwcaps->i & v9d_hwcaps_mask)
4904         mach = bfd_mach_sparc_v9d;
4905       else if (hwcaps->i & v9c_hwcaps_mask)
4906         mach = bfd_mach_sparc_v9c;
4907       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4908         mach = bfd_mach_sparc_v9b;
4909       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4910         mach = bfd_mach_sparc_v9a;
4911       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4912     }
4913   else
4914     {
4915       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4916         {
4917           if (hwcaps2->i & v9m_hwcaps2_mask)
4918             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4919                                               bfd_mach_sparc_v8plusm);
4920           else if (hwcaps->i & v9v_hwcaps_mask)
4921             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4922                                               bfd_mach_sparc_v8plusv);
4923           else if (hwcaps->i & v9e_hwcaps_mask)
4924             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4925                                               bfd_mach_sparc_v8pluse);
4926           else if (hwcaps->i & v9d_hwcaps_mask)
4927             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4928                                               bfd_mach_sparc_v8plusd);
4929           else if (hwcaps->i & v9c_hwcaps_mask)
4930             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4931                                               bfd_mach_sparc_v8plusc);
4932           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4933             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4934                                               bfd_mach_sparc_v8plusb);
4935           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4936             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4937                                               bfd_mach_sparc_v8plusa);
4938           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4939             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4940                                               bfd_mach_sparc_v8plus);
4941           else
4942             return FALSE;
4943         }
4944       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4945         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4946                                           bfd_mach_sparc_sparclite_le);
4947       else
4948         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4949     }
4950 }
4951
4952 /* Return address for Ith PLT stub in section PLT, for relocation REL
4953    or (bfd_vma) -1 if it should not be included.  */
4954
4955 bfd_vma
4956 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4957 {
4958   if (ABI_64_P (plt->owner))
4959     {
4960       bfd_vma j;
4961
4962       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4963       if (i < PLT64_LARGE_THRESHOLD)
4964         return plt->vma + i * PLT64_ENTRY_SIZE;
4965
4966       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4967       i -= j;
4968       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4969     }
4970   else
4971     return rel->address;
4972 }
4973
4974 /* Merge backend specific data from an object file to the output
4975    object file when linking.  */
4976
4977 bfd_boolean
4978 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4979 {
4980   bfd *obfd = info->output_bfd;
4981   obj_attribute *in_attr, *in_attrs;
4982   obj_attribute *out_attr, *out_attrs;
4983
4984   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4985     {
4986       /* This is the first object.  Copy the attributes.  */
4987       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4988
4989       /* Use the Tag_null value to indicate the attributes have been
4990          initialized.  */
4991       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4992
4993       return TRUE;
4994     }
4995
4996   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4997   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4998
4999   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
5000   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
5001
5002   out_attr->i |= in_attr->i;
5003   out_attr->type = 1;
5004
5005   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS2];
5006   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS2];
5007
5008   out_attr->i |= in_attr->i;
5009   out_attr->type = 1;
5010
5011   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5012   _bfd_elf_merge_object_attributes (ibfd, info);
5013
5014   return TRUE;
5015 }