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