bfd/elfxx-sparc.c

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