bfd/elfxx-sparc.c

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