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