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