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