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