bfd/elfxx-sparc.c

   1 /* SPARC-specific support for ELF
   2    Copyright (C) 2005-2016 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   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1210   if (!bfd_link_pic (info))
1211     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
1212
1213   if (htab->is_vxworks)
1214     {
1215       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1216         return FALSE;
1217       if (bfd_link_pic (info))
1218         {
1219           htab->plt_header_size
1220             = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1221           htab->plt_entry_size
1222             = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1223         }
1224       else
1225         {
1226           htab->plt_header_size
1227             = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1228           htab->plt_entry_size
1229             = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1230         }
1231     }
1232
1233   if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1234       || (!bfd_link_pic (info) && !htab->srelbss))
1235     abort ();
1236
1237   return TRUE;
1238 }
1239
1240 static bfd_boolean
1241 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1242 {
1243   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1244   struct elf_link_hash_table *htab = elf_hash_table (info);
1245   flagword flags, pltflags;
1246   asection *s;
1247
1248   if (htab->irelifunc != NULL || htab->iplt != NULL)
1249     return TRUE;
1250
1251   flags = bed->dynamic_sec_flags;
1252   pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1253
1254   s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1255   if (s == NULL
1256       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1257     return FALSE;
1258   htab->iplt = s;
1259
1260   s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1261                                    flags | SEC_READONLY);
1262   if (s == NULL
1263       || ! bfd_set_section_alignment (abfd, s,
1264                                       bed->s->log_file_align))
1265     return FALSE;
1266   htab->irelplt = s;
1267
1268   return TRUE;
1269 }
1270
1271 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1272
1273 void
1274 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1275                                      struct elf_link_hash_entry *dir,
1276                                      struct elf_link_hash_entry *ind)
1277 {
1278   struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1279
1280   edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1281   eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1282
1283   if (eind->dyn_relocs != NULL)
1284     {
1285       if (edir->dyn_relocs != NULL)
1286         {
1287           struct _bfd_sparc_elf_dyn_relocs **pp;
1288           struct _bfd_sparc_elf_dyn_relocs *p;
1289
1290           /* Add reloc counts against the indirect sym to the direct sym
1291              list.  Merge any entries against the same section.  */
1292           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1293             {
1294               struct _bfd_sparc_elf_dyn_relocs *q;
1295
1296               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1297                 if (q->sec == p->sec)
1298                   {
1299                     q->pc_count += p->pc_count;
1300                     q->count += p->count;
1301                     *pp = p->next;
1302                     break;
1303                   }
1304               if (q == NULL)
1305                 pp = &p->next;
1306             }
1307           *pp = edir->dyn_relocs;
1308         }
1309
1310       edir->dyn_relocs = eind->dyn_relocs;
1311       eind->dyn_relocs = NULL;
1312     }
1313
1314   if (ind->root.type == bfd_link_hash_indirect
1315       && dir->got.refcount <= 0)
1316     {
1317       edir->tls_type = eind->tls_type;
1318       eind->tls_type = GOT_UNKNOWN;
1319     }
1320   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1321 }
1322
1323 static int
1324 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1325                           int r_type, int is_local)
1326 {
1327   if (! ABI_64_P (abfd)
1328       && r_type == R_SPARC_TLS_GD_HI22
1329       && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1330     r_type = R_SPARC_REV32;
1331
1332   if (bfd_link_pic (info))
1333     return r_type;
1334
1335   switch (r_type)
1336     {
1337     case R_SPARC_TLS_GD_HI22:
1338       if (is_local)
1339         return R_SPARC_TLS_LE_HIX22;
1340       return R_SPARC_TLS_IE_HI22;
1341     case R_SPARC_TLS_GD_LO10:
1342       if (is_local)
1343         return R_SPARC_TLS_LE_LOX10;
1344       return R_SPARC_TLS_IE_LO10;
1345     case R_SPARC_TLS_IE_HI22:
1346       if (is_local)
1347         return R_SPARC_TLS_LE_HIX22;
1348       return r_type;
1349     case R_SPARC_TLS_IE_LO10:
1350       if (is_local)
1351         return R_SPARC_TLS_LE_LOX10;
1352       return r_type;
1353     case R_SPARC_TLS_LDM_HI22:
1354       return R_SPARC_TLS_LE_HIX22;
1355     case R_SPARC_TLS_LDM_LO10:
1356       return R_SPARC_TLS_LE_LOX10;
1357     }
1358
1359   return r_type;
1360 }
1361 \f
1362 /* Look through the relocs for a section during the first phase, and
1363    allocate space in the global offset table or procedure linkage
1364    table.  */
1365
1366 bfd_boolean
1367 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1368                              asection *sec, const Elf_Internal_Rela *relocs)
1369 {
1370   struct _bfd_sparc_elf_link_hash_table *htab;
1371   Elf_Internal_Shdr *symtab_hdr;
1372   struct elf_link_hash_entry **sym_hashes;
1373   const Elf_Internal_Rela *rel;
1374   const Elf_Internal_Rela *rel_end;
1375   asection *sreloc;
1376   int num_relocs;
1377   bfd_boolean checked_tlsgd = FALSE;
1378
1379   if (bfd_link_relocatable (info))
1380     return TRUE;
1381
1382   htab = _bfd_sparc_elf_hash_table (info);
1383   BFD_ASSERT (htab != NULL);
1384   symtab_hdr = &elf_symtab_hdr (abfd);
1385   sym_hashes = elf_sym_hashes (abfd);
1386
1387   sreloc = NULL;
1388
1389   if (ABI_64_P (abfd))
1390     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1391   else
1392     num_relocs = sec->reloc_count;
1393
1394   BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1395
1396   if (htab->elf.dynobj == NULL)
1397     htab->elf.dynobj = abfd;
1398   if (!create_ifunc_sections (htab->elf.dynobj, info))
1399     return FALSE;
1400
1401   rel_end = relocs + num_relocs;
1402   for (rel = relocs; rel < rel_end; rel++)
1403     {
1404       unsigned int r_type;
1405       unsigned long r_symndx;
1406       struct elf_link_hash_entry *h;
1407       Elf_Internal_Sym *isym;
1408
1409       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1410       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1411
1412       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1413         {
1414           _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx);
1415           return FALSE;
1416         }
1417
1418       isym = NULL;
1419       if (r_symndx < symtab_hdr->sh_info)
1420         {
1421           /* A local symbol.  */
1422           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1423                                         abfd, r_symndx);
1424           if (isym == NULL)
1425             return FALSE;
1426
1427           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1428           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1429             {
1430               h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1431                                                 TRUE);
1432               if (h == NULL)
1433                 return FALSE;
1434
1435               /* Fake a STT_GNU_IFUNC symbol.  */
1436               h->type = STT_GNU_IFUNC;
1437               h->def_regular = 1;
1438               h->ref_regular = 1;
1439               h->forced_local = 1;
1440               h->root.type = bfd_link_hash_defined;
1441             }
1442           else
1443             h = NULL;
1444         }
1445       else
1446         {
1447           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1448           while (h->root.type == bfd_link_hash_indirect
1449                  || h->root.type == bfd_link_hash_warning)
1450             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1451
1452           /* PR15323, ref flags aren't set for references in the same
1453              object.  */
1454           h->root.non_ir_ref = 1;
1455         }
1456
1457       if (h && h->type == STT_GNU_IFUNC)
1458         {
1459           if (h->def_regular)
1460             {
1461               h->ref_regular = 1;
1462               h->plt.refcount += 1;
1463             }
1464         }
1465
1466       /* Compatibility with old R_SPARC_REV32 reloc conflicting
1467          with R_SPARC_TLS_GD_HI22.  */
1468       if (! ABI_64_P (abfd) && ! checked_tlsgd)
1469         switch (r_type)
1470           {
1471           case R_SPARC_TLS_GD_HI22:
1472             {
1473               const Elf_Internal_Rela *relt;
1474
1475               for (relt = rel + 1; relt < rel_end; relt++)
1476                 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1477                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1478                     || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1479                   break;
1480               checked_tlsgd = TRUE;
1481               _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1482             }
1483             break;
1484           case R_SPARC_TLS_GD_LO10:
1485           case R_SPARC_TLS_GD_ADD:
1486           case R_SPARC_TLS_GD_CALL:
1487             checked_tlsgd = TRUE;
1488             _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1489             break;
1490           }
1491
1492       r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1493       switch (r_type)
1494         {
1495         case R_SPARC_TLS_LDM_HI22:
1496         case R_SPARC_TLS_LDM_LO10:
1497           htab->tls_ldm_got.refcount += 1;
1498           break;
1499
1500         case R_SPARC_TLS_LE_HIX22:
1501         case R_SPARC_TLS_LE_LOX10:
1502           if (bfd_link_pic (info))
1503             goto r_sparc_plt32;
1504           break;
1505
1506         case R_SPARC_TLS_IE_HI22:
1507         case R_SPARC_TLS_IE_LO10:
1508           if (bfd_link_pic (info))
1509             info->flags |= DF_STATIC_TLS;
1510           /* Fall through */
1511
1512         case R_SPARC_GOT10:
1513         case R_SPARC_GOT13:
1514         case R_SPARC_GOT22:
1515         case R_SPARC_GOTDATA_HIX22:
1516         case R_SPARC_GOTDATA_LOX10:
1517         case R_SPARC_GOTDATA_OP_HIX22:
1518         case R_SPARC_GOTDATA_OP_LOX10:
1519         case R_SPARC_TLS_GD_HI22:
1520         case R_SPARC_TLS_GD_LO10:
1521           /* This symbol requires a global offset table entry.  */
1522           {
1523             int tls_type, old_tls_type;
1524
1525             switch (r_type)
1526               {
1527               default:
1528               case R_SPARC_GOT10:
1529               case R_SPARC_GOT13:
1530               case R_SPARC_GOT22:
1531               case R_SPARC_GOTDATA_OP_HIX22:
1532               case R_SPARC_GOTDATA_OP_LOX10:
1533                 tls_type = GOT_NORMAL;
1534                 break;
1535               case R_SPARC_TLS_GD_HI22:
1536               case R_SPARC_TLS_GD_LO10:
1537                 tls_type = GOT_TLS_GD;
1538                 break;
1539               case R_SPARC_TLS_IE_HI22:
1540               case R_SPARC_TLS_IE_LO10:
1541                 tls_type = GOT_TLS_IE;
1542                 break;
1543               }
1544
1545             if (h != NULL)
1546               {
1547                 h->got.refcount += 1;
1548                 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1549               }
1550             else
1551               {
1552                 bfd_signed_vma *local_got_refcounts;
1553
1554                 /* This is a global offset table entry for a local symbol.  */
1555                 local_got_refcounts = elf_local_got_refcounts (abfd);
1556                 if (local_got_refcounts == NULL)
1557                   {
1558                     bfd_size_type size;
1559
1560                     size = symtab_hdr->sh_info;
1561                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
1562                     local_got_refcounts = ((bfd_signed_vma *)
1563                                            bfd_zalloc (abfd, size));
1564                     if (local_got_refcounts == NULL)
1565                       return FALSE;
1566                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1567                     _bfd_sparc_elf_local_got_tls_type (abfd)
1568                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1569                   }
1570                 switch (r_type)
1571                   {
1572                   case R_SPARC_GOTDATA_OP_HIX22:
1573                   case R_SPARC_GOTDATA_OP_LOX10:
1574                     break;
1575
1576                   default:
1577                     local_got_refcounts[r_symndx] += 1;
1578                     break;
1579                   }
1580                 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1581               }
1582
1583             /* If a TLS symbol is accessed using IE at least once,
1584                there is no point to use dynamic model for it.  */
1585             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1586                 && (old_tls_type != GOT_TLS_GD
1587                     || tls_type != GOT_TLS_IE))
1588               {
1589                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1590                   tls_type = old_tls_type;
1591                 else
1592                   {
1593                     _bfd_error_handler
1594                       (_("%B: `%s' accessed both as normal and thread local symbol"),
1595                        abfd, h ? h->root.root.string : "<local>");
1596                     return FALSE;
1597                   }
1598               }
1599
1600             if (old_tls_type != tls_type)
1601               {
1602                 if (h != NULL)
1603                   _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1604                 else
1605                   _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1606               }
1607           }
1608
1609           if (htab->elf.sgot == NULL)
1610             {
1611               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1612                 return FALSE;
1613             }
1614           break;
1615
1616         case R_SPARC_TLS_GD_CALL:
1617         case R_SPARC_TLS_LDM_CALL:
1618           if (bfd_link_pic (info))
1619             {
1620               /* These are basically R_SPARC_TLS_WPLT30 relocs against
1621                  __tls_get_addr.  */
1622               struct bfd_link_hash_entry *bh = NULL;
1623               if (! _bfd_generic_link_add_one_symbol (info, abfd,
1624                                                       "__tls_get_addr", 0,
1625                                                       bfd_und_section_ptr, 0,
1626                                                       NULL, FALSE, FALSE,
1627                                                       &bh))
1628                 return FALSE;
1629               h = (struct elf_link_hash_entry *) bh;
1630             }
1631           else
1632             break;
1633           /* Fall through */
1634
1635         case R_SPARC_PLT32:
1636         case R_SPARC_WPLT30:
1637         case R_SPARC_HIPLT22:
1638         case R_SPARC_LOPLT10:
1639         case R_SPARC_PCPLT32:
1640         case R_SPARC_PCPLT22:
1641         case R_SPARC_PCPLT10:
1642         case R_SPARC_PLT64:
1643           /* This symbol requires a procedure linkage table entry.  We
1644              actually build the entry in adjust_dynamic_symbol,
1645              because this might be a case of linking PIC code without
1646              linking in any dynamic objects, in which case we don't
1647              need to generate a procedure linkage table after all.  */
1648
1649           if (h == NULL)
1650             {
1651               if (! ABI_64_P (abfd))
1652                 {
1653                   /* The Solaris native assembler will generate a WPLT30
1654                      reloc for a local symbol if you assemble a call from
1655                      one section to another when using -K pic.  We treat
1656                      it as WDISP30.  */
1657                   if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1658                     goto r_sparc_plt32;
1659                   break;
1660                 }
1661               /* PR 7027: We need similar behaviour for 64-bit binaries.  */
1662               else if (r_type == R_SPARC_WPLT30)
1663                 break;
1664
1665               /* It does not make sense to have a procedure linkage
1666                  table entry for a local symbol.  */
1667               bfd_set_error (bfd_error_bad_value);
1668               return FALSE;
1669             }
1670
1671           h->needs_plt = 1;
1672
1673           {
1674             int this_r_type;
1675
1676             this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1677             if (this_r_type == R_SPARC_PLT32
1678                 || this_r_type == R_SPARC_PLT64)
1679               goto r_sparc_plt32;
1680           }
1681           h->plt.refcount += 1;
1682           break;
1683
1684         case R_SPARC_PC10:
1685         case R_SPARC_PC22:
1686         case R_SPARC_PC_HH22:
1687         case R_SPARC_PC_HM10:
1688         case R_SPARC_PC_LM22:
1689           if (h != NULL)
1690             h->non_got_ref = 1;
1691
1692           if (h != NULL
1693               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1694             break;
1695           /* Fall through.  */
1696
1697         case R_SPARC_DISP8:
1698         case R_SPARC_DISP16:
1699         case R_SPARC_DISP32:
1700         case R_SPARC_DISP64:
1701         case R_SPARC_WDISP30:
1702         case R_SPARC_WDISP22:
1703         case R_SPARC_WDISP19:
1704         case R_SPARC_WDISP16:
1705         case R_SPARC_WDISP10:
1706         case R_SPARC_8:
1707         case R_SPARC_16:
1708         case R_SPARC_32:
1709         case R_SPARC_HI22:
1710         case R_SPARC_22:
1711         case R_SPARC_13:
1712         case R_SPARC_LO10:
1713         case R_SPARC_UA16:
1714         case R_SPARC_UA32:
1715         case R_SPARC_10:
1716         case R_SPARC_11:
1717         case R_SPARC_64:
1718         case R_SPARC_OLO10:
1719         case R_SPARC_HH22:
1720         case R_SPARC_HM10:
1721         case R_SPARC_LM22:
1722         case R_SPARC_7:
1723         case R_SPARC_5:
1724         case R_SPARC_6:
1725         case R_SPARC_HIX22:
1726         case R_SPARC_LOX10:
1727         case R_SPARC_H44:
1728         case R_SPARC_M44:
1729         case R_SPARC_L44:
1730         case R_SPARC_H34:
1731         case R_SPARC_UA64:
1732           if (h != NULL)
1733             h->non_got_ref = 1;
1734
1735         r_sparc_plt32:
1736           if (h != NULL && !bfd_link_pic (info))
1737             {
1738               /* We may need a .plt entry if the function this reloc
1739                  refers to is in a shared lib.  */
1740               h->plt.refcount += 1;
1741             }
1742
1743           /* If we are creating a shared library, and this is a reloc
1744              against a global symbol, or a non PC relative reloc
1745              against a local symbol, then we need to copy the reloc
1746              into the shared library.  However, if we are linking with
1747              -Bsymbolic, we do not need to copy a reloc against a
1748              global symbol which is defined in an object we are
1749              including in the link (i.e., DEF_REGULAR is set).  At
1750              this point we have not seen all the input files, so it is
1751              possible that DEF_REGULAR is not set now but will be set
1752              later (it is never cleared).  In case of a weak definition,
1753              DEF_REGULAR may be cleared later by a strong definition in
1754              a shared library.  We account for that possibility below by
1755              storing information in the relocs_copied field of the hash
1756              table entry.  A similar situation occurs when creating
1757              shared libraries and symbol visibility changes render the
1758              symbol local.
1759
1760              If on the other hand, we are creating an executable, we
1761              may need to keep relocations for symbols satisfied by a
1762              dynamic library if we manage to avoid copy relocs for the
1763              symbol.  */
1764           if ((bfd_link_pic (info)
1765                && (sec->flags & SEC_ALLOC) != 0
1766                && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1767                    || (h != NULL
1768                        && (! SYMBOLIC_BIND (info, h)
1769                            || h->root.type == bfd_link_hash_defweak
1770                            || !h->def_regular))))
1771               || (!bfd_link_pic (info)
1772                   && (sec->flags & SEC_ALLOC) != 0
1773                   && h != NULL
1774                   && (h->root.type == bfd_link_hash_defweak
1775                       || !h->def_regular))
1776               || (!bfd_link_pic (info)
1777                   && h != NULL
1778                   && h->type == STT_GNU_IFUNC))
1779             {
1780               struct _bfd_sparc_elf_dyn_relocs *p;
1781               struct _bfd_sparc_elf_dyn_relocs **head;
1782
1783               /* When creating a shared object, we must copy these
1784                  relocs into the output file.  We create a reloc
1785                  section in dynobj and make room for the reloc.  */
1786               if (sreloc == NULL)
1787                 {
1788                   sreloc = _bfd_elf_make_dynamic_reloc_section
1789                     (sec, htab->elf.dynobj, htab->word_align_power,
1790                      abfd, /*rela?*/ TRUE);
1791
1792                   if (sreloc == NULL)
1793                     return FALSE;
1794                 }
1795
1796               /* If this is a global symbol, we count the number of
1797                  relocations we need for this symbol.  */
1798               if (h != NULL)
1799                 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1800               else
1801                 {
1802                   /* Track dynamic relocs needed for local syms too.
1803                      We really need local syms available to do this
1804                      easily.  Oh well.  */
1805                   asection *s;
1806                   void *vpp;
1807
1808                   BFD_ASSERT (isym != NULL);
1809                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1810                   if (s == NULL)
1811                     s = sec;
1812
1813                   vpp = &elf_section_data (s)->local_dynrel;
1814                   head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1815                 }
1816
1817               p = *head;
1818               if (p == NULL || p->sec != sec)
1819                 {
1820                   bfd_size_type amt = sizeof *p;
1821                   p = ((struct _bfd_sparc_elf_dyn_relocs *)
1822                        bfd_alloc (htab->elf.dynobj, amt));
1823                   if (p == NULL)
1824                     return FALSE;
1825                   p->next = *head;
1826                   *head = p;
1827                   p->sec = sec;
1828                   p->count = 0;
1829                   p->pc_count = 0;
1830                 }
1831
1832               p->count += 1;
1833               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1834                 p->pc_count += 1;
1835             }
1836
1837           break;
1838
1839         case R_SPARC_GNU_VTINHERIT:
1840           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1841             return FALSE;
1842           break;
1843
1844         case R_SPARC_GNU_VTENTRY:
1845           BFD_ASSERT (h != NULL);
1846           if (h != NULL
1847               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1848             return FALSE;
1849           break;
1850
1851         case R_SPARC_REGISTER:
1852           /* Nothing to do.  */
1853           break;
1854
1855         default:
1856           break;
1857         }
1858     }
1859
1860   return TRUE;
1861 }
1862 \f
1863 asection *
1864 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1865                              struct bfd_link_info *info,
1866                              Elf_Internal_Rela *rel,
1867                              struct elf_link_hash_entry *h,
1868                              Elf_Internal_Sym *sym)
1869 {
1870   if (h != NULL)
1871     switch (SPARC_ELF_R_TYPE (rel->r_info))
1872       {
1873       case R_SPARC_GNU_VTINHERIT:
1874       case R_SPARC_GNU_VTENTRY:
1875         return NULL;
1876       }
1877
1878   /* FIXME: The test here, in check_relocs and in relocate_section
1879      dealing with TLS optimization, ought to be !bfd_link_executable (info).  */
1880   if (bfd_link_pic (info))
1881     {
1882       switch (SPARC_ELF_R_TYPE (rel->r_info))
1883         {
1884         case R_SPARC_TLS_GD_CALL:
1885         case R_SPARC_TLS_LDM_CALL:
1886           /* This reloc implicitly references __tls_get_addr.  We know
1887              another reloc will reference the same symbol as the one
1888              on this reloc, so the real symbol and section will be
1889              gc marked when processing the other reloc.  That lets
1890              us handle __tls_get_addr here.  */
1891           h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr",
1892                                     FALSE, FALSE, TRUE);
1893           BFD_ASSERT (h != NULL);
1894           h->mark = 1;
1895           if (h->u.weakdef != NULL)
1896             h->u.weakdef->mark = 1;
1897           sym = NULL;
1898         }
1899     }
1900
1901   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1902 }
1903
1904 static Elf_Internal_Rela *
1905 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1906                              Elf_Internal_Rela *relend,
1907                              bfd_vma offset)
1908 {
1909   while (rel < relend)
1910     {
1911       if (rel->r_offset == offset)
1912         return rel;
1913       rel++;
1914     }
1915   return NULL;
1916 }
1917
1918 /* Update the got entry reference counts for the section being removed.  */
1919 bfd_boolean
1920 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1921                               asection *sec, const Elf_Internal_Rela *relocs)
1922 {
1923   struct _bfd_sparc_elf_link_hash_table *htab;
1924   Elf_Internal_Shdr *symtab_hdr;
1925   struct elf_link_hash_entry **sym_hashes;
1926   bfd_signed_vma *local_got_refcounts;
1927   const Elf_Internal_Rela *rel, *relend;
1928
1929   if (bfd_link_relocatable (info))
1930     return TRUE;
1931
1932   BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1933
1934   elf_section_data (sec)->local_dynrel = NULL;
1935
1936   htab = _bfd_sparc_elf_hash_table (info);
1937   BFD_ASSERT (htab != NULL);
1938   symtab_hdr = &elf_symtab_hdr (abfd);
1939   sym_hashes = elf_sym_hashes (abfd);
1940   local_got_refcounts = elf_local_got_refcounts (abfd);
1941
1942   relend = relocs + sec->reloc_count;
1943   for (rel = relocs; rel < relend; rel++)
1944     {
1945       unsigned long r_symndx;
1946       unsigned int r_type;
1947       struct elf_link_hash_entry *h = NULL;
1948
1949       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1950       if (r_symndx >= symtab_hdr->sh_info)
1951         {
1952           struct _bfd_sparc_elf_link_hash_entry *eh;
1953           struct _bfd_sparc_elf_dyn_relocs **pp;
1954           struct _bfd_sparc_elf_dyn_relocs *p;
1955
1956           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1957           while (h->root.type == bfd_link_hash_indirect
1958                  || h->root.type == bfd_link_hash_warning)
1959             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1960           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1961           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1962             if (p->sec == sec)
1963               {
1964                 /* Everything must go for SEC.  */
1965                 *pp = p->next;
1966                 break;
1967               }
1968         }
1969
1970       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1971       r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1972       switch (r_type)
1973         {
1974         case R_SPARC_TLS_LDM_HI22:
1975         case R_SPARC_TLS_LDM_LO10:
1976           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1977             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1978           break;
1979
1980         case R_SPARC_TLS_GD_HI22:
1981         case R_SPARC_TLS_GD_LO10:
1982         case R_SPARC_TLS_IE_HI22:
1983         case R_SPARC_TLS_IE_LO10:
1984         case R_SPARC_GOT10:
1985         case R_SPARC_GOT13:
1986         case R_SPARC_GOT22:
1987         case R_SPARC_GOTDATA_HIX22:
1988         case R_SPARC_GOTDATA_LOX10:
1989         case R_SPARC_GOTDATA_OP_HIX22:
1990         case R_SPARC_GOTDATA_OP_LOX10:
1991           if (h != NULL)
1992             {
1993               if (h->got.refcount > 0)
1994                 h->got.refcount--;
1995             }
1996           else
1997             {
1998               switch (r_type)
1999                 {
2000                 case R_SPARC_GOTDATA_OP_HIX22:
2001                 case R_SPARC_GOTDATA_OP_LOX10:
2002                   break;
2003
2004                 default:
2005                   if (local_got_refcounts[r_symndx] > 0)
2006                     local_got_refcounts[r_symndx]--;
2007                   break;
2008                 }
2009             }
2010           break;
2011
2012         case R_SPARC_PC10:
2013         case R_SPARC_PC22:
2014         case R_SPARC_PC_HH22:
2015         case R_SPARC_PC_HM10:
2016         case R_SPARC_PC_LM22:
2017           if (h != NULL
2018               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2019             break;
2020           /* Fall through.  */
2021
2022         case R_SPARC_DISP8:
2023         case R_SPARC_DISP16:
2024         case R_SPARC_DISP32:
2025         case R_SPARC_DISP64:
2026         case R_SPARC_WDISP30:
2027         case R_SPARC_WDISP22:
2028         case R_SPARC_WDISP19:
2029         case R_SPARC_WDISP16:
2030         case R_SPARC_WDISP10:
2031         case R_SPARC_8:
2032         case R_SPARC_16:
2033         case R_SPARC_32:
2034         case R_SPARC_HI22:
2035         case R_SPARC_22:
2036         case R_SPARC_13:
2037         case R_SPARC_LO10:
2038         case R_SPARC_UA16:
2039         case R_SPARC_UA32:
2040         case R_SPARC_PLT32:
2041         case R_SPARC_10:
2042         case R_SPARC_11:
2043         case R_SPARC_64:
2044         case R_SPARC_OLO10:
2045         case R_SPARC_HH22:
2046         case R_SPARC_HM10:
2047         case R_SPARC_LM22:
2048         case R_SPARC_7:
2049         case R_SPARC_5:
2050         case R_SPARC_6:
2051         case R_SPARC_HIX22:
2052         case R_SPARC_LOX10:
2053         case R_SPARC_H44:
2054         case R_SPARC_M44:
2055         case R_SPARC_L44:
2056         case R_SPARC_H34:
2057         case R_SPARC_UA64:
2058           if (bfd_link_pic (info))
2059             break;
2060           /* Fall through.  */
2061
2062         case R_SPARC_WPLT30:
2063           if (h != NULL)
2064             {
2065               if (h->plt.refcount > 0)
2066                 h->plt.refcount--;
2067             }
2068           break;
2069
2070         default:
2071           break;
2072         }
2073     }
2074
2075   return TRUE;
2076 }
2077
2078 /* Adjust a symbol defined by a dynamic object and referenced by a
2079    regular object.  The current definition is in some section of the
2080    dynamic object, but we're not including those sections.  We have to
2081    change the definition to something the rest of the link can
2082    understand.  */
2083
2084 bfd_boolean
2085 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2086                                      struct elf_link_hash_entry *h)
2087 {
2088   struct _bfd_sparc_elf_link_hash_table *htab;
2089   struct _bfd_sparc_elf_link_hash_entry * eh;
2090   struct _bfd_sparc_elf_dyn_relocs *p;
2091   asection *s;
2092
2093   htab = _bfd_sparc_elf_hash_table (info);
2094   BFD_ASSERT (htab != NULL);
2095
2096   /* Make sure we know what is going on here.  */
2097   BFD_ASSERT (htab->elf.dynobj != NULL
2098               && (h->needs_plt
2099                   || h->type == STT_GNU_IFUNC
2100                   || h->u.weakdef != NULL
2101                   || (h->def_dynamic
2102                       && h->ref_regular
2103                       && !h->def_regular)));
2104
2105   /* If this is a function, put it in the procedure linkage table.  We
2106      will fill in the contents of the procedure linkage table later
2107      (although we could actually do it here).  The STT_NOTYPE
2108      condition is a hack specifically for the Oracle libraries
2109      delivered for Solaris; for some inexplicable reason, they define
2110      some of their functions as STT_NOTYPE when they really should be
2111      STT_FUNC.  */
2112   if (h->type == STT_FUNC
2113       || h->type == STT_GNU_IFUNC
2114       || h->needs_plt
2115       || (h->type == STT_NOTYPE
2116           && (h->root.type == bfd_link_hash_defined
2117               || h->root.type == bfd_link_hash_defweak)
2118           && (h->root.u.def.section->flags & SEC_CODE) != 0))
2119     {
2120       if (h->plt.refcount <= 0
2121           || (h->type != STT_GNU_IFUNC
2122               && (SYMBOL_CALLS_LOCAL (info, h)
2123                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2124                       && h->root.type == bfd_link_hash_undefweak))))
2125         {
2126           /* This case can occur if we saw a WPLT30 reloc in an input
2127              file, but the symbol was never referred to by a dynamic
2128              object, or if all references were garbage collected.  In
2129              such a case, we don't actually need to build a procedure
2130              linkage table, and we can just do a WDISP30 reloc instead.  */
2131           h->plt.offset = (bfd_vma) -1;
2132           h->needs_plt = 0;
2133         }
2134
2135       return TRUE;
2136     }
2137   else
2138     h->plt.offset = (bfd_vma) -1;
2139
2140   /* If this is a weak symbol, and there is a real definition, the
2141      processor independent code will have arranged for us to see the
2142      real definition first, and we can just use the same value.  */
2143   if (h->u.weakdef != NULL)
2144     {
2145       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2146                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2147       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2148       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2149       return TRUE;
2150     }
2151
2152   /* This is a reference to a symbol defined by a dynamic object which
2153      is not a function.  */
2154
2155   /* If we are creating a shared library, we must presume that the
2156      only references to the symbol are via the global offset table.
2157      For such cases we need not do anything here; the relocations will
2158      be handled correctly by relocate_section.  */
2159   if (bfd_link_pic (info))
2160     return TRUE;
2161
2162   /* If there are no references to this symbol that do not use the
2163      GOT, we don't need to generate a copy reloc.  */
2164   if (!h->non_got_ref)
2165     return TRUE;
2166
2167   /* If -z nocopyreloc was given, we won't generate them either.  */
2168   if (info->nocopyreloc)
2169     {
2170       h->non_got_ref = 0;
2171       return TRUE;
2172     }
2173
2174   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2175   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2176     {
2177       s = p->sec->output_section;
2178       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2179         break;
2180     }
2181
2182   /* If we didn't find any dynamic relocs in read-only sections, then
2183      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2184   if (p == NULL)
2185     {
2186       h->non_got_ref = 0;
2187       return TRUE;
2188     }
2189
2190   /* We must allocate the symbol in our .dynbss section, which will
2191      become part of the .bss section of the executable.  There will be
2192      an entry for this symbol in the .dynsym section.  The dynamic
2193      object will contain position independent code, so all references
2194      from the dynamic object to this symbol will go through the global
2195      offset table.  The dynamic linker will use the .dynsym entry to
2196      determine the address it must put in the global offset table, so
2197      both the dynamic object and the regular object will refer to the
2198      same memory location for the variable.  */
2199
2200   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2201      to copy the initial value out of the dynamic object and into the
2202      runtime process image.  We need to remember the offset into the
2203      .rel.bss section we are going to use.  */
2204   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2205     {
2206       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2207       h->needs_copy = 1;
2208     }
2209
2210   s = htab->sdynbss;
2211
2212   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2213 }
2214
2215 /* Allocate space in .plt, .got and associated reloc sections for
2216    dynamic relocs.  */
2217
2218 static bfd_boolean
2219 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2220 {
2221   struct bfd_link_info *info;
2222   struct _bfd_sparc_elf_link_hash_table *htab;
2223   struct _bfd_sparc_elf_link_hash_entry *eh;
2224   struct _bfd_sparc_elf_dyn_relocs *p;
2225
2226   if (h->root.type == bfd_link_hash_indirect)
2227     return TRUE;
2228
2229   info = (struct bfd_link_info *) inf;
2230   htab = _bfd_sparc_elf_hash_table (info);
2231   BFD_ASSERT (htab != NULL);
2232
2233   if ((htab->elf.dynamic_sections_created
2234        && h->plt.refcount > 0)
2235       || (h->type == STT_GNU_IFUNC
2236           && h->def_regular
2237           && h->ref_regular))
2238     {
2239       /* Make sure this symbol is output as a dynamic symbol.
2240          Undefined weak syms won't yet be marked as dynamic.  */
2241       if (h->dynindx == -1
2242           && !h->forced_local)
2243         {
2244           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2245             return FALSE;
2246         }
2247
2248       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)
2249           || (h->type == STT_GNU_IFUNC
2250               && h->def_regular))
2251         {
2252           asection *s = htab->elf.splt;
2253
2254           if (s == NULL)
2255             s = htab->elf.iplt;
2256
2257           /* Allocate room for the header.  */
2258           if (s->size == 0)
2259             {
2260               s->size = htab->plt_header_size;
2261
2262               /* Allocate space for the .rela.plt.unloaded relocations.  */
2263               if (htab->is_vxworks && !bfd_link_pic (info))
2264                 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2265             }
2266
2267           /* The procedure linkage table size is bounded by the magnitude
2268              of the offset we can describe in the entry.  */
2269           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2270                           (((bfd_vma)1 << 31) << 1) : 0x400000))
2271             {
2272               bfd_set_error (bfd_error_bad_value);
2273               return FALSE;
2274             }
2275
2276           if (SPARC_ELF_WORD_BYTES(htab) == 8
2277               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2278             {
2279               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2280
2281
2282               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2283
2284               h->plt.offset = (s->size - (off * 8));
2285             }
2286           else
2287             h->plt.offset = s->size;
2288
2289           /* If this symbol is not defined in a regular file, and we are
2290              not generating a shared library, then set the symbol to this
2291              location in the .plt.  This is required to make function
2292              pointers compare as equal between the normal executable and
2293              the shared library.  */
2294           if (! bfd_link_pic (info)
2295               && !h->def_regular)
2296             {
2297               h->root.u.def.section = s;
2298               h->root.u.def.value = h->plt.offset;
2299             }
2300
2301           /* Make room for this entry.  */
2302           s->size += htab->plt_entry_size;
2303
2304           /* We also need to make an entry in the .rela.plt section.  */
2305           if (s == htab->elf.splt)
2306             htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2307           else
2308             htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2309
2310           if (htab->is_vxworks)
2311             {
2312               /* Allocate space for the .got.plt entry.  */
2313               htab->elf.sgotplt->size += 4;
2314
2315               /* ...and for the .rela.plt.unloaded relocations.  */
2316               if (!bfd_link_pic (info))
2317                 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2318             }
2319         }
2320       else
2321         {
2322           h->plt.offset = (bfd_vma) -1;
2323           h->needs_plt = 0;
2324         }
2325     }
2326   else
2327     {
2328       h->plt.offset = (bfd_vma) -1;
2329       h->needs_plt = 0;
2330     }
2331
2332   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2333      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
2334   if (h->got.refcount > 0
2335       && !bfd_link_pic (info)
2336       && h->dynindx == -1
2337       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2338     h->got.offset = (bfd_vma) -1;
2339   else if (h->got.refcount > 0)
2340     {
2341       asection *s;
2342       bfd_boolean dyn;
2343       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2344
2345       /* Make sure this symbol is output as a dynamic symbol.
2346          Undefined weak syms won't yet be marked as dynamic.  */
2347       if (h->dynindx == -1
2348           && !h->forced_local)
2349         {
2350           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2351             return FALSE;
2352         }
2353
2354       s = htab->elf.sgot;
2355       h->got.offset = s->size;
2356       s->size += SPARC_ELF_WORD_BYTES (htab);
2357       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
2358       if (tls_type == GOT_TLS_GD)
2359         s->size += SPARC_ELF_WORD_BYTES (htab);
2360       dyn = htab->elf.dynamic_sections_created;
2361       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2362          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2363          global.  */
2364       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2365           || tls_type == GOT_TLS_IE
2366           || h->type == STT_GNU_IFUNC)
2367         htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2368       else if (tls_type == GOT_TLS_GD)
2369         htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2370       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2371                                                 bfd_link_pic (info),
2372                                                 h))
2373         htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2374     }
2375   else
2376     h->got.offset = (bfd_vma) -1;
2377
2378   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2379   if (eh->dyn_relocs == NULL)
2380     return TRUE;
2381
2382   /* In the shared -Bsymbolic case, discard space allocated for
2383      dynamic pc-relative relocs against symbols which turn out to be
2384      defined in regular objects.  For the normal shared case, discard
2385      space for pc-relative relocs that have become local due to symbol
2386      visibility changes.  */
2387
2388   if (bfd_link_pic (info))
2389     {
2390       if (SYMBOL_CALLS_LOCAL (info, h))
2391         {
2392           struct _bfd_sparc_elf_dyn_relocs **pp;
2393
2394           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2395             {
2396               p->count -= p->pc_count;
2397               p->pc_count = 0;
2398               if (p->count == 0)
2399                 *pp = p->next;
2400               else
2401                 pp = &p->next;
2402             }
2403         }
2404
2405       if (htab->is_vxworks)
2406         {
2407           struct _bfd_sparc_elf_dyn_relocs **pp;
2408
2409           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2410             {
2411               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2412                 *pp = p->next;
2413               else
2414                 pp = &p->next;
2415             }
2416         }
2417
2418       /* Also discard relocs on undefined weak syms with non-default
2419          visibility.  */
2420       if (eh->dyn_relocs != NULL
2421           && h->root.type == bfd_link_hash_undefweak)
2422         {
2423           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2424             eh->dyn_relocs = NULL;
2425
2426           /* Make sure undefined weak symbols are output as a dynamic
2427              symbol in PIEs.  */
2428           else if (h->dynindx == -1
2429                    && !h->forced_local)
2430             {
2431               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2432                 return FALSE;
2433             }
2434         }
2435     }
2436   else
2437     {
2438       /* For the non-shared case, discard space for relocs against
2439          symbols which turn out to need copy relocs or are not
2440          dynamic.  */
2441
2442       if (!h->non_got_ref
2443           && ((h->def_dynamic
2444                && !h->def_regular)
2445               || (htab->elf.dynamic_sections_created
2446                   && (h->root.type == bfd_link_hash_undefweak
2447                       || h->root.type == bfd_link_hash_undefined))))
2448         {
2449           /* Make sure this symbol is output as a dynamic symbol.
2450              Undefined weak syms won't yet be marked as dynamic.  */
2451           if (h->dynindx == -1
2452               && !h->forced_local)
2453             {
2454               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2455                 return FALSE;
2456             }
2457
2458           /* If that succeeded, we know we'll be keeping all the
2459              relocs.  */
2460           if (h->dynindx != -1)
2461             goto keep;
2462         }
2463
2464       eh->dyn_relocs = NULL;
2465
2466     keep: ;
2467     }
2468
2469   /* Finally, allocate space.  */
2470   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2471     {
2472       asection *sreloc = elf_section_data (p->sec)->sreloc;
2473       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2474     }
2475
2476   return TRUE;
2477 }
2478
2479 /* Allocate space in .plt, .got and associated reloc sections for
2480    local dynamic relocs.  */
2481
2482 static bfd_boolean
2483 allocate_local_dynrelocs (void **slot, void *inf)
2484 {
2485   struct elf_link_hash_entry *h
2486     = (struct elf_link_hash_entry *) *slot;
2487
2488   if (h->type != STT_GNU_IFUNC
2489       || !h->def_regular
2490       || !h->ref_regular
2491       || !h->forced_local
2492       || h->root.type != bfd_link_hash_defined)
2493     abort ();
2494
2495   return allocate_dynrelocs (h, inf);
2496 }
2497
2498 /* Find any dynamic relocs that apply to read-only sections.  */
2499
2500 static bfd_boolean
2501 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2502 {
2503   struct _bfd_sparc_elf_link_hash_entry *eh;
2504   struct _bfd_sparc_elf_dyn_relocs *p;
2505
2506   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2507   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2508     {
2509       asection *s = p->sec->output_section;
2510
2511       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2512         {
2513           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2514
2515           info->flags |= DF_TEXTREL;
2516
2517           /* Not an error, just cut short the traversal.  */
2518           return FALSE;
2519         }
2520     }
2521   return TRUE;
2522 }
2523
2524 /* Return true if the dynamic symbol for a given section should be
2525    omitted when creating a shared library.  */
2526
2527 bfd_boolean
2528 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2529                                     struct bfd_link_info *info,
2530                                     asection *p)
2531 {
2532   /* We keep the .got section symbol so that explicit relocations
2533      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2534      can be turned into relocations against the .got symbol.  */
2535   if (strcmp (p->name, ".got") == 0)
2536     return FALSE;
2537
2538   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2539 }
2540
2541 /* Set the sizes of the dynamic sections.  */
2542
2543 bfd_boolean
2544 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2545                                       struct bfd_link_info *info)
2546 {
2547   struct _bfd_sparc_elf_link_hash_table *htab;
2548   bfd *dynobj;
2549   asection *s;
2550   bfd *ibfd;
2551
2552   htab = _bfd_sparc_elf_hash_table (info);
2553   BFD_ASSERT (htab != NULL);
2554   dynobj = htab->elf.dynobj;
2555   BFD_ASSERT (dynobj != NULL);
2556
2557   if (elf_hash_table (info)->dynamic_sections_created)
2558     {
2559       /* Set the contents of the .interp section to the interpreter.  */
2560       if (bfd_link_executable (info) && !info->nointerp)
2561         {
2562           s = bfd_get_linker_section (dynobj, ".interp");
2563           BFD_ASSERT (s != NULL);
2564           s->size = htab->dynamic_interpreter_size;
2565           s->contents = (unsigned char *) htab->dynamic_interpreter;
2566         }
2567     }
2568
2569   /* Set up .got offsets for local syms, and space for local dynamic
2570      relocs.  */
2571   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2572     {
2573       bfd_signed_vma *local_got;
2574       bfd_signed_vma *end_local_got;
2575       char *local_tls_type;
2576       bfd_size_type locsymcount;
2577       Elf_Internal_Shdr *symtab_hdr;
2578       asection *srel;
2579
2580       if (! is_sparc_elf (ibfd))
2581         continue;
2582
2583       for (s = ibfd->sections; s != NULL; s = s->next)
2584         {
2585           struct _bfd_sparc_elf_dyn_relocs *p;
2586
2587           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2588             {
2589               if (!bfd_is_abs_section (p->sec)
2590                   && bfd_is_abs_section (p->sec->output_section))
2591                 {
2592                   /* Input section has been discarded, either because
2593                      it is a copy of a linkonce section or due to
2594                      linker script /DISCARD/, so we'll be discarding
2595                      the relocs too.  */
2596                 }
2597               else if (htab->is_vxworks
2598                        && strcmp (p->sec->output_section->name,
2599                                   ".tls_vars") == 0)
2600                 {
2601                   /* Relocations in vxworks .tls_vars sections are
2602                      handled specially by the loader.  */
2603                 }
2604               else if (p->count != 0)
2605                 {
2606                   srel = elf_section_data (p->sec)->sreloc;
2607                   if (!htab->elf.dynamic_sections_created)
2608                     srel = htab->elf.irelplt;
2609                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2610                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2611                     info->flags |= DF_TEXTREL;
2612                 }
2613             }
2614         }
2615
2616       local_got = elf_local_got_refcounts (ibfd);
2617       if (!local_got)
2618         continue;
2619
2620       symtab_hdr = &elf_symtab_hdr (ibfd);
2621       locsymcount = symtab_hdr->sh_info;
2622       end_local_got = local_got + locsymcount;
2623       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2624       s = htab->elf.sgot;
2625       srel = htab->elf.srelgot;
2626       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2627         {
2628           if (*local_got > 0)
2629             {
2630               *local_got = s->size;
2631               s->size += SPARC_ELF_WORD_BYTES (htab);
2632               if (*local_tls_type == GOT_TLS_GD)
2633                 s->size += SPARC_ELF_WORD_BYTES (htab);
2634               if (bfd_link_pic (info)
2635                   || *local_tls_type == GOT_TLS_GD
2636                   || *local_tls_type == GOT_TLS_IE)
2637                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2638             }
2639           else
2640             *local_got = (bfd_vma) -1;
2641         }
2642     }
2643
2644   if (htab->tls_ldm_got.refcount > 0)
2645     {
2646       /* Allocate 2 got entries and 1 dynamic reloc for
2647          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2648       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2649       htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2650       htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2651     }
2652   else
2653     htab->tls_ldm_got.offset = -1;
2654
2655   /* Allocate global sym .plt and .got entries, and space for global
2656      sym dynamic relocs.  */
2657   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2658
2659   /* Allocate .plt and .got entries, and space for local symbols.  */
2660   htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2661
2662   if (!htab->is_vxworks
2663       && elf_hash_table (info)->dynamic_sections_created)
2664     {
2665       if (! ABI_64_P (output_bfd))
2666         {
2667           /* Make space for the trailing nop in .plt.  */
2668           if (htab->elf.splt->size > 0)
2669             htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2670         }
2671
2672       /* If the .got section is more than 0x1000 bytes, we add
2673          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2674          bit relocations have a greater chance of working.  */
2675       if (htab->elf.sgot->size >= 0x1000
2676           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2677         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2678     }
2679
2680   /* The check_relocs and adjust_dynamic_symbol entry points have
2681      determined the sizes of the various dynamic sections.  Allocate
2682      memory for them.  */
2683   for (s = dynobj->sections; s != NULL; s = s->next)
2684     {
2685       if ((s->flags & SEC_LINKER_CREATED) == 0)
2686         continue;
2687
2688       if (s == htab->elf.splt
2689           || s == htab->elf.sgot
2690           || s == htab->sdynbss
2691           || s == htab->elf.iplt
2692           || s == htab->elf.sgotplt)
2693         {
2694           /* Strip this section if we don't need it; see the
2695              comment below.  */
2696         }
2697       else if (CONST_STRNEQ (s->name, ".rela"))
2698         {
2699           if (s->size != 0)
2700             {
2701               /* We use the reloc_count field as a counter if we need
2702                  to copy relocs into the output file.  */
2703               s->reloc_count = 0;
2704             }
2705         }
2706       else
2707         {
2708           /* It's not one of our sections.  */
2709           continue;
2710         }
2711
2712       if (s->size == 0)
2713         {
2714           /* If we don't need this section, strip it from the
2715              output file.  This is mostly to handle .rela.bss and
2716              .rela.plt.  We must create both sections in
2717              create_dynamic_sections, because they must be created
2718              before the linker maps input sections to output
2719              sections.  The linker does that before
2720              adjust_dynamic_symbol is called, and it is that
2721              function which decides whether anything needs to go
2722              into these sections.  */
2723           s->flags |= SEC_EXCLUDE;
2724           continue;
2725         }
2726
2727       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2728         continue;
2729
2730       /* Allocate memory for the section contents.  Zero the memory
2731          for the benefit of .rela.plt, which has 4 unused entries
2732          at the beginning, and we don't want garbage.  */
2733       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2734       if (s->contents == NULL)
2735         return FALSE;
2736     }
2737
2738   if (elf_hash_table (info)->dynamic_sections_created)
2739     {
2740       /* Add some entries to the .dynamic section.  We fill in the
2741          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2742          must add the entries now so that we get the correct size for
2743          the .dynamic section.  The DT_DEBUG entry is filled in by the
2744          dynamic linker and used by the debugger.  */
2745 #define add_dynamic_entry(TAG, VAL) \
2746   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2747
2748       if (bfd_link_executable (info))
2749         {
2750           if (!add_dynamic_entry (DT_DEBUG, 0))
2751             return FALSE;
2752         }
2753
2754       if (htab->elf.srelplt->size != 0)
2755         {
2756           if (!add_dynamic_entry (DT_PLTGOT, 0)
2757               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2758               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2759               || !add_dynamic_entry (DT_JMPREL, 0))
2760             return FALSE;
2761         }
2762
2763       if (!add_dynamic_entry (DT_RELA, 0)
2764           || !add_dynamic_entry (DT_RELASZ, 0)
2765           || !add_dynamic_entry (DT_RELAENT,
2766                                  SPARC_ELF_RELA_BYTES (htab)))
2767         return FALSE;
2768
2769       /* If any dynamic relocs apply to a read-only section,
2770          then we need a DT_TEXTREL entry.  */
2771       if ((info->flags & DF_TEXTREL) == 0)
2772         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2773
2774       if (info->flags & DF_TEXTREL)
2775         {
2776           if (!add_dynamic_entry (DT_TEXTREL, 0))
2777             return FALSE;
2778         }
2779
2780       if (ABI_64_P (output_bfd))
2781         {
2782           int reg;
2783           struct _bfd_sparc_elf_app_reg * app_regs;
2784           struct elf_strtab_hash *dynstr;
2785           struct elf_link_hash_table *eht = elf_hash_table (info);
2786
2787           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2788              entries if needed.  */
2789           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2790           dynstr = eht->dynstr;
2791
2792           for (reg = 0; reg < 4; reg++)
2793             if (app_regs [reg].name != NULL)
2794               {
2795                 struct elf_link_local_dynamic_entry *entry, *e;
2796
2797                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2798                   return FALSE;
2799
2800                 entry = (struct elf_link_local_dynamic_entry *)
2801                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2802                 if (entry == NULL)
2803                   return FALSE;
2804
2805                 /* We cheat here a little bit: the symbol will not be local, so we
2806                    put it at the end of the dynlocal linked list.  We will fix it
2807                    later on, as we have to fix other fields anyway.  */
2808                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2809                 entry->isym.st_size = 0;
2810                 if (*app_regs [reg].name != '\0')
2811                   entry->isym.st_name
2812                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2813                 else
2814                   entry->isym.st_name = 0;
2815                 entry->isym.st_other = 0;
2816                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2817                                                    STT_REGISTER);
2818                 entry->isym.st_shndx = app_regs [reg].shndx;
2819                 entry->isym.st_target_internal = 0;
2820                 entry->next = NULL;
2821                 entry->input_bfd = output_bfd;
2822                 entry->input_indx = -1;
2823
2824                 if (eht->dynlocal == NULL)
2825                   eht->dynlocal = entry;
2826                 else
2827                   {
2828                     for (e = eht->dynlocal; e->next; e = e->next)
2829                       ;
2830                     e->next = entry;
2831                   }
2832                 eht->dynsymcount++;
2833               }
2834         }
2835       if (htab->is_vxworks
2836           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2837         return FALSE;
2838     }
2839 #undef add_dynamic_entry
2840
2841   return TRUE;
2842 }
2843 \f
2844 bfd_boolean
2845 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2846 {
2847   if (!sec->used_by_bfd)
2848     {
2849       struct _bfd_sparc_elf_section_data *sdata;
2850       bfd_size_type amt = sizeof (*sdata);
2851
2852       sdata = bfd_zalloc (abfd, amt);
2853       if (sdata == NULL)
2854         return FALSE;
2855       sec->used_by_bfd = sdata;
2856     }
2857
2858   return _bfd_elf_new_section_hook (abfd, sec);
2859 }
2860
2861 bfd_boolean
2862 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2863                               struct bfd_section *section,
2864                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2865                               bfd_boolean *again)
2866 {
2867   if (bfd_link_relocatable (link_info))
2868     (*link_info->callbacks->einfo)
2869       (_("%P%F: --relax and -r may not be used together\n"));
2870
2871   *again = FALSE;
2872   sec_do_relax (section) = 1;
2873   return TRUE;
2874 }
2875 \f
2876 /* Return the base VMA address which should be subtracted from real addresses
2877    when resolving @dtpoff relocation.
2878    This is PT_TLS segment p_vaddr.  */
2879
2880 static bfd_vma
2881 dtpoff_base (struct bfd_link_info *info)
2882 {
2883   /* If tls_sec is NULL, we should have signalled an error already.  */
2884   if (elf_hash_table (info)->tls_sec == NULL)
2885     return 0;
2886   return elf_hash_table (info)->tls_sec->vma;
2887 }
2888
2889 /* Return the relocation value for @tpoff relocation
2890    if STT_TLS virtual address is ADDRESS.  */
2891
2892 static bfd_vma
2893 tpoff (struct bfd_link_info *info, bfd_vma address)
2894 {
2895   struct elf_link_hash_table *htab = elf_hash_table (info);
2896   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2897   bfd_vma static_tls_size;
2898
2899   /* If tls_sec is NULL, we should have signalled an error already.  */
2900   if (htab->tls_sec == NULL)
2901     return 0;
2902
2903   /* Consider special static TLS alignment requirements.  */
2904   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2905   return address - static_tls_size - htab->tls_sec->vma;
2906 }
2907
2908 /* Return the relocation value for a %gdop relocation.  */
2909
2910 static bfd_vma
2911 gdopoff (struct bfd_link_info *info, bfd_vma address)
2912 {
2913   struct elf_link_hash_table *htab = elf_hash_table (info);
2914   bfd_vma got_base;
2915
2916   got_base = (htab->hgot->root.u.def.value
2917               + htab->hgot->root.u.def.section->output_offset
2918               + htab->hgot->root.u.def.section->output_section->vma);
2919
2920   return address - got_base;
2921 }
2922
2923 /* Relocate a SPARC ELF section.  */
2924
2925 bfd_boolean
2926 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2927                                  struct bfd_link_info *info,
2928                                  bfd *input_bfd,
2929                                  asection *input_section,
2930                                  bfd_byte *contents,
2931                                  Elf_Internal_Rela *relocs,
2932                                  Elf_Internal_Sym *local_syms,
2933                                  asection **local_sections)
2934 {
2935   struct _bfd_sparc_elf_link_hash_table *htab;
2936   Elf_Internal_Shdr *symtab_hdr;
2937   struct elf_link_hash_entry **sym_hashes;
2938   bfd_vma *local_got_offsets;
2939   bfd_vma got_base;
2940   asection *sreloc;
2941   Elf_Internal_Rela *rel;
2942   Elf_Internal_Rela *relend;
2943   int num_relocs;
2944   bfd_boolean is_vxworks_tls;
2945
2946   htab = _bfd_sparc_elf_hash_table (info);
2947   BFD_ASSERT (htab != NULL);
2948   symtab_hdr = &elf_symtab_hdr (input_bfd);
2949   sym_hashes = elf_sym_hashes (input_bfd);
2950   local_got_offsets = elf_local_got_offsets (input_bfd);
2951
2952   if (elf_hash_table (info)->hgot == NULL)
2953     got_base = 0;
2954   else
2955     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2956
2957   sreloc = elf_section_data (input_section)->sreloc;
2958   /* We have to handle relocations in vxworks .tls_vars sections
2959      specially, because the dynamic loader is 'weird'.  */
2960   is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info)
2961                     && !strcmp (input_section->output_section->name,
2962                                 ".tls_vars"));
2963
2964   rel = relocs;
2965   if (ABI_64_P (output_bfd))
2966     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2967   else
2968     num_relocs = input_section->reloc_count;
2969   relend = relocs + num_relocs;
2970   for (; rel < relend; rel++)
2971     {
2972       int r_type, tls_type;
2973       reloc_howto_type *howto;
2974       unsigned long r_symndx;
2975       struct elf_link_hash_entry *h;
2976       Elf_Internal_Sym *sym;
2977       asection *sec;
2978       bfd_vma relocation, off;
2979       bfd_reloc_status_type r;
2980       bfd_boolean is_plt = FALSE;
2981       bfd_boolean unresolved_reloc;
2982
2983       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2984       if (r_type == R_SPARC_GNU_VTINHERIT
2985           || r_type == R_SPARC_GNU_VTENTRY)
2986         continue;
2987
2988       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2989         {
2990           bfd_set_error (bfd_error_bad_value);
2991           return FALSE;
2992         }
2993       howto = _bfd_sparc_elf_howto_table + r_type;
2994
2995       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2996       h = NULL;
2997       sym = NULL;
2998       sec = NULL;
2999       unresolved_reloc = FALSE;
3000       if (r_symndx < symtab_hdr->sh_info)
3001         {
3002           sym = local_syms + r_symndx;
3003           sec = local_sections[r_symndx];
3004           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3005
3006           if (!bfd_link_relocatable (info)
3007               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3008             {
3009               /* Relocate against local STT_GNU_IFUNC symbol.  */
3010               h = elf_sparc_get_local_sym_hash (htab, input_bfd,
3011                                                 rel, FALSE);
3012               if (h == NULL)
3013                 abort ();
3014
3015               /* Set STT_GNU_IFUNC symbol value.  */
3016               h->root.u.def.value = sym->st_value;
3017               h->root.u.def.section = sec;
3018             }
3019         }
3020       else
3021         {
3022           bfd_boolean warned, ignored;
3023
3024           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3025                                    r_symndx, symtab_hdr, sym_hashes,
3026                                    h, sec, relocation,
3027                                    unresolved_reloc, warned, ignored);
3028           if (warned)
3029             {
3030               /* To avoid generating warning messages about truncated
3031                  relocations, set the relocation's address to be the same as
3032                  the start of this section.  */
3033               if (input_section->output_section != NULL)
3034                 relocation = input_section->output_section->vma;
3035               else
3036                 relocation = 0;
3037             }
3038         }
3039
3040       if (sec != NULL && discarded_section (sec))
3041         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3042                                          rel, 1, relend, howto, 0, contents);
3043
3044       if (bfd_link_relocatable (info))
3045         continue;
3046
3047       if (h != NULL
3048           && h->type == STT_GNU_IFUNC
3049           && h->def_regular)
3050         {
3051           asection *plt_sec;
3052           const char *name;
3053
3054           if ((input_section->flags & SEC_ALLOC) == 0
3055               || h->plt.offset == (bfd_vma) -1)
3056             abort ();
3057
3058           plt_sec = htab->elf.splt;
3059           if (! plt_sec)
3060             plt_sec =htab->elf.iplt;
3061
3062           switch (r_type)
3063             {
3064             case R_SPARC_GOTDATA_OP:
3065               continue;
3066
3067             case R_SPARC_GOTDATA_OP_HIX22:
3068             case R_SPARC_GOTDATA_OP_LOX10:
3069               r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3070                         ? R_SPARC_GOT22
3071                         : R_SPARC_GOT10);
3072               howto = _bfd_sparc_elf_howto_table + r_type;
3073               /* Fall through.  */
3074
3075             case R_SPARC_GOT10:
3076             case R_SPARC_GOT13:
3077             case R_SPARC_GOT22:
3078               if (htab->elf.sgot == NULL)
3079                 abort ();
3080               off = h->got.offset;
3081               if (off == (bfd_vma) -1)
3082                 abort();
3083               relocation = htab->elf.sgot->output_offset + off - got_base;
3084               goto do_relocation;
3085
3086             case R_SPARC_WPLT30:
3087             case R_SPARC_WDISP30:
3088               relocation = (plt_sec->output_section->vma
3089                             + plt_sec->output_offset + h->plt.offset);
3090               goto do_relocation;
3091
3092             case R_SPARC_32:
3093             case R_SPARC_64:
3094               if (bfd_link_pic (info) && h->non_got_ref)
3095                 {
3096                   Elf_Internal_Rela outrel;
3097                   bfd_vma offset;
3098
3099                   offset = _bfd_elf_section_offset (output_bfd, info,
3100                                                     input_section,
3101                                                     rel->r_offset);
3102                   if (offset == (bfd_vma) -1
3103                       || offset == (bfd_vma) -2)
3104                     abort();
3105
3106                   outrel.r_offset = (input_section->output_section->vma
3107                                      + input_section->output_offset
3108                                      + offset);
3109
3110                   if (h->dynindx == -1
3111                       || h->forced_local
3112                       || bfd_link_executable (info))
3113                     {
3114                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3115                                                         0, R_SPARC_IRELATIVE);
3116                       outrel.r_addend = relocation + rel->r_addend;
3117                     }
3118                   else
3119                     {
3120                       if (h->dynindx == -1)
3121                         abort();
3122                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3123                       outrel.r_addend = rel->r_addend;
3124                     }
3125
3126                   sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3127                   continue;
3128                 }
3129
3130               relocation = (plt_sec->output_section->vma
3131                             + plt_sec->output_offset + h->plt.offset);
3132               goto do_relocation;
3133
3134             case R_SPARC_HI22:
3135             case R_SPARC_LO10:
3136               /* We should only see such relocs in static links.  */
3137               if (bfd_link_pic (info))
3138                 abort();
3139               relocation = (plt_sec->output_section->vma
3140                             + plt_sec->output_offset + h->plt.offset);
3141               goto do_relocation;
3142
3143             default:
3144               if (h->root.root.string)
3145                 name = h->root.root.string;
3146               else
3147                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3148                                          NULL);
3149               _bfd_error_handler
3150                 (_("%B: relocation %s against STT_GNU_IFUNC "
3151                    "symbol `%s' isn't handled by %s"), input_bfd,
3152                  _bfd_sparc_elf_howto_table[r_type].name,
3153                  name, __FUNCTION__);
3154               bfd_set_error (bfd_error_bad_value);
3155               return FALSE;
3156             }
3157         }
3158
3159       switch (r_type)
3160         {
3161         case R_SPARC_GOTDATA_OP_HIX22:
3162         case R_SPARC_GOTDATA_OP_LOX10:
3163           if (SYMBOL_REFERENCES_LOCAL (info, h))
3164             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3165                       ? R_SPARC_GOTDATA_HIX22
3166                       : R_SPARC_GOTDATA_LOX10);
3167           else
3168             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3169                       ? R_SPARC_GOT22
3170                       : R_SPARC_GOT10);
3171           howto = _bfd_sparc_elf_howto_table + r_type;
3172           break;
3173
3174         case R_SPARC_GOTDATA_OP:
3175           if (SYMBOL_REFERENCES_LOCAL (info, h))
3176             {
3177               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3178
3179               /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3180               relocation = 0x80000000 | (insn & 0x3e07c01f);
3181               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3182             }
3183           continue;
3184         }
3185
3186       switch (r_type)
3187         {
3188         case R_SPARC_GOTDATA_HIX22:
3189         case R_SPARC_GOTDATA_LOX10:
3190           relocation = gdopoff (info, relocation);
3191           break;
3192
3193         case R_SPARC_GOT10:
3194         case R_SPARC_GOT13:
3195         case R_SPARC_GOT22:
3196           /* Relocation is to the entry for this symbol in the global
3197              offset table.  */
3198           if (htab->elf.sgot == NULL)
3199             abort ();
3200
3201           if (h != NULL)
3202             {
3203               bfd_boolean dyn;
3204
3205               off = h->got.offset;
3206               BFD_ASSERT (off != (bfd_vma) -1);
3207               dyn = elf_hash_table (info)->dynamic_sections_created;
3208
3209               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3210                                                      bfd_link_pic (info),
3211                                                      h)
3212                   || (bfd_link_pic (info)
3213                       && SYMBOL_REFERENCES_LOCAL (info, h)))
3214                 {
3215                   /* This is actually a static link, or it is a
3216                      -Bsymbolic link and the symbol is defined
3217                      locally, or the symbol was forced to be local
3218                      because of a version file.  We must initialize
3219                      this entry in the global offset table.  Since the
3220                      offset must always be a multiple of 8 for 64-bit
3221                      and 4 for 32-bit, we use the least significant bit
3222                      to record whether we have initialized it already.
3223
3224                      When doing a dynamic link, we create a .rela.got
3225                      relocation entry to initialize the value.  This
3226                      is done in the finish_dynamic_symbol routine.  */
3227                   if ((off & 1) != 0)
3228                     off &= ~1;
3229                   else
3230                     {
3231                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3232                                           htab->elf.sgot->contents + off);
3233                       h->got.offset |= 1;
3234                     }
3235                 }
3236               else
3237                 unresolved_reloc = FALSE;
3238             }
3239           else
3240             {
3241               BFD_ASSERT (local_got_offsets != NULL
3242                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3243
3244               off = local_got_offsets[r_symndx];
3245
3246               /* The offset must always be a multiple of 8 on 64-bit and
3247                  4 on 32-bit.  We use the least significant bit to record
3248                  whether we have already processed this entry.  */
3249               if ((off & 1) != 0)
3250                 off &= ~1;
3251               else
3252                 {
3253
3254                   if (bfd_link_pic (info))
3255                     {
3256                       asection *s;
3257                       Elf_Internal_Rela outrel;
3258
3259                       /* We need to generate a R_SPARC_RELATIVE reloc
3260                          for the dynamic linker.  */
3261                       s = htab->elf.srelgot;
3262                       BFD_ASSERT (s != NULL);
3263
3264                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3265                                          + htab->elf.sgot->output_offset
3266                                          + off);
3267                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3268                                                         0, R_SPARC_RELATIVE);
3269                       outrel.r_addend = relocation;
3270                       relocation = 0;
3271                       sparc_elf_append_rela (output_bfd, s, &outrel);
3272                     }
3273
3274                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3275                                       htab->elf.sgot->contents + off);
3276                   local_got_offsets[r_symndx] |= 1;
3277                 }
3278             }
3279           relocation = htab->elf.sgot->output_offset + off - got_base;
3280           break;
3281
3282         case R_SPARC_PLT32:
3283         case R_SPARC_PLT64:
3284           if (h == NULL || h->plt.offset == (bfd_vma) -1)
3285             {
3286               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3287               goto r_sparc_plt32;
3288             }
3289           /* Fall through.  */
3290
3291         case R_SPARC_WPLT30:
3292         case R_SPARC_HIPLT22:
3293         case R_SPARC_LOPLT10:
3294         case R_SPARC_PCPLT32:
3295         case R_SPARC_PCPLT22:
3296         case R_SPARC_PCPLT10:
3297         r_sparc_wplt30:
3298           /* Relocation is to the entry for this symbol in the
3299              procedure linkage table.  */
3300
3301           if (! ABI_64_P (output_bfd))
3302             {
3303               /* The Solaris native assembler will generate a WPLT30 reloc
3304                  for a local symbol if you assemble a call from one
3305                  section to another when using -K pic.  We treat it as
3306                  WDISP30.  */
3307               if (h == NULL)
3308                 break;
3309             }
3310           /* PR 7027: We need similar behaviour for 64-bit binaries.  */
3311           else if (r_type == R_SPARC_WPLT30 && h == NULL)
3312             break;
3313           else
3314             {
3315               BFD_ASSERT (h != NULL);
3316             }
3317
3318           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3319             {
3320               /* We didn't make a PLT entry for this symbol.  This
3321                  happens when statically linking PIC code, or when
3322                  using -Bsymbolic.  */
3323               break;
3324             }
3325
3326           relocation = (htab->elf.splt->output_section->vma
3327                         + htab->elf.splt->output_offset
3328                         + h->plt.offset);
3329           unresolved_reloc = FALSE;
3330           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3331             {
3332               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3333               is_plt = TRUE;
3334               goto r_sparc_plt32;
3335             }
3336           break;
3337
3338         case R_SPARC_PC10:
3339         case R_SPARC_PC22:
3340         case R_SPARC_PC_HH22:
3341         case R_SPARC_PC_HM10:
3342         case R_SPARC_PC_LM22:
3343           if (h != NULL
3344               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3345             break;
3346           /* Fall through.  */
3347         case R_SPARC_DISP8:
3348         case R_SPARC_DISP16:
3349         case R_SPARC_DISP32:
3350         case R_SPARC_DISP64:
3351         case R_SPARC_WDISP30:
3352         case R_SPARC_WDISP22:
3353         case R_SPARC_WDISP19:
3354         case R_SPARC_WDISP16:
3355         case R_SPARC_WDISP10:
3356         case R_SPARC_8:
3357         case R_SPARC_16:
3358         case R_SPARC_32:
3359         case R_SPARC_HI22:
3360         case R_SPARC_22:
3361         case R_SPARC_13:
3362         case R_SPARC_LO10:
3363         case R_SPARC_UA16:
3364         case R_SPARC_UA32:
3365         case R_SPARC_10:
3366         case R_SPARC_11:
3367         case R_SPARC_64:
3368         case R_SPARC_OLO10:
3369         case R_SPARC_HH22:
3370         case R_SPARC_HM10:
3371         case R_SPARC_LM22:
3372         case R_SPARC_7:
3373         case R_SPARC_5:
3374         case R_SPARC_6:
3375         case R_SPARC_HIX22:
3376         case R_SPARC_LOX10:
3377         case R_SPARC_H44:
3378         case R_SPARC_M44:
3379         case R_SPARC_L44:
3380         case R_SPARC_H34:
3381         case R_SPARC_UA64:
3382         r_sparc_plt32:
3383           if ((input_section->flags & SEC_ALLOC) == 0
3384               || is_vxworks_tls)
3385             break;
3386
3387           if ((bfd_link_pic (info)
3388                && (h == NULL
3389                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3390                    || h->root.type != bfd_link_hash_undefweak)
3391                && (! howto->pc_relative
3392                    || !SYMBOL_CALLS_LOCAL (info, h)))
3393               || (!bfd_link_pic (info)
3394                   && h != NULL
3395                   && h->dynindx != -1
3396                   && !h->non_got_ref
3397                   && ((h->def_dynamic
3398                        && !h->def_regular)
3399                       || h->root.type == bfd_link_hash_undefweak
3400                       || h->root.type == bfd_link_hash_undefined)))
3401             {
3402               Elf_Internal_Rela outrel;
3403               bfd_boolean skip, relocate = FALSE;
3404
3405               /* When generating a shared object, these relocations
3406                  are copied into the output file to be resolved at run
3407                  time.  */
3408
3409               BFD_ASSERT (sreloc != NULL);
3410
3411               skip = FALSE;
3412
3413               outrel.r_offset =
3414                 _bfd_elf_section_offset (output_bfd, info, input_section,
3415                                          rel->r_offset);
3416               if (outrel.r_offset == (bfd_vma) -1)
3417                 skip = TRUE;
3418               else if (outrel.r_offset == (bfd_vma) -2)
3419                 skip = TRUE, relocate = TRUE;
3420               outrel.r_offset += (input_section->output_section->vma
3421                                   + input_section->output_offset);
3422
3423               /* Optimize unaligned reloc usage now that we know where
3424                  it finally resides.  */
3425               switch (r_type)
3426                 {
3427                 case R_SPARC_16:
3428                   if (outrel.r_offset & 1)
3429                     r_type = R_SPARC_UA16;
3430                   break;
3431                 case R_SPARC_UA16:
3432                   if (!(outrel.r_offset & 1))
3433                     r_type = R_SPARC_16;
3434                   break;
3435                 case R_SPARC_32:
3436                   if (outrel.r_offset & 3)
3437                     r_type = R_SPARC_UA32;
3438                   break;
3439                 case R_SPARC_UA32:
3440                   if (!(outrel.r_offset & 3))
3441                     r_type = R_SPARC_32;
3442                   break;
3443                 case R_SPARC_64:
3444                   if (outrel.r_offset & 7)
3445                     r_type = R_SPARC_UA64;
3446                   break;
3447                 case R_SPARC_UA64:
3448                   if (!(outrel.r_offset & 7))
3449                     r_type = R_SPARC_64;
3450                   break;
3451                 case R_SPARC_DISP8:
3452                 case R_SPARC_DISP16:
3453                 case R_SPARC_DISP32:
3454                 case R_SPARC_DISP64:
3455                   /* If the symbol is not dynamic, we should not keep
3456                      a dynamic relocation.  But an .rela.* slot has been
3457                      allocated for it, output R_SPARC_NONE.
3458                      FIXME: Add code tracking needed dynamic relocs as
3459                      e.g. i386 has.  */
3460                   if (h->dynindx == -1)
3461                     skip = TRUE, relocate = TRUE;
3462                   break;
3463                 }
3464
3465               if (skip)
3466                 memset (&outrel, 0, sizeof outrel);
3467               /* h->dynindx may be -1 if the symbol was marked to
3468                  become local.  */
3469               else if (h != NULL
3470                        && h->dynindx != -1
3471                        && (_bfd_sparc_elf_howto_table[r_type].pc_relative
3472                            || !bfd_link_pic (info)
3473                            || !SYMBOLIC_BIND (info, h)
3474                            || !h->def_regular))
3475                 {
3476                   BFD_ASSERT (h->dynindx != -1);
3477                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3478                   outrel.r_addend = rel->r_addend;
3479                 }
3480               else
3481                 {
3482                   if (  (!ABI_64_P (output_bfd) && r_type == R_SPARC_32)
3483                       || (ABI_64_P (output_bfd) && r_type == R_SPARC_64))
3484                     {
3485                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3486                                                         0, R_SPARC_RELATIVE);
3487                       outrel.r_addend = relocation + rel->r_addend;
3488                     }
3489                   else
3490                     {
3491                       long indx;
3492
3493                       outrel.r_addend = relocation + rel->r_addend;
3494
3495                       if (is_plt)
3496                         sec = htab->elf.splt;
3497
3498                       if (bfd_is_abs_section (sec))
3499                         indx = 0;
3500                       else if (sec == NULL || sec->owner == NULL)
3501                         {
3502                           bfd_set_error (bfd_error_bad_value);
3503                           return FALSE;
3504                         }
3505                       else
3506                         {
3507                           asection *osec;
3508
3509                           /* We are turning this relocation into one
3510                              against a section symbol.  It would be
3511                              proper to subtract the symbol's value,
3512                              osec->vma, from the emitted reloc addend,
3513                              but ld.so expects buggy relocs.  */
3514                           osec = sec->output_section;
3515                           indx = elf_section_data (osec)->dynindx;
3516
3517                           if (indx == 0)
3518                             {
3519                               osec = htab->elf.text_index_section;
3520                               indx = elf_section_data (osec)->dynindx;
3521                             }
3522
3523                           /* FIXME: we really should be able to link non-pic
3524                              shared libraries.  */
3525                           if (indx == 0)
3526                             {
3527                               BFD_FAIL ();
3528                               _bfd_error_handler
3529                                 (_("%B: probably compiled without -fPIC?"),
3530                                  input_bfd);
3531                               bfd_set_error (bfd_error_bad_value);
3532                               return FALSE;
3533                             }
3534                         }
3535
3536                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3537                                                         r_type);
3538                     }
3539                 }
3540
3541               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3542
3543               /* This reloc will be computed at runtime, so there's no
3544                  need to do anything now.  */
3545               if (! relocate)
3546                 continue;
3547             }
3548           break;
3549
3550         case R_SPARC_TLS_GD_HI22:
3551           if (! ABI_64_P (input_bfd)
3552               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3553             {
3554               /* R_SPARC_REV32 used the same reloc number as
3555                  R_SPARC_TLS_GD_HI22.  */
3556               r_type = R_SPARC_REV32;
3557               break;
3558             }
3559           /* Fall through */
3560
3561         case R_SPARC_TLS_GD_LO10:
3562         case R_SPARC_TLS_IE_HI22:
3563         case R_SPARC_TLS_IE_LO10:
3564           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3565           tls_type = GOT_UNKNOWN;
3566           if (h == NULL && local_got_offsets)
3567             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3568           else if (h != NULL)
3569             {
3570               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3571               if (!bfd_link_pic (info)
3572                   && h->dynindx == -1
3573                   && tls_type == GOT_TLS_IE)
3574                 switch (SPARC_ELF_R_TYPE (rel->r_info))
3575                   {
3576                   case R_SPARC_TLS_GD_HI22:
3577                   case R_SPARC_TLS_IE_HI22:
3578                     r_type = R_SPARC_TLS_LE_HIX22;
3579                     break;
3580                   default:
3581                     r_type = R_SPARC_TLS_LE_LOX10;
3582                     break;
3583                   }
3584             }
3585           if (tls_type == GOT_TLS_IE)
3586             switch (r_type)
3587               {
3588               case R_SPARC_TLS_GD_HI22:
3589                 r_type = R_SPARC_TLS_IE_HI22;
3590                 break;
3591               case R_SPARC_TLS_GD_LO10:
3592                 r_type = R_SPARC_TLS_IE_LO10;
3593                 break;
3594               }
3595
3596           if (r_type == R_SPARC_TLS_LE_HIX22)
3597             {
3598               relocation = tpoff (info, relocation);
3599               break;
3600             }
3601           if (r_type == R_SPARC_TLS_LE_LOX10)
3602             {
3603               /* Change add into xor.  */
3604               relocation = tpoff (info, relocation);
3605               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3606                                                    contents + rel->r_offset)
3607                                        | 0x80182000), contents + rel->r_offset);
3608               break;
3609             }
3610
3611           if (h != NULL)
3612             {
3613               off = h->got.offset;
3614               h->got.offset |= 1;
3615             }
3616           else
3617             {
3618               BFD_ASSERT (local_got_offsets != NULL);
3619               off = local_got_offsets[r_symndx];
3620               local_got_offsets[r_symndx] |= 1;
3621             }
3622
3623         r_sparc_tlsldm:
3624           if (htab->elf.sgot == NULL)
3625             abort ();
3626
3627           if ((off & 1) != 0)
3628             off &= ~1;
3629           else
3630             {
3631               Elf_Internal_Rela outrel;
3632               int dr_type, indx;
3633
3634               if (htab->elf.srelgot == NULL)
3635                 abort ();
3636
3637               SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3638                                   htab->elf.sgot->contents + off);
3639               outrel.r_offset = (htab->elf.sgot->output_section->vma
3640                                  + htab->elf.sgot->output_offset + off);
3641               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3642               if (r_type == R_SPARC_TLS_IE_HI22
3643                   || r_type == R_SPARC_TLS_IE_LO10)
3644                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3645               else
3646                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3647               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3648                 outrel.r_addend = relocation - dtpoff_base (info);
3649               else
3650                 outrel.r_addend = 0;
3651               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3652               sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3653
3654               if (r_type == R_SPARC_TLS_GD_HI22
3655                   || r_type == R_SPARC_TLS_GD_LO10)
3656                 {
3657                   if (indx == 0)
3658                     {
3659                       BFD_ASSERT (! unresolved_reloc);
3660                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3661                                           relocation - dtpoff_base (info),
3662                                           (htab->elf.sgot->contents + off
3663                                            + SPARC_ELF_WORD_BYTES (htab)));
3664                     }
3665                   else
3666                     {
3667                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3668                                           (htab->elf.sgot->contents + off
3669                                            + SPARC_ELF_WORD_BYTES (htab)));
3670                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3671                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3672                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3673                       sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3674                                              &outrel);
3675                     }
3676                 }
3677               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3678                 {
3679                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3680                                       (htab->elf.sgot->contents + off
3681                                        + SPARC_ELF_WORD_BYTES (htab)));
3682                 }
3683             }
3684
3685           if (off >= (bfd_vma) -2)
3686             abort ();
3687
3688           relocation = htab->elf.sgot->output_offset + off - got_base;
3689           unresolved_reloc = FALSE;
3690           howto = _bfd_sparc_elf_howto_table + r_type;
3691           break;
3692
3693         case R_SPARC_TLS_LDM_HI22:
3694         case R_SPARC_TLS_LDM_LO10:
3695           if (! bfd_link_pic (info))
3696             {
3697               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3698               continue;
3699             }
3700           off = htab->tls_ldm_got.offset;
3701           htab->tls_ldm_got.offset |= 1;
3702           goto r_sparc_tlsldm;
3703
3704         case R_SPARC_TLS_LDO_HIX22:
3705         case R_SPARC_TLS_LDO_LOX10:
3706           if (bfd_link_pic (info))
3707             {
3708               relocation -= dtpoff_base (info);
3709               break;
3710             }
3711
3712           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3713                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3714           /* Fall through.  */
3715
3716         case R_SPARC_TLS_LE_HIX22:
3717         case R_SPARC_TLS_LE_LOX10:
3718           if (bfd_link_pic (info))
3719             {
3720               Elf_Internal_Rela outrel;
3721               bfd_boolean skip;
3722
3723               BFD_ASSERT (sreloc != NULL);
3724               skip = FALSE;
3725               outrel.r_offset =
3726                 _bfd_elf_section_offset (output_bfd, info, input_section,
3727                                          rel->r_offset);
3728               if (outrel.r_offset == (bfd_vma) -1)
3729                 skip = TRUE;
3730               else if (outrel.r_offset == (bfd_vma) -2)
3731                 skip = TRUE;
3732               outrel.r_offset += (input_section->output_section->vma
3733                                   + input_section->output_offset);
3734               if (skip)
3735                 memset (&outrel, 0, sizeof outrel);
3736               else
3737                 {
3738                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3739                   outrel.r_addend = relocation - dtpoff_base (info)
3740                                     + rel->r_addend;
3741                 }
3742
3743               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3744               continue;
3745             }
3746           relocation = tpoff (info, relocation);
3747           break;
3748
3749         case R_SPARC_TLS_LDM_CALL:
3750           if (! bfd_link_pic (info))
3751             {
3752               /* mov %g0, %o0 */
3753               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3754               continue;
3755             }
3756           /* Fall through */
3757
3758         case R_SPARC_TLS_GD_CALL:
3759           tls_type = GOT_UNKNOWN;
3760           if (h == NULL && local_got_offsets)
3761             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3762           else if (h != NULL)
3763             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3764           if (! bfd_link_pic (info)
3765               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3766             {
3767               Elf_Internal_Rela *rel2;
3768               bfd_vma insn;
3769
3770               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3771                 {
3772                   /* GD -> LE */
3773                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3774                   continue;
3775                 }
3776
3777               /* GD -> IE */
3778               if (rel + 1 < relend
3779                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3780                   && rel[1].r_offset == rel->r_offset + 4
3781                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3782                   && (((insn = bfd_get_32 (input_bfd,
3783                                            contents + rel[1].r_offset))
3784                        >> 25) & 0x1f) == 8)
3785                 {
3786                   /* We have
3787                      call __tls_get_addr, %tgd_call(foo)
3788                       add %reg1, %reg2, %o0, %tgd_add(foo)
3789                      and change it into IE:
3790                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3791                      add %g7, %o0, %o0, %tie_add(foo).
3792                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3793                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3794                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3795                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3796                               contents + rel->r_offset);
3797                   bfd_put_32 (output_bfd, 0x9001c008,
3798                               contents + rel->r_offset + 4);
3799                   rel++;
3800                   continue;
3801                 }
3802
3803               /* We cannot just overwrite the delay slot instruction,
3804                  as it might be what puts the %o0 argument to
3805                  __tls_get_addr into place.  So we have to transpose
3806                  the delay slot with the add we patch in.  */
3807               insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3808               bfd_put_32 (output_bfd, insn,
3809                           contents + rel->r_offset);
3810               bfd_put_32 (output_bfd, 0x9001c008,
3811                           contents + rel->r_offset + 4);
3812
3813               rel2 = rel;
3814               while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3815                                                           rel->r_offset + 4))
3816                      != NULL)
3817                 {
3818                   /* If the instruction we moved has a relocation attached to
3819                      it, adjust the offset so that it will apply to the correct
3820                      instruction.  */
3821                   rel2->r_offset -= 4;
3822                 }
3823               continue;
3824             }
3825
3826           h = (struct elf_link_hash_entry *)
3827               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3828                                     FALSE, TRUE);
3829           BFD_ASSERT (h != NULL);
3830           r_type = R_SPARC_WPLT30;
3831           howto = _bfd_sparc_elf_howto_table + r_type;
3832           goto r_sparc_wplt30;
3833
3834         case R_SPARC_TLS_GD_ADD:
3835           tls_type = GOT_UNKNOWN;
3836           if (h == NULL && local_got_offsets)
3837             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3838           else if (h != NULL)
3839             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3840           if (! bfd_link_pic (info) || tls_type == GOT_TLS_IE)
3841             {
3842               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3843                  changed into IE:
3844                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3845                  or LE:
3846                  add %g7, %reg2, %reg3.  */
3847               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3848               if ((h != NULL && h->dynindx != -1) || bfd_link_pic (info))
3849                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3850               else
3851                 relocation = (insn & ~0x7c000) | 0x1c000;
3852               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3853             }
3854           continue;
3855
3856         case R_SPARC_TLS_LDM_ADD:
3857           if (! bfd_link_pic (info))
3858             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3859           continue;
3860
3861         case R_SPARC_TLS_LDO_ADD:
3862           if (! bfd_link_pic (info))
3863             {
3864               /* Change rs1 into %g7.  */
3865               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3866               insn = (insn & ~0x7c000) | 0x1c000;
3867               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3868             }
3869           continue;
3870
3871         case R_SPARC_TLS_IE_LD:
3872         case R_SPARC_TLS_IE_LDX:
3873           if (! bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3874             {
3875               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3876               int rs2 = insn & 0x1f;
3877               int rd = (insn >> 25) & 0x1f;
3878
3879               if (rs2 == rd)
3880                 relocation = SPARC_NOP;
3881               else
3882                 relocation = 0x80100000 | (insn & 0x3e00001f);
3883               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3884             }
3885           continue;
3886
3887         case R_SPARC_TLS_IE_ADD:
3888           /* Totally useless relocation.  */
3889           continue;
3890
3891         case R_SPARC_TLS_DTPOFF32:
3892         case R_SPARC_TLS_DTPOFF64:
3893           relocation -= dtpoff_base (info);
3894           break;
3895
3896         default:
3897           break;
3898         }
3899
3900       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3901          because such sections are not SEC_ALLOC and thus ld.so will
3902          not process them.  */
3903       if (unresolved_reloc
3904           && !((input_section->flags & SEC_DEBUGGING) != 0
3905                && h->def_dynamic)
3906           && _bfd_elf_section_offset (output_bfd, info, input_section,
3907                                       rel->r_offset) != (bfd_vma) -1)
3908         _bfd_error_handler
3909           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3910            input_bfd,
3911            input_section,
3912            (long) rel->r_offset,
3913            howto->name,
3914            h->root.root.string);
3915
3916       r = bfd_reloc_continue;
3917       if (r_type == R_SPARC_OLO10)
3918         {
3919             bfd_vma x;
3920
3921             if (! ABI_64_P (output_bfd))
3922               abort ();
3923
3924             relocation += rel->r_addend;
3925             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3926
3927             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3928             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3929             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3930
3931             r = bfd_check_overflow (howto->complain_on_overflow,
3932                                     howto->bitsize, howto->rightshift,
3933                                     bfd_arch_bits_per_address (input_bfd),
3934                                     relocation);
3935         }
3936       else if (r_type == R_SPARC_WDISP16)
3937         {
3938           bfd_vma x;
3939
3940           relocation += rel->r_addend;
3941           relocation -= (input_section->output_section->vma
3942                          + input_section->output_offset);
3943           relocation -= rel->r_offset;
3944
3945           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3946           x |= ((((relocation >> 2) & 0xc000) << 6)
3947                 | ((relocation >> 2) & 0x3fff));
3948           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3949
3950           r = bfd_check_overflow (howto->complain_on_overflow,
3951                                   howto->bitsize, howto->rightshift,
3952                                   bfd_arch_bits_per_address (input_bfd),
3953                                   relocation);
3954         }
3955       else if (r_type == R_SPARC_WDISP10)
3956         {
3957           bfd_vma x;
3958
3959           relocation += rel->r_addend;
3960           relocation -= (input_section->output_section->vma
3961                          + input_section->output_offset);
3962           relocation -= rel->r_offset;
3963
3964           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3965           x |= ((((relocation >> 2) & 0x300) << 11)
3966                 | (((relocation >> 2) & 0xff) << 5));
3967           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3968
3969           r = bfd_check_overflow (howto->complain_on_overflow,
3970                                   howto->bitsize, howto->rightshift,
3971                                   bfd_arch_bits_per_address (input_bfd),
3972                                   relocation);
3973         }
3974       else if (r_type == R_SPARC_REV32)
3975         {
3976           bfd_vma x;
3977
3978           relocation = relocation + rel->r_addend;
3979
3980           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3981           x = x + relocation;
3982           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3983           r = bfd_reloc_ok;
3984         }
3985       else if (r_type == R_SPARC_TLS_LDO_HIX22
3986                || r_type == R_SPARC_TLS_LE_HIX22)
3987         {
3988           bfd_vma x;
3989
3990           relocation += rel->r_addend;
3991           if (r_type == R_SPARC_TLS_LE_HIX22)
3992             relocation ^= MINUS_ONE;
3993
3994           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3995           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3996           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3997           r = bfd_reloc_ok;
3998         }
3999       else if (r_type == R_SPARC_TLS_LDO_LOX10
4000                || r_type == R_SPARC_TLS_LE_LOX10)
4001         {
4002           bfd_vma x;
4003
4004           relocation += rel->r_addend;
4005           relocation &= 0x3ff;
4006           if (r_type == R_SPARC_TLS_LE_LOX10)
4007             relocation |= 0x1c00;
4008
4009           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4010           x = (x & ~(bfd_vma) 0x1fff) | relocation;
4011           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4012
4013           r = bfd_reloc_ok;
4014         }
4015       else if (r_type == R_SPARC_HIX22
4016                || r_type == R_SPARC_GOTDATA_HIX22)
4017         {
4018           bfd_vma x;
4019
4020           relocation += rel->r_addend;
4021           if (r_type == R_SPARC_HIX22
4022               || (bfd_signed_vma) relocation < 0)
4023             relocation = relocation ^ MINUS_ONE;
4024
4025           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4026           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
4027           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4028
4029           r = bfd_check_overflow (howto->complain_on_overflow,
4030                                   howto->bitsize, howto->rightshift,
4031                                   bfd_arch_bits_per_address (input_bfd),
4032                                   relocation);
4033         }
4034       else if (r_type == R_SPARC_LOX10
4035                || r_type == R_SPARC_GOTDATA_LOX10)
4036         {
4037           bfd_vma x;
4038
4039           relocation += rel->r_addend;
4040           if (r_type == R_SPARC_LOX10
4041               || (bfd_signed_vma) relocation < 0)
4042             relocation = (relocation & 0x3ff) | 0x1c00;
4043           else
4044             relocation = (relocation & 0x3ff);
4045
4046           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4047           x = (x & ~(bfd_vma) 0x1fff) | relocation;
4048           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4049
4050           r = bfd_reloc_ok;
4051         }
4052       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4053                && sec_do_relax (input_section)
4054                && rel->r_offset + 4 < input_section->size)
4055         {
4056 #define G0              0
4057 #define O7              15
4058 #define XCC             (2 << 20)
4059 #define COND(x)         (((x)&0xf)<<25)
4060 #define CONDA           COND(0x8)
4061 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
4062 #define INSN_BA         (F2(0,2) | CONDA)
4063 #define INSN_OR         F3(2, 0x2, 0)
4064 #define INSN_NOP        F2(0,4)
4065
4066           bfd_vma x, y;
4067
4068           /* If the instruction is a call with either:
4069              restore
4070              arithmetic instruction with rd == %o7
4071              where rs1 != %o7 and rs2 if it is register != %o7
4072              then we can optimize if the call destination is near
4073              by changing the call into a branch always.  */
4074           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4075           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4076           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4077             {
4078               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4079                    || ((y & OP3(0x28)) == 0 /* arithmetic */
4080                        && (y & RD(~0)) == RD(O7)))
4081                   && (y & RS1(~0)) != RS1(O7)
4082                   && ((y & F3I(~0))
4083                       || (y & RS2(~0)) != RS2(O7)))
4084                 {
4085                   bfd_vma reloc;
4086
4087                   reloc = relocation + rel->r_addend - rel->r_offset;
4088                   reloc -= (input_section->output_section->vma
4089                             + input_section->output_offset);
4090
4091                   /* Ensure the branch fits into simm22.  */
4092                   if ((reloc & 3) == 0
4093                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
4094                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4095                     {
4096                       reloc >>= 2;
4097
4098                       /* Check whether it fits into simm19.  */
4099                       if (((reloc & 0x3c0000) == 0
4100                            || (reloc & 0x3c0000) == 0x3c0000)
4101                           && (ABI_64_P (output_bfd)
4102                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4103                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4104                       else
4105                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
4106                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4107                       r = bfd_reloc_ok;
4108                       if (rel->r_offset >= 4
4109                           && (y & (0xffffffff ^ RS1(~0)))
4110                              == (INSN_OR | RD(O7) | RS2(G0)))
4111                         {
4112                           bfd_vma z;
4113                           unsigned int reg;
4114
4115                           z = bfd_get_32 (input_bfd,
4116                                           contents + rel->r_offset - 4);
4117                           if ((z & (0xffffffff ^ RD(~0)))
4118                               != (INSN_OR | RS1(O7) | RS2(G0)))
4119                             break;
4120
4121                           /* The sequence was
4122                              or %o7, %g0, %rN
4123                              call foo
4124                              or %rN, %g0, %o7
4125
4126                              If call foo was replaced with ba, replace
4127                              or %rN, %g0, %o7 with nop.  */
4128
4129                           reg = (y & RS1(~0)) >> 14;
4130                           if (reg != ((z & RD(~0)) >> 25)
4131                               || reg == G0 || reg == O7)
4132                             break;
4133
4134                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4135                                       contents + rel->r_offset + 4);
4136                         }
4137
4138                     }
4139                 }
4140             }
4141         }
4142
4143       if (r == bfd_reloc_continue)
4144         {
4145 do_relocation:
4146           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4147                                         contents, rel->r_offset,
4148                                         relocation, rel->r_addend);
4149         }
4150       if (r != bfd_reloc_ok)
4151         {
4152           switch (r)
4153             {
4154             default:
4155             case bfd_reloc_outofrange:
4156               abort ();
4157             case bfd_reloc_overflow:
4158               {
4159                 const char *name;
4160
4161                 /* The Solaris native linker silently disregards overflows.
4162                    We don't, but this breaks stabs debugging info, whose
4163                    relocations are only 32-bits wide.  Ignore overflows in
4164                    this case and also for discarded entries.  */
4165                 if ((r_type == R_SPARC_32
4166                      || r_type == R_SPARC_UA32
4167                      || r_type == R_SPARC_DISP32)
4168                     && (((input_section->flags & SEC_DEBUGGING) != 0
4169                          && strcmp (bfd_section_name (input_bfd,
4170                                                       input_section),
4171                                     ".stab") == 0)
4172                         || _bfd_elf_section_offset (output_bfd, info,
4173                                                     input_section,
4174                                                     rel->r_offset)
4175                              == (bfd_vma)-1))
4176                   break;
4177
4178                 if (h != NULL)
4179                   {
4180                     /* Assume this is a call protected by other code that
4181                        detect the symbol is undefined.  If this is the case,
4182                        we can safely ignore the overflow.  If not, the
4183                        program is hosed anyway, and a little warning isn't
4184                        going to help.  */
4185                     if (h->root.type == bfd_link_hash_undefweak
4186                         && howto->pc_relative)
4187                       break;
4188
4189                     name = NULL;
4190                   }
4191                 else
4192                   {
4193                     name = bfd_elf_string_from_elf_section (input_bfd,
4194                                                             symtab_hdr->sh_link,
4195                                                             sym->st_name);
4196                     if (name == NULL)
4197                       return FALSE;
4198                     if (*name == '\0')
4199                       name = bfd_section_name (input_bfd, sec);
4200                   }
4201                 (*info->callbacks->reloc_overflow)
4202                   (info, (h ? &h->root : NULL), name, howto->name,
4203                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4204               }
4205               break;
4206             }
4207         }
4208     }
4209
4210   return TRUE;
4211 }
4212
4213 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
4214    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
4215    is the offset of the associated .got.plt entry from
4216    _GLOBAL_OFFSET_TABLE_.  */
4217
4218 static void
4219 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4220                                bfd_vma plt_offset, bfd_vma plt_index,
4221                                bfd_vma got_offset)
4222 {
4223   bfd_vma got_base;
4224   const bfd_vma *plt_entry;
4225   struct _bfd_sparc_elf_link_hash_table *htab;
4226   bfd_byte *loc;
4227   Elf_Internal_Rela rela;
4228
4229   htab = _bfd_sparc_elf_hash_table (info);
4230   BFD_ASSERT (htab != NULL);
4231
4232   if (bfd_link_pic (info))
4233     {
4234       plt_entry = sparc_vxworks_shared_plt_entry;
4235       got_base = 0;
4236     }
4237   else
4238     {
4239       plt_entry = sparc_vxworks_exec_plt_entry;
4240       got_base = (htab->elf.hgot->root.u.def.value
4241                   + htab->elf.hgot->root.u.def.section->output_offset
4242                   + htab->elf.hgot->root.u.def.section->output_section->vma);
4243     }
4244
4245   /* Fill in the entry in the procedure linkage table.  */
4246   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4247               htab->elf.splt->contents + plt_offset);
4248   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4249               htab->elf.splt->contents + plt_offset + 4);
4250   bfd_put_32 (output_bfd, plt_entry[2],
4251               htab->elf.splt->contents + plt_offset + 8);
4252   bfd_put_32 (output_bfd, plt_entry[3],
4253               htab->elf.splt->contents + plt_offset + 12);
4254   bfd_put_32 (output_bfd, plt_entry[4],
4255               htab->elf.splt->contents + plt_offset + 16);
4256   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4257               htab->elf.splt->contents + plt_offset + 20);
4258   /* PC-relative displacement for a branch to the start of
4259      the PLT section.  */
4260   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4261                                           & 0x003fffff),
4262               htab->elf.splt->contents + plt_offset + 24);
4263   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4264               htab->elf.splt->contents + plt_offset + 28);
4265
4266   /* Fill in the .got.plt entry, pointing initially at the
4267      second half of the PLT entry.  */
4268   BFD_ASSERT (htab->elf.sgotplt != NULL);
4269   bfd_put_32 (output_bfd,
4270               htab->elf.splt->output_section->vma
4271               + htab->elf.splt->output_offset
4272               + plt_offset + 20,
4273               htab->elf.sgotplt->contents + got_offset);
4274
4275   /* Add relocations to .rela.plt.unloaded.  */
4276   if (!bfd_link_pic (info))
4277     {
4278       loc = (htab->srelplt2->contents
4279              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4280
4281       /* Relocate the initial sethi.  */
4282       rela.r_offset = (htab->elf.splt->output_section->vma
4283                        + htab->elf.splt->output_offset
4284                        + plt_offset);
4285       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4286       rela.r_addend = got_offset;
4287       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4288       loc += sizeof (Elf32_External_Rela);
4289
4290       /* Likewise the following or.  */
4291       rela.r_offset += 4;
4292       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4293       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4294       loc += sizeof (Elf32_External_Rela);
4295
4296       /* Relocate the .got.plt entry.  */
4297       rela.r_offset = (htab->elf.sgotplt->output_section->vma
4298                        + htab->elf.sgotplt->output_offset
4299                        + got_offset);
4300       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4301       rela.r_addend = plt_offset + 20;
4302       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4303     }
4304 }
4305
4306 /* Finish up dynamic symbol handling.  We set the contents of various
4307    dynamic sections here.  */
4308
4309 bfd_boolean
4310 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4311                                       struct bfd_link_info *info,
4312                                       struct elf_link_hash_entry *h,
4313                                       Elf_Internal_Sym *sym)
4314 {
4315   struct _bfd_sparc_elf_link_hash_table *htab;
4316   const struct elf_backend_data *bed;
4317
4318   htab = _bfd_sparc_elf_hash_table (info);
4319   BFD_ASSERT (htab != NULL);
4320   bed = get_elf_backend_data (output_bfd);
4321
4322   if (h->plt.offset != (bfd_vma) -1)
4323     {
4324       asection *splt;
4325       asection *srela;
4326       Elf_Internal_Rela rela;
4327       bfd_byte *loc;
4328       bfd_vma r_offset, got_offset;
4329       int rela_index;
4330
4331       /* When building a static executable, use .iplt and
4332          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4333       if (htab->elf.splt != NULL)
4334         {
4335           splt = htab->elf.splt;
4336           srela = htab->elf.srelplt;
4337         }
4338       else
4339         {
4340           splt = htab->elf.iplt;
4341           srela = htab->elf.irelplt;
4342         }
4343
4344       if (splt == NULL || srela == NULL)
4345         abort ();
4346
4347       /* Fill in the entry in the .rela.plt section.  */
4348       if (htab->is_vxworks)
4349         {
4350           /* Work out the index of this PLT entry.  */
4351           rela_index = ((h->plt.offset - htab->plt_header_size)
4352                         / htab->plt_entry_size);
4353
4354           /* Calculate the offset of the associated .got.plt entry.
4355              The first three entries are reserved.  */
4356           got_offset = (rela_index + 3) * 4;
4357
4358           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4359                                          rela_index, got_offset);
4360
4361
4362           /* On VxWorks, the relocation points to the .got.plt entry,
4363              not the .plt entry.  */
4364           rela.r_offset = (htab->elf.sgotplt->output_section->vma
4365                            + htab->elf.sgotplt->output_offset
4366                            + got_offset);
4367           rela.r_addend = 0;
4368           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4369                                           R_SPARC_JMP_SLOT);
4370         }
4371       else
4372         {
4373           bfd_boolean ifunc = FALSE;
4374
4375           /* Fill in the entry in the procedure linkage table.  */
4376           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4377                                                   h->plt.offset, splt->size,
4378                                                   &r_offset);
4379
4380           if (h == NULL
4381               || h->dynindx == -1
4382               || ((bfd_link_executable (info)
4383                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4384                   && h->def_regular
4385                   && h->type == STT_GNU_IFUNC))
4386             {
4387               ifunc = TRUE;
4388               BFD_ASSERT (h == NULL
4389                           || (h->type == STT_GNU_IFUNC
4390                               && h->def_regular
4391                               && (h->root.type == bfd_link_hash_defined
4392                                   || h->root.type == bfd_link_hash_defweak)));
4393             }
4394
4395           rela.r_offset = r_offset
4396             + (splt->output_section->vma + splt->output_offset);
4397           if (ABI_64_P (output_bfd)
4398               && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4399             {
4400               if (ifunc)
4401                 {
4402                   rela.r_addend = (h->root.u.def.section->output_section->vma
4403                                    + h->root.u.def.section->output_offset
4404                                    + h->root.u.def.value);
4405                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4406                                                   R_SPARC_IRELATIVE);
4407                 }
4408               else
4409                 {
4410                   rela.r_addend = (-(h->plt.offset + 4)
4411                                    - splt->output_section->vma
4412                                    - splt->output_offset);
4413                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4414                                                   R_SPARC_JMP_SLOT);
4415                 }
4416             }
4417           else
4418             {
4419               if (ifunc)
4420                 {
4421                   rela.r_addend = (h->root.u.def.section->output_section->vma
4422                                    + h->root.u.def.section->output_offset
4423                                    + h->root.u.def.value);
4424                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4425                                                   R_SPARC_JMP_IREL);
4426                 }
4427               else
4428                 {
4429                   rela.r_addend = 0;
4430                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4431                                                   R_SPARC_JMP_SLOT);
4432                 }
4433             }
4434         }
4435
4436       /* Adjust for the first 4 reserved elements in the .plt section
4437          when setting the offset in the .rela.plt section.
4438          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4439          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
4440
4441       loc = srela->contents;
4442       loc += rela_index * bed->s->sizeof_rela;
4443       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4444
4445       if (!h->def_regular)
4446         {
4447           /* Mark the symbol as undefined, rather than as defined in
4448              the .plt section.  Leave the value alone.  */
4449           sym->st_shndx = SHN_UNDEF;
4450           /* If the symbol is weak, we do need to clear the value.
4451              Otherwise, the PLT entry would provide a definition for
4452              the symbol even if the symbol wasn't defined anywhere,
4453              and so the symbol would never be NULL.  */
4454           if (!h->ref_regular_nonweak)
4455             sym->st_value = 0;
4456         }
4457     }
4458
4459   if (h->got.offset != (bfd_vma) -1
4460       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4461       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4462     {
4463       asection *sgot;
4464       asection *srela;
4465       Elf_Internal_Rela rela;
4466
4467       /* This symbol has an entry in the GOT.  Set it up.  */
4468
4469       sgot = htab->elf.sgot;
4470       srela = htab->elf.srelgot;
4471       BFD_ASSERT (sgot != NULL && srela != NULL);
4472
4473       rela.r_offset = (sgot->output_section->vma
4474                        + sgot->output_offset
4475                        + (h->got.offset &~ (bfd_vma) 1));
4476
4477       /* If this is a -Bsymbolic link, and the symbol is defined
4478          locally, we just want to emit a RELATIVE reloc.  Likewise if
4479          the symbol was forced to be local because of a version file.
4480          The entry in the global offset table will already have been
4481          initialized in the relocate_section function.  */
4482       if (! bfd_link_pic (info)
4483           && h->type == STT_GNU_IFUNC
4484           && h->def_regular)
4485         {
4486           asection *plt;
4487
4488           /* We load the GOT entry with the PLT entry.  */
4489           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4490           SPARC_ELF_PUT_WORD (htab, output_bfd,
4491                               (plt->output_section->vma
4492                                + plt->output_offset + h->plt.offset),
4493                               htab->elf.sgot->contents
4494                               + (h->got.offset & ~(bfd_vma) 1));
4495           return TRUE;
4496         }
4497       else if (bfd_link_pic (info)
4498                && SYMBOL_REFERENCES_LOCAL (info, h))
4499         {
4500           asection *sec = h->root.u.def.section;
4501           if (h->type == STT_GNU_IFUNC)
4502             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4503           else
4504             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4505           rela.r_addend = (h->root.u.def.value
4506                            + sec->output_section->vma
4507                            + sec->output_offset);
4508         }
4509       else
4510         {
4511           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4512           rela.r_addend = 0;
4513         }
4514
4515       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4516                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4517       sparc_elf_append_rela (output_bfd, srela, &rela);
4518     }
4519
4520   if (h->needs_copy)
4521     {
4522       asection *s;
4523       Elf_Internal_Rela rela;
4524
4525       /* This symbols needs a copy reloc.  Set it up.  */
4526       BFD_ASSERT (h->dynindx != -1);
4527
4528       s = bfd_get_linker_section (h->root.u.def.section->owner,
4529                                   ".rela.bss");
4530       BFD_ASSERT (s != NULL);
4531
4532       rela.r_offset = (h->root.u.def.value
4533                        + h->root.u.def.section->output_section->vma
4534                        + h->root.u.def.section->output_offset);
4535       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4536       rela.r_addend = 0;
4537       sparc_elf_append_rela (output_bfd, s, &rela);
4538     }
4539
4540   /* Mark some specially defined symbols as absolute.  On VxWorks,
4541      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4542      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
4543   if (sym != NULL
4544       && (h == htab->elf.hdynamic
4545           || (!htab->is_vxworks
4546               && (h == htab->elf.hgot || h == htab->elf.hplt))))
4547     sym->st_shndx = SHN_ABS;
4548
4549   return TRUE;
4550 }
4551
4552 /* Finish up the dynamic sections.  */
4553
4554 static bfd_boolean
4555 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4556                   bfd *dynobj, asection *sdyn,
4557                   asection *splt ATTRIBUTE_UNUSED)
4558 {
4559   struct _bfd_sparc_elf_link_hash_table *htab;
4560   const struct elf_backend_data *bed;
4561   bfd_byte *dyncon, *dynconend;
4562   size_t dynsize;
4563   int stt_regidx = -1;
4564   bfd_boolean abi_64_p;
4565
4566   htab = _bfd_sparc_elf_hash_table (info);
4567   BFD_ASSERT (htab != NULL);
4568   bed = get_elf_backend_data (output_bfd);
4569   dynsize = bed->s->sizeof_dyn;
4570   dynconend = sdyn->contents + sdyn->size;
4571   abi_64_p = ABI_64_P (output_bfd);
4572   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4573     {
4574       Elf_Internal_Dyn dyn;
4575       const char *name;
4576       bfd_boolean size;
4577
4578       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4579
4580       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4581         {
4582           /* On VxWorks, DT_RELASZ should not include the relocations
4583              in .rela.plt.  */
4584           if (htab->elf.srelplt)
4585             {
4586               dyn.d_un.d_val -= htab->elf.srelplt->size;
4587               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4588             }
4589         }
4590       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4591         {
4592           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4593              not to the start of the PLT.  */
4594           if (htab->elf.sgotplt)
4595             {
4596               dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4597                                 + htab->elf.sgotplt->output_offset);
4598               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4599             }
4600         }
4601       else if (htab->is_vxworks
4602                && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4603         bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4604       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4605         {
4606           if (stt_regidx == -1)
4607             {
4608               stt_regidx =
4609                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4610               if (stt_regidx == -1)
4611                 return FALSE;
4612             }
4613           dyn.d_un.d_val = stt_regidx++;
4614           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4615         }
4616       else
4617         {
4618           switch (dyn.d_tag)
4619             {
4620             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
4621             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4622             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
4623             default:          name = NULL; size = FALSE; break;
4624             }
4625
4626           if (name != NULL)
4627             {
4628               asection *s;
4629
4630               s = bfd_get_linker_section (dynobj, name);
4631               if (s == NULL)
4632                 dyn.d_un.d_val = 0;
4633               else
4634                 {
4635                   if (! size)
4636                     dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4637                   else
4638                     dyn.d_un.d_val = s->size;
4639                 }
4640               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4641             }
4642         }
4643     }
4644   return TRUE;
4645 }
4646
4647 /* Install the first PLT entry in a VxWorks executable and make sure that
4648    .rela.plt.unloaded relocations have the correct symbol indexes.  */
4649
4650 static void
4651 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4652 {
4653   struct _bfd_sparc_elf_link_hash_table *htab;
4654   Elf_Internal_Rela rela;
4655   bfd_vma got_base;
4656   bfd_byte *loc;
4657
4658   htab = _bfd_sparc_elf_hash_table (info);
4659   BFD_ASSERT (htab != NULL);
4660
4661   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
4662   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4663               + htab->elf.hgot->root.u.def.section->output_offset
4664               + htab->elf.hgot->root.u.def.value);
4665
4666   /* Install the initial PLT entry.  */
4667   bfd_put_32 (output_bfd,
4668               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4669               htab->elf.splt->contents);
4670   bfd_put_32 (output_bfd,
4671               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4672               htab->elf.splt->contents + 4);
4673   bfd_put_32 (output_bfd,
4674               sparc_vxworks_exec_plt0_entry[2],
4675               htab->elf.splt->contents + 8);
4676   bfd_put_32 (output_bfd,
4677               sparc_vxworks_exec_plt0_entry[3],
4678               htab->elf.splt->contents + 12);
4679   bfd_put_32 (output_bfd,
4680               sparc_vxworks_exec_plt0_entry[4],
4681               htab->elf.splt->contents + 16);
4682
4683   loc = htab->srelplt2->contents;
4684
4685   /* Add an unloaded relocation for the initial entry's "sethi".  */
4686   rela.r_offset = (htab->elf.splt->output_section->vma
4687                    + htab->elf.splt->output_offset);
4688   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4689   rela.r_addend = 8;
4690   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4691   loc += sizeof (Elf32_External_Rela);
4692
4693   /* Likewise the following "or".  */
4694   rela.r_offset += 4;
4695   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4696   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4697   loc += sizeof (Elf32_External_Rela);
4698
4699   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4700      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4701      in which symbols were output.  */
4702   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4703     {
4704       Elf_Internal_Rela rel;
4705
4706       /* The entry's initial "sethi" (against _G_O_T_).  */
4707       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4708       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4709       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4710       loc += sizeof (Elf32_External_Rela);
4711
4712       /* The following "or" (also against _G_O_T_).  */
4713       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4714       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4715       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4716       loc += sizeof (Elf32_External_Rela);
4717
4718       /* The .got.plt entry (against _P_L_T_).  */
4719       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4720       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4721       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4722       loc += sizeof (Elf32_External_Rela);
4723     }
4724 }
4725
4726 /* Install the first PLT entry in a VxWorks shared object.  */
4727
4728 static void
4729 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4730 {
4731   struct _bfd_sparc_elf_link_hash_table *htab;
4732   unsigned int i;
4733
4734   htab = _bfd_sparc_elf_hash_table (info);
4735   BFD_ASSERT (htab != NULL);
4736
4737   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4738     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4739                 htab->elf.splt->contents + i * 4);
4740 }
4741
4742 /* Finish up local dynamic symbol handling.  We set the contents of
4743    various dynamic sections here.  */
4744
4745 static bfd_boolean
4746 finish_local_dynamic_symbol (void **slot, void *inf)
4747 {
4748   struct elf_link_hash_entry *h
4749     = (struct elf_link_hash_entry *) *slot;
4750   struct bfd_link_info *info
4751     = (struct bfd_link_info *) inf;
4752
4753   return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4754                                                h, NULL);
4755 }
4756
4757 bfd_boolean
4758 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4759 {
4760   bfd *dynobj;
4761   asection *sdyn;
4762   struct _bfd_sparc_elf_link_hash_table *htab;
4763
4764   htab = _bfd_sparc_elf_hash_table (info);
4765   BFD_ASSERT (htab != NULL);
4766   dynobj = htab->elf.dynobj;
4767
4768   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4769
4770   if (elf_hash_table (info)->dynamic_sections_created)
4771     {
4772       asection *splt;
4773
4774       splt = htab->elf.splt;
4775       BFD_ASSERT (splt != NULL && sdyn != NULL);
4776
4777       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4778         return FALSE;
4779
4780       /* Initialize the contents of the .plt section.  */
4781       if (splt->size > 0)
4782         {
4783           if (htab->is_vxworks)
4784             {
4785               if (bfd_link_pic (info))
4786                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4787               else
4788                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4789             }
4790           else
4791             {
4792               memset (splt->contents, 0, htab->plt_header_size);
4793               if (!ABI_64_P (output_bfd))
4794                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4795                             splt->contents + splt->size - 4);
4796             }
4797         }
4798
4799       if (elf_section_data (splt->output_section) != NULL)
4800         elf_section_data (splt->output_section)->this_hdr.sh_entsize
4801           = ((htab->is_vxworks || !ABI_64_P (output_bfd))
4802              ? 0 : htab->plt_entry_size);
4803     }
4804
4805   /* Set the first entry in the global offset table to the address of
4806      the dynamic section.  */
4807   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4808     {
4809       bfd_vma val = (sdyn ?
4810                      sdyn->output_section->vma + sdyn->output_offset :
4811                      0);
4812
4813       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4814     }
4815
4816   if (htab->elf.sgot)
4817     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4818       SPARC_ELF_WORD_BYTES (htab);
4819
4820   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4821   htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4822
4823   return TRUE;
4824 }
4825
4826 \f
4827 /* Set the right machine number for a SPARC ELF file.  */
4828
4829 bfd_boolean
4830 _bfd_sparc_elf_object_p (bfd *abfd)
4831 {
4832   obj_attribute *attrs = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
4833   obj_attribute *hwcaps = &attrs[Tag_GNU_Sparc_HWCAPS];
4834   obj_attribute *hwcaps2 = &attrs[Tag_GNU_Sparc_HWCAPS2];
4835
4836   unsigned int v9c_hwcaps_mask = ELF_SPARC_HWCAP_ASI_BLK_INIT;
4837   unsigned int v9d_hwcaps_mask = (ELF_SPARC_HWCAP_FMAF
4838                                   | ELF_SPARC_HWCAP_VIS3
4839                                   | ELF_SPARC_HWCAP_HPC);
4840   unsigned int v9e_hwcaps_mask = (ELF_SPARC_HWCAP_AES
4841                                   | ELF_SPARC_HWCAP_DES
4842                                   | ELF_SPARC_HWCAP_KASUMI
4843                                   | ELF_SPARC_HWCAP_CAMELLIA
4844                                   | ELF_SPARC_HWCAP_MD5
4845                                   | ELF_SPARC_HWCAP_SHA1
4846                                   | ELF_SPARC_HWCAP_SHA256
4847                                   | ELF_SPARC_HWCAP_SHA512
4848                                   | ELF_SPARC_HWCAP_MPMUL
4849                                   | ELF_SPARC_HWCAP_MONT
4850                                   | ELF_SPARC_HWCAP_CRC32C
4851                                   | ELF_SPARC_HWCAP_CBCOND
4852                                   | ELF_SPARC_HWCAP_PAUSE);
4853   unsigned int v9v_hwcaps_mask = (ELF_SPARC_HWCAP_FJFMAU
4854                                  | ELF_SPARC_HWCAP_IMA);
4855   unsigned int v9m_hwcaps2_mask = (ELF_SPARC_HWCAP2_SPARC5
4856                                    | ELF_SPARC_HWCAP2_MWAIT
4857                                    | ELF_SPARC_HWCAP2_XMPMUL
4858                                    | ELF_SPARC_HWCAP2_XMONT);
4859
4860   if (ABI_64_P (abfd))
4861     {
4862       unsigned long mach = bfd_mach_sparc_v9;
4863
4864       if (hwcaps2->i & v9m_hwcaps2_mask)
4865         mach = bfd_mach_sparc_v9m;
4866       else if (hwcaps->i & v9v_hwcaps_mask)
4867         mach = bfd_mach_sparc_v9v;
4868       else if (hwcaps->i & v9e_hwcaps_mask)
4869         mach = bfd_mach_sparc_v9e;
4870       else if (hwcaps->i & v9d_hwcaps_mask)
4871         mach = bfd_mach_sparc_v9d;
4872       else if (hwcaps->i & v9c_hwcaps_mask)
4873         mach = bfd_mach_sparc_v9c;
4874       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4875         mach = bfd_mach_sparc_v9b;
4876       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4877         mach = bfd_mach_sparc_v9a;
4878       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4879     }
4880   else
4881     {
4882       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4883         {
4884           if (hwcaps2->i & v9m_hwcaps2_mask)
4885             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4886                                               bfd_mach_sparc_v8plusm);
4887           else if (hwcaps->i & v9v_hwcaps_mask)
4888             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4889                                               bfd_mach_sparc_v8plusv);
4890           else if (hwcaps->i & v9e_hwcaps_mask)
4891             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4892                                               bfd_mach_sparc_v8pluse);
4893           else if (hwcaps->i & v9d_hwcaps_mask)
4894             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4895                                               bfd_mach_sparc_v8plusd);
4896           else if (hwcaps->i & v9c_hwcaps_mask)
4897             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4898                                               bfd_mach_sparc_v8plusc);
4899           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4900             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4901                                               bfd_mach_sparc_v8plusb);
4902           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4903             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4904                                               bfd_mach_sparc_v8plusa);
4905           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4906             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4907                                               bfd_mach_sparc_v8plus);
4908           else
4909             return FALSE;
4910         }
4911       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4912         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4913                                           bfd_mach_sparc_sparclite_le);
4914       else
4915         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4916     }
4917 }
4918
4919 /* Return address for Ith PLT stub in section PLT, for relocation REL
4920    or (bfd_vma) -1 if it should not be included.  */
4921
4922 bfd_vma
4923 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4924 {
4925   if (ABI_64_P (plt->owner))
4926     {
4927       bfd_vma j;
4928
4929       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4930       if (i < PLT64_LARGE_THRESHOLD)
4931         return plt->vma + i * PLT64_ENTRY_SIZE;
4932
4933       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4934       i -= j;
4935       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4936     }
4937   else
4938     return rel->address;
4939 }
4940
4941 /* Merge backend specific data from an object file to the output
4942    object file when linking.  */
4943
4944 bfd_boolean
4945 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4946 {
4947   bfd *obfd = info->output_bfd;
4948   obj_attribute *in_attr, *in_attrs;
4949   obj_attribute *out_attr, *out_attrs;
4950
4951   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4952     {
4953       /* This is the first object.  Copy the attributes.  */
4954       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4955
4956       /* Use the Tag_null value to indicate the attributes have been
4957          initialized.  */
4958       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4959
4960       return TRUE;
4961     }
4962
4963   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4964   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4965
4966   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4967   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4968
4969   out_attr->i |= in_attr->i;
4970   out_attr->type = 1;
4971
4972   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS2];
4973   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS2];
4974
4975   out_attr->i |= in_attr->i;
4976   out_attr->type = 1;
4977
4978   /* Merge Tag_compatibility attributes and any common GNU ones.  */
4979   _bfd_elf_merge_object_attributes (ibfd, info);
4980
4981   return TRUE;
4982 }