bfd/elfxx-sparc.c

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