contrib/binutils/bfd/elfxx-sparc.c

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