bfd/elfxx-sparc.c

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