bfd/elfxx-sparc.c

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