bfd/elfxx-sparc.c

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