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