bfd/elfxx-sparc.c

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