bfd/elfxx-sparc.c

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