bfd/elfxx-sparc.c

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