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