bfd/elfxx-sparc.c

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