bfd/elfxx-sparc.c

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