bfd/elfxx-sparc.c

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