bfd/elfxx-sparc.c

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