bfd/elfxx-sparc.c

   1 /* SPARC-specific support for ELF
   2    Copyright 2005, 2006, 2007, 2008, 2009 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                   asection *s;
1469                   void *vpp;
1470                   Elf_Internal_Sym *isym;
1471
1472                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1473                                                 abfd, r_symndx);
1474                   if (isym == NULL)
1475                     return FALSE;
1476
1477                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1478                   if (s == NULL)
1479                     s = sec;
1480
1481                   vpp = &elf_section_data (s)->local_dynrel;
1482                   head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1483                 }
1484
1485               p = *head;
1486               if (p == NULL || p->sec != sec)
1487                 {
1488                   bfd_size_type amt = sizeof *p;
1489                   p = ((struct _bfd_sparc_elf_dyn_relocs *)
1490                        bfd_alloc (htab->elf.dynobj, amt));
1491                   if (p == NULL)
1492                     return FALSE;
1493                   p->next = *head;
1494                   *head = p;
1495                   p->sec = sec;
1496                   p->count = 0;
1497                   p->pc_count = 0;
1498                 }
1499
1500               p->count += 1;
1501               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1502                 p->pc_count += 1;
1503             }
1504
1505           break;
1506
1507         case R_SPARC_GNU_VTINHERIT:
1508           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1509             return FALSE;
1510           break;
1511
1512         case R_SPARC_GNU_VTENTRY:
1513           BFD_ASSERT (h != NULL);
1514           if (h != NULL
1515               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1516             return FALSE;
1517           break;
1518
1519         case R_SPARC_REGISTER:
1520           /* Nothing to do.  */
1521           break;
1522
1523         default:
1524           break;
1525         }
1526     }
1527
1528   return TRUE;
1529 }
1530 \f
1531 asection *
1532 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1533                              struct bfd_link_info *info,
1534                              Elf_Internal_Rela *rel,
1535                              struct elf_link_hash_entry *h,
1536                              Elf_Internal_Sym *sym)
1537 {
1538   if (h != NULL)
1539     switch (SPARC_ELF_R_TYPE (rel->r_info))
1540       {
1541       case R_SPARC_GNU_VTINHERIT:
1542       case R_SPARC_GNU_VTENTRY:
1543         return NULL;
1544       }
1545
1546   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1547 }
1548
1549 /* Update the got entry reference counts for the section being removed.  */
1550 bfd_boolean
1551 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1552                               asection *sec, const Elf_Internal_Rela *relocs)
1553 {
1554   struct _bfd_sparc_elf_link_hash_table *htab;
1555   Elf_Internal_Shdr *symtab_hdr;
1556   struct elf_link_hash_entry **sym_hashes;
1557   bfd_signed_vma *local_got_refcounts;
1558   const Elf_Internal_Rela *rel, *relend;
1559
1560   if (info->relocatable)
1561     return TRUE;
1562
1563   BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1564
1565   elf_section_data (sec)->local_dynrel = NULL;
1566
1567   htab = _bfd_sparc_elf_hash_table (info);
1568   symtab_hdr = &elf_symtab_hdr (abfd);
1569   sym_hashes = elf_sym_hashes (abfd);
1570   local_got_refcounts = elf_local_got_refcounts (abfd);
1571
1572   relend = relocs + sec->reloc_count;
1573   for (rel = relocs; rel < relend; rel++)
1574     {
1575       unsigned long r_symndx;
1576       unsigned int r_type;
1577       struct elf_link_hash_entry *h = NULL;
1578
1579       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1580       if (r_symndx >= symtab_hdr->sh_info)
1581         {
1582           struct _bfd_sparc_elf_link_hash_entry *eh;
1583           struct _bfd_sparc_elf_dyn_relocs **pp;
1584           struct _bfd_sparc_elf_dyn_relocs *p;
1585
1586           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1587           while (h->root.type == bfd_link_hash_indirect
1588                  || h->root.type == bfd_link_hash_warning)
1589             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1590           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1591           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1592             if (p->sec == sec)
1593               {
1594                 /* Everything must go for SEC.  */
1595                 *pp = p->next;
1596                 break;
1597               }
1598         }
1599
1600       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1601       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1602       switch (r_type)
1603         {
1604         case R_SPARC_TLS_LDM_HI22:
1605         case R_SPARC_TLS_LDM_LO10:
1606           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1607             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1608           break;
1609
1610         case R_SPARC_TLS_GD_HI22:
1611         case R_SPARC_TLS_GD_LO10:
1612         case R_SPARC_TLS_IE_HI22:
1613         case R_SPARC_TLS_IE_LO10:
1614         case R_SPARC_GOT10:
1615         case R_SPARC_GOT13:
1616         case R_SPARC_GOT22:
1617         case R_SPARC_GOTDATA_HIX22:
1618         case R_SPARC_GOTDATA_LOX10:
1619         case R_SPARC_GOTDATA_OP_HIX22:
1620         case R_SPARC_GOTDATA_OP_LOX10:
1621           if (h != NULL)
1622             {
1623               if (h->got.refcount > 0)
1624                 h->got.refcount--;
1625             }
1626           else
1627             {
1628               if (local_got_refcounts[r_symndx] > 0)
1629                 local_got_refcounts[r_symndx]--;
1630             }
1631           break;
1632
1633         case R_SPARC_PC10:
1634         case R_SPARC_PC22:
1635         case R_SPARC_PC_HH22:
1636         case R_SPARC_PC_HM10:
1637         case R_SPARC_PC_LM22:
1638           if (h != NULL
1639               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1640             break;
1641           /* Fall through.  */
1642
1643         case R_SPARC_DISP8:
1644         case R_SPARC_DISP16:
1645         case R_SPARC_DISP32:
1646         case R_SPARC_DISP64:
1647         case R_SPARC_WDISP30:
1648         case R_SPARC_WDISP22:
1649         case R_SPARC_WDISP19:
1650         case R_SPARC_WDISP16:
1651         case R_SPARC_8:
1652         case R_SPARC_16:
1653         case R_SPARC_32:
1654         case R_SPARC_HI22:
1655         case R_SPARC_22:
1656         case R_SPARC_13:
1657         case R_SPARC_LO10:
1658         case R_SPARC_UA16:
1659         case R_SPARC_UA32:
1660         case R_SPARC_PLT32:
1661         case R_SPARC_10:
1662         case R_SPARC_11:
1663         case R_SPARC_64:
1664         case R_SPARC_OLO10:
1665         case R_SPARC_HH22:
1666         case R_SPARC_HM10:
1667         case R_SPARC_LM22:
1668         case R_SPARC_7:
1669         case R_SPARC_5:
1670         case R_SPARC_6:
1671         case R_SPARC_HIX22:
1672         case R_SPARC_LOX10:
1673         case R_SPARC_H44:
1674         case R_SPARC_M44:
1675         case R_SPARC_L44:
1676         case R_SPARC_UA64:
1677           if (info->shared)
1678             break;
1679           /* Fall through.  */
1680
1681         case R_SPARC_WPLT30:
1682           if (h != NULL)
1683             {
1684               if (h->plt.refcount > 0)
1685                 h->plt.refcount--;
1686             }
1687           break;
1688
1689         default:
1690           break;
1691         }
1692     }
1693
1694   return TRUE;
1695 }
1696
1697 /* Adjust a symbol defined by a dynamic object and referenced by a
1698    regular object.  The current definition is in some section of the
1699    dynamic object, but we're not including those sections.  We have to
1700    change the definition to something the rest of the link can
1701    understand.  */
1702
1703 bfd_boolean
1704 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1705                                      struct elf_link_hash_entry *h)
1706 {
1707   struct _bfd_sparc_elf_link_hash_table *htab;
1708   struct _bfd_sparc_elf_link_hash_entry * eh;
1709   struct _bfd_sparc_elf_dyn_relocs *p;
1710   asection *s;
1711
1712   htab = _bfd_sparc_elf_hash_table (info);
1713
1714   /* Make sure we know what is going on here.  */
1715   BFD_ASSERT (htab->elf.dynobj != NULL
1716               && (h->needs_plt
1717                   || h->u.weakdef != NULL
1718                   || (h->def_dynamic
1719                       && h->ref_regular
1720                       && !h->def_regular)));
1721
1722   /* If this is a function, put it in the procedure linkage table.  We
1723      will fill in the contents of the procedure linkage table later
1724      (although we could actually do it here).  The STT_NOTYPE
1725      condition is a hack specifically for the Oracle libraries
1726      delivered for Solaris; for some inexplicable reason, they define
1727      some of their functions as STT_NOTYPE when they really should be
1728      STT_FUNC.  */
1729   if (h->type == STT_FUNC
1730       || h->needs_plt
1731       || (h->type == STT_NOTYPE
1732           && (h->root.type == bfd_link_hash_defined
1733               || h->root.type == bfd_link_hash_defweak)
1734           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1735     {
1736       if (h->plt.refcount <= 0
1737           || (! info->shared
1738               && !h->def_dynamic
1739               && !h->ref_dynamic
1740               && h->root.type != bfd_link_hash_undefweak
1741               && h->root.type != bfd_link_hash_undefined))
1742         {
1743           /* This case can occur if we saw a WPLT30 reloc in an input
1744              file, but the symbol was never referred to by a dynamic
1745              object, or if all references were garbage collected.  In
1746              such a case, we don't actually need to build a procedure
1747              linkage table, and we can just do a WDISP30 reloc instead.  */
1748           h->plt.offset = (bfd_vma) -1;
1749           h->needs_plt = 0;
1750         }
1751
1752       return TRUE;
1753     }
1754   else
1755     h->plt.offset = (bfd_vma) -1;
1756
1757   /* If this is a weak symbol, and there is a real definition, the
1758      processor independent code will have arranged for us to see the
1759      real definition first, and we can just use the same value.  */
1760   if (h->u.weakdef != NULL)
1761     {
1762       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1763                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1764       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1765       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1766       return TRUE;
1767     }
1768
1769   /* This is a reference to a symbol defined by a dynamic object which
1770      is not a function.  */
1771
1772   /* If we are creating a shared library, we must presume that the
1773      only references to the symbol are via the global offset table.
1774      For such cases we need not do anything here; the relocations will
1775      be handled correctly by relocate_section.  */
1776   if (info->shared)
1777     return TRUE;
1778
1779   /* If there are no references to this symbol that do not use the
1780      GOT, we don't need to generate a copy reloc.  */
1781   if (!h->non_got_ref)
1782     return TRUE;
1783
1784   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1785   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1786     {
1787       s = p->sec->output_section;
1788       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1789         break;
1790     }
1791
1792   /* If we didn't find any dynamic relocs in read-only sections, then
1793      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1794   if (p == NULL)
1795     {
1796       h->non_got_ref = 0;
1797       return TRUE;
1798     }
1799
1800   if (h->size == 0)
1801     {
1802       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1803                              h->root.root.string);
1804       return TRUE;
1805     }
1806
1807   /* We must allocate the symbol in our .dynbss section, which will
1808      become part of the .bss section of the executable.  There will be
1809      an entry for this symbol in the .dynsym section.  The dynamic
1810      object will contain position independent code, so all references
1811      from the dynamic object to this symbol will go through the global
1812      offset table.  The dynamic linker will use the .dynsym entry to
1813      determine the address it must put in the global offset table, so
1814      both the dynamic object and the regular object will refer to the
1815      same memory location for the variable.  */
1816
1817   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1818      to copy the initial value out of the dynamic object and into the
1819      runtime process image.  We need to remember the offset into the
1820      .rel.bss section we are going to use.  */
1821   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1822     {
1823       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1824       h->needs_copy = 1;
1825     }
1826
1827   s = htab->sdynbss;
1828
1829   return _bfd_elf_adjust_dynamic_copy (h, s);
1830 }
1831
1832 /* Allocate space in .plt, .got and associated reloc sections for
1833    dynamic relocs.  */
1834
1835 static bfd_boolean
1836 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1837 {
1838   struct bfd_link_info *info;
1839   struct _bfd_sparc_elf_link_hash_table *htab;
1840   struct _bfd_sparc_elf_link_hash_entry *eh;
1841   struct _bfd_sparc_elf_dyn_relocs *p;
1842
1843   if (h->root.type == bfd_link_hash_indirect)
1844     return TRUE;
1845
1846   if (h->root.type == bfd_link_hash_warning)
1847     /* When warning symbols are created, they **replace** the "real"
1848        entry in the hash table, thus we never get to see the real
1849        symbol in a hash traversal.  So look at it now.  */
1850     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1851
1852   info = (struct bfd_link_info *) inf;
1853   htab = _bfd_sparc_elf_hash_table (info);
1854
1855   if (htab->elf.dynamic_sections_created
1856       && h->plt.refcount > 0)
1857     {
1858       /* Make sure this symbol is output as a dynamic symbol.
1859          Undefined weak syms won't yet be marked as dynamic.  */
1860       if (h->dynindx == -1
1861           && !h->forced_local)
1862         {
1863           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1864             return FALSE;
1865         }
1866
1867       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1868         {
1869           asection *s = htab->splt;
1870
1871           /* Allocate room for the header.  */
1872           if (s->size == 0)
1873             {
1874               s->size = htab->plt_header_size;
1875
1876               /* Allocate space for the .rela.plt.unloaded relocations.  */
1877               if (htab->is_vxworks && !info->shared)
1878                 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1879             }
1880
1881           /* The procedure linkage table size is bounded by the magnitude
1882              of the offset we can describe in the entry.  */
1883           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1884                           (((bfd_vma)1 << 31) << 1) : 0x400000))
1885             {
1886               bfd_set_error (bfd_error_bad_value);
1887               return FALSE;
1888             }
1889
1890           if (SPARC_ELF_WORD_BYTES(htab) == 8
1891               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1892             {
1893               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1894
1895
1896               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1897
1898               h->plt.offset = (s->size - (off * 8));
1899             }
1900           else
1901             h->plt.offset = s->size;
1902
1903           /* If this symbol is not defined in a regular file, and we are
1904              not generating a shared library, then set the symbol to this
1905              location in the .plt.  This is required to make function
1906              pointers compare as equal between the normal executable and
1907              the shared library.  */
1908           if (! info->shared
1909               && !h->def_regular)
1910             {
1911               h->root.u.def.section = s;
1912               h->root.u.def.value = h->plt.offset;
1913             }
1914
1915           /* Make room for this entry.  */
1916           s->size += htab->plt_entry_size;
1917
1918           /* We also need to make an entry in the .rela.plt section.  */
1919           htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1920
1921           if (htab->is_vxworks)
1922             {
1923               /* Allocate space for the .got.plt entry.  */
1924               htab->sgotplt->size += 4;
1925
1926               /* ...and for the .rela.plt.unloaded relocations.  */
1927               if (!info->shared)
1928                 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1929             }
1930         }
1931       else
1932         {
1933           h->plt.offset = (bfd_vma) -1;
1934           h->needs_plt = 0;
1935         }
1936     }
1937   else
1938     {
1939       h->plt.offset = (bfd_vma) -1;
1940       h->needs_plt = 0;
1941     }
1942
1943   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1944      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1945   if (h->got.refcount > 0
1946       && !info->shared
1947       && h->dynindx == -1
1948       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1949     h->got.offset = (bfd_vma) -1;
1950   else if (h->got.refcount > 0)
1951     {
1952       asection *s;
1953       bfd_boolean dyn;
1954       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1955
1956       /* Make sure this symbol is output as a dynamic symbol.
1957          Undefined weak syms won't yet be marked as dynamic.  */
1958       if (h->dynindx == -1
1959           && !h->forced_local)
1960         {
1961           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1962             return FALSE;
1963         }
1964
1965       s = htab->sgot;
1966       h->got.offset = s->size;
1967       s->size += SPARC_ELF_WORD_BYTES (htab);
1968       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1969       if (tls_type == GOT_TLS_GD)
1970         s->size += SPARC_ELF_WORD_BYTES (htab);
1971       dyn = htab->elf.dynamic_sections_created;
1972       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1973          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1974          global.  */
1975       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1976           || tls_type == GOT_TLS_IE)
1977         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1978       else if (tls_type == GOT_TLS_GD)
1979         htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
1980       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1981         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1982     }
1983   else
1984     h->got.offset = (bfd_vma) -1;
1985
1986   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1987   if (eh->dyn_relocs == NULL)
1988     return TRUE;
1989
1990   /* In the shared -Bsymbolic case, discard space allocated for
1991      dynamic pc-relative relocs against symbols which turn out to be
1992      defined in regular objects.  For the normal shared case, discard
1993      space for pc-relative relocs that have become local due to symbol
1994      visibility changes.  */
1995
1996   if (info->shared)
1997     {
1998       if (h->def_regular
1999           && (h->forced_local
2000               || info->symbolic))
2001         {
2002           struct _bfd_sparc_elf_dyn_relocs **pp;
2003
2004           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2005             {
2006               p->count -= p->pc_count;
2007               p->pc_count = 0;
2008               if (p->count == 0)
2009                 *pp = p->next;
2010               else
2011                 pp = &p->next;
2012             }
2013         }
2014
2015       if (htab->is_vxworks)
2016         {
2017           struct _bfd_sparc_elf_dyn_relocs **pp;
2018
2019           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2020             {
2021               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2022                 *pp = p->next;
2023               else
2024                 pp = &p->next;
2025             }
2026         }
2027
2028       /* Also discard relocs on undefined weak syms with non-default
2029          visibility.  */
2030       if (eh->dyn_relocs != NULL
2031           && h->root.type == bfd_link_hash_undefweak)
2032         {
2033           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2034             eh->dyn_relocs = NULL;
2035
2036           /* Make sure undefined weak symbols are output as a dynamic
2037              symbol in PIEs.  */
2038           else if (h->dynindx == -1
2039                    && !h->forced_local)
2040             {
2041               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2042                 return FALSE;
2043             }
2044         }
2045     }
2046   else
2047     {
2048       /* For the non-shared case, discard space for relocs against
2049          symbols which turn out to need copy relocs or are not
2050          dynamic.  */
2051
2052       if (!h->non_got_ref
2053           && ((h->def_dynamic
2054                && !h->def_regular)
2055               || (htab->elf.dynamic_sections_created
2056                   && (h->root.type == bfd_link_hash_undefweak
2057                       || h->root.type == bfd_link_hash_undefined))))
2058         {
2059           /* Make sure this symbol is output as a dynamic symbol.
2060              Undefined weak syms won't yet be marked as dynamic.  */
2061           if (h->dynindx == -1
2062               && !h->forced_local)
2063             {
2064               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2065                 return FALSE;
2066             }
2067
2068           /* If that succeeded, we know we'll be keeping all the
2069              relocs.  */
2070           if (h->dynindx != -1)
2071             goto keep;
2072         }
2073
2074       eh->dyn_relocs = NULL;
2075
2076     keep: ;
2077     }
2078
2079   /* Finally, allocate space.  */
2080   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2081     {
2082       asection *sreloc = elf_section_data (p->sec)->sreloc;
2083       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2084     }
2085
2086   return TRUE;
2087 }
2088
2089 /* Find any dynamic relocs that apply to read-only sections.  */
2090
2091 static bfd_boolean
2092 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2093 {
2094   struct _bfd_sparc_elf_link_hash_entry *eh;
2095   struct _bfd_sparc_elf_dyn_relocs *p;
2096
2097   if (h->root.type == bfd_link_hash_warning)
2098     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2099
2100   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2101   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2102     {
2103       asection *s = p->sec->output_section;
2104
2105       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2106         {
2107           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2108
2109           info->flags |= DF_TEXTREL;
2110
2111           /* Not an error, just cut short the traversal.  */
2112           return FALSE;
2113         }
2114     }
2115   return TRUE;
2116 }
2117
2118 /* Return true if the dynamic symbol for a given section should be
2119    omitted when creating a shared library.  */
2120
2121 bfd_boolean
2122 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2123                                     struct bfd_link_info *info,
2124                                     asection *p)
2125 {
2126   /* We keep the .got section symbol so that explicit relocations
2127      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2128      can be turned into relocations against the .got symbol.  */
2129   if (strcmp (p->name, ".got") == 0)
2130     return FALSE;
2131
2132   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2133 }
2134
2135 /* Set the sizes of the dynamic sections.  */
2136
2137 bfd_boolean
2138 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2139                                       struct bfd_link_info *info)
2140 {
2141   struct _bfd_sparc_elf_link_hash_table *htab;
2142   bfd *dynobj;
2143   asection *s;
2144   bfd *ibfd;
2145
2146   htab = _bfd_sparc_elf_hash_table (info);
2147   dynobj = htab->elf.dynobj;
2148   BFD_ASSERT (dynobj != NULL);
2149
2150   if (elf_hash_table (info)->dynamic_sections_created)
2151     {
2152       /* Set the contents of the .interp section to the interpreter.  */
2153       if (info->executable)
2154         {
2155           s = bfd_get_section_by_name (dynobj, ".interp");
2156           BFD_ASSERT (s != NULL);
2157           s->size = htab->dynamic_interpreter_size;
2158           s->contents = (unsigned char *) htab->dynamic_interpreter;
2159         }
2160     }
2161
2162   /* Set up .got offsets for local syms, and space for local dynamic
2163      relocs.  */
2164   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2165     {
2166       bfd_signed_vma *local_got;
2167       bfd_signed_vma *end_local_got;
2168       char *local_tls_type;
2169       bfd_size_type locsymcount;
2170       Elf_Internal_Shdr *symtab_hdr;
2171       asection *srel;
2172
2173       if (! is_sparc_elf (ibfd))
2174         continue;
2175
2176       for (s = ibfd->sections; s != NULL; s = s->next)
2177         {
2178           struct _bfd_sparc_elf_dyn_relocs *p;
2179
2180           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2181             {
2182               if (!bfd_is_abs_section (p->sec)
2183                   && bfd_is_abs_section (p->sec->output_section))
2184                 {
2185                   /* Input section has been discarded, either because
2186                      it is a copy of a linkonce section or due to
2187                      linker script /DISCARD/, so we'll be discarding
2188                      the relocs too.  */
2189                 }
2190               else if (htab->is_vxworks
2191                        && strcmp (p->sec->output_section->name,
2192                                   ".tls_vars") == 0)
2193                 {
2194                   /* Relocations in vxworks .tls_vars sections are
2195                      handled specially by the loader.  */
2196                 }
2197               else if (p->count != 0)
2198                 {
2199                   srel = elf_section_data (p->sec)->sreloc;
2200                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2201                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2202                     info->flags |= DF_TEXTREL;
2203                 }
2204             }
2205         }
2206
2207       local_got = elf_local_got_refcounts (ibfd);
2208       if (!local_got)
2209         continue;
2210
2211       symtab_hdr = &elf_symtab_hdr (ibfd);
2212       locsymcount = symtab_hdr->sh_info;
2213       end_local_got = local_got + locsymcount;
2214       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2215       s = htab->sgot;
2216       srel = htab->srelgot;
2217       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2218         {
2219           if (*local_got > 0)
2220             {
2221               *local_got = s->size;
2222               s->size += SPARC_ELF_WORD_BYTES (htab);
2223               if (*local_tls_type == GOT_TLS_GD)
2224                 s->size += SPARC_ELF_WORD_BYTES (htab);
2225               if (info->shared
2226                   || *local_tls_type == GOT_TLS_GD
2227                   || *local_tls_type == GOT_TLS_IE)
2228                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2229             }
2230           else
2231             *local_got = (bfd_vma) -1;
2232         }
2233     }
2234
2235   if (htab->tls_ldm_got.refcount > 0)
2236     {
2237       /* Allocate 2 got entries and 1 dynamic reloc for
2238          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2239       htab->tls_ldm_got.offset = htab->sgot->size;
2240       htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2241       htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2242     }
2243   else
2244     htab->tls_ldm_got.offset = -1;
2245
2246   /* Allocate global sym .plt and .got entries, and space for global
2247      sym dynamic relocs.  */
2248   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2249
2250   if (! ABI_64_P (output_bfd)
2251       && !htab->is_vxworks
2252       && elf_hash_table (info)->dynamic_sections_created)
2253     {
2254       /* Make space for the trailing nop in .plt.  */
2255       if (htab->splt->size > 0)
2256         htab->splt->size += 1 * SPARC_INSN_BYTES;
2257
2258       /* If the .got section is more than 0x1000 bytes, we add
2259          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2260          bit relocations have a greater chance of working.
2261
2262          FIXME: Make this optimization work for 64-bit too.  */
2263       if (htab->sgot->size >= 0x1000
2264           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2265         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2266     }
2267
2268   /* The check_relocs and adjust_dynamic_symbol entry points have
2269      determined the sizes of the various dynamic sections.  Allocate
2270      memory for them.  */
2271   for (s = dynobj->sections; s != NULL; s = s->next)
2272     {
2273       if ((s->flags & SEC_LINKER_CREATED) == 0)
2274         continue;
2275
2276       if (s == htab->splt
2277           || s == htab->sgot
2278           || s == htab->sdynbss
2279           || s == htab->sgotplt)
2280         {
2281           /* Strip this section if we don't need it; see the
2282              comment below.  */
2283         }
2284       else if (CONST_STRNEQ (s->name, ".rela"))
2285         {
2286           if (s->size != 0)
2287             {
2288               /* We use the reloc_count field as a counter if we need
2289                  to copy relocs into the output file.  */
2290               s->reloc_count = 0;
2291             }
2292         }
2293       else
2294         {
2295           /* It's not one of our sections.  */
2296           continue;
2297         }
2298
2299       if (s->size == 0)
2300         {
2301           /* If we don't need this section, strip it from the
2302              output file.  This is mostly to handle .rela.bss and
2303              .rela.plt.  We must create both sections in
2304              create_dynamic_sections, because they must be created
2305              before the linker maps input sections to output
2306              sections.  The linker does that before
2307              adjust_dynamic_symbol is called, and it is that
2308              function which decides whether anything needs to go
2309              into these sections.  */
2310           s->flags |= SEC_EXCLUDE;
2311           continue;
2312         }
2313
2314       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2315         continue;
2316
2317       /* Allocate memory for the section contents.  Zero the memory
2318          for the benefit of .rela.plt, which has 4 unused entries
2319          at the beginning, and we don't want garbage.  */
2320       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2321       if (s->contents == NULL)
2322         return FALSE;
2323     }
2324
2325   if (elf_hash_table (info)->dynamic_sections_created)
2326     {
2327       /* Add some entries to the .dynamic section.  We fill in the
2328          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2329          must add the entries now so that we get the correct size for
2330          the .dynamic section.  The DT_DEBUG entry is filled in by the
2331          dynamic linker and used by the debugger.  */
2332 #define add_dynamic_entry(TAG, VAL) \
2333   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2334
2335       if (info->executable)
2336         {
2337           if (!add_dynamic_entry (DT_DEBUG, 0))
2338             return FALSE;
2339         }
2340
2341       if (htab->srelplt->size != 0)
2342         {
2343           if (!add_dynamic_entry (DT_PLTGOT, 0)
2344               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2345               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2346               || !add_dynamic_entry (DT_JMPREL, 0))
2347             return FALSE;
2348         }
2349
2350       if (!add_dynamic_entry (DT_RELA, 0)
2351           || !add_dynamic_entry (DT_RELASZ, 0)
2352           || !add_dynamic_entry (DT_RELAENT,
2353                                  SPARC_ELF_RELA_BYTES (htab)))
2354         return FALSE;
2355
2356       /* If any dynamic relocs apply to a read-only section,
2357          then we need a DT_TEXTREL entry.  */
2358       if ((info->flags & DF_TEXTREL) == 0)
2359         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2360                                 (PTR) info);
2361
2362       if (info->flags & DF_TEXTREL)
2363         {
2364           if (!add_dynamic_entry (DT_TEXTREL, 0))
2365             return FALSE;
2366         }
2367
2368       if (ABI_64_P (output_bfd))
2369         {
2370           int reg;
2371           struct _bfd_sparc_elf_app_reg * app_regs;
2372           struct elf_strtab_hash *dynstr;
2373           struct elf_link_hash_table *eht = elf_hash_table (info);
2374
2375           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2376              entries if needed.  */
2377           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2378           dynstr = eht->dynstr;
2379
2380           for (reg = 0; reg < 4; reg++)
2381             if (app_regs [reg].name != NULL)
2382               {
2383                 struct elf_link_local_dynamic_entry *entry, *e;
2384
2385                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2386                   return FALSE;
2387
2388                 entry = (struct elf_link_local_dynamic_entry *)
2389                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2390                 if (entry == NULL)
2391                   return FALSE;
2392
2393                 /* We cheat here a little bit: the symbol will not be local, so we
2394                    put it at the end of the dynlocal linked list.  We will fix it
2395                    later on, as we have to fix other fields anyway.  */
2396                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2397                 entry->isym.st_size = 0;
2398                 if (*app_regs [reg].name != '\0')
2399                   entry->isym.st_name
2400                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2401                 else
2402                   entry->isym.st_name = 0;
2403                 entry->isym.st_other = 0;
2404                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2405                                                    STT_REGISTER);
2406                 entry->isym.st_shndx = app_regs [reg].shndx;
2407                 entry->next = NULL;
2408                 entry->input_bfd = output_bfd;
2409                 entry->input_indx = -1;
2410
2411                 if (eht->dynlocal == NULL)
2412                   eht->dynlocal = entry;
2413                 else
2414                   {
2415                     for (e = eht->dynlocal; e->next; e = e->next)
2416                       ;
2417                     e->next = entry;
2418                   }
2419                 eht->dynsymcount++;
2420               }
2421         }
2422       if (htab->is_vxworks
2423           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2424         return FALSE;
2425     }
2426 #undef add_dynamic_entry
2427
2428   return TRUE;
2429 }
2430 \f
2431 bfd_boolean
2432 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2433 {
2434   if (!sec->used_by_bfd)
2435     {
2436       struct _bfd_sparc_elf_section_data *sdata;
2437       bfd_size_type amt = sizeof (*sdata);
2438
2439       sdata = bfd_zalloc (abfd, amt);
2440       if (sdata == NULL)
2441         return FALSE;
2442       sec->used_by_bfd = sdata;
2443     }
2444
2445   return _bfd_elf_new_section_hook (abfd, sec);
2446 }
2447
2448 bfd_boolean
2449 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2450                               struct bfd_section *section,
2451                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2452                               bfd_boolean *again)
2453 {
2454   if (link_info->relocatable)
2455     (*link_info->callbacks->einfo)
2456       (_("%P%F: --relax and -r may not be used together\n"));
2457
2458   *again = FALSE;
2459   sec_do_relax (section) = 1;
2460   return TRUE;
2461 }
2462 \f
2463 /* Return the base VMA address which should be subtracted from real addresses
2464    when resolving @dtpoff relocation.
2465    This is PT_TLS segment p_vaddr.  */
2466
2467 static bfd_vma
2468 dtpoff_base (struct bfd_link_info *info)
2469 {
2470   /* If tls_sec is NULL, we should have signalled an error already.  */
2471   if (elf_hash_table (info)->tls_sec == NULL)
2472     return 0;
2473   return elf_hash_table (info)->tls_sec->vma;
2474 }
2475
2476 /* Return the relocation value for @tpoff relocation
2477    if STT_TLS virtual address is ADDRESS.  */
2478
2479 static bfd_vma
2480 tpoff (struct bfd_link_info *info, bfd_vma address)
2481 {
2482   struct elf_link_hash_table *htab = elf_hash_table (info);
2483
2484   /* If tls_sec is NULL, we should have signalled an error already.  */
2485   if (htab->tls_sec == NULL)
2486     return 0;
2487   return address - htab->tls_size - htab->tls_sec->vma;
2488 }
2489
2490 /* Relocate a SPARC ELF section.  */
2491
2492 bfd_boolean
2493 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2494                                  struct bfd_link_info *info,
2495                                  bfd *input_bfd,
2496                                  asection *input_section,
2497                                  bfd_byte *contents,
2498                                  Elf_Internal_Rela *relocs,
2499                                  Elf_Internal_Sym *local_syms,
2500                                  asection **local_sections)
2501 {
2502   struct _bfd_sparc_elf_link_hash_table *htab;
2503   Elf_Internal_Shdr *symtab_hdr;
2504   struct elf_link_hash_entry **sym_hashes;
2505   bfd_vma *local_got_offsets;
2506   bfd_vma got_base;
2507   asection *sreloc;
2508   Elf_Internal_Rela *rel;
2509   Elf_Internal_Rela *relend;
2510   int num_relocs;
2511   bfd_boolean is_vxworks_tls;
2512
2513   htab = _bfd_sparc_elf_hash_table (info);
2514   symtab_hdr = &elf_symtab_hdr (input_bfd);
2515   sym_hashes = elf_sym_hashes (input_bfd);
2516   local_got_offsets = elf_local_got_offsets (input_bfd);
2517
2518   if (elf_hash_table (info)->hgot == NULL)
2519     got_base = 0;
2520   else
2521     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2522
2523   sreloc = elf_section_data (input_section)->sreloc;
2524   /* We have to handle relocations in vxworks .tls_vars sections
2525      specially, because the dynamic loader is 'weird'.  */
2526   is_vxworks_tls = (htab->is_vxworks && info->shared
2527                     && !strcmp (input_section->output_section->name,
2528                                 ".tls_vars"));
2529
2530   rel = relocs;
2531   if (ABI_64_P (output_bfd))
2532     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2533   else
2534     num_relocs = input_section->reloc_count;
2535   relend = relocs + num_relocs;
2536   for (; rel < relend; rel++)
2537     {
2538       int r_type, tls_type;
2539       reloc_howto_type *howto;
2540       unsigned long r_symndx;
2541       struct elf_link_hash_entry *h;
2542       Elf_Internal_Sym *sym;
2543       asection *sec;
2544       bfd_vma relocation, off;
2545       bfd_reloc_status_type r;
2546       bfd_boolean is_plt = FALSE;
2547       bfd_boolean unresolved_reloc;
2548
2549       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2550       if (r_type == R_SPARC_GNU_VTINHERIT
2551           || r_type == R_SPARC_GNU_VTENTRY)
2552         continue;
2553
2554       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2555         {
2556           bfd_set_error (bfd_error_bad_value);
2557           return FALSE;
2558         }
2559       howto = _bfd_sparc_elf_howto_table + r_type;
2560
2561       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2562       h = NULL;
2563       sym = NULL;
2564       sec = NULL;
2565       unresolved_reloc = FALSE;
2566       if (r_symndx < symtab_hdr->sh_info)
2567         {
2568           sym = local_syms + r_symndx;
2569           sec = local_sections[r_symndx];
2570           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2571         }
2572       else
2573         {
2574           bfd_boolean warned;
2575
2576           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2577                                    r_symndx, symtab_hdr, sym_hashes,
2578                                    h, sec, relocation,
2579                                    unresolved_reloc, warned);
2580           if (warned)
2581             {
2582               /* To avoid generating warning messages about truncated
2583                  relocations, set the relocation's address to be the same as
2584                  the start of this section.  */
2585               if (input_section->output_section != NULL)
2586                 relocation = input_section->output_section->vma;
2587               else
2588                 relocation = 0;
2589             }
2590         }
2591
2592       if (sec != NULL && elf_discarded_section (sec))
2593         {
2594           /* For relocs against symbols from removed linkonce
2595              sections, or sections discarded by a linker script, we
2596              just want the section contents zeroed.  Avoid any
2597              special processing.  */
2598           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2599           rel->r_info = 0;
2600           rel->r_addend = 0;
2601           continue;
2602         }
2603
2604       if (info->relocatable)
2605         continue;
2606
2607       switch (r_type)
2608         {
2609         case R_SPARC_GOTDATA_HIX22:
2610         case R_SPARC_GOTDATA_LOX10:
2611         case R_SPARC_GOTDATA_OP_HIX22:
2612         case R_SPARC_GOTDATA_OP_LOX10:
2613           /* We don't support these code transformation optimizations
2614              yet, so just leave the sequence alone and treat as
2615              GOT22/GOT10.  */
2616           if (r_type == R_SPARC_GOTDATA_HIX22
2617               || r_type == R_SPARC_GOTDATA_OP_HIX22)
2618             r_type = R_SPARC_GOT22;
2619           else
2620             r_type = R_SPARC_GOT10;
2621           /* Fall through. */
2622
2623         case R_SPARC_GOT10:
2624         case R_SPARC_GOT13:
2625         case R_SPARC_GOT22:
2626           /* Relocation is to the entry for this symbol in the global
2627              offset table.  */
2628           if (htab->sgot == NULL)
2629             abort ();
2630
2631           if (h != NULL)
2632             {
2633               bfd_boolean dyn;
2634
2635               off = h->got.offset;
2636               BFD_ASSERT (off != (bfd_vma) -1);
2637               dyn = elf_hash_table (info)->dynamic_sections_created;
2638
2639               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2640                   || (info->shared
2641                       && (info->symbolic
2642                           || h->dynindx == -1
2643                           || h->forced_local)
2644                       && h->def_regular))
2645                 {
2646                   /* This is actually a static link, or it is a
2647                      -Bsymbolic link and the symbol is defined
2648                      locally, or the symbol was forced to be local
2649                      because of a version file.  We must initialize
2650                      this entry in the global offset table.  Since the
2651                      offset must always be a multiple of 8 for 64-bit
2652                      and 4 for 32-bit, we use the least significant bit
2653                      to record whether we have initialized it already.
2654
2655                      When doing a dynamic link, we create a .rela.got
2656                      relocation entry to initialize the value.  This
2657                      is done in the finish_dynamic_symbol routine.  */
2658                   if ((off & 1) != 0)
2659                     off &= ~1;
2660                   else
2661                     {
2662                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2663                                           htab->sgot->contents + off);
2664                       h->got.offset |= 1;
2665                     }
2666                 }
2667               else
2668                 unresolved_reloc = FALSE;
2669             }
2670           else
2671             {
2672               BFD_ASSERT (local_got_offsets != NULL
2673                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2674
2675               off = local_got_offsets[r_symndx];
2676
2677               /* The offset must always be a multiple of 8 on 64-bit and
2678                  4 on 32-bit.  We use the least significant bit to record
2679                  whether we have already processed this entry.  */
2680               if ((off & 1) != 0)
2681                 off &= ~1;
2682               else
2683                 {
2684
2685                   if (info->shared)
2686                     {
2687                       asection *s;
2688                       Elf_Internal_Rela outrel;
2689
2690                       /* We need to generate a R_SPARC_RELATIVE reloc
2691                          for the dynamic linker.  */
2692                       s = htab->srelgot;
2693                       BFD_ASSERT (s != NULL);
2694
2695                       outrel.r_offset = (htab->sgot->output_section->vma
2696                                          + htab->sgot->output_offset
2697                                          + off);
2698                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2699                                                         0, R_SPARC_RELATIVE);
2700                       outrel.r_addend = relocation;
2701                       relocation = 0;
2702                       sparc_elf_append_rela (output_bfd, s, &outrel);
2703                     }
2704
2705                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2706                                       htab->sgot->contents + off);
2707                   local_got_offsets[r_symndx] |= 1;
2708                 }
2709             }
2710           relocation = htab->sgot->output_offset + off - got_base;
2711           break;
2712
2713         case R_SPARC_PLT32:
2714         case R_SPARC_PLT64:
2715           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2716             {
2717               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2718               goto r_sparc_plt32;
2719             }
2720           /* Fall through.  */
2721
2722         case R_SPARC_WPLT30:
2723         case R_SPARC_HIPLT22:
2724         case R_SPARC_LOPLT10:
2725         case R_SPARC_PCPLT32:
2726         case R_SPARC_PCPLT22:
2727         case R_SPARC_PCPLT10:
2728         r_sparc_wplt30:
2729           /* Relocation is to the entry for this symbol in the
2730              procedure linkage table.  */
2731
2732           if (! ABI_64_P (output_bfd))
2733             {
2734               /* The Solaris native assembler will generate a WPLT30 reloc
2735                  for a local symbol if you assemble a call from one
2736                  section to another when using -K pic.  We treat it as
2737                  WDISP30.  */
2738               if (h == NULL)
2739                 break;
2740             }
2741           /* PR 7027: We need similar behaviour for 64-bit binaries.  */
2742           else if (r_type == R_SPARC_WPLT30 && h == NULL)
2743             break;
2744           else
2745             {
2746               BFD_ASSERT (h != NULL);
2747             }
2748
2749           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2750             {
2751               /* We didn't make a PLT entry for this symbol.  This
2752                  happens when statically linking PIC code, or when
2753                  using -Bsymbolic.  */
2754               break;
2755             }
2756
2757           relocation = (htab->splt->output_section->vma
2758                         + htab->splt->output_offset
2759                         + h->plt.offset);
2760           unresolved_reloc = FALSE;
2761           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2762             {
2763               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2764               is_plt = TRUE;
2765               goto r_sparc_plt32;
2766             }
2767           break;
2768
2769         case R_SPARC_PC10:
2770         case R_SPARC_PC22:
2771         case R_SPARC_PC_HH22:
2772         case R_SPARC_PC_HM10:
2773         case R_SPARC_PC_LM22:
2774           if (h != NULL
2775               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2776             break;
2777           /* Fall through.  */
2778         case R_SPARC_DISP8:
2779         case R_SPARC_DISP16:
2780         case R_SPARC_DISP32:
2781         case R_SPARC_DISP64:
2782         case R_SPARC_WDISP30:
2783         case R_SPARC_WDISP22:
2784         case R_SPARC_WDISP19:
2785         case R_SPARC_WDISP16:
2786         case R_SPARC_8:
2787         case R_SPARC_16:
2788         case R_SPARC_32:
2789         case R_SPARC_HI22:
2790         case R_SPARC_22:
2791         case R_SPARC_13:
2792         case R_SPARC_LO10:
2793         case R_SPARC_UA16:
2794         case R_SPARC_UA32:
2795         case R_SPARC_10:
2796         case R_SPARC_11:
2797         case R_SPARC_64:
2798         case R_SPARC_OLO10:
2799         case R_SPARC_HH22:
2800         case R_SPARC_HM10:
2801         case R_SPARC_LM22:
2802         case R_SPARC_7:
2803         case R_SPARC_5:
2804         case R_SPARC_6:
2805         case R_SPARC_HIX22:
2806         case R_SPARC_LOX10:
2807         case R_SPARC_H44:
2808         case R_SPARC_M44:
2809         case R_SPARC_L44:
2810         case R_SPARC_UA64:
2811         r_sparc_plt32:
2812           if ((input_section->flags & SEC_ALLOC) == 0
2813               || is_vxworks_tls)
2814             break;
2815
2816           if ((info->shared
2817                && (h == NULL
2818                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2819                    || h->root.type != bfd_link_hash_undefweak)
2820                && (! howto->pc_relative
2821                    || (h != NULL
2822                        && h->dynindx != -1
2823                        && (! info->symbolic
2824                            || !h->def_regular))))
2825               || (!info->shared
2826                   && h != NULL
2827                   && h->dynindx != -1
2828                   && !h->non_got_ref
2829                   && ((h->def_dynamic
2830                        && !h->def_regular)
2831                       || h->root.type == bfd_link_hash_undefweak
2832                       || h->root.type == bfd_link_hash_undefined)))
2833             {
2834               Elf_Internal_Rela outrel;
2835               bfd_boolean skip, relocate = FALSE;
2836
2837               /* When generating a shared object, these relocations
2838                  are copied into the output file to be resolved at run
2839                  time.  */
2840
2841               BFD_ASSERT (sreloc != NULL);
2842
2843               skip = FALSE;
2844
2845               outrel.r_offset =
2846                 _bfd_elf_section_offset (output_bfd, info, input_section,
2847                                          rel->r_offset);
2848               if (outrel.r_offset == (bfd_vma) -1)
2849                 skip = TRUE;
2850               else if (outrel.r_offset == (bfd_vma) -2)
2851                 skip = TRUE, relocate = TRUE;
2852               outrel.r_offset += (input_section->output_section->vma
2853                                   + input_section->output_offset);
2854
2855               /* Optimize unaligned reloc usage now that we know where
2856                  it finally resides.  */
2857               switch (r_type)
2858                 {
2859                 case R_SPARC_16:
2860                   if (outrel.r_offset & 1)
2861                     r_type = R_SPARC_UA16;
2862                   break;
2863                 case R_SPARC_UA16:
2864                   if (!(outrel.r_offset & 1))
2865                     r_type = R_SPARC_16;
2866                   break;
2867                 case R_SPARC_32:
2868                   if (outrel.r_offset & 3)
2869                     r_type = R_SPARC_UA32;
2870                   break;
2871                 case R_SPARC_UA32:
2872                   if (!(outrel.r_offset & 3))
2873                     r_type = R_SPARC_32;
2874                   break;
2875                 case R_SPARC_64:
2876                   if (outrel.r_offset & 7)
2877                     r_type = R_SPARC_UA64;
2878                   break;
2879                 case R_SPARC_UA64:
2880                   if (!(outrel.r_offset & 7))
2881                     r_type = R_SPARC_64;
2882                   break;
2883                 case R_SPARC_DISP8:
2884                 case R_SPARC_DISP16:
2885                 case R_SPARC_DISP32:
2886                 case R_SPARC_DISP64:
2887                   /* If the symbol is not dynamic, we should not keep
2888                      a dynamic relocation.  But an .rela.* slot has been
2889                      allocated for it, output R_SPARC_NONE.
2890                      FIXME: Add code tracking needed dynamic relocs as
2891                      e.g. i386 has.  */
2892                   if (h->dynindx == -1)
2893                     skip = TRUE, relocate = TRUE;
2894                   break;
2895                 }
2896
2897               if (skip)
2898                 memset (&outrel, 0, sizeof outrel);
2899               /* h->dynindx may be -1 if the symbol was marked to
2900                  become local.  */
2901               else if (h != NULL && ! is_plt
2902                        && ((! info->symbolic && h->dynindx != -1)
2903                            || !h->def_regular))
2904                 {
2905                   BFD_ASSERT (h->dynindx != -1);
2906                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2907                   outrel.r_addend = rel->r_addend;
2908                 }
2909               else
2910                 {
2911                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2912                     {
2913                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2914                                                         0, R_SPARC_RELATIVE);
2915                       outrel.r_addend = relocation + rel->r_addend;
2916                     }
2917                   else
2918                     {
2919                       long indx;
2920
2921                       outrel.r_addend = relocation + rel->r_addend;
2922
2923                       if (is_plt)
2924                         sec = htab->splt;
2925
2926                       if (bfd_is_abs_section (sec))
2927                         indx = 0;
2928                       else if (sec == NULL || sec->owner == NULL)
2929                         {
2930                           bfd_set_error (bfd_error_bad_value);
2931                           return FALSE;
2932                         }
2933                       else
2934                         {
2935                           asection *osec;
2936
2937                           /* We are turning this relocation into one
2938                              against a section symbol.  It would be
2939                              proper to subtract the symbol's value,
2940                              osec->vma, from the emitted reloc addend,
2941                              but ld.so expects buggy relocs.  */
2942                           osec = sec->output_section;
2943                           indx = elf_section_data (osec)->dynindx;
2944
2945                           if (indx == 0)
2946                             {
2947                               osec = htab->elf.text_index_section;
2948                               indx = elf_section_data (osec)->dynindx;
2949                             }
2950
2951                           /* FIXME: we really should be able to link non-pic
2952                              shared libraries.  */
2953                           if (indx == 0)
2954                             {
2955                               BFD_FAIL ();
2956                               (*_bfd_error_handler)
2957                                 (_("%B: probably compiled without -fPIC?"),
2958                                  input_bfd);
2959                               bfd_set_error (bfd_error_bad_value);
2960                               return FALSE;
2961                             }
2962                         }
2963
2964                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
2965                                                         r_type);
2966                     }
2967                 }
2968
2969               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
2970
2971               /* This reloc will be computed at runtime, so there's no
2972                  need to do anything now.  */
2973               if (! relocate)
2974                 continue;
2975             }
2976           break;
2977
2978         case R_SPARC_TLS_GD_HI22:
2979           if (! ABI_64_P (input_bfd)
2980               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2981             {
2982               /* R_SPARC_REV32 used the same reloc number as
2983                  R_SPARC_TLS_GD_HI22.  */
2984               r_type = R_SPARC_REV32;
2985               break;
2986             }
2987           /* Fall through */
2988
2989         case R_SPARC_TLS_GD_LO10:
2990         case R_SPARC_TLS_IE_HI22:
2991         case R_SPARC_TLS_IE_LO10:
2992           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2993           tls_type = GOT_UNKNOWN;
2994           if (h == NULL && local_got_offsets)
2995             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2996           else if (h != NULL)
2997             {
2998               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2999               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3000                 switch (SPARC_ELF_R_TYPE (rel->r_info))
3001                   {
3002                   case R_SPARC_TLS_GD_HI22:
3003                   case R_SPARC_TLS_IE_HI22:
3004                     r_type = R_SPARC_TLS_LE_HIX22;
3005                     break;
3006                   default:
3007                     r_type = R_SPARC_TLS_LE_LOX10;
3008                     break;
3009                   }
3010             }
3011           if (tls_type == GOT_TLS_IE)
3012             switch (r_type)
3013               {
3014               case R_SPARC_TLS_GD_HI22:
3015                 r_type = R_SPARC_TLS_IE_HI22;
3016                 break;
3017               case R_SPARC_TLS_GD_LO10:
3018                 r_type = R_SPARC_TLS_IE_LO10;
3019                 break;
3020               }
3021
3022           if (r_type == R_SPARC_TLS_LE_HIX22)
3023             {
3024               relocation = tpoff (info, relocation);
3025               break;
3026             }
3027           if (r_type == R_SPARC_TLS_LE_LOX10)
3028             {
3029               /* Change add into xor.  */
3030               relocation = tpoff (info, relocation);
3031               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3032                                                    contents + rel->r_offset)
3033                                        | 0x80182000), contents + rel->r_offset);
3034               break;
3035             }
3036
3037           if (h != NULL)
3038             {
3039               off = h->got.offset;
3040               h->got.offset |= 1;
3041             }
3042           else
3043             {
3044               BFD_ASSERT (local_got_offsets != NULL);
3045               off = local_got_offsets[r_symndx];
3046               local_got_offsets[r_symndx] |= 1;
3047             }
3048
3049         r_sparc_tlsldm:
3050           if (htab->sgot == NULL)
3051             abort ();
3052
3053           if ((off & 1) != 0)
3054             off &= ~1;
3055           else
3056             {
3057               Elf_Internal_Rela outrel;
3058               int dr_type, indx;
3059
3060               if (htab->srelgot == NULL)
3061                 abort ();
3062
3063               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3064               outrel.r_offset = (htab->sgot->output_section->vma
3065                                  + htab->sgot->output_offset + off);
3066               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3067               if (r_type == R_SPARC_TLS_IE_HI22
3068                   || r_type == R_SPARC_TLS_IE_LO10)
3069                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3070               else
3071                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3072               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3073                 outrel.r_addend = relocation - dtpoff_base (info);
3074               else
3075                 outrel.r_addend = 0;
3076               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3077               sparc_elf_append_rela (output_bfd, htab->srelgot, &outrel);
3078
3079               if (r_type == R_SPARC_TLS_GD_HI22
3080                   || r_type == R_SPARC_TLS_GD_LO10)
3081                 {
3082                   if (indx == 0)
3083                     {
3084                       BFD_ASSERT (! unresolved_reloc);
3085                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3086                                           relocation - dtpoff_base (info),
3087                                           (htab->sgot->contents + off
3088                                            + SPARC_ELF_WORD_BYTES (htab)));
3089                     }
3090                   else
3091                     {
3092                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3093                                           (htab->sgot->contents + off
3094                                            + SPARC_ELF_WORD_BYTES (htab)));
3095                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3096                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3097                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3098                       sparc_elf_append_rela (output_bfd, htab->srelgot,
3099                                              &outrel);
3100                     }
3101                 }
3102               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3103                 {
3104                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3105                                       (htab->sgot->contents + off
3106                                        + SPARC_ELF_WORD_BYTES (htab)));
3107                 }
3108             }
3109
3110           if (off >= (bfd_vma) -2)
3111             abort ();
3112
3113           relocation = htab->sgot->output_offset + off - got_base;
3114           unresolved_reloc = FALSE;
3115           howto = _bfd_sparc_elf_howto_table + r_type;
3116           break;
3117
3118         case R_SPARC_TLS_LDM_HI22:
3119         case R_SPARC_TLS_LDM_LO10:
3120           if (! info->shared)
3121             {
3122               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3123               continue;
3124             }
3125           off = htab->tls_ldm_got.offset;
3126           htab->tls_ldm_got.offset |= 1;
3127           goto r_sparc_tlsldm;
3128
3129         case R_SPARC_TLS_LDO_HIX22:
3130         case R_SPARC_TLS_LDO_LOX10:
3131           if (info->shared)
3132             {
3133               relocation -= dtpoff_base (info);
3134               break;
3135             }
3136
3137           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3138                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3139           /* Fall through.  */
3140
3141         case R_SPARC_TLS_LE_HIX22:
3142         case R_SPARC_TLS_LE_LOX10:
3143           if (info->shared)
3144             {
3145               Elf_Internal_Rela outrel;
3146               bfd_boolean skip, relocate = FALSE;
3147
3148               BFD_ASSERT (sreloc != NULL);
3149               skip = FALSE;
3150               outrel.r_offset =
3151                 _bfd_elf_section_offset (output_bfd, info, input_section,
3152                                          rel->r_offset);
3153               if (outrel.r_offset == (bfd_vma) -1)
3154                 skip = TRUE;
3155               else if (outrel.r_offset == (bfd_vma) -2)
3156                 skip = TRUE, relocate = TRUE;
3157               outrel.r_offset += (input_section->output_section->vma
3158                                   + input_section->output_offset);
3159               if (skip)
3160                 memset (&outrel, 0, sizeof outrel);
3161               else
3162                 {
3163                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3164                   outrel.r_addend = relocation - dtpoff_base (info)
3165                                     + rel->r_addend;
3166                 }
3167
3168               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3169               continue;
3170             }
3171           relocation = tpoff (info, relocation);
3172           break;
3173
3174         case R_SPARC_TLS_LDM_CALL:
3175           if (! info->shared)
3176             {
3177               /* mov %g0, %o0 */
3178               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3179               continue;
3180             }
3181           /* Fall through */
3182
3183         case R_SPARC_TLS_GD_CALL:
3184           tls_type = GOT_UNKNOWN;
3185           if (h == NULL && local_got_offsets)
3186             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3187           else if (h != NULL)
3188             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3189           if (! info->shared
3190               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3191             {
3192               bfd_vma insn;
3193
3194               if (!info->shared && (h == NULL || h->dynindx == -1))
3195                 {
3196                   /* GD -> LE */
3197                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3198                   continue;
3199                 }
3200
3201               /* GD -> IE */
3202               if (rel + 1 < relend
3203                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3204                   && rel[1].r_offset == rel->r_offset + 4
3205                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3206                   && (((insn = bfd_get_32 (input_bfd,
3207                                            contents + rel[1].r_offset))
3208                        >> 25) & 0x1f) == 8)
3209                 {
3210                   /* We have
3211                      call __tls_get_addr, %tgd_call(foo)
3212                       add %reg1, %reg2, %o0, %tgd_add(foo)
3213                      and change it into IE:
3214                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3215                      add %g7, %o0, %o0, %tie_add(foo).
3216                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3217                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3218                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3219                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3220                               contents + rel->r_offset);
3221                   bfd_put_32 (output_bfd, 0x9001c008,
3222                               contents + rel->r_offset + 4);
3223                   rel++;
3224                   continue;
3225                 }
3226
3227               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3228               continue;
3229             }
3230
3231           h = (struct elf_link_hash_entry *)
3232               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3233                                     FALSE, TRUE);
3234           BFD_ASSERT (h != NULL);
3235           r_type = R_SPARC_WPLT30;
3236           howto = _bfd_sparc_elf_howto_table + r_type;
3237           goto r_sparc_wplt30;
3238
3239         case R_SPARC_TLS_GD_ADD:
3240           tls_type = GOT_UNKNOWN;
3241           if (h == NULL && local_got_offsets)
3242             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3243           else if (h != NULL)
3244             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3245           if (! info->shared || tls_type == GOT_TLS_IE)
3246             {
3247               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3248                  changed into IE:
3249                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3250                  or LE:
3251                  add %g7, %reg2, %reg3.  */
3252               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3253               if ((h != NULL && h->dynindx != -1) || info->shared)
3254                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3255               else
3256                 relocation = (insn & ~0x7c000) | 0x1c000;
3257               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3258             }
3259           continue;
3260
3261         case R_SPARC_TLS_LDM_ADD:
3262           if (! info->shared)
3263             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3264           continue;
3265
3266         case R_SPARC_TLS_LDO_ADD:
3267           if (! info->shared)
3268             {
3269               /* Change rs1 into %g7.  */
3270               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3271               insn = (insn & ~0x7c000) | 0x1c000;
3272               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3273             }
3274           continue;
3275
3276         case R_SPARC_GOTDATA_OP:
3277           /* We don't support gotdata code transformation optimizations
3278              yet, so simply leave the sequence as-is.  */
3279           continue;
3280
3281         case R_SPARC_TLS_IE_LD:
3282         case R_SPARC_TLS_IE_LDX:
3283           if (! info->shared && (h == NULL || h->dynindx == -1))
3284             {
3285               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3286               int rs2 = insn & 0x1f;
3287               int rd = (insn >> 25) & 0x1f;
3288
3289               if (rs2 == rd)
3290                 relocation = SPARC_NOP;
3291               else
3292                 relocation = 0x80100000 | (insn & 0x3e00001f);
3293               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3294             }
3295           continue;
3296
3297         case R_SPARC_TLS_IE_ADD:
3298           /* Totally useless relocation.  */
3299           continue;
3300
3301         case R_SPARC_TLS_DTPOFF32:
3302         case R_SPARC_TLS_DTPOFF64:
3303           relocation -= dtpoff_base (info);
3304           break;
3305
3306         default:
3307           break;
3308         }
3309
3310       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3311          because such sections are not SEC_ALLOC and thus ld.so will
3312          not process them.  */
3313       if (unresolved_reloc
3314           && !((input_section->flags & SEC_DEBUGGING) != 0
3315                && h->def_dynamic))
3316         (*_bfd_error_handler)
3317           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3318            input_bfd,
3319            input_section,
3320            (long) rel->r_offset,
3321            howto->name,
3322            h->root.root.string);
3323
3324       r = bfd_reloc_continue;
3325       if (r_type == R_SPARC_OLO10)
3326         {
3327             bfd_vma x;
3328
3329             if (! ABI_64_P (output_bfd))
3330               abort ();
3331
3332             relocation += rel->r_addend;
3333             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3334
3335             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3336             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3337             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3338
3339             r = bfd_check_overflow (howto->complain_on_overflow,
3340                                     howto->bitsize, howto->rightshift,
3341                                     bfd_arch_bits_per_address (input_bfd),
3342                                     relocation);
3343         }
3344       else if (r_type == R_SPARC_WDISP16)
3345         {
3346           bfd_vma x;
3347
3348           relocation += rel->r_addend;
3349           relocation -= (input_section->output_section->vma
3350                          + input_section->output_offset);
3351           relocation -= rel->r_offset;
3352
3353           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3354           x |= ((((relocation >> 2) & 0xc000) << 6)
3355                 | ((relocation >> 2) & 0x3fff));
3356           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3357
3358           r = bfd_check_overflow (howto->complain_on_overflow,
3359                                   howto->bitsize, howto->rightshift,
3360                                   bfd_arch_bits_per_address (input_bfd),
3361                                   relocation);
3362         }
3363       else if (r_type == R_SPARC_REV32)
3364         {
3365           bfd_vma x;
3366
3367           relocation = relocation + rel->r_addend;
3368
3369           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3370           x = x + relocation;
3371           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3372           r = bfd_reloc_ok;
3373         }
3374       else if (r_type == R_SPARC_TLS_LDO_HIX22
3375                || r_type == R_SPARC_TLS_LE_HIX22)
3376         {
3377           bfd_vma x;
3378
3379           relocation += rel->r_addend;
3380           if (r_type == R_SPARC_TLS_LE_HIX22)
3381             relocation ^= MINUS_ONE;
3382
3383           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3384           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3385           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3386           r = bfd_reloc_ok;
3387         }
3388       else if (r_type == R_SPARC_TLS_LDO_LOX10
3389                || r_type == R_SPARC_TLS_LE_LOX10)
3390         {
3391           bfd_vma x;
3392
3393           relocation += rel->r_addend;
3394           relocation &= 0x3ff;
3395           if (r_type == R_SPARC_TLS_LE_LOX10)
3396             relocation |= 0x1c00;
3397
3398           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3399           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3400           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3401
3402           r = bfd_reloc_ok;
3403         }
3404       else if (r_type == R_SPARC_HIX22)
3405         {
3406           bfd_vma x;
3407
3408           relocation += rel->r_addend;
3409           relocation = relocation ^ MINUS_ONE;
3410
3411           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3412           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3413           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3414
3415           r = bfd_check_overflow (howto->complain_on_overflow,
3416                                   howto->bitsize, howto->rightshift,
3417                                   bfd_arch_bits_per_address (input_bfd),
3418                                   relocation);
3419         }
3420       else if (r_type == R_SPARC_LOX10)
3421         {
3422           bfd_vma x;
3423
3424           relocation += rel->r_addend;
3425           relocation = (relocation & 0x3ff) | 0x1c00;
3426
3427           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3428           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3429           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3430
3431           r = bfd_reloc_ok;
3432         }
3433       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3434                && sec_do_relax (input_section)
3435                && rel->r_offset + 4 < input_section->size)
3436         {
3437 #define G0              0
3438 #define O7              15
3439 #define XCC             (2 << 20)
3440 #define COND(x)         (((x)&0xf)<<25)
3441 #define CONDA           COND(0x8)
3442 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3443 #define INSN_BA         (F2(0,2) | CONDA)
3444 #define INSN_OR         F3(2, 0x2, 0)
3445 #define INSN_NOP        F2(0,4)
3446
3447           bfd_vma x, y;
3448
3449           /* If the instruction is a call with either:
3450              restore
3451              arithmetic instruction with rd == %o7
3452              where rs1 != %o7 and rs2 if it is register != %o7
3453              then we can optimize if the call destination is near
3454              by changing the call into a branch always.  */
3455           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3456           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3457           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3458             {
3459               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3460                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3461                        && (y & RD(~0)) == RD(O7)))
3462                   && (y & RS1(~0)) != RS1(O7)
3463                   && ((y & F3I(~0))
3464                       || (y & RS2(~0)) != RS2(O7)))
3465                 {
3466                   bfd_vma reloc;
3467
3468                   reloc = relocation + rel->r_addend - rel->r_offset;
3469                   reloc -= (input_section->output_section->vma
3470                             + input_section->output_offset);
3471
3472                   /* Ensure the branch fits into simm22.  */
3473                   if ((reloc & 3) == 0
3474                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3475                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3476                     {
3477                       reloc >>= 2;
3478
3479                       /* Check whether it fits into simm19.  */
3480                       if (((reloc & 0x3c0000) == 0
3481                            || (reloc & 0x3c0000) == 0x3c0000)
3482                           && (ABI_64_P (output_bfd)
3483                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3484                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3485                       else
3486                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3487                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3488                       r = bfd_reloc_ok;
3489                       if (rel->r_offset >= 4
3490                           && (y & (0xffffffff ^ RS1(~0)))
3491                              == (INSN_OR | RD(O7) | RS2(G0)))
3492                         {
3493                           bfd_vma z;
3494                           unsigned int reg;
3495
3496                           z = bfd_get_32 (input_bfd,
3497                                           contents + rel->r_offset - 4);
3498                           if ((z & (0xffffffff ^ RD(~0)))
3499                               != (INSN_OR | RS1(O7) | RS2(G0)))
3500                             break;
3501
3502                           /* The sequence was
3503                              or %o7, %g0, %rN
3504                              call foo
3505                              or %rN, %g0, %o7
3506
3507                              If call foo was replaced with ba, replace
3508                              or %rN, %g0, %o7 with nop.  */
3509
3510                           reg = (y & RS1(~0)) >> 14;
3511                           if (reg != ((z & RD(~0)) >> 25)
3512                               || reg == G0 || reg == O7)
3513                             break;
3514
3515                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3516                                       contents + rel->r_offset + 4);
3517                         }
3518
3519                     }
3520                 }
3521             }
3522         }
3523
3524       if (r == bfd_reloc_continue)
3525         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3526                                       contents, rel->r_offset,
3527                                       relocation, rel->r_addend);
3528
3529       if (r != bfd_reloc_ok)
3530         {
3531           switch (r)
3532             {
3533             default:
3534             case bfd_reloc_outofrange:
3535               abort ();
3536             case bfd_reloc_overflow:
3537               {
3538                 const char *name;
3539
3540                 /* The Solaris native linker silently disregards overflows.
3541                    We don't, but this breaks stabs debugging info, whose
3542                    relocations are only 32-bits wide.  Ignore overflows in
3543                    this case and also for discarded entries.  */
3544                 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3545                     && (((input_section->flags & SEC_DEBUGGING) != 0
3546                          && strcmp (bfd_section_name (input_bfd,
3547                                                       input_section),
3548                                     ".stab") == 0)
3549                         || _bfd_elf_section_offset (output_bfd, info,
3550                                                     input_section,
3551                                                     rel->r_offset)
3552                              == (bfd_vma)-1))
3553                   break;
3554
3555                 if (h != NULL)
3556                   {
3557                     /* Assume this is a call protected by other code that
3558                        detect the symbol is undefined.  If this is the case,
3559                        we can safely ignore the overflow.  If not, the
3560                        program is hosed anyway, and a little warning isn't
3561                        going to help.  */
3562                     if (h->root.type == bfd_link_hash_undefweak
3563                         && howto->pc_relative)
3564                       break;
3565
3566                     name = NULL;
3567                   }
3568                 else
3569                   {
3570                     name = bfd_elf_string_from_elf_section (input_bfd,
3571                                                             symtab_hdr->sh_link,
3572                                                             sym->st_name);
3573                     if (name == NULL)
3574                       return FALSE;
3575                     if (*name == '\0')
3576                       name = bfd_section_name (input_bfd, sec);
3577                   }
3578                 if (! ((*info->callbacks->reloc_overflow)
3579                        (info, (h ? &h->root : NULL), name, howto->name,
3580                         (bfd_vma) 0, input_bfd, input_section,
3581                         rel->r_offset)))
3582                   return FALSE;
3583               }
3584               break;
3585             }
3586         }
3587     }
3588
3589   return TRUE;
3590 }
3591
3592 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
3593    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
3594    is the offset of the associated .got.plt entry from
3595    _GLOBAL_OFFSET_TABLE_.  */
3596
3597 static void
3598 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3599                                bfd_vma plt_offset, bfd_vma plt_index,
3600                                bfd_vma got_offset)
3601 {
3602   bfd_vma got_base;
3603   const bfd_vma *plt_entry;
3604   struct _bfd_sparc_elf_link_hash_table *htab;
3605   bfd_byte *loc;
3606   Elf_Internal_Rela rela;
3607
3608   htab = _bfd_sparc_elf_hash_table (info);
3609   if (info->shared)
3610     {
3611       plt_entry = sparc_vxworks_shared_plt_entry;
3612       got_base = 0;
3613     }
3614   else
3615     {
3616       plt_entry = sparc_vxworks_exec_plt_entry;
3617       got_base = (htab->elf.hgot->root.u.def.value
3618                   + htab->elf.hgot->root.u.def.section->output_offset
3619                   + htab->elf.hgot->root.u.def.section->output_section->vma);
3620     }
3621
3622   /* Fill in the entry in the procedure linkage table.  */
3623   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3624               htab->splt->contents + plt_offset);
3625   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3626               htab->splt->contents + plt_offset + 4);
3627   bfd_put_32 (output_bfd, plt_entry[2],
3628               htab->splt->contents + plt_offset + 8);
3629   bfd_put_32 (output_bfd, plt_entry[3],
3630               htab->splt->contents + plt_offset + 12);
3631   bfd_put_32 (output_bfd, plt_entry[4],
3632               htab->splt->contents + plt_offset + 16);
3633   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3634               htab->splt->contents + plt_offset + 20);
3635   /* PC-relative displacement for a branch to the start of
3636      the PLT section.  */
3637   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3638                                           & 0x003fffff),
3639               htab->splt->contents + plt_offset + 24);
3640   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3641               htab->splt->contents + plt_offset + 28);
3642
3643   /* Fill in the .got.plt entry, pointing initially at the
3644      second half of the PLT entry.  */
3645   BFD_ASSERT (htab->sgotplt != NULL);
3646   bfd_put_32 (output_bfd,
3647               htab->splt->output_section->vma
3648               + htab->splt->output_offset
3649               + plt_offset + 20,
3650               htab->sgotplt->contents + got_offset);
3651
3652   /* Add relocations to .rela.plt.unloaded.  */
3653   if (!info->shared)
3654     {
3655       loc = (htab->srelplt2->contents
3656              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3657
3658       /* Relocate the initial sethi.  */
3659       rela.r_offset = (htab->splt->output_section->vma
3660                        + htab->splt->output_offset
3661                        + plt_offset);
3662       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3663       rela.r_addend = got_offset;
3664       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3665       loc += sizeof (Elf32_External_Rela);
3666
3667       /* Likewise the following or.  */
3668       rela.r_offset += 4;
3669       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3670       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3671       loc += sizeof (Elf32_External_Rela);
3672
3673       /* Relocate the .got.plt entry.  */
3674       rela.r_offset = (htab->sgotplt->output_section->vma
3675                        + htab->sgotplt->output_offset
3676                        + got_offset);
3677       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3678       rela.r_addend = plt_offset + 20;
3679       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3680     }
3681 }
3682
3683 /* Finish up dynamic symbol handling.  We set the contents of various
3684    dynamic sections here.  */
3685
3686 bfd_boolean
3687 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3688                                       struct bfd_link_info *info,
3689                                       struct elf_link_hash_entry *h,
3690                                       Elf_Internal_Sym *sym)
3691 {
3692   bfd *dynobj;
3693   struct _bfd_sparc_elf_link_hash_table *htab;
3694   const struct elf_backend_data *bed;
3695
3696   htab = _bfd_sparc_elf_hash_table (info);
3697   dynobj = htab->elf.dynobj;
3698   bed = get_elf_backend_data (output_bfd);
3699
3700   if (h->plt.offset != (bfd_vma) -1)
3701     {
3702       asection *splt;
3703       asection *srela;
3704       Elf_Internal_Rela rela;
3705       bfd_byte *loc;
3706       bfd_vma r_offset, got_offset;
3707       int rela_index;
3708
3709       /* This symbol has an entry in the PLT.  Set it up.  */
3710
3711       BFD_ASSERT (h->dynindx != -1);
3712
3713       splt = htab->splt;
3714       srela = htab->srelplt;
3715       BFD_ASSERT (splt != NULL && srela != NULL);
3716
3717       /* Fill in the entry in the .rela.plt section.  */
3718       if (htab->is_vxworks)
3719         {
3720           /* Work out the index of this PLT entry.  */
3721           rela_index = ((h->plt.offset - htab->plt_header_size)
3722                         / htab->plt_entry_size);
3723
3724           /* Calculate the offset of the associated .got.plt entry.
3725              The first three entries are reserved.  */
3726           got_offset = (rela_index + 3) * 4;
3727
3728           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3729                                          rela_index, got_offset);
3730
3731
3732           /* On VxWorks, the relocation points to the .got.plt entry,
3733              not the .plt entry.  */
3734           rela.r_offset = (htab->sgotplt->output_section->vma
3735                            + htab->sgotplt->output_offset
3736                            + got_offset);
3737           rela.r_addend = 0;
3738         }
3739       else
3740         {
3741           /* Fill in the entry in the procedure linkage table.  */
3742           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3743                                                   h->plt.offset, splt->size,
3744                                                   &r_offset);
3745
3746           rela.r_offset = r_offset
3747             + (splt->output_section->vma + splt->output_offset);
3748           if (! ABI_64_P (output_bfd)
3749               || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3750             {
3751               rela.r_addend = 0;
3752             }
3753           else
3754             {
3755               rela.r_addend = (-(h->plt.offset + 4)
3756                                - splt->output_section->vma
3757                                - splt->output_offset);
3758             }
3759         }
3760       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3761
3762       /* Adjust for the first 4 reserved elements in the .plt section
3763          when setting the offset in the .rela.plt section.
3764          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3765          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3766
3767       loc = srela->contents;
3768       loc += rela_index * bed->s->sizeof_rela;
3769       bed->s->swap_reloca_out (output_bfd, &rela, loc);
3770
3771       if (!h->def_regular)
3772         {
3773           /* Mark the symbol as undefined, rather than as defined in
3774              the .plt section.  Leave the value alone.  */
3775           sym->st_shndx = SHN_UNDEF;
3776           /* If the symbol is weak, we do need to clear the value.
3777              Otherwise, the PLT entry would provide a definition for
3778              the symbol even if the symbol wasn't defined anywhere,
3779              and so the symbol would never be NULL.  */
3780           if (!h->ref_regular_nonweak)
3781             sym->st_value = 0;
3782         }
3783     }
3784
3785   if (h->got.offset != (bfd_vma) -1
3786       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3787       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3788     {
3789       asection *sgot;
3790       asection *srela;
3791       Elf_Internal_Rela rela;
3792
3793       /* This symbol has an entry in the GOT.  Set it up.  */
3794
3795       sgot = htab->sgot;
3796       srela = htab->srelgot;
3797       BFD_ASSERT (sgot != NULL && srela != NULL);
3798
3799       rela.r_offset = (sgot->output_section->vma
3800                        + sgot->output_offset
3801                        + (h->got.offset &~ (bfd_vma) 1));
3802
3803       /* If this is a -Bsymbolic link, and the symbol is defined
3804          locally, we just want to emit a RELATIVE reloc.  Likewise if
3805          the symbol was forced to be local because of a version file.
3806          The entry in the global offset table will already have been
3807          initialized in the relocate_section function.  */
3808       if (info->shared
3809           && (info->symbolic || h->dynindx == -1)
3810           && h->def_regular)
3811         {
3812           asection *sec = h->root.u.def.section;
3813           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3814           rela.r_addend = (h->root.u.def.value
3815                            + sec->output_section->vma
3816                            + sec->output_offset);
3817         }
3818       else
3819         {
3820           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3821           rela.r_addend = 0;
3822         }
3823
3824       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3825                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3826       sparc_elf_append_rela (output_bfd, srela, &rela);
3827     }
3828
3829   if (h->needs_copy)
3830     {
3831       asection *s;
3832       Elf_Internal_Rela rela;
3833
3834       /* This symbols needs a copy reloc.  Set it up.  */
3835       BFD_ASSERT (h->dynindx != -1);
3836
3837       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3838                                    ".rela.bss");
3839       BFD_ASSERT (s != NULL);
3840
3841       rela.r_offset = (h->root.u.def.value
3842                        + h->root.u.def.section->output_section->vma
3843                        + h->root.u.def.section->output_offset);
3844       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3845       rela.r_addend = 0;
3846       sparc_elf_append_rela (output_bfd, s, &rela);
3847     }
3848
3849   /* Mark some specially defined symbols as absolute.  On VxWorks,
3850      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3851      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
3852   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3853       || (!htab->is_vxworks
3854           && (h == htab->elf.hgot || h == htab->elf.hplt)))
3855     sym->st_shndx = SHN_ABS;
3856
3857   return TRUE;
3858 }
3859
3860 /* Finish up the dynamic sections.  */
3861
3862 static bfd_boolean
3863 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3864                   bfd *dynobj, asection *sdyn,
3865                   asection *splt ATTRIBUTE_UNUSED)
3866 {
3867   struct _bfd_sparc_elf_link_hash_table *htab;
3868   const struct elf_backend_data *bed;
3869   bfd_byte *dyncon, *dynconend;
3870   size_t dynsize;
3871   int stt_regidx = -1;
3872   bfd_boolean abi_64_p;
3873
3874   htab = _bfd_sparc_elf_hash_table (info);
3875   bed = get_elf_backend_data (output_bfd);
3876   dynsize = bed->s->sizeof_dyn;
3877   dynconend = sdyn->contents + sdyn->size;
3878   abi_64_p = ABI_64_P (output_bfd);
3879   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
3880     {
3881       Elf_Internal_Dyn dyn;
3882       const char *name;
3883       bfd_boolean size;
3884
3885       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
3886
3887       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3888         {
3889           /* On VxWorks, DT_RELASZ should not include the relocations
3890              in .rela.plt.  */
3891           if (htab->srelplt)
3892             {
3893               dyn.d_un.d_val -= htab->srelplt->size;
3894               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3895             }
3896         }
3897       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3898         {
3899           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3900              not to the start of the PLT.  */
3901           if (htab->sgotplt)
3902             {
3903               dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3904                                 + htab->sgotplt->output_offset);
3905               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3906             }
3907         }
3908       else if (htab->is_vxworks
3909                && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
3910         bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3911       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
3912         {
3913           if (stt_regidx == -1)
3914             {
3915               stt_regidx =
3916                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3917               if (stt_regidx == -1)
3918                 return FALSE;
3919             }
3920           dyn.d_un.d_val = stt_regidx++;
3921           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3922         }
3923       else
3924         {
3925           switch (dyn.d_tag)
3926             {
3927             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3928             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3929             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3930             default:          name = NULL; size = FALSE; break;
3931             }
3932
3933           if (name != NULL)
3934             {
3935               asection *s;
3936
3937               s = bfd_get_section_by_name (output_bfd, name);
3938               if (s == NULL)
3939                 dyn.d_un.d_val = 0;
3940               else
3941                 {
3942                   if (! size)
3943                     dyn.d_un.d_ptr = s->vma;
3944                   else
3945                     dyn.d_un.d_val = s->size;
3946                 }
3947               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3948             }
3949         }
3950     }
3951   return TRUE;
3952 }
3953
3954 /* Install the first PLT entry in a VxWorks executable and make sure that
3955    .rela.plt.unloaded relocations have the correct symbol indexes.  */
3956
3957 static void
3958 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3959 {
3960   struct _bfd_sparc_elf_link_hash_table *htab;
3961   Elf_Internal_Rela rela;
3962   bfd_vma got_base;
3963   bfd_byte *loc;
3964
3965   htab = _bfd_sparc_elf_hash_table (info);
3966
3967   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
3968   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3969               + htab->elf.hgot->root.u.def.section->output_offset
3970               + htab->elf.hgot->root.u.def.value);
3971
3972   /* Install the initial PLT entry.  */
3973   bfd_put_32 (output_bfd,
3974               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3975               htab->splt->contents);
3976   bfd_put_32 (output_bfd,
3977               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3978               htab->splt->contents + 4);
3979   bfd_put_32 (output_bfd,
3980               sparc_vxworks_exec_plt0_entry[2],
3981               htab->splt->contents + 8);
3982   bfd_put_32 (output_bfd,
3983               sparc_vxworks_exec_plt0_entry[3],
3984               htab->splt->contents + 12);
3985   bfd_put_32 (output_bfd,
3986               sparc_vxworks_exec_plt0_entry[4],
3987               htab->splt->contents + 16);
3988
3989   loc = htab->srelplt2->contents;
3990
3991   /* Add an unloaded relocation for the initial entry's "sethi".  */
3992   rela.r_offset = (htab->splt->output_section->vma
3993                    + htab->splt->output_offset);
3994   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3995   rela.r_addend = 8;
3996   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3997   loc += sizeof (Elf32_External_Rela);
3998
3999   /* Likewise the following "or".  */
4000   rela.r_offset += 4;
4001   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4002   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4003   loc += sizeof (Elf32_External_Rela);
4004
4005   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4006      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4007      in which symbols were output.  */
4008   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4009     {
4010       Elf_Internal_Rela rel;
4011
4012       /* The entry's initial "sethi" (against _G_O_T_).  */
4013       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4014       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4015       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4016       loc += sizeof (Elf32_External_Rela);
4017
4018       /* The following "or" (also against _G_O_T_).  */
4019       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4020       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4021       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4022       loc += sizeof (Elf32_External_Rela);
4023
4024       /* The .got.plt entry (against _P_L_T_).  */
4025       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4026       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4027       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4028       loc += sizeof (Elf32_External_Rela);
4029     }
4030 }
4031
4032 /* Install the first PLT entry in a VxWorks shared object.  */
4033
4034 static void
4035 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4036 {
4037   struct _bfd_sparc_elf_link_hash_table *htab;
4038   unsigned int i;
4039
4040   htab = _bfd_sparc_elf_hash_table (info);
4041   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4042     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4043                 htab->splt->contents + i * 4);
4044 }
4045
4046 bfd_boolean
4047 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4048 {
4049   bfd *dynobj;
4050   asection *sdyn;
4051   struct _bfd_sparc_elf_link_hash_table *htab;
4052
4053   htab = _bfd_sparc_elf_hash_table (info);
4054   dynobj = htab->elf.dynobj;
4055
4056   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4057
4058   if (elf_hash_table (info)->dynamic_sections_created)
4059     {
4060       asection *splt;
4061
4062       splt = bfd_get_section_by_name (dynobj, ".plt");
4063       BFD_ASSERT (splt != NULL && sdyn != NULL);
4064
4065       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4066         return FALSE;
4067
4068       /* Initialize the contents of the .plt section.  */
4069       if (splt->size > 0)
4070         {
4071           if (htab->is_vxworks)
4072             {
4073               if (info->shared)
4074                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4075               else
4076                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4077             }
4078           else
4079             {
4080               memset (splt->contents, 0, htab->plt_header_size);
4081               if (!ABI_64_P (output_bfd))
4082                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4083                             splt->contents + splt->size - 4);
4084             }
4085         }
4086
4087       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4088         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4089           ? 0 : htab->plt_entry_size;
4090     }
4091
4092   /* Set the first entry in the global offset table to the address of
4093      the dynamic section.  */
4094   if (htab->sgot && htab->sgot->size > 0)
4095     {
4096       bfd_vma val = (sdyn ?
4097                      sdyn->output_section->vma + sdyn->output_offset :
4098                      0);
4099
4100       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4101     }
4102
4103   if (htab->sgot)
4104     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4105       SPARC_ELF_WORD_BYTES (htab);
4106
4107   return TRUE;
4108 }
4109
4110 \f
4111 /* Set the right machine number for a SPARC ELF file.  */
4112
4113 bfd_boolean
4114 _bfd_sparc_elf_object_p (bfd *abfd)
4115 {
4116   if (ABI_64_P (abfd))
4117     {
4118       unsigned long mach = bfd_mach_sparc_v9;
4119
4120       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4121         mach = bfd_mach_sparc_v9b;
4122       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4123         mach = bfd_mach_sparc_v9a;
4124       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4125     }
4126   else
4127     {
4128       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4129         {
4130           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4131             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4132                                               bfd_mach_sparc_v8plusb);
4133           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4134             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4135                                               bfd_mach_sparc_v8plusa);
4136           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4137             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4138                                               bfd_mach_sparc_v8plus);
4139           else
4140             return FALSE;
4141         }
4142       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4143         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4144                                           bfd_mach_sparc_sparclite_le);
4145       else
4146         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4147     }
4148 }
4149
4150 /* Return address for Ith PLT stub in section PLT, for relocation REL
4151    or (bfd_vma) -1 if it should not be included.  */
4152
4153 bfd_vma
4154 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4155 {
4156   if (ABI_64_P (plt->owner))
4157     {
4158       bfd_vma j;
4159
4160       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4161       if (i < PLT64_LARGE_THRESHOLD)
4162         return plt->vma + i * PLT64_ENTRY_SIZE;
4163
4164       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4165       i -= j;
4166       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4167     }
4168   else
4169     return rel->address;
4170 }