bfd/elfxx-sparc.c

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