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                  void * 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                         void * 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                          void * 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                          void * 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                        void * 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                        void * 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_linker_section (dynobj, ".dynbss");
1211   if (!info->shared)
1212     htab->srelbss = bfd_get_linker_section (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, void * 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, void * 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_linker_section (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, 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, info);
2746
2747       if (info->flags & DF_TEXTREL)
2748         {
2749           if (!add_dynamic_entry (DT_TEXTREL, 0))
2750             return FALSE;
2751         }
2752
2753       if (ABI_64_P (output_bfd))
2754         {
2755           int reg;
2756           struct _bfd_sparc_elf_app_reg * app_regs;
2757           struct elf_strtab_hash *dynstr;
2758           struct elf_link_hash_table *eht = elf_hash_table (info);
2759
2760           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2761              entries if needed.  */
2762           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2763           dynstr = eht->dynstr;
2764
2765           for (reg = 0; reg < 4; reg++)
2766             if (app_regs [reg].name != NULL)
2767               {
2768                 struct elf_link_local_dynamic_entry *entry, *e;
2769
2770                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2771                   return FALSE;
2772
2773                 entry = (struct elf_link_local_dynamic_entry *)
2774                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2775                 if (entry == NULL)
2776                   return FALSE;
2777
2778                 /* We cheat here a little bit: the symbol will not be local, so we
2779                    put it at the end of the dynlocal linked list.  We will fix it
2780                    later on, as we have to fix other fields anyway.  */
2781                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2782                 entry->isym.st_size = 0;
2783                 if (*app_regs [reg].name != '\0')
2784                   entry->isym.st_name
2785                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2786                 else
2787                   entry->isym.st_name = 0;
2788                 entry->isym.st_other = 0;
2789                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2790                                                    STT_REGISTER);
2791                 entry->isym.st_shndx = app_regs [reg].shndx;
2792                 entry->isym.st_target_internal = 0;
2793                 entry->next = NULL;
2794                 entry->input_bfd = output_bfd;
2795                 entry->input_indx = -1;
2796
2797                 if (eht->dynlocal == NULL)
2798                   eht->dynlocal = entry;
2799                 else
2800                   {
2801                     for (e = eht->dynlocal; e->next; e = e->next)
2802                       ;
2803                     e->next = entry;
2804                   }
2805                 eht->dynsymcount++;
2806               }
2807         }
2808       if (htab->is_vxworks
2809           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2810         return FALSE;
2811     }
2812 #undef add_dynamic_entry
2813
2814   return TRUE;
2815 }
2816 \f
2817 bfd_boolean
2818 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2819 {
2820   if (!sec->used_by_bfd)
2821     {
2822       struct _bfd_sparc_elf_section_data *sdata;
2823       bfd_size_type amt = sizeof (*sdata);
2824
2825       sdata = bfd_zalloc (abfd, amt);
2826       if (sdata == NULL)
2827         return FALSE;
2828       sec->used_by_bfd = sdata;
2829     }
2830
2831   return _bfd_elf_new_section_hook (abfd, sec);
2832 }
2833
2834 bfd_boolean
2835 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2836                               struct bfd_section *section,
2837                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2838                               bfd_boolean *again)
2839 {
2840   if (link_info->relocatable)
2841     (*link_info->callbacks->einfo)
2842       (_("%P%F: --relax and -r may not be used together\n"));
2843
2844   *again = FALSE;
2845   sec_do_relax (section) = 1;
2846   return TRUE;
2847 }
2848 \f
2849 /* Return the base VMA address which should be subtracted from real addresses
2850    when resolving @dtpoff relocation.
2851    This is PT_TLS segment p_vaddr.  */
2852
2853 static bfd_vma
2854 dtpoff_base (struct bfd_link_info *info)
2855 {
2856   /* If tls_sec is NULL, we should have signalled an error already.  */
2857   if (elf_hash_table (info)->tls_sec == NULL)
2858     return 0;
2859   return elf_hash_table (info)->tls_sec->vma;
2860 }
2861
2862 /* Return the relocation value for @tpoff relocation
2863    if STT_TLS virtual address is ADDRESS.  */
2864
2865 static bfd_vma
2866 tpoff (struct bfd_link_info *info, bfd_vma address)
2867 {
2868   struct elf_link_hash_table *htab = elf_hash_table (info);
2869   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2870   bfd_vma static_tls_size;
2871
2872   /* If tls_sec is NULL, we should have signalled an error already.  */
2873   if (htab->tls_sec == NULL)
2874     return 0;
2875
2876   /* Consider special static TLS alignment requirements.  */
2877   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2878   return address - static_tls_size - htab->tls_sec->vma;
2879 }
2880
2881 /* Return the relocation value for a %gdop relocation.  */
2882
2883 static bfd_vma
2884 gdopoff (struct bfd_link_info *info, bfd_vma address)
2885 {
2886   struct elf_link_hash_table *htab = elf_hash_table (info);
2887   bfd_vma got_base;
2888
2889   got_base = (htab->hgot->root.u.def.value
2890               + htab->hgot->root.u.def.section->output_offset
2891               + htab->hgot->root.u.def.section->output_section->vma);
2892
2893   return address - got_base;
2894 }
2895
2896 /* Relocate a SPARC ELF section.  */
2897
2898 bfd_boolean
2899 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2900                                  struct bfd_link_info *info,
2901                                  bfd *input_bfd,
2902                                  asection *input_section,
2903                                  bfd_byte *contents,
2904                                  Elf_Internal_Rela *relocs,
2905                                  Elf_Internal_Sym *local_syms,
2906                                  asection **local_sections)
2907 {
2908   struct _bfd_sparc_elf_link_hash_table *htab;
2909   Elf_Internal_Shdr *symtab_hdr;
2910   struct elf_link_hash_entry **sym_hashes;
2911   bfd_vma *local_got_offsets;
2912   bfd_vma got_base;
2913   asection *sreloc;
2914   Elf_Internal_Rela *rel;
2915   Elf_Internal_Rela *relend;
2916   int num_relocs;
2917   bfd_boolean is_vxworks_tls;
2918
2919   htab = _bfd_sparc_elf_hash_table (info);
2920   BFD_ASSERT (htab != NULL);
2921   symtab_hdr = &elf_symtab_hdr (input_bfd);
2922   sym_hashes = elf_sym_hashes (input_bfd);
2923   local_got_offsets = elf_local_got_offsets (input_bfd);
2924
2925   if (elf_hash_table (info)->hgot == NULL)
2926     got_base = 0;
2927   else
2928     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2929
2930   sreloc = elf_section_data (input_section)->sreloc;
2931   /* We have to handle relocations in vxworks .tls_vars sections
2932      specially, because the dynamic loader is 'weird'.  */
2933   is_vxworks_tls = (htab->is_vxworks && info->shared
2934                     && !strcmp (input_section->output_section->name,
2935                                 ".tls_vars"));
2936
2937   rel = relocs;
2938   if (ABI_64_P (output_bfd))
2939     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2940   else
2941     num_relocs = input_section->reloc_count;
2942   relend = relocs + num_relocs;
2943   for (; rel < relend; rel++)
2944     {
2945       int r_type, tls_type;
2946       reloc_howto_type *howto;
2947       unsigned long r_symndx;
2948       struct elf_link_hash_entry *h;
2949       Elf_Internal_Sym *sym;
2950       asection *sec;
2951       bfd_vma relocation, off;
2952       bfd_reloc_status_type r;
2953       bfd_boolean is_plt = FALSE;
2954       bfd_boolean unresolved_reloc;
2955
2956       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2957       if (r_type == R_SPARC_GNU_VTINHERIT
2958           || r_type == R_SPARC_GNU_VTENTRY)
2959         continue;
2960
2961       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2962         {
2963           bfd_set_error (bfd_error_bad_value);
2964           return FALSE;
2965         }
2966       howto = _bfd_sparc_elf_howto_table + r_type;
2967
2968       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2969       h = NULL;
2970       sym = NULL;
2971       sec = NULL;
2972       unresolved_reloc = FALSE;
2973       if (r_symndx < symtab_hdr->sh_info)
2974         {
2975           sym = local_syms + r_symndx;
2976           sec = local_sections[r_symndx];
2977           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2978
2979           if (!info->relocatable
2980               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2981             {
2982               /* Relocate against local STT_GNU_IFUNC symbol.  */
2983               h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2984                                                 rel, FALSE);
2985               if (h == NULL)
2986                 abort ();
2987
2988               /* Set STT_GNU_IFUNC symbol value.  */
2989               h->root.u.def.value = sym->st_value;
2990               h->root.u.def.section = sec;
2991             }
2992         }
2993       else
2994         {
2995           bfd_boolean warned;
2996
2997           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2998                                    r_symndx, symtab_hdr, sym_hashes,
2999                                    h, sec, relocation,
3000                                    unresolved_reloc, warned);
3001           if (warned)
3002             {
3003               /* To avoid generating warning messages about truncated
3004                  relocations, set the relocation's address to be the same as
3005                  the start of this section.  */
3006               if (input_section->output_section != NULL)
3007                 relocation = input_section->output_section->vma;
3008               else
3009                 relocation = 0;
3010             }
3011         }
3012
3013       if (sec != NULL && discarded_section (sec))
3014         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3015                                          rel, 1, relend, howto, 0, contents);
3016
3017       if (info->relocatable)
3018         continue;
3019
3020       if (h != NULL
3021           && h->type == STT_GNU_IFUNC
3022           && h->def_regular)
3023         {
3024           asection *plt_sec;
3025           const char *name;
3026
3027           if ((input_section->flags & SEC_ALLOC) == 0
3028               || h->plt.offset == (bfd_vma) -1)
3029             abort ();
3030
3031           plt_sec = htab->elf.splt;
3032           if (! plt_sec)
3033             plt_sec =htab->elf.iplt;
3034
3035           switch (r_type)
3036             {
3037             case R_SPARC_GOTDATA_OP:
3038               continue;
3039
3040             case R_SPARC_GOTDATA_OP_HIX22:
3041             case R_SPARC_GOTDATA_OP_LOX10:
3042               r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3043                         ? R_SPARC_GOT22
3044                         : R_SPARC_GOT10);
3045               howto = _bfd_sparc_elf_howto_table + r_type;
3046               /* Fall through.  */
3047
3048             case R_SPARC_GOT10:
3049             case R_SPARC_GOT13:
3050             case R_SPARC_GOT22:
3051               if (htab->elf.sgot == NULL)
3052                 abort ();
3053               off = h->got.offset;
3054               if (off == (bfd_vma) -1)
3055                 abort();
3056               relocation = htab->elf.sgot->output_offset + off - got_base;
3057               goto do_relocation;
3058
3059             case R_SPARC_WPLT30:
3060             case R_SPARC_WDISP30:
3061               relocation = (plt_sec->output_section->vma
3062                             + plt_sec->output_offset + h->plt.offset);
3063               goto do_relocation;
3064
3065             case R_SPARC_32:
3066             case R_SPARC_64:
3067               if (info->shared && h->non_got_ref)
3068                 {
3069                   Elf_Internal_Rela outrel;
3070                   bfd_vma offset;
3071
3072                   offset = _bfd_elf_section_offset (output_bfd, info,
3073                                                     input_section,
3074                                                     rel->r_offset);
3075                   if (offset == (bfd_vma) -1
3076                       || offset == (bfd_vma) -2)
3077                     abort();
3078
3079                   outrel.r_offset = (input_section->output_section->vma
3080                                      + input_section->output_offset
3081                                      + offset);
3082
3083                   if (h->dynindx == -1
3084                       || h->forced_local
3085                       || info->executable)
3086                     {
3087                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3088                                                         0, R_SPARC_IRELATIVE);
3089                       outrel.r_addend = relocation + rel->r_addend;
3090                     }
3091                   else
3092                     {
3093                       if (h->dynindx == -1)
3094                         abort();
3095                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3096                       outrel.r_addend = rel->r_addend;
3097                     }
3098
3099                   sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3100                   continue;
3101                 }
3102
3103               relocation = (plt_sec->output_section->vma
3104                             + plt_sec->output_offset + h->plt.offset);
3105               goto do_relocation;
3106
3107             case R_SPARC_HI22:
3108             case R_SPARC_LO10:
3109               /* We should only see such relocs in static links.  */
3110               if (info->shared)
3111                 abort();
3112               relocation = (plt_sec->output_section->vma
3113                             + plt_sec->output_offset + h->plt.offset);
3114               goto do_relocation;
3115
3116             default:
3117               if (h->root.root.string)
3118                 name = h->root.root.string;
3119               else
3120                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3121                                          NULL);
3122               (*_bfd_error_handler)
3123                 (_("%B: relocation %s against STT_GNU_IFUNC "
3124                    "symbol `%s' isn't handled by %s"), input_bfd,
3125                  _bfd_sparc_elf_howto_table[r_type].name,
3126                  name, __FUNCTION__);
3127               bfd_set_error (bfd_error_bad_value);
3128               return FALSE;
3129             }
3130         }
3131
3132       switch (r_type)
3133         {
3134         case R_SPARC_GOTDATA_OP_HIX22:
3135         case R_SPARC_GOTDATA_OP_LOX10:
3136           if (SYMBOL_REFERENCES_LOCAL (info, h))
3137             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3138                       ? R_SPARC_GOTDATA_HIX22
3139                       : R_SPARC_GOTDATA_LOX10);
3140           else
3141             r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3142                       ? R_SPARC_GOT22
3143                       : R_SPARC_GOT10);
3144           howto = _bfd_sparc_elf_howto_table + r_type;
3145           break;
3146
3147         case R_SPARC_GOTDATA_OP:
3148           if (SYMBOL_REFERENCES_LOCAL (info, h))
3149             {
3150               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3151
3152               /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3153               relocation = 0x80000000 | (insn & 0x3e07c01f);
3154               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3155             }
3156           continue;
3157         }
3158
3159       switch (r_type)
3160         {
3161         case R_SPARC_GOTDATA_HIX22:
3162         case R_SPARC_GOTDATA_LOX10:
3163           relocation = gdopoff (info, relocation);
3164           break;
3165
3166         case R_SPARC_GOT10:
3167         case R_SPARC_GOT13:
3168         case R_SPARC_GOT22:
3169           /* Relocation is to the entry for this symbol in the global
3170              offset table.  */
3171           if (htab->elf.sgot == NULL)
3172             abort ();
3173
3174           if (h != NULL)
3175             {
3176               bfd_boolean dyn;
3177
3178               off = h->got.offset;
3179               BFD_ASSERT (off != (bfd_vma) -1);
3180               dyn = elf_hash_table (info)->dynamic_sections_created;
3181
3182               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3183                   || (info->shared
3184                       && SYMBOL_REFERENCES_LOCAL (info, h)))
3185                 {
3186                   /* This is actually a static link, or it is a
3187                      -Bsymbolic link and the symbol is defined
3188                      locally, or the symbol was forced to be local
3189                      because of a version file.  We must initialize
3190                      this entry in the global offset table.  Since the
3191                      offset must always be a multiple of 8 for 64-bit
3192                      and 4 for 32-bit, we use the least significant bit
3193                      to record whether we have initialized it already.
3194
3195                      When doing a dynamic link, we create a .rela.got
3196                      relocation entry to initialize the value.  This
3197                      is done in the finish_dynamic_symbol routine.  */
3198                   if ((off & 1) != 0)
3199                     off &= ~1;
3200                   else
3201                     {
3202                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3203                                           htab->elf.sgot->contents + off);
3204                       h->got.offset |= 1;
3205                     }
3206                 }
3207               else
3208                 unresolved_reloc = FALSE;
3209             }
3210           else
3211             {
3212               BFD_ASSERT (local_got_offsets != NULL
3213                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3214
3215               off = local_got_offsets[r_symndx];
3216
3217               /* The offset must always be a multiple of 8 on 64-bit and
3218                  4 on 32-bit.  We use the least significant bit to record
3219                  whether we have already processed this entry.  */
3220               if ((off & 1) != 0)
3221                 off &= ~1;
3222               else
3223                 {
3224
3225                   if (info->shared)
3226                     {
3227                       asection *s;
3228                       Elf_Internal_Rela outrel;
3229
3230                       /* We need to generate a R_SPARC_RELATIVE reloc
3231                          for the dynamic linker.  */
3232                       s = htab->elf.srelgot;
3233                       BFD_ASSERT (s != NULL);
3234
3235                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3236                                          + htab->elf.sgot->output_offset
3237                                          + off);
3238                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3239                                                         0, R_SPARC_RELATIVE);
3240                       outrel.r_addend = relocation;
3241                       relocation = 0;
3242                       sparc_elf_append_rela (output_bfd, s, &outrel);
3243                     }
3244
3245                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3246                                       htab->elf.sgot->contents + off);
3247                   local_got_offsets[r_symndx] |= 1;
3248                 }
3249             }
3250           relocation = htab->elf.sgot->output_offset + off - got_base;
3251           break;
3252
3253         case R_SPARC_PLT32:
3254         case R_SPARC_PLT64:
3255           if (h == NULL || h->plt.offset == (bfd_vma) -1)
3256             {
3257               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3258               goto r_sparc_plt32;
3259             }
3260           /* Fall through.  */
3261
3262         case R_SPARC_WPLT30:
3263         case R_SPARC_HIPLT22:
3264         case R_SPARC_LOPLT10:
3265         case R_SPARC_PCPLT32:
3266         case R_SPARC_PCPLT22:
3267         case R_SPARC_PCPLT10:
3268         r_sparc_wplt30:
3269           /* Relocation is to the entry for this symbol in the
3270              procedure linkage table.  */
3271
3272           if (! ABI_64_P (output_bfd))
3273             {
3274               /* The Solaris native assembler will generate a WPLT30 reloc
3275                  for a local symbol if you assemble a call from one
3276                  section to another when using -K pic.  We treat it as
3277                  WDISP30.  */
3278               if (h == NULL)
3279                 break;
3280             }
3281           /* PR 7027: We need similar behaviour for 64-bit binaries.  */
3282           else if (r_type == R_SPARC_WPLT30 && h == NULL)
3283             break;
3284           else
3285             {
3286               BFD_ASSERT (h != NULL);
3287             }
3288
3289           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3290             {
3291               /* We didn't make a PLT entry for this symbol.  This
3292                  happens when statically linking PIC code, or when
3293                  using -Bsymbolic.  */
3294               break;
3295             }
3296
3297           relocation = (htab->elf.splt->output_section->vma
3298                         + htab->elf.splt->output_offset
3299                         + h->plt.offset);
3300           unresolved_reloc = FALSE;
3301           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3302             {
3303               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3304               is_plt = TRUE;
3305               goto r_sparc_plt32;
3306             }
3307           break;
3308
3309         case R_SPARC_PC10:
3310         case R_SPARC_PC22:
3311         case R_SPARC_PC_HH22:
3312         case R_SPARC_PC_HM10:
3313         case R_SPARC_PC_LM22:
3314           if (h != NULL
3315               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3316             break;
3317           /* Fall through.  */
3318         case R_SPARC_DISP8:
3319         case R_SPARC_DISP16:
3320         case R_SPARC_DISP32:
3321         case R_SPARC_DISP64:
3322         case R_SPARC_WDISP30:
3323         case R_SPARC_WDISP22:
3324         case R_SPARC_WDISP19:
3325         case R_SPARC_WDISP16:
3326         case R_SPARC_WDISP10:
3327         case R_SPARC_8:
3328         case R_SPARC_16:
3329         case R_SPARC_32:
3330         case R_SPARC_HI22:
3331         case R_SPARC_22:
3332         case R_SPARC_13:
3333         case R_SPARC_LO10:
3334         case R_SPARC_UA16:
3335         case R_SPARC_UA32:
3336         case R_SPARC_10:
3337         case R_SPARC_11:
3338         case R_SPARC_64:
3339         case R_SPARC_OLO10:
3340         case R_SPARC_HH22:
3341         case R_SPARC_HM10:
3342         case R_SPARC_LM22:
3343         case R_SPARC_7:
3344         case R_SPARC_5:
3345         case R_SPARC_6:
3346         case R_SPARC_HIX22:
3347         case R_SPARC_LOX10:
3348         case R_SPARC_H44:
3349         case R_SPARC_M44:
3350         case R_SPARC_L44:
3351         case R_SPARC_H34:
3352         case R_SPARC_UA64:
3353         r_sparc_plt32:
3354           if ((input_section->flags & SEC_ALLOC) == 0
3355               || is_vxworks_tls)
3356             break;
3357
3358           if ((info->shared
3359                && (h == NULL
3360                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3361                    || h->root.type != bfd_link_hash_undefweak)
3362                && (! howto->pc_relative
3363                    || !SYMBOL_CALLS_LOCAL (info, h)))
3364               || (!info->shared
3365                   && h != NULL
3366                   && h->dynindx != -1
3367                   && !h->non_got_ref
3368                   && ((h->def_dynamic
3369                        && !h->def_regular)
3370                       || h->root.type == bfd_link_hash_undefweak
3371                       || h->root.type == bfd_link_hash_undefined)))
3372             {
3373               Elf_Internal_Rela outrel;
3374               bfd_boolean skip, relocate = FALSE;
3375
3376               /* When generating a shared object, these relocations
3377                  are copied into the output file to be resolved at run
3378                  time.  */
3379
3380               BFD_ASSERT (sreloc != NULL);
3381
3382               skip = FALSE;
3383
3384               outrel.r_offset =
3385                 _bfd_elf_section_offset (output_bfd, info, input_section,
3386                                          rel->r_offset);
3387               if (outrel.r_offset == (bfd_vma) -1)
3388                 skip = TRUE;
3389               else if (outrel.r_offset == (bfd_vma) -2)
3390                 skip = TRUE, relocate = TRUE;
3391               outrel.r_offset += (input_section->output_section->vma
3392                                   + input_section->output_offset);
3393
3394               /* Optimize unaligned reloc usage now that we know where
3395                  it finally resides.  */
3396               switch (r_type)
3397                 {
3398                 case R_SPARC_16:
3399                   if (outrel.r_offset & 1)
3400                     r_type = R_SPARC_UA16;
3401                   break;
3402                 case R_SPARC_UA16:
3403                   if (!(outrel.r_offset & 1))
3404                     r_type = R_SPARC_16;
3405                   break;
3406                 case R_SPARC_32:
3407                   if (outrel.r_offset & 3)
3408                     r_type = R_SPARC_UA32;
3409                   break;
3410                 case R_SPARC_UA32:
3411                   if (!(outrel.r_offset & 3))
3412                     r_type = R_SPARC_32;
3413                   break;
3414                 case R_SPARC_64:
3415                   if (outrel.r_offset & 7)
3416                     r_type = R_SPARC_UA64;
3417                   break;
3418                 case R_SPARC_UA64:
3419                   if (!(outrel.r_offset & 7))
3420                     r_type = R_SPARC_64;
3421                   break;
3422                 case R_SPARC_DISP8:
3423                 case R_SPARC_DISP16:
3424                 case R_SPARC_DISP32:
3425                 case R_SPARC_DISP64:
3426                   /* If the symbol is not dynamic, we should not keep
3427                      a dynamic relocation.  But an .rela.* slot has been
3428                      allocated for it, output R_SPARC_NONE.
3429                      FIXME: Add code tracking needed dynamic relocs as
3430                      e.g. i386 has.  */
3431                   if (h->dynindx == -1)
3432                     skip = TRUE, relocate = TRUE;
3433                   break;
3434                 }
3435
3436               if (skip)
3437                 memset (&outrel, 0, sizeof outrel);
3438               /* h->dynindx may be -1 if the symbol was marked to
3439                  become local.  */
3440               else if (h != NULL &&
3441                        h->dynindx != -1
3442                        && (! is_plt
3443                            || !info->shared
3444                            || !SYMBOLIC_BIND (info, h)
3445                            || !h->def_regular))
3446                 {
3447                   BFD_ASSERT (h->dynindx != -1);
3448                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3449                   outrel.r_addend = rel->r_addend;
3450                 }
3451               else
3452                 {
3453                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3454                     {
3455                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3456                                                         0, R_SPARC_RELATIVE);
3457                       outrel.r_addend = relocation + rel->r_addend;
3458                     }
3459                   else
3460                     {
3461                       long indx;
3462
3463                       outrel.r_addend = relocation + rel->r_addend;
3464
3465                       if (is_plt)
3466                         sec = htab->elf.splt;
3467
3468                       if (bfd_is_abs_section (sec))
3469                         indx = 0;
3470                       else if (sec == NULL || sec->owner == NULL)
3471                         {
3472                           bfd_set_error (bfd_error_bad_value);
3473                           return FALSE;
3474                         }
3475                       else
3476                         {
3477                           asection *osec;
3478
3479                           /* We are turning this relocation into one
3480                              against a section symbol.  It would be
3481                              proper to subtract the symbol's value,
3482                              osec->vma, from the emitted reloc addend,
3483                              but ld.so expects buggy relocs.  */
3484                           osec = sec->output_section;
3485                           indx = elf_section_data (osec)->dynindx;
3486
3487                           if (indx == 0)
3488                             {
3489                               osec = htab->elf.text_index_section;
3490                               indx = elf_section_data (osec)->dynindx;
3491                             }
3492
3493                           /* FIXME: we really should be able to link non-pic
3494                              shared libraries.  */
3495                           if (indx == 0)
3496                             {
3497                               BFD_FAIL ();
3498                               (*_bfd_error_handler)
3499                                 (_("%B: probably compiled without -fPIC?"),
3500                                  input_bfd);
3501                               bfd_set_error (bfd_error_bad_value);
3502                               return FALSE;
3503                             }
3504                         }
3505
3506                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3507                                                         r_type);
3508                     }
3509                 }
3510
3511               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3512
3513               /* This reloc will be computed at runtime, so there's no
3514                  need to do anything now.  */
3515               if (! relocate)
3516                 continue;
3517             }
3518           break;
3519
3520         case R_SPARC_TLS_GD_HI22:
3521           if (! ABI_64_P (input_bfd)
3522               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3523             {
3524               /* R_SPARC_REV32 used the same reloc number as
3525                  R_SPARC_TLS_GD_HI22.  */
3526               r_type = R_SPARC_REV32;
3527               break;
3528             }
3529           /* Fall through */
3530
3531         case R_SPARC_TLS_GD_LO10:
3532         case R_SPARC_TLS_IE_HI22:
3533         case R_SPARC_TLS_IE_LO10:
3534           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3535           tls_type = GOT_UNKNOWN;
3536           if (h == NULL && local_got_offsets)
3537             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3538           else if (h != NULL)
3539             {
3540               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3541               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3542                 switch (SPARC_ELF_R_TYPE (rel->r_info))
3543                   {
3544                   case R_SPARC_TLS_GD_HI22:
3545                   case R_SPARC_TLS_IE_HI22:
3546                     r_type = R_SPARC_TLS_LE_HIX22;
3547                     break;
3548                   default:
3549                     r_type = R_SPARC_TLS_LE_LOX10;
3550                     break;
3551                   }
3552             }
3553           if (tls_type == GOT_TLS_IE)
3554             switch (r_type)
3555               {
3556               case R_SPARC_TLS_GD_HI22:
3557                 r_type = R_SPARC_TLS_IE_HI22;
3558                 break;
3559               case R_SPARC_TLS_GD_LO10:
3560                 r_type = R_SPARC_TLS_IE_LO10;
3561                 break;
3562               }
3563
3564           if (r_type == R_SPARC_TLS_LE_HIX22)
3565             {
3566               relocation = tpoff (info, relocation);
3567               break;
3568             }
3569           if (r_type == R_SPARC_TLS_LE_LOX10)
3570             {
3571               /* Change add into xor.  */
3572               relocation = tpoff (info, relocation);
3573               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3574                                                    contents + rel->r_offset)
3575                                        | 0x80182000), contents + rel->r_offset);
3576               break;
3577             }
3578
3579           if (h != NULL)
3580             {
3581               off = h->got.offset;
3582               h->got.offset |= 1;
3583             }
3584           else
3585             {
3586               BFD_ASSERT (local_got_offsets != NULL);
3587               off = local_got_offsets[r_symndx];
3588               local_got_offsets[r_symndx] |= 1;
3589             }
3590
3591         r_sparc_tlsldm:
3592           if (htab->elf.sgot == NULL)
3593             abort ();
3594
3595           if ((off & 1) != 0)
3596             off &= ~1;
3597           else
3598             {
3599               Elf_Internal_Rela outrel;
3600               int dr_type, indx;
3601
3602               if (htab->elf.srelgot == NULL)
3603                 abort ();
3604
3605               SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3606                                   htab->elf.sgot->contents + off);
3607               outrel.r_offset = (htab->elf.sgot->output_section->vma
3608                                  + htab->elf.sgot->output_offset + off);
3609               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3610               if (r_type == R_SPARC_TLS_IE_HI22
3611                   || r_type == R_SPARC_TLS_IE_LO10)
3612                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3613               else
3614                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3615               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3616                 outrel.r_addend = relocation - dtpoff_base (info);
3617               else
3618                 outrel.r_addend = 0;
3619               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3620               sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3621
3622               if (r_type == R_SPARC_TLS_GD_HI22
3623                   || r_type == R_SPARC_TLS_GD_LO10)
3624                 {
3625                   if (indx == 0)
3626                     {
3627                       BFD_ASSERT (! unresolved_reloc);
3628                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3629                                           relocation - dtpoff_base (info),
3630                                           (htab->elf.sgot->contents + off
3631                                            + SPARC_ELF_WORD_BYTES (htab)));
3632                     }
3633                   else
3634                     {
3635                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3636                                           (htab->elf.sgot->contents + off
3637                                            + SPARC_ELF_WORD_BYTES (htab)));
3638                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3639                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3640                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3641                       sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3642                                              &outrel);
3643                     }
3644                 }
3645               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3646                 {
3647                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3648                                       (htab->elf.sgot->contents + off
3649                                        + SPARC_ELF_WORD_BYTES (htab)));
3650                 }
3651             }
3652
3653           if (off >= (bfd_vma) -2)
3654             abort ();
3655
3656           relocation = htab->elf.sgot->output_offset + off - got_base;
3657           unresolved_reloc = FALSE;
3658           howto = _bfd_sparc_elf_howto_table + r_type;
3659           break;
3660
3661         case R_SPARC_TLS_LDM_HI22:
3662         case R_SPARC_TLS_LDM_LO10:
3663           if (! info->shared)
3664             {
3665               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3666               continue;
3667             }
3668           off = htab->tls_ldm_got.offset;
3669           htab->tls_ldm_got.offset |= 1;
3670           goto r_sparc_tlsldm;
3671
3672         case R_SPARC_TLS_LDO_HIX22:
3673         case R_SPARC_TLS_LDO_LOX10:
3674           if (info->shared)
3675             {
3676               relocation -= dtpoff_base (info);
3677               break;
3678             }
3679
3680           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3681                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3682           /* Fall through.  */
3683
3684         case R_SPARC_TLS_LE_HIX22:
3685         case R_SPARC_TLS_LE_LOX10:
3686           if (info->shared)
3687             {
3688               Elf_Internal_Rela outrel;
3689               bfd_boolean skip;
3690
3691               BFD_ASSERT (sreloc != NULL);
3692               skip = FALSE;
3693               outrel.r_offset =
3694                 _bfd_elf_section_offset (output_bfd, info, input_section,
3695                                          rel->r_offset);
3696               if (outrel.r_offset == (bfd_vma) -1)
3697                 skip = TRUE;
3698               else if (outrel.r_offset == (bfd_vma) -2)
3699                 skip = TRUE;
3700               outrel.r_offset += (input_section->output_section->vma
3701                                   + input_section->output_offset);
3702               if (skip)
3703                 memset (&outrel, 0, sizeof outrel);
3704               else
3705                 {
3706                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3707                   outrel.r_addend = relocation - dtpoff_base (info)
3708                                     + rel->r_addend;
3709                 }
3710
3711               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3712               continue;
3713             }
3714           relocation = tpoff (info, relocation);
3715           break;
3716
3717         case R_SPARC_TLS_LDM_CALL:
3718           if (! info->shared)
3719             {
3720               /* mov %g0, %o0 */
3721               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3722               continue;
3723             }
3724           /* Fall through */
3725
3726         case R_SPARC_TLS_GD_CALL:
3727           tls_type = GOT_UNKNOWN;
3728           if (h == NULL && local_got_offsets)
3729             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3730           else if (h != NULL)
3731             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3732           if (! info->shared
3733               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3734             {
3735               Elf_Internal_Rela *rel2;
3736               bfd_vma insn;
3737
3738               if (!info->shared && (h == NULL || h->dynindx == -1))
3739                 {
3740                   /* GD -> LE */
3741                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3742                   continue;
3743                 }
3744
3745               /* GD -> IE */
3746               if (rel + 1 < relend
3747                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3748                   && rel[1].r_offset == rel->r_offset + 4
3749                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3750                   && (((insn = bfd_get_32 (input_bfd,
3751                                            contents + rel[1].r_offset))
3752                        >> 25) & 0x1f) == 8)
3753                 {
3754                   /* We have
3755                      call __tls_get_addr, %tgd_call(foo)
3756                       add %reg1, %reg2, %o0, %tgd_add(foo)
3757                      and change it into IE:
3758                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3759                      add %g7, %o0, %o0, %tie_add(foo).
3760                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3761                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3762                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3763                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3764                               contents + rel->r_offset);
3765                   bfd_put_32 (output_bfd, 0x9001c008,
3766                               contents + rel->r_offset + 4);
3767                   rel++;
3768                   continue;
3769                 }
3770
3771               /* We cannot just overwrite the delay slot instruction,
3772                  as it might be what puts the %o0 argument to
3773                  __tls_get_addr into place.  So we have to transpose
3774                  the delay slot with the add we patch in.  */
3775               insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3776               bfd_put_32 (output_bfd, insn,
3777                           contents + rel->r_offset);
3778               bfd_put_32 (output_bfd, 0x9001c008,
3779                           contents + rel->r_offset + 4);
3780
3781               rel2 = rel;
3782               while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3783                                                           rel->r_offset + 4))
3784                      != NULL)
3785                 {
3786                   /* If the instruction we moved has a relocation attached to
3787                      it, adjust the offset so that it will apply to the correct
3788                      instruction.  */
3789                   rel2->r_offset -= 4;
3790                 }
3791               continue;
3792             }
3793
3794           h = (struct elf_link_hash_entry *)
3795               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3796                                     FALSE, TRUE);
3797           BFD_ASSERT (h != NULL);
3798           r_type = R_SPARC_WPLT30;
3799           howto = _bfd_sparc_elf_howto_table + r_type;
3800           goto r_sparc_wplt30;
3801
3802         case R_SPARC_TLS_GD_ADD:
3803           tls_type = GOT_UNKNOWN;
3804           if (h == NULL && local_got_offsets)
3805             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3806           else if (h != NULL)
3807             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3808           if (! info->shared || tls_type == GOT_TLS_IE)
3809             {
3810               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3811                  changed into IE:
3812                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3813                  or LE:
3814                  add %g7, %reg2, %reg3.  */
3815               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3816               if ((h != NULL && h->dynindx != -1) || info->shared)
3817                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3818               else
3819                 relocation = (insn & ~0x7c000) | 0x1c000;
3820               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3821             }
3822           continue;
3823
3824         case R_SPARC_TLS_LDM_ADD:
3825           if (! info->shared)
3826             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3827           continue;
3828
3829         case R_SPARC_TLS_LDO_ADD:
3830           if (! info->shared)
3831             {
3832               /* Change rs1 into %g7.  */
3833               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3834               insn = (insn & ~0x7c000) | 0x1c000;
3835               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3836             }
3837           continue;
3838
3839         case R_SPARC_TLS_IE_LD:
3840         case R_SPARC_TLS_IE_LDX:
3841           if (! info->shared && (h == NULL || h->dynindx == -1))
3842             {
3843               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3844               int rs2 = insn & 0x1f;
3845               int rd = (insn >> 25) & 0x1f;
3846
3847               if (rs2 == rd)
3848                 relocation = SPARC_NOP;
3849               else
3850                 relocation = 0x80100000 | (insn & 0x3e00001f);
3851               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3852             }
3853           continue;
3854
3855         case R_SPARC_TLS_IE_ADD:
3856           /* Totally useless relocation.  */
3857           continue;
3858
3859         case R_SPARC_TLS_DTPOFF32:
3860         case R_SPARC_TLS_DTPOFF64:
3861           relocation -= dtpoff_base (info);
3862           break;
3863
3864         default:
3865           break;
3866         }
3867
3868       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3869          because such sections are not SEC_ALLOC and thus ld.so will
3870          not process them.  */
3871       if (unresolved_reloc
3872           && !((input_section->flags & SEC_DEBUGGING) != 0
3873                && h->def_dynamic)
3874           && _bfd_elf_section_offset (output_bfd, info, input_section,
3875                                       rel->r_offset) != (bfd_vma) -1)
3876         (*_bfd_error_handler)
3877           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3878            input_bfd,
3879            input_section,
3880            (long) rel->r_offset,
3881            howto->name,
3882            h->root.root.string);
3883
3884       r = bfd_reloc_continue;
3885       if (r_type == R_SPARC_OLO10)
3886         {
3887             bfd_vma x;
3888
3889             if (! ABI_64_P (output_bfd))
3890               abort ();
3891
3892             relocation += rel->r_addend;
3893             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3894
3895             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3896             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3897             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3898
3899             r = bfd_check_overflow (howto->complain_on_overflow,
3900                                     howto->bitsize, howto->rightshift,
3901                                     bfd_arch_bits_per_address (input_bfd),
3902                                     relocation);
3903         }
3904       else if (r_type == R_SPARC_WDISP16)
3905         {
3906           bfd_vma x;
3907
3908           relocation += rel->r_addend;
3909           relocation -= (input_section->output_section->vma
3910                          + input_section->output_offset);
3911           relocation -= rel->r_offset;
3912
3913           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3914           x |= ((((relocation >> 2) & 0xc000) << 6)
3915                 | ((relocation >> 2) & 0x3fff));
3916           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3917
3918           r = bfd_check_overflow (howto->complain_on_overflow,
3919                                   howto->bitsize, howto->rightshift,
3920                                   bfd_arch_bits_per_address (input_bfd),
3921                                   relocation);
3922         }
3923       else if (r_type == R_SPARC_WDISP10)
3924         {
3925           bfd_vma x;
3926
3927           relocation += rel->r_addend;
3928           relocation -= (input_section->output_section->vma
3929                          + input_section->output_offset);
3930           relocation -= rel->r_offset;
3931
3932           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3933           x |= ((((relocation >> 2) & 0x300) << 11)
3934                 | (((relocation >> 2) & 0xff) << 5));
3935           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3936
3937           r = bfd_check_overflow (howto->complain_on_overflow,
3938                                   howto->bitsize, howto->rightshift,
3939                                   bfd_arch_bits_per_address (input_bfd),
3940                                   relocation);
3941         }
3942       else if (r_type == R_SPARC_REV32)
3943         {
3944           bfd_vma x;
3945
3946           relocation = relocation + rel->r_addend;
3947
3948           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3949           x = x + relocation;
3950           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3951           r = bfd_reloc_ok;
3952         }
3953       else if (r_type == R_SPARC_TLS_LDO_HIX22
3954                || r_type == R_SPARC_TLS_LE_HIX22)
3955         {
3956           bfd_vma x;
3957
3958           relocation += rel->r_addend;
3959           if (r_type == R_SPARC_TLS_LE_HIX22)
3960             relocation ^= MINUS_ONE;
3961
3962           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3963           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3964           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3965           r = bfd_reloc_ok;
3966         }
3967       else if (r_type == R_SPARC_TLS_LDO_LOX10
3968                || r_type == R_SPARC_TLS_LE_LOX10)
3969         {
3970           bfd_vma x;
3971
3972           relocation += rel->r_addend;
3973           relocation &= 0x3ff;
3974           if (r_type == R_SPARC_TLS_LE_LOX10)
3975             relocation |= 0x1c00;
3976
3977           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3978           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3979           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3980
3981           r = bfd_reloc_ok;
3982         }
3983       else if (r_type == R_SPARC_HIX22
3984                || r_type == R_SPARC_GOTDATA_HIX22)
3985         {
3986           bfd_vma x;
3987
3988           relocation += rel->r_addend;
3989           if (r_type == R_SPARC_HIX22
3990               || (bfd_signed_vma) relocation < 0)
3991             relocation = relocation ^ MINUS_ONE;
3992
3993           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3994           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3995           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3996
3997           r = bfd_check_overflow (howto->complain_on_overflow,
3998                                   howto->bitsize, howto->rightshift,
3999                                   bfd_arch_bits_per_address (input_bfd),
4000                                   relocation);
4001         }
4002       else if (r_type == R_SPARC_LOX10
4003                || r_type == R_SPARC_GOTDATA_LOX10)
4004         {
4005           bfd_vma x;
4006
4007           relocation += rel->r_addend;
4008           if (r_type == R_SPARC_LOX10
4009               || (bfd_signed_vma) relocation < 0)
4010             relocation = (relocation & 0x3ff) | 0x1c00;
4011           else
4012             relocation = (relocation & 0x3ff);
4013
4014           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4015           x = (x & ~(bfd_vma) 0x1fff) | relocation;
4016           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4017
4018           r = bfd_reloc_ok;
4019         }
4020       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4021                && sec_do_relax (input_section)
4022                && rel->r_offset + 4 < input_section->size)
4023         {
4024 #define G0              0
4025 #define O7              15
4026 #define XCC             (2 << 20)
4027 #define COND(x)         (((x)&0xf)<<25)
4028 #define CONDA           COND(0x8)
4029 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
4030 #define INSN_BA         (F2(0,2) | CONDA)
4031 #define INSN_OR         F3(2, 0x2, 0)
4032 #define INSN_NOP        F2(0,4)
4033
4034           bfd_vma x, y;
4035
4036           /* If the instruction is a call with either:
4037              restore
4038              arithmetic instruction with rd == %o7
4039              where rs1 != %o7 and rs2 if it is register != %o7
4040              then we can optimize if the call destination is near
4041              by changing the call into a branch always.  */
4042           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4043           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4044           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4045             {
4046               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4047                    || ((y & OP3(0x28)) == 0 /* arithmetic */
4048                        && (y & RD(~0)) == RD(O7)))
4049                   && (y & RS1(~0)) != RS1(O7)
4050                   && ((y & F3I(~0))
4051                       || (y & RS2(~0)) != RS2(O7)))
4052                 {
4053                   bfd_vma reloc;
4054
4055                   reloc = relocation + rel->r_addend - rel->r_offset;
4056                   reloc -= (input_section->output_section->vma
4057                             + input_section->output_offset);
4058
4059                   /* Ensure the branch fits into simm22.  */
4060                   if ((reloc & 3) == 0
4061                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
4062                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4063                     {
4064                       reloc >>= 2;
4065
4066                       /* Check whether it fits into simm19.  */
4067                       if (((reloc & 0x3c0000) == 0
4068                            || (reloc & 0x3c0000) == 0x3c0000)
4069                           && (ABI_64_P (output_bfd)
4070                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4071                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4072                       else
4073                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
4074                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4075                       r = bfd_reloc_ok;
4076                       if (rel->r_offset >= 4
4077                           && (y & (0xffffffff ^ RS1(~0)))
4078                              == (INSN_OR | RD(O7) | RS2(G0)))
4079                         {
4080                           bfd_vma z;
4081                           unsigned int reg;
4082
4083                           z = bfd_get_32 (input_bfd,
4084                                           contents + rel->r_offset - 4);
4085                           if ((z & (0xffffffff ^ RD(~0)))
4086                               != (INSN_OR | RS1(O7) | RS2(G0)))
4087                             break;
4088
4089                           /* The sequence was
4090                              or %o7, %g0, %rN
4091                              call foo
4092                              or %rN, %g0, %o7
4093
4094                              If call foo was replaced with ba, replace
4095                              or %rN, %g0, %o7 with nop.  */
4096
4097                           reg = (y & RS1(~0)) >> 14;
4098                           if (reg != ((z & RD(~0)) >> 25)
4099                               || reg == G0 || reg == O7)
4100                             break;
4101
4102                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4103                                       contents + rel->r_offset + 4);
4104                         }
4105
4106                     }
4107                 }
4108             }
4109         }
4110
4111       if (r == bfd_reloc_continue)
4112         {
4113 do_relocation:
4114           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4115                                         contents, rel->r_offset,
4116                                         relocation, rel->r_addend);
4117         }
4118       if (r != bfd_reloc_ok)
4119         {
4120           switch (r)
4121             {
4122             default:
4123             case bfd_reloc_outofrange:
4124               abort ();
4125             case bfd_reloc_overflow:
4126               {
4127                 const char *name;
4128
4129                 /* The Solaris native linker silently disregards overflows.
4130                    We don't, but this breaks stabs debugging info, whose
4131                    relocations are only 32-bits wide.  Ignore overflows in
4132                    this case and also for discarded entries.  */
4133                 if ((r_type == R_SPARC_32
4134                      || r_type == R_SPARC_UA32
4135                      || r_type == R_SPARC_DISP32)
4136                     && (((input_section->flags & SEC_DEBUGGING) != 0
4137                          && strcmp (bfd_section_name (input_bfd,
4138                                                       input_section),
4139                                     ".stab") == 0)
4140                         || _bfd_elf_section_offset (output_bfd, info,
4141                                                     input_section,
4142                                                     rel->r_offset)
4143                              == (bfd_vma)-1))
4144                   break;
4145
4146                 if (h != NULL)
4147                   {
4148                     /* Assume this is a call protected by other code that
4149                        detect the symbol is undefined.  If this is the case,
4150                        we can safely ignore the overflow.  If not, the
4151                        program is hosed anyway, and a little warning isn't
4152                        going to help.  */
4153                     if (h->root.type == bfd_link_hash_undefweak
4154                         && howto->pc_relative)
4155                       break;
4156
4157                     name = NULL;
4158                   }
4159                 else
4160                   {
4161                     name = bfd_elf_string_from_elf_section (input_bfd,
4162                                                             symtab_hdr->sh_link,
4163                                                             sym->st_name);
4164                     if (name == NULL)
4165                       return FALSE;
4166                     if (*name == '\0')
4167                       name = bfd_section_name (input_bfd, sec);
4168                   }
4169                 if (! ((*info->callbacks->reloc_overflow)
4170                        (info, (h ? &h->root : NULL), name, howto->name,
4171                         (bfd_vma) 0, input_bfd, input_section,
4172                         rel->r_offset)))
4173                   return FALSE;
4174               }
4175               break;
4176             }
4177         }
4178     }
4179
4180   return TRUE;
4181 }
4182
4183 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
4184    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
4185    is the offset of the associated .got.plt entry from
4186    _GLOBAL_OFFSET_TABLE_.  */
4187
4188 static void
4189 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4190                                bfd_vma plt_offset, bfd_vma plt_index,
4191                                bfd_vma got_offset)
4192 {
4193   bfd_vma got_base;
4194   const bfd_vma *plt_entry;
4195   struct _bfd_sparc_elf_link_hash_table *htab;
4196   bfd_byte *loc;
4197   Elf_Internal_Rela rela;
4198
4199   htab = _bfd_sparc_elf_hash_table (info);
4200   BFD_ASSERT (htab != NULL);
4201
4202   if (info->shared)
4203     {
4204       plt_entry = sparc_vxworks_shared_plt_entry;
4205       got_base = 0;
4206     }
4207   else
4208     {
4209       plt_entry = sparc_vxworks_exec_plt_entry;
4210       got_base = (htab->elf.hgot->root.u.def.value
4211                   + htab->elf.hgot->root.u.def.section->output_offset
4212                   + htab->elf.hgot->root.u.def.section->output_section->vma);
4213     }
4214
4215   /* Fill in the entry in the procedure linkage table.  */
4216   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4217               htab->elf.splt->contents + plt_offset);
4218   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4219               htab->elf.splt->contents + plt_offset + 4);
4220   bfd_put_32 (output_bfd, plt_entry[2],
4221               htab->elf.splt->contents + plt_offset + 8);
4222   bfd_put_32 (output_bfd, plt_entry[3],
4223               htab->elf.splt->contents + plt_offset + 12);
4224   bfd_put_32 (output_bfd, plt_entry[4],
4225               htab->elf.splt->contents + plt_offset + 16);
4226   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4227               htab->elf.splt->contents + plt_offset + 20);
4228   /* PC-relative displacement for a branch to the start of
4229      the PLT section.  */
4230   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4231                                           & 0x003fffff),
4232               htab->elf.splt->contents + plt_offset + 24);
4233   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4234               htab->elf.splt->contents + plt_offset + 28);
4235
4236   /* Fill in the .got.plt entry, pointing initially at the
4237      second half of the PLT entry.  */
4238   BFD_ASSERT (htab->elf.sgotplt != NULL);
4239   bfd_put_32 (output_bfd,
4240               htab->elf.splt->output_section->vma
4241               + htab->elf.splt->output_offset
4242               + plt_offset + 20,
4243               htab->elf.sgotplt->contents + got_offset);
4244
4245   /* Add relocations to .rela.plt.unloaded.  */
4246   if (!info->shared)
4247     {
4248       loc = (htab->srelplt2->contents
4249              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4250
4251       /* Relocate the initial sethi.  */
4252       rela.r_offset = (htab->elf.splt->output_section->vma
4253                        + htab->elf.splt->output_offset
4254                        + plt_offset);
4255       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4256       rela.r_addend = got_offset;
4257       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4258       loc += sizeof (Elf32_External_Rela);
4259
4260       /* Likewise the following or.  */
4261       rela.r_offset += 4;
4262       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4263       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4264       loc += sizeof (Elf32_External_Rela);
4265
4266       /* Relocate the .got.plt entry.  */
4267       rela.r_offset = (htab->elf.sgotplt->output_section->vma
4268                        + htab->elf.sgotplt->output_offset
4269                        + got_offset);
4270       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4271       rela.r_addend = plt_offset + 20;
4272       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4273     }
4274 }
4275
4276 /* Finish up dynamic symbol handling.  We set the contents of various
4277    dynamic sections here.  */
4278
4279 bfd_boolean
4280 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4281                                       struct bfd_link_info *info,
4282                                       struct elf_link_hash_entry *h,
4283                                       Elf_Internal_Sym *sym)
4284 {
4285   struct _bfd_sparc_elf_link_hash_table *htab;
4286   const struct elf_backend_data *bed;
4287
4288   htab = _bfd_sparc_elf_hash_table (info);
4289   BFD_ASSERT (htab != NULL);
4290   bed = get_elf_backend_data (output_bfd);
4291
4292   if (h->plt.offset != (bfd_vma) -1)
4293     {
4294       asection *splt;
4295       asection *srela;
4296       Elf_Internal_Rela rela;
4297       bfd_byte *loc;
4298       bfd_vma r_offset, got_offset;
4299       int rela_index;
4300
4301       /* When building a static executable, use .iplt and
4302          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4303       if (htab->elf.splt != NULL)
4304         {
4305           splt = htab->elf.splt;
4306           srela = htab->elf.srelplt;
4307         }
4308       else
4309         {
4310           splt = htab->elf.iplt;
4311           srela = htab->elf.irelplt;
4312         }
4313
4314       if (splt == NULL || srela == NULL)
4315         abort ();
4316
4317       /* Fill in the entry in the .rela.plt section.  */
4318       if (htab->is_vxworks)
4319         {
4320           /* Work out the index of this PLT entry.  */
4321           rela_index = ((h->plt.offset - htab->plt_header_size)
4322                         / htab->plt_entry_size);
4323
4324           /* Calculate the offset of the associated .got.plt entry.
4325              The first three entries are reserved.  */
4326           got_offset = (rela_index + 3) * 4;
4327
4328           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4329                                          rela_index, got_offset);
4330
4331
4332           /* On VxWorks, the relocation points to the .got.plt entry,
4333              not the .plt entry.  */
4334           rela.r_offset = (htab->elf.sgotplt->output_section->vma
4335                            + htab->elf.sgotplt->output_offset
4336                            + got_offset);
4337           rela.r_addend = 0;
4338           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4339                                           R_SPARC_JMP_SLOT);
4340         }
4341       else
4342         {
4343           bfd_boolean ifunc = FALSE;
4344
4345           /* Fill in the entry in the procedure linkage table.  */
4346           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4347                                                   h->plt.offset, splt->size,
4348                                                   &r_offset);
4349
4350           if (h == NULL
4351               || h->dynindx == -1
4352               || ((info->executable
4353                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4354                   && h->def_regular
4355                   && h->type == STT_GNU_IFUNC))
4356             {
4357               ifunc = TRUE;
4358               BFD_ASSERT (h == NULL
4359                           || (h->type == STT_GNU_IFUNC
4360                               && h->def_regular
4361                               && (h->root.type == bfd_link_hash_defined
4362                                   || h->root.type == bfd_link_hash_defweak)));
4363             }
4364
4365           rela.r_offset = r_offset
4366             + (splt->output_section->vma + splt->output_offset);
4367           if (ABI_64_P (output_bfd)
4368               && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4369             {
4370               if (ifunc)
4371                 {
4372                   rela.r_addend = (h->root.u.def.section->output_section->vma
4373                                    + h->root.u.def.section->output_offset
4374                                    + h->root.u.def.value);
4375                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4376                                                   R_SPARC_IRELATIVE);
4377                 }
4378               else
4379                 {
4380                   rela.r_addend = (-(h->plt.offset + 4)
4381                                    - splt->output_section->vma
4382                                    - splt->output_offset);
4383                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4384                                                   R_SPARC_JMP_SLOT);
4385                 }
4386             }
4387           else
4388             {
4389               if (ifunc)
4390                 {
4391                   rela.r_addend = (h->root.u.def.section->output_section->vma
4392                                    + h->root.u.def.section->output_offset
4393                                    + h->root.u.def.value);
4394                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4395                                                   R_SPARC_JMP_IREL);
4396                 }
4397               else
4398                 {
4399                   rela.r_addend = 0;
4400                   rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4401                                                   R_SPARC_JMP_SLOT);
4402                 }
4403             }
4404         }
4405
4406       /* Adjust for the first 4 reserved elements in the .plt section
4407          when setting the offset in the .rela.plt section.
4408          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4409          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
4410
4411       loc = srela->contents;
4412       loc += rela_index * bed->s->sizeof_rela;
4413       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4414
4415       if (!h->def_regular)
4416         {
4417           /* Mark the symbol as undefined, rather than as defined in
4418              the .plt section.  Leave the value alone.  */
4419           sym->st_shndx = SHN_UNDEF;
4420           /* If the symbol is weak, we do need to clear the value.
4421              Otherwise, the PLT entry would provide a definition for
4422              the symbol even if the symbol wasn't defined anywhere,
4423              and so the symbol would never be NULL.  */
4424           if (!h->ref_regular_nonweak)
4425             sym->st_value = 0;
4426         }
4427     }
4428
4429   if (h->got.offset != (bfd_vma) -1
4430       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4431       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4432     {
4433       asection *sgot;
4434       asection *srela;
4435       Elf_Internal_Rela rela;
4436
4437       /* This symbol has an entry in the GOT.  Set it up.  */
4438
4439       sgot = htab->elf.sgot;
4440       srela = htab->elf.srelgot;
4441       BFD_ASSERT (sgot != NULL && srela != NULL);
4442
4443       rela.r_offset = (sgot->output_section->vma
4444                        + sgot->output_offset
4445                        + (h->got.offset &~ (bfd_vma) 1));
4446
4447       /* If this is a -Bsymbolic link, and the symbol is defined
4448          locally, we just want to emit a RELATIVE reloc.  Likewise if
4449          the symbol was forced to be local because of a version file.
4450          The entry in the global offset table will already have been
4451          initialized in the relocate_section function.  */
4452       if (! info->shared
4453           && h->type == STT_GNU_IFUNC
4454           && h->def_regular)
4455         {
4456           asection *plt;
4457
4458           /* We load the GOT entry with the PLT entry.  */
4459           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4460           SPARC_ELF_PUT_WORD (htab, output_bfd,
4461                               (plt->output_section->vma
4462                                + plt->output_offset + h->plt.offset),
4463                               htab->elf.sgot->contents
4464                               + (h->got.offset & ~(bfd_vma) 1));
4465           return TRUE;
4466         }
4467       else if (info->shared
4468                && SYMBOL_REFERENCES_LOCAL (info, h))
4469         {
4470           asection *sec = h->root.u.def.section;
4471           if (h->type == STT_GNU_IFUNC)
4472             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4473           else
4474             rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4475           rela.r_addend = (h->root.u.def.value
4476                            + sec->output_section->vma
4477                            + sec->output_offset);
4478         }
4479       else
4480         {
4481           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4482           rela.r_addend = 0;
4483         }
4484
4485       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4486                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4487       sparc_elf_append_rela (output_bfd, srela, &rela);
4488     }
4489
4490   if (h->needs_copy)
4491     {
4492       asection *s;
4493       Elf_Internal_Rela rela;
4494
4495       /* This symbols needs a copy reloc.  Set it up.  */
4496       BFD_ASSERT (h->dynindx != -1);
4497
4498       s = bfd_get_linker_section (h->root.u.def.section->owner,
4499                                   ".rela.bss");
4500       BFD_ASSERT (s != NULL);
4501
4502       rela.r_offset = (h->root.u.def.value
4503                        + h->root.u.def.section->output_section->vma
4504                        + h->root.u.def.section->output_offset);
4505       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4506       rela.r_addend = 0;
4507       sparc_elf_append_rela (output_bfd, s, &rela);
4508     }
4509
4510   /* Mark some specially defined symbols as absolute.  On VxWorks,
4511      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4512      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
4513   if (sym != NULL
4514       && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4515           || (!htab->is_vxworks
4516               && (h == htab->elf.hgot || h == htab->elf.hplt))))
4517     sym->st_shndx = SHN_ABS;
4518
4519   return TRUE;
4520 }
4521
4522 /* Finish up the dynamic sections.  */
4523
4524 static bfd_boolean
4525 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4526                   bfd *dynobj, asection *sdyn,
4527                   asection *splt ATTRIBUTE_UNUSED)
4528 {
4529   struct _bfd_sparc_elf_link_hash_table *htab;
4530   const struct elf_backend_data *bed;
4531   bfd_byte *dyncon, *dynconend;
4532   size_t dynsize;
4533   int stt_regidx = -1;
4534   bfd_boolean abi_64_p;
4535
4536   htab = _bfd_sparc_elf_hash_table (info);
4537   BFD_ASSERT (htab != NULL);
4538   bed = get_elf_backend_data (output_bfd);
4539   dynsize = bed->s->sizeof_dyn;
4540   dynconend = sdyn->contents + sdyn->size;
4541   abi_64_p = ABI_64_P (output_bfd);
4542   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4543     {
4544       Elf_Internal_Dyn dyn;
4545       const char *name;
4546       bfd_boolean size;
4547
4548       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4549
4550       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4551         {
4552           /* On VxWorks, DT_RELASZ should not include the relocations
4553              in .rela.plt.  */
4554           if (htab->elf.srelplt)
4555             {
4556               dyn.d_un.d_val -= htab->elf.srelplt->size;
4557               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4558             }
4559         }
4560       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4561         {
4562           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4563              not to the start of the PLT.  */
4564           if (htab->elf.sgotplt)
4565             {
4566               dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4567                                 + htab->elf.sgotplt->output_offset);
4568               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4569             }
4570         }
4571       else if (htab->is_vxworks
4572                && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4573         bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4574       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4575         {
4576           if (stt_regidx == -1)
4577             {
4578               stt_regidx =
4579                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4580               if (stt_regidx == -1)
4581                 return FALSE;
4582             }
4583           dyn.d_un.d_val = stt_regidx++;
4584           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4585         }
4586       else
4587         {
4588           switch (dyn.d_tag)
4589             {
4590             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
4591             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4592             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
4593             default:          name = NULL; size = FALSE; break;
4594             }
4595
4596           if (name != NULL)
4597             {
4598               asection *s;
4599
4600               s = bfd_get_section_by_name (output_bfd, name);
4601               if (s == NULL)
4602                 dyn.d_un.d_val = 0;
4603               else
4604                 {
4605                   if (! size)
4606                     dyn.d_un.d_ptr = s->vma;
4607                   else
4608                     dyn.d_un.d_val = s->size;
4609                 }
4610               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4611             }
4612         }
4613     }
4614   return TRUE;
4615 }
4616
4617 /* Install the first PLT entry in a VxWorks executable and make sure that
4618    .rela.plt.unloaded relocations have the correct symbol indexes.  */
4619
4620 static void
4621 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4622 {
4623   struct _bfd_sparc_elf_link_hash_table *htab;
4624   Elf_Internal_Rela rela;
4625   bfd_vma got_base;
4626   bfd_byte *loc;
4627
4628   htab = _bfd_sparc_elf_hash_table (info);
4629   BFD_ASSERT (htab != NULL);
4630
4631   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
4632   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4633               + htab->elf.hgot->root.u.def.section->output_offset
4634               + htab->elf.hgot->root.u.def.value);
4635
4636   /* Install the initial PLT entry.  */
4637   bfd_put_32 (output_bfd,
4638               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4639               htab->elf.splt->contents);
4640   bfd_put_32 (output_bfd,
4641               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4642               htab->elf.splt->contents + 4);
4643   bfd_put_32 (output_bfd,
4644               sparc_vxworks_exec_plt0_entry[2],
4645               htab->elf.splt->contents + 8);
4646   bfd_put_32 (output_bfd,
4647               sparc_vxworks_exec_plt0_entry[3],
4648               htab->elf.splt->contents + 12);
4649   bfd_put_32 (output_bfd,
4650               sparc_vxworks_exec_plt0_entry[4],
4651               htab->elf.splt->contents + 16);
4652
4653   loc = htab->srelplt2->contents;
4654
4655   /* Add an unloaded relocation for the initial entry's "sethi".  */
4656   rela.r_offset = (htab->elf.splt->output_section->vma
4657                    + htab->elf.splt->output_offset);
4658   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4659   rela.r_addend = 8;
4660   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4661   loc += sizeof (Elf32_External_Rela);
4662
4663   /* Likewise the following "or".  */
4664   rela.r_offset += 4;
4665   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4666   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4667   loc += sizeof (Elf32_External_Rela);
4668
4669   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4670      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4671      in which symbols were output.  */
4672   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4673     {
4674       Elf_Internal_Rela rel;
4675
4676       /* The entry's initial "sethi" (against _G_O_T_).  */
4677       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4678       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4679       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4680       loc += sizeof (Elf32_External_Rela);
4681
4682       /* The following "or" (also against _G_O_T_).  */
4683       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4684       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4685       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4686       loc += sizeof (Elf32_External_Rela);
4687
4688       /* The .got.plt entry (against _P_L_T_).  */
4689       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4690       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4691       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4692       loc += sizeof (Elf32_External_Rela);
4693     }
4694 }
4695
4696 /* Install the first PLT entry in a VxWorks shared object.  */
4697
4698 static void
4699 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4700 {
4701   struct _bfd_sparc_elf_link_hash_table *htab;
4702   unsigned int i;
4703
4704   htab = _bfd_sparc_elf_hash_table (info);
4705   BFD_ASSERT (htab != NULL);
4706
4707   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4708     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4709                 htab->elf.splt->contents + i * 4);
4710 }
4711
4712 /* Finish up local dynamic symbol handling.  We set the contents of
4713    various dynamic sections here.  */
4714
4715 static bfd_boolean
4716 finish_local_dynamic_symbol (void **slot, void *inf)
4717 {
4718   struct elf_link_hash_entry *h
4719     = (struct elf_link_hash_entry *) *slot;
4720   struct bfd_link_info *info
4721     = (struct bfd_link_info *) inf;
4722
4723   return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4724                                                h, NULL);
4725 }
4726
4727 bfd_boolean
4728 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4729 {
4730   bfd *dynobj;
4731   asection *sdyn;
4732   struct _bfd_sparc_elf_link_hash_table *htab;
4733
4734   htab = _bfd_sparc_elf_hash_table (info);
4735   BFD_ASSERT (htab != NULL);
4736   dynobj = htab->elf.dynobj;
4737
4738   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4739
4740   if (elf_hash_table (info)->dynamic_sections_created)
4741     {
4742       asection *splt;
4743
4744       splt = htab->elf.splt;
4745       BFD_ASSERT (splt != NULL && sdyn != NULL);
4746
4747       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4748         return FALSE;
4749
4750       /* Initialize the contents of the .plt section.  */
4751       if (splt->size > 0)
4752         {
4753           if (htab->is_vxworks)
4754             {
4755               if (info->shared)
4756                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4757               else
4758                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4759             }
4760           else
4761             {
4762               memset (splt->contents, 0, htab->plt_header_size);
4763               if (!ABI_64_P (output_bfd))
4764                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4765                             splt->contents + splt->size - 4);
4766             }
4767         }
4768
4769       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4770         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4771           ? 0 : htab->plt_entry_size;
4772     }
4773
4774   /* Set the first entry in the global offset table to the address of
4775      the dynamic section.  */
4776   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4777     {
4778       bfd_vma val = (sdyn ?
4779                      sdyn->output_section->vma + sdyn->output_offset :
4780                      0);
4781
4782       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4783     }
4784
4785   if (htab->elf.sgot)
4786     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4787       SPARC_ELF_WORD_BYTES (htab);
4788
4789   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4790   htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4791
4792   return TRUE;
4793 }
4794
4795 \f
4796 /* Set the right machine number for a SPARC ELF file.  */
4797
4798 bfd_boolean
4799 _bfd_sparc_elf_object_p (bfd *abfd)
4800 {
4801   if (ABI_64_P (abfd))
4802     {
4803       unsigned long mach = bfd_mach_sparc_v9;
4804
4805       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4806         mach = bfd_mach_sparc_v9b;
4807       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4808         mach = bfd_mach_sparc_v9a;
4809       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4810     }
4811   else
4812     {
4813       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4814         {
4815           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4816             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4817                                               bfd_mach_sparc_v8plusb);
4818           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4819             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4820                                               bfd_mach_sparc_v8plusa);
4821           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4822             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4823                                               bfd_mach_sparc_v8plus);
4824           else
4825             return FALSE;
4826         }
4827       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4828         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4829                                           bfd_mach_sparc_sparclite_le);
4830       else
4831         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4832     }
4833 }
4834
4835 /* Return address for Ith PLT stub in section PLT, for relocation REL
4836    or (bfd_vma) -1 if it should not be included.  */
4837
4838 bfd_vma
4839 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4840 {
4841   if (ABI_64_P (plt->owner))
4842     {
4843       bfd_vma j;
4844
4845       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4846       if (i < PLT64_LARGE_THRESHOLD)
4847         return plt->vma + i * PLT64_ENTRY_SIZE;
4848
4849       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4850       i -= j;
4851       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4852     }
4853   else
4854     return rel->address;
4855 }
4856
4857 /* Merge backend specific data from an object file to the output
4858    object file when linking.  */
4859
4860 bfd_boolean
4861 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4862 {
4863   obj_attribute *in_attr, *in_attrs;
4864   obj_attribute *out_attr, *out_attrs;
4865
4866   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4867     {
4868       /* This is the first object.  Copy the attributes.  */
4869       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4870
4871       /* Use the Tag_null value to indicate the attributes have been
4872          initialized.  */
4873       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4874
4875       return TRUE;
4876     }
4877
4878   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4879   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4880
4881   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4882   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4883
4884   out_attr->i |= in_attr->i;
4885
4886   /* Merge Tag_compatibility attributes and any common GNU ones.  */
4887   _bfd_elf_merge_object_attributes (ibfd, obfd);
4888
4889   return TRUE;
4890 }