bfd/elfxx-sparc.c

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