bfd/elfxx-sparc.c

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