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