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
2478   htab = _bfd_sparc_elf_hash_table (info);
2479   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2480   sym_hashes = elf_sym_hashes (input_bfd);
2481   local_got_offsets = elf_local_got_offsets (input_bfd);
2482
2483   if (elf_hash_table (info)->hgot == NULL)
2484     got_base = 0;
2485   else
2486     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2487
2488   sreloc = elf_section_data (input_section)->sreloc;
2489
2490   rel = relocs;
2491   if (ABI_64_P (output_bfd))
2492     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2493   else
2494     num_relocs = input_section->reloc_count;
2495   relend = relocs + num_relocs;
2496   for (; rel < relend; rel++)
2497     {
2498       int r_type, tls_type;
2499       reloc_howto_type *howto;
2500       unsigned long r_symndx;
2501       struct elf_link_hash_entry *h;
2502       Elf_Internal_Sym *sym;
2503       asection *sec;
2504       bfd_vma relocation, off;
2505       bfd_reloc_status_type r;
2506       bfd_boolean is_plt = FALSE;
2507       bfd_boolean unresolved_reloc;
2508
2509       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2510       if (r_type == R_SPARC_GNU_VTINHERIT
2511           || r_type == R_SPARC_GNU_VTENTRY)
2512         continue;
2513
2514       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2515         {
2516           bfd_set_error (bfd_error_bad_value);
2517           return FALSE;
2518         }
2519       howto = _bfd_sparc_elf_howto_table + r_type;
2520
2521       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2522       h = NULL;
2523       sym = NULL;
2524       sec = NULL;
2525       unresolved_reloc = FALSE;
2526       if (r_symndx < symtab_hdr->sh_info)
2527         {
2528           sym = local_syms + r_symndx;
2529           sec = local_sections[r_symndx];
2530           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2531         }
2532       else
2533         {
2534           bfd_boolean warned;
2535
2536           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2537                                    r_symndx, symtab_hdr, sym_hashes,
2538                                    h, sec, relocation,
2539                                    unresolved_reloc, warned);
2540           if (warned)
2541             {
2542               /* To avoid generating warning messages about truncated
2543                  relocations, set the relocation's address to be the same as
2544                  the start of this section.  */
2545               if (input_section->output_section != NULL)
2546                 relocation = input_section->output_section->vma;
2547               else
2548                 relocation = 0;
2549             }
2550         }
2551
2552       if (sec != NULL && elf_discarded_section (sec))
2553         {
2554           /* For relocs against symbols from removed linkonce
2555              sections, or sections discarded by a linker script, we
2556              just want the section contents zeroed.  Avoid any
2557              special processing.  */
2558           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2559           rel->r_info = 0;
2560           rel->r_addend = 0;
2561           continue;
2562         }
2563
2564       if (info->relocatable)
2565         continue;
2566
2567       switch (r_type)
2568         {
2569         case R_SPARC_GOT10:
2570         case R_SPARC_GOT13:
2571         case R_SPARC_GOT22:
2572           /* Relocation is to the entry for this symbol in the global
2573              offset table.  */
2574           if (htab->sgot == NULL)
2575             abort ();
2576
2577           if (h != NULL)
2578             {
2579               bfd_boolean dyn;
2580
2581               off = h->got.offset;
2582               BFD_ASSERT (off != (bfd_vma) -1);
2583               dyn = elf_hash_table (info)->dynamic_sections_created;
2584
2585               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2586                   || (info->shared
2587                       && (info->symbolic
2588                           || h->dynindx == -1
2589                           || h->forced_local)
2590                       && h->def_regular))
2591                 {
2592                   /* This is actually a static link, or it is a
2593                      -Bsymbolic link and the symbol is defined
2594                      locally, or the symbol was forced to be local
2595                      because of a version file.  We must initialize
2596                      this entry in the global offset table.  Since the
2597                      offset must always be a multiple of 8 for 64-bit
2598                      and 4 for 32-bit, we use the least significant bit
2599                      to record whether we have initialized it already.
2600
2601                      When doing a dynamic link, we create a .rela.got
2602                      relocation entry to initialize the value.  This
2603                      is done in the finish_dynamic_symbol routine.  */
2604                   if ((off & 1) != 0)
2605                     off &= ~1;
2606                   else
2607                     {
2608                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2609                                           htab->sgot->contents + off);
2610                       h->got.offset |= 1;
2611                     }
2612                 }
2613               else
2614                 unresolved_reloc = FALSE;
2615             }
2616           else
2617             {
2618               BFD_ASSERT (local_got_offsets != NULL
2619                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2620
2621               off = local_got_offsets[r_symndx];
2622
2623               /* The offset must always be a multiple of 8 on 64-bit and
2624                  4 on 32-bit.  We use the least significant bit to record
2625                  whether we have already processed this entry.  */
2626               if ((off & 1) != 0)
2627                 off &= ~1;
2628               else
2629                 {
2630
2631                   if (info->shared)
2632                     {
2633                       asection *s;
2634                       Elf_Internal_Rela outrel;
2635
2636                       /* We need to generate a R_SPARC_RELATIVE reloc
2637                          for the dynamic linker.  */
2638                       s = htab->srelgot;
2639                       BFD_ASSERT (s != NULL);
2640
2641                       outrel.r_offset = (htab->sgot->output_section->vma
2642                                          + htab->sgot->output_offset
2643                                          + off);
2644                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2645                                                         0, R_SPARC_RELATIVE);
2646                       outrel.r_addend = relocation;
2647                       relocation = 0;
2648                       sparc_elf_append_rela (output_bfd, s, &outrel);
2649                     }
2650
2651                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2652                                       htab->sgot->contents + off);
2653                   local_got_offsets[r_symndx] |= 1;
2654                 }
2655             }
2656           relocation = htab->sgot->output_offset + off - got_base;
2657           break;
2658
2659         case R_SPARC_PLT32:
2660         case R_SPARC_PLT64:
2661           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2662             {
2663               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2664               goto r_sparc_plt32;
2665             }
2666           /* Fall through.  */
2667
2668         case R_SPARC_WPLT30:
2669         case R_SPARC_HIPLT22:
2670         case R_SPARC_LOPLT10:
2671         case R_SPARC_PCPLT32:
2672         case R_SPARC_PCPLT22:
2673         case R_SPARC_PCPLT10:
2674         r_sparc_wplt30:
2675           /* Relocation is to the entry for this symbol in the
2676              procedure linkage table.  */
2677
2678           if (! ABI_64_P (output_bfd))
2679             {
2680               /* The Solaris native assembler will generate a WPLT30 reloc
2681                  for a local symbol if you assemble a call from one
2682                  section to another when using -K pic.  We treat it as
2683                  WDISP30.  */
2684               if (h == NULL)
2685                 break;
2686             }
2687           else
2688             {
2689               BFD_ASSERT (h != NULL);
2690             }
2691
2692           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2693             {
2694               /* We didn't make a PLT entry for this symbol.  This
2695                  happens when statically linking PIC code, or when
2696                  using -Bsymbolic.  */
2697               break;
2698             }
2699
2700           relocation = (htab->splt->output_section->vma
2701                         + htab->splt->output_offset
2702                         + h->plt.offset);
2703           unresolved_reloc = FALSE;
2704           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2705             {
2706               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2707               is_plt = TRUE;
2708               goto r_sparc_plt32;
2709             }
2710           break;
2711
2712         case R_SPARC_PC10:
2713         case R_SPARC_PC22:
2714         case R_SPARC_PC_HH22:
2715         case R_SPARC_PC_HM10:
2716         case R_SPARC_PC_LM22:
2717           if (h != NULL
2718               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2719             break;
2720           /* Fall through.  */
2721         case R_SPARC_DISP8:
2722         case R_SPARC_DISP16:
2723         case R_SPARC_DISP32:
2724         case R_SPARC_DISP64:
2725         case R_SPARC_WDISP30:
2726         case R_SPARC_WDISP22:
2727         case R_SPARC_WDISP19:
2728         case R_SPARC_WDISP16:
2729         case R_SPARC_8:
2730         case R_SPARC_16:
2731         case R_SPARC_32:
2732         case R_SPARC_HI22:
2733         case R_SPARC_22:
2734         case R_SPARC_13:
2735         case R_SPARC_LO10:
2736         case R_SPARC_UA16:
2737         case R_SPARC_UA32:
2738         case R_SPARC_10:
2739         case R_SPARC_11:
2740         case R_SPARC_64:
2741         case R_SPARC_OLO10:
2742         case R_SPARC_HH22:
2743         case R_SPARC_HM10:
2744         case R_SPARC_LM22:
2745         case R_SPARC_7:
2746         case R_SPARC_5:
2747         case R_SPARC_6:
2748         case R_SPARC_HIX22:
2749         case R_SPARC_LOX10:
2750         case R_SPARC_H44:
2751         case R_SPARC_M44:
2752         case R_SPARC_L44:
2753         case R_SPARC_UA64:
2754         r_sparc_plt32:
2755           if ((input_section->flags & SEC_ALLOC) == 0)
2756             break;
2757
2758           if ((info->shared
2759                && (h == NULL
2760                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2761                    || h->root.type != bfd_link_hash_undefweak)
2762                && (! howto->pc_relative
2763                    || (h != NULL
2764                        && h->dynindx != -1
2765                        && (! info->symbolic
2766                            || !h->def_regular))))
2767               || (!info->shared
2768                   && h != NULL
2769                   && h->dynindx != -1
2770                   && !h->non_got_ref
2771                   && ((h->def_dynamic
2772                        && !h->def_regular)
2773                       || h->root.type == bfd_link_hash_undefweak
2774                       || h->root.type == bfd_link_hash_undefined)))
2775             {
2776               Elf_Internal_Rela outrel;
2777               bfd_boolean skip, relocate = FALSE;
2778
2779               /* When generating a shared object, these relocations
2780                  are copied into the output file to be resolved at run
2781                  time.  */
2782
2783               BFD_ASSERT (sreloc != NULL);
2784
2785               skip = FALSE;
2786
2787               outrel.r_offset =
2788                 _bfd_elf_section_offset (output_bfd, info, input_section,
2789                                          rel->r_offset);
2790               if (outrel.r_offset == (bfd_vma) -1)
2791                 skip = TRUE;
2792               else if (outrel.r_offset == (bfd_vma) -2)
2793                 skip = TRUE, relocate = TRUE;
2794               outrel.r_offset += (input_section->output_section->vma
2795                                   + input_section->output_offset);
2796
2797               /* Optimize unaligned reloc usage now that we know where
2798                  it finally resides.  */
2799               switch (r_type)
2800                 {
2801                 case R_SPARC_16:
2802                   if (outrel.r_offset & 1)
2803                     r_type = R_SPARC_UA16;
2804                   break;
2805                 case R_SPARC_UA16:
2806                   if (!(outrel.r_offset & 1))
2807                     r_type = R_SPARC_16;
2808                   break;
2809                 case R_SPARC_32:
2810                   if (outrel.r_offset & 3)
2811                     r_type = R_SPARC_UA32;
2812                   break;
2813                 case R_SPARC_UA32:
2814                   if (!(outrel.r_offset & 3))
2815                     r_type = R_SPARC_32;
2816                   break;
2817                 case R_SPARC_64:
2818                   if (outrel.r_offset & 7)
2819                     r_type = R_SPARC_UA64;
2820                   break;
2821                 case R_SPARC_UA64:
2822                   if (!(outrel.r_offset & 7))
2823                     r_type = R_SPARC_64;
2824                   break;
2825                 case R_SPARC_DISP8:
2826                 case R_SPARC_DISP16:
2827                 case R_SPARC_DISP32:
2828                 case R_SPARC_DISP64:
2829                   /* If the symbol is not dynamic, we should not keep
2830                      a dynamic relocation.  But an .rela.* slot has been
2831                      allocated for it, output R_SPARC_NONE.
2832                      FIXME: Add code tracking needed dynamic relocs as
2833                      e.g. i386 has.  */
2834                   if (h->dynindx == -1)
2835                     skip = TRUE, relocate = TRUE;
2836                   break;
2837                 }
2838
2839               if (skip)
2840                 memset (&outrel, 0, sizeof outrel);
2841               /* h->dynindx may be -1 if the symbol was marked to
2842                  become local.  */
2843               else if (h != NULL && ! is_plt
2844                        && ((! info->symbolic && h->dynindx != -1)
2845                            || !h->def_regular))
2846                 {
2847                   BFD_ASSERT (h->dynindx != -1);
2848                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2849                   outrel.r_addend = rel->r_addend;
2850                 }
2851               else
2852                 {
2853                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2854                     {
2855                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2856                                                         0, R_SPARC_RELATIVE);
2857                       outrel.r_addend = relocation + rel->r_addend;
2858                     }
2859                   else
2860                     {
2861                       long indx;
2862
2863                       outrel.r_addend = relocation + rel->r_addend;
2864
2865                       if (is_plt)
2866                         sec = htab->splt;
2867
2868                       if (bfd_is_abs_section (sec))
2869                         indx = 0;
2870                       else if (sec == NULL || sec->owner == NULL)
2871                         {
2872                           bfd_set_error (bfd_error_bad_value);
2873                           return FALSE;
2874                         }
2875                       else
2876                         {
2877                           asection *osec;
2878
2879                           /* We are turning this relocation into one
2880                              against a section symbol.  It would be
2881                              proper to subtract the symbol's value,
2882                              osec->vma, from the emitted reloc addend,
2883                              but ld.so expects buggy relocs.  */
2884                           osec = sec->output_section;
2885                           indx = elf_section_data (osec)->dynindx;
2886
2887                           if (indx == 0)
2888                             {
2889                               osec = htab->elf.text_index_section;
2890                               indx = elf_section_data (osec)->dynindx;
2891                             }
2892
2893                           /* FIXME: we really should be able to link non-pic
2894                              shared libraries.  */
2895                           if (indx == 0)
2896                             {
2897                               BFD_FAIL ();
2898                               (*_bfd_error_handler)
2899                                 (_("%B: probably compiled without -fPIC?"),
2900                                  input_bfd);
2901                               bfd_set_error (bfd_error_bad_value);
2902                               return FALSE;
2903                             }
2904                         }
2905
2906                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
2907                                                         r_type);
2908                     }
2909                 }
2910
2911               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
2912
2913               /* This reloc will be computed at runtime, so there's no
2914                  need to do anything now.  */
2915               if (! relocate)
2916                 continue;
2917             }
2918           break;
2919
2920         case R_SPARC_TLS_GD_HI22:
2921           if (! ABI_64_P (input_bfd)
2922               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2923             {
2924               /* R_SPARC_REV32 used the same reloc number as
2925                  R_SPARC_TLS_GD_HI22.  */
2926               r_type = R_SPARC_REV32;
2927               break;
2928             }
2929           /* Fall through */
2930
2931         case R_SPARC_TLS_GD_LO10:
2932         case R_SPARC_TLS_IE_HI22:
2933         case R_SPARC_TLS_IE_LO10:
2934           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2935           tls_type = GOT_UNKNOWN;
2936           if (h == NULL && local_got_offsets)
2937             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2938           else if (h != NULL)
2939             {
2940               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2941               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2942                 switch (SPARC_ELF_R_TYPE (rel->r_info))
2943                   {
2944                   case R_SPARC_TLS_GD_HI22:
2945                   case R_SPARC_TLS_IE_HI22:
2946                     r_type = R_SPARC_TLS_LE_HIX22;
2947                     break;
2948                   default:
2949                     r_type = R_SPARC_TLS_LE_LOX10;
2950                     break;
2951                   }
2952             }
2953           if (tls_type == GOT_TLS_IE)
2954             switch (r_type)
2955               {
2956               case R_SPARC_TLS_GD_HI22:
2957                 r_type = R_SPARC_TLS_IE_HI22;
2958                 break;
2959               case R_SPARC_TLS_GD_LO10:
2960                 r_type = R_SPARC_TLS_IE_LO10;
2961                 break;
2962               }
2963
2964           if (r_type == R_SPARC_TLS_LE_HIX22)
2965             {
2966               relocation = tpoff (info, relocation);
2967               break;
2968             }
2969           if (r_type == R_SPARC_TLS_LE_LOX10)
2970             {
2971               /* Change add into xor.  */
2972               relocation = tpoff (info, relocation);
2973               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2974                                                    contents + rel->r_offset)
2975                                        | 0x80182000), contents + rel->r_offset);
2976               break;
2977             }
2978
2979           if (h != NULL)
2980             {
2981               off = h->got.offset;
2982               h->got.offset |= 1;
2983             }
2984           else
2985             {
2986               BFD_ASSERT (local_got_offsets != NULL);
2987               off = local_got_offsets[r_symndx];
2988               local_got_offsets[r_symndx] |= 1;
2989             }
2990
2991         r_sparc_tlsldm:
2992           if (htab->sgot == NULL)
2993             abort ();
2994
2995           if ((off & 1) != 0)
2996             off &= ~1;
2997           else
2998             {
2999               Elf_Internal_Rela outrel;
3000               int dr_type, indx;
3001
3002               if (htab->srelgot == NULL)
3003                 abort ();
3004
3005               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3006               outrel.r_offset = (htab->sgot->output_section->vma
3007                                  + htab->sgot->output_offset + off);
3008               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3009               if (r_type == R_SPARC_TLS_IE_HI22
3010                   || r_type == R_SPARC_TLS_IE_LO10)
3011                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3012               else
3013                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3014               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3015                 outrel.r_addend = relocation - dtpoff_base (info);
3016               else
3017                 outrel.r_addend = 0;
3018               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3019               sparc_elf_append_rela (output_bfd, htab->srelgot, &outrel);
3020
3021               if (r_type == R_SPARC_TLS_GD_HI22
3022                   || r_type == R_SPARC_TLS_GD_LO10)
3023                 {
3024                   if (indx == 0)
3025                     {
3026                       BFD_ASSERT (! unresolved_reloc);
3027                       SPARC_ELF_PUT_WORD (htab, output_bfd,
3028                                           relocation - dtpoff_base (info),
3029                                           (htab->sgot->contents + off
3030                                            + SPARC_ELF_WORD_BYTES (htab)));
3031                     }
3032                   else
3033                     {
3034                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3035                                           (htab->sgot->contents + off
3036                                            + SPARC_ELF_WORD_BYTES (htab)));
3037                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3038                                                         SPARC_ELF_DTPOFF_RELOC (htab));
3039                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3040                       sparc_elf_append_rela (output_bfd, htab->srelgot,
3041                                              &outrel);
3042                     }
3043                 }
3044               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3045                 {
3046                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3047                                       (htab->sgot->contents + off
3048                                        + SPARC_ELF_WORD_BYTES (htab)));
3049                 }
3050             }
3051
3052           if (off >= (bfd_vma) -2)
3053             abort ();
3054
3055           relocation = htab->sgot->output_offset + off - got_base;
3056           unresolved_reloc = FALSE;
3057           howto = _bfd_sparc_elf_howto_table + r_type;
3058           break;
3059
3060         case R_SPARC_TLS_LDM_HI22:
3061         case R_SPARC_TLS_LDM_LO10:
3062           if (! info->shared)
3063             {
3064               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3065               continue;
3066             }
3067           off = htab->tls_ldm_got.offset;
3068           htab->tls_ldm_got.offset |= 1;
3069           goto r_sparc_tlsldm;
3070
3071         case R_SPARC_TLS_LDO_HIX22:
3072         case R_SPARC_TLS_LDO_LOX10:
3073           if (info->shared)
3074             {
3075               relocation -= dtpoff_base (info);
3076               break;
3077             }
3078
3079           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3080                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3081           /* Fall through.  */
3082
3083         case R_SPARC_TLS_LE_HIX22:
3084         case R_SPARC_TLS_LE_LOX10:
3085           if (info->shared)
3086             {
3087               Elf_Internal_Rela outrel;
3088               bfd_boolean skip, relocate = FALSE;
3089
3090               BFD_ASSERT (sreloc != NULL);
3091               skip = FALSE;
3092               outrel.r_offset =
3093                 _bfd_elf_section_offset (output_bfd, info, input_section,
3094                                          rel->r_offset);
3095               if (outrel.r_offset == (bfd_vma) -1)
3096                 skip = TRUE;
3097               else if (outrel.r_offset == (bfd_vma) -2)
3098                 skip = TRUE, relocate = TRUE;
3099               outrel.r_offset += (input_section->output_section->vma
3100                                   + input_section->output_offset);
3101               if (skip)
3102                 memset (&outrel, 0, sizeof outrel);
3103               else
3104                 {
3105                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3106                   outrel.r_addend = relocation - dtpoff_base (info)
3107                                     + rel->r_addend;
3108                 }
3109
3110               sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3111               continue;
3112             }
3113           relocation = tpoff (info, relocation);
3114           break;
3115
3116         case R_SPARC_TLS_LDM_CALL:
3117           if (! info->shared)
3118             {
3119               /* mov %g0, %o0 */
3120               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3121               continue;
3122             }
3123           /* Fall through */
3124
3125         case R_SPARC_TLS_GD_CALL:
3126           tls_type = GOT_UNKNOWN;
3127           if (h == NULL && local_got_offsets)
3128             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3129           else if (h != NULL)
3130             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3131           if (! info->shared
3132               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3133             {
3134               bfd_vma insn;
3135
3136               if (!info->shared && (h == NULL || h->dynindx == -1))
3137                 {
3138                   /* GD -> LE */
3139                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3140                   continue;
3141                 }
3142
3143               /* GD -> IE */
3144               if (rel + 1 < relend
3145                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3146                   && rel[1].r_offset == rel->r_offset + 4
3147                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3148                   && (((insn = bfd_get_32 (input_bfd,
3149                                            contents + rel[1].r_offset))
3150                        >> 25) & 0x1f) == 8)
3151                 {
3152                   /* We have
3153                      call __tls_get_addr, %tgd_call(foo)
3154                       add %reg1, %reg2, %o0, %tgd_add(foo)
3155                      and change it into IE:
3156                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3157                      add %g7, %o0, %o0, %tie_add(foo).
3158                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3159                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3160                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3161                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3162                               contents + rel->r_offset);
3163                   bfd_put_32 (output_bfd, 0x9001c008,
3164                               contents + rel->r_offset + 4);
3165                   rel++;
3166                   continue;
3167                 }
3168
3169               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3170               continue;
3171             }
3172
3173           h = (struct elf_link_hash_entry *)
3174               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3175                                     FALSE, TRUE);
3176           BFD_ASSERT (h != NULL);
3177           r_type = R_SPARC_WPLT30;
3178           howto = _bfd_sparc_elf_howto_table + r_type;
3179           goto r_sparc_wplt30;
3180
3181         case R_SPARC_TLS_GD_ADD:
3182           tls_type = GOT_UNKNOWN;
3183           if (h == NULL && local_got_offsets)
3184             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3185           else if (h != NULL)
3186             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3187           if (! info->shared || tls_type == GOT_TLS_IE)
3188             {
3189               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3190                  changed into IE:
3191                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3192                  or LE:
3193                  add %g7, %reg2, %reg3.  */
3194               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3195               if ((h != NULL && h->dynindx != -1) || info->shared)
3196                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3197               else
3198                 relocation = (insn & ~0x7c000) | 0x1c000;
3199               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3200             }
3201           continue;
3202
3203         case R_SPARC_TLS_LDM_ADD:
3204           if (! info->shared)
3205             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3206           continue;
3207
3208         case R_SPARC_TLS_LDO_ADD:
3209           if (! info->shared)
3210             {
3211               /* Change rs1 into %g7.  */
3212               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3213               insn = (insn & ~0x7c000) | 0x1c000;
3214               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3215             }
3216           continue;
3217
3218         case R_SPARC_TLS_IE_LD:
3219         case R_SPARC_TLS_IE_LDX:
3220           if (! info->shared && (h == NULL || h->dynindx == -1))
3221             {
3222               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3223               int rs2 = insn & 0x1f;
3224               int rd = (insn >> 25) & 0x1f;
3225
3226               if (rs2 == rd)
3227                 relocation = SPARC_NOP;
3228               else
3229                 relocation = 0x80100000 | (insn & 0x3e00001f);
3230               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3231             }
3232           continue;
3233
3234         case R_SPARC_TLS_IE_ADD:
3235           /* Totally useless relocation.  */
3236           continue;
3237
3238         case R_SPARC_TLS_DTPOFF32:
3239         case R_SPARC_TLS_DTPOFF64:
3240           relocation -= dtpoff_base (info);
3241           break;
3242
3243         default:
3244           break;
3245         }
3246
3247       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3248          because such sections are not SEC_ALLOC and thus ld.so will
3249          not process them.  */
3250       if (unresolved_reloc
3251           && !((input_section->flags & SEC_DEBUGGING) != 0
3252                && h->def_dynamic))
3253         (*_bfd_error_handler)
3254           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3255            input_bfd,
3256            input_section,
3257            (long) rel->r_offset,
3258            howto->name,
3259            h->root.root.string);
3260
3261       r = bfd_reloc_continue;
3262       if (r_type == R_SPARC_OLO10)
3263         {
3264             bfd_vma x;
3265
3266             if (! ABI_64_P (output_bfd))
3267               abort ();
3268
3269             relocation += rel->r_addend;
3270             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3271
3272             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3273             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3274             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3275
3276             r = bfd_check_overflow (howto->complain_on_overflow,
3277                                     howto->bitsize, howto->rightshift,
3278                                     bfd_arch_bits_per_address (input_bfd),
3279                                     relocation);
3280         }
3281       else if (r_type == R_SPARC_WDISP16)
3282         {
3283           bfd_vma x;
3284
3285           relocation += rel->r_addend;
3286           relocation -= (input_section->output_section->vma
3287                          + input_section->output_offset);
3288           relocation -= rel->r_offset;
3289
3290           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3291           x |= ((((relocation >> 2) & 0xc000) << 6)
3292                 | ((relocation >> 2) & 0x3fff));
3293           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3294
3295           r = bfd_check_overflow (howto->complain_on_overflow,
3296                                   howto->bitsize, howto->rightshift,
3297                                   bfd_arch_bits_per_address (input_bfd),
3298                                   relocation);
3299         }
3300       else if (r_type == R_SPARC_REV32)
3301         {
3302           bfd_vma x;
3303
3304           relocation = relocation + rel->r_addend;
3305
3306           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3307           x = x + relocation;
3308           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3309           r = bfd_reloc_ok;
3310         }
3311       else if (r_type == R_SPARC_TLS_LDO_HIX22
3312                || r_type == R_SPARC_TLS_LE_HIX22)
3313         {
3314           bfd_vma x;
3315
3316           relocation += rel->r_addend;
3317           if (r_type == R_SPARC_TLS_LE_HIX22)
3318             relocation ^= MINUS_ONE;
3319
3320           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3321           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3322           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3323           r = bfd_reloc_ok;
3324         }
3325       else if (r_type == R_SPARC_TLS_LDO_LOX10
3326                || r_type == R_SPARC_TLS_LE_LOX10)
3327         {
3328           bfd_vma x;
3329
3330           relocation += rel->r_addend;
3331           relocation &= 0x3ff;
3332           if (r_type == R_SPARC_TLS_LE_LOX10)
3333             relocation |= 0x1c00;
3334
3335           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3336           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3337           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3338
3339           r = bfd_reloc_ok;
3340         }
3341       else if (r_type == R_SPARC_HIX22)
3342         {
3343           bfd_vma x;
3344
3345           relocation += rel->r_addend;
3346           relocation = relocation ^ MINUS_ONE;
3347
3348           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3349           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3350           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3351
3352           r = bfd_check_overflow (howto->complain_on_overflow,
3353                                   howto->bitsize, howto->rightshift,
3354                                   bfd_arch_bits_per_address (input_bfd),
3355                                   relocation);
3356         }
3357       else if (r_type == R_SPARC_LOX10)
3358         {
3359           bfd_vma x;
3360
3361           relocation += rel->r_addend;
3362           relocation = (relocation & 0x3ff) | 0x1c00;
3363
3364           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3365           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3366           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3367
3368           r = bfd_reloc_ok;
3369         }
3370       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3371                && sec_do_relax (input_section)
3372                && rel->r_offset + 4 < input_section->size)
3373         {
3374 #define G0              0
3375 #define O7              15
3376 #define XCC             (2 << 20)
3377 #define COND(x)         (((x)&0xf)<<25)
3378 #define CONDA           COND(0x8)
3379 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3380 #define INSN_BA         (F2(0,2) | CONDA)
3381 #define INSN_OR         F3(2, 0x2, 0)
3382 #define INSN_NOP        F2(0,4)
3383
3384           bfd_vma x, y;
3385
3386           /* If the instruction is a call with either:
3387              restore
3388              arithmetic instruction with rd == %o7
3389              where rs1 != %o7 and rs2 if it is register != %o7
3390              then we can optimize if the call destination is near
3391              by changing the call into a branch always.  */
3392           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3393           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3394           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3395             {
3396               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3397                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3398                        && (y & RD(~0)) == RD(O7)))
3399                   && (y & RS1(~0)) != RS1(O7)
3400                   && ((y & F3I(~0))
3401                       || (y & RS2(~0)) != RS2(O7)))
3402                 {
3403                   bfd_vma reloc;
3404
3405                   reloc = relocation + rel->r_addend - rel->r_offset;
3406                   reloc -= (input_section->output_section->vma
3407                             + input_section->output_offset);
3408
3409                   /* Ensure the branch fits into simm22.  */
3410                   if ((reloc & 3) == 0
3411                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3412                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3413                     {
3414                       reloc >>= 2;
3415
3416                       /* Check whether it fits into simm19.  */
3417                       if (((reloc & 0x3c0000) == 0
3418                            || (reloc & 0x3c0000) == 0x3c0000)
3419                           && (ABI_64_P (output_bfd)
3420                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3421                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3422                       else
3423                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3424                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3425                       r = bfd_reloc_ok;
3426                       if (rel->r_offset >= 4
3427                           && (y & (0xffffffff ^ RS1(~0)))
3428                              == (INSN_OR | RD(O7) | RS2(G0)))
3429                         {
3430                           bfd_vma z;
3431                           unsigned int reg;
3432
3433                           z = bfd_get_32 (input_bfd,
3434                                           contents + rel->r_offset - 4);
3435                           if ((z & (0xffffffff ^ RD(~0)))
3436                               != (INSN_OR | RS1(O7) | RS2(G0)))
3437                             break;
3438
3439                           /* The sequence was
3440                              or %o7, %g0, %rN
3441                              call foo
3442                              or %rN, %g0, %o7
3443
3444                              If call foo was replaced with ba, replace
3445                              or %rN, %g0, %o7 with nop.  */
3446
3447                           reg = (y & RS1(~0)) >> 14;
3448                           if (reg != ((z & RD(~0)) >> 25)
3449                               || reg == G0 || reg == O7)
3450                             break;
3451
3452                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3453                                       contents + rel->r_offset + 4);
3454                         }
3455
3456                     }
3457                 }
3458             }
3459         }
3460
3461       if (r == bfd_reloc_continue)
3462         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3463                                       contents, rel->r_offset,
3464                                       relocation, rel->r_addend);
3465
3466       if (r != bfd_reloc_ok)
3467         {
3468           switch (r)
3469             {
3470             default:
3471             case bfd_reloc_outofrange:
3472               abort ();
3473             case bfd_reloc_overflow:
3474               {
3475                 const char *name;
3476
3477                 /* The Solaris native linker silently disregards overflows.
3478                    We don't, but this breaks stabs debugging info, whose
3479                    relocations are only 32-bits wide.  Ignore overflows in
3480                    this case and also for discarded entries.  */
3481                 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3482                     && (((input_section->flags & SEC_DEBUGGING) != 0
3483                          && strcmp (bfd_section_name (input_bfd,
3484                                                       input_section),
3485                                     ".stab") == 0)
3486                         || _bfd_elf_section_offset (output_bfd, info,
3487                                                     input_section,
3488                                                     rel->r_offset)
3489                              == (bfd_vma)-1))
3490                   break;
3491
3492                 if (h != NULL)
3493                   {
3494                     /* Assume this is a call protected by other code that
3495                        detect the symbol is undefined.  If this is the case,
3496                        we can safely ignore the overflow.  If not, the
3497                        program is hosed anyway, and a little warning isn't
3498                        going to help.  */
3499                     if (h->root.type == bfd_link_hash_undefweak
3500                         && howto->pc_relative)
3501                       break;
3502
3503                     name = NULL;
3504                   }
3505                 else
3506                   {
3507                     name = bfd_elf_string_from_elf_section (input_bfd,
3508                                                             symtab_hdr->sh_link,
3509                                                             sym->st_name);
3510                     if (name == NULL)
3511                       return FALSE;
3512                     if (*name == '\0')
3513                       name = bfd_section_name (input_bfd, sec);
3514                   }
3515                 if (! ((*info->callbacks->reloc_overflow)
3516                        (info, (h ? &h->root : NULL), name, howto->name,
3517                         (bfd_vma) 0, input_bfd, input_section,
3518                         rel->r_offset)))
3519                   return FALSE;
3520               }
3521               break;
3522             }
3523         }
3524     }
3525
3526   return TRUE;
3527 }
3528
3529 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
3530    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
3531    is the offset of the associated .got.plt entry from
3532    _GLOBAL_OFFSET_TABLE_.  */
3533
3534 static void
3535 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3536                                bfd_vma plt_offset, bfd_vma plt_index,
3537                                bfd_vma got_offset)
3538 {
3539   bfd_vma got_base;
3540   const bfd_vma *plt_entry;
3541   struct _bfd_sparc_elf_link_hash_table *htab;
3542   bfd_byte *loc;
3543   Elf_Internal_Rela rela;
3544
3545   htab = _bfd_sparc_elf_hash_table (info);
3546   if (info->shared)
3547     {
3548       plt_entry = sparc_vxworks_shared_plt_entry;
3549       got_base = 0;
3550     }
3551   else
3552     {
3553       plt_entry = sparc_vxworks_exec_plt_entry;
3554       got_base = (htab->elf.hgot->root.u.def.value
3555                   + htab->elf.hgot->root.u.def.section->output_offset
3556                   + htab->elf.hgot->root.u.def.section->output_section->vma);
3557     }
3558
3559   /* Fill in the entry in the procedure linkage table.  */
3560   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3561               htab->splt->contents + plt_offset);
3562   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3563               htab->splt->contents + plt_offset + 4);
3564   bfd_put_32 (output_bfd, plt_entry[2],
3565               htab->splt->contents + plt_offset + 8);
3566   bfd_put_32 (output_bfd, plt_entry[3],
3567               htab->splt->contents + plt_offset + 12);
3568   bfd_put_32 (output_bfd, plt_entry[4],
3569               htab->splt->contents + plt_offset + 16);
3570   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3571               htab->splt->contents + plt_offset + 20);
3572   /* PC-relative displacement for a branch to the start of
3573      the PLT section.  */
3574   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3575                                           & 0x003fffff),
3576               htab->splt->contents + plt_offset + 24);
3577   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3578               htab->splt->contents + plt_offset + 28);
3579
3580   /* Fill in the .got.plt entry, pointing initially at the
3581      second half of the PLT entry.  */
3582   BFD_ASSERT (htab->sgotplt != NULL);
3583   bfd_put_32 (output_bfd,
3584               htab->splt->output_section->vma
3585               + htab->splt->output_offset
3586               + plt_offset + 20,
3587               htab->sgotplt->contents + got_offset);
3588
3589   /* Add relocations to .rela.plt.unloaded.  */
3590   if (!info->shared)
3591     {
3592       loc = (htab->srelplt2->contents
3593              + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3594
3595       /* Relocate the initial sethi.  */
3596       rela.r_offset = (htab->splt->output_section->vma
3597                        + htab->splt->output_offset
3598                        + plt_offset);
3599       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3600       rela.r_addend = got_offset;
3601       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3602       loc += sizeof (Elf32_External_Rela);
3603
3604       /* Likewise the following or.  */
3605       rela.r_offset += 4;
3606       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3607       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3608       loc += sizeof (Elf32_External_Rela);
3609
3610       /* Relocate the .got.plt entry.  */
3611       rela.r_offset = (htab->sgotplt->output_section->vma
3612                        + htab->sgotplt->output_offset
3613                        + got_offset);
3614       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3615       rela.r_addend = plt_offset + 20;
3616       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3617     }
3618 }
3619
3620 /* Finish up dynamic symbol handling.  We set the contents of various
3621    dynamic sections here.  */
3622
3623 bfd_boolean
3624 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3625                                       struct bfd_link_info *info,
3626                                       struct elf_link_hash_entry *h,
3627                                       Elf_Internal_Sym *sym)
3628 {
3629   bfd *dynobj;
3630   struct _bfd_sparc_elf_link_hash_table *htab;
3631   const struct elf_backend_data *bed;
3632
3633   htab = _bfd_sparc_elf_hash_table (info);
3634   dynobj = htab->elf.dynobj;
3635   bed = get_elf_backend_data (output_bfd);
3636
3637   if (h->plt.offset != (bfd_vma) -1)
3638     {
3639       asection *splt;
3640       asection *srela;
3641       Elf_Internal_Rela rela;
3642       bfd_byte *loc;
3643       bfd_vma r_offset, got_offset;
3644       int rela_index;
3645
3646       /* This symbol has an entry in the PLT.  Set it up.  */
3647
3648       BFD_ASSERT (h->dynindx != -1);
3649
3650       splt = htab->splt;
3651       srela = htab->srelplt;
3652       BFD_ASSERT (splt != NULL && srela != NULL);
3653
3654       /* Fill in the entry in the .rela.plt section.  */
3655       if (htab->is_vxworks)
3656         {
3657           /* Work out the index of this PLT entry.  */
3658           rela_index = ((h->plt.offset - htab->plt_header_size)
3659                         / htab->plt_entry_size);
3660
3661           /* Calculate the offset of the associated .got.plt entry.
3662              The first three entries are reserved.  */
3663           got_offset = (rela_index + 3) * 4;
3664
3665           sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3666                                          rela_index, got_offset);
3667
3668
3669           /* On VxWorks, the relocation points to the .got.plt entry,
3670              not the .plt entry.  */
3671           rela.r_offset = (htab->sgotplt->output_section->vma
3672                            + htab->sgotplt->output_offset
3673                            + got_offset);
3674           rela.r_addend = 0;
3675         }
3676       else
3677         {
3678           /* Fill in the entry in the procedure linkage table.  */
3679           rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3680                                                   h->plt.offset, splt->size,
3681                                                   &r_offset);
3682
3683           rela.r_offset = r_offset
3684             + (splt->output_section->vma + splt->output_offset);
3685           if (! ABI_64_P (output_bfd)
3686               || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3687             {
3688               rela.r_addend = 0;
3689             }
3690           else
3691             {
3692               rela.r_addend = (-(h->plt.offset + 4)
3693                                - splt->output_section->vma
3694                                - splt->output_offset);
3695             }
3696         }
3697       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3698
3699       /* Adjust for the first 4 reserved elements in the .plt section
3700          when setting the offset in the .rela.plt section.
3701          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3702          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3703
3704       loc = srela->contents;
3705       loc += rela_index * bed->s->sizeof_rela;
3706       bed->s->swap_reloca_out (output_bfd, &rela, loc);
3707
3708       if (!h->def_regular)
3709         {
3710           /* Mark the symbol as undefined, rather than as defined in
3711              the .plt section.  Leave the value alone.  */
3712           sym->st_shndx = SHN_UNDEF;
3713           /* If the symbol is weak, we do need to clear the value.
3714              Otherwise, the PLT entry would provide a definition for
3715              the symbol even if the symbol wasn't defined anywhere,
3716              and so the symbol would never be NULL.  */
3717           if (!h->ref_regular_nonweak)
3718             sym->st_value = 0;
3719         }
3720     }
3721
3722   if (h->got.offset != (bfd_vma) -1
3723       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3724       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3725     {
3726       asection *sgot;
3727       asection *srela;
3728       Elf_Internal_Rela rela;
3729
3730       /* This symbol has an entry in the GOT.  Set it up.  */
3731
3732       sgot = htab->sgot;
3733       srela = htab->srelgot;
3734       BFD_ASSERT (sgot != NULL && srela != NULL);
3735
3736       rela.r_offset = (sgot->output_section->vma
3737                        + sgot->output_offset
3738                        + (h->got.offset &~ (bfd_vma) 1));
3739
3740       /* If this is a -Bsymbolic link, and the symbol is defined
3741          locally, we just want to emit a RELATIVE reloc.  Likewise if
3742          the symbol was forced to be local because of a version file.
3743          The entry in the global offset table will already have been
3744          initialized in the relocate_section function.  */
3745       if (info->shared
3746           && (info->symbolic || h->dynindx == -1)
3747           && h->def_regular)
3748         {
3749           asection *sec = h->root.u.def.section;
3750           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3751           rela.r_addend = (h->root.u.def.value
3752                            + sec->output_section->vma
3753                            + sec->output_offset);
3754         }
3755       else
3756         {
3757           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3758           rela.r_addend = 0;
3759         }
3760
3761       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3762                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3763       sparc_elf_append_rela (output_bfd, srela, &rela);
3764     }
3765
3766   if (h->needs_copy)
3767     {
3768       asection *s;
3769       Elf_Internal_Rela rela;
3770
3771       /* This symbols needs a copy reloc.  Set it up.  */
3772       BFD_ASSERT (h->dynindx != -1);
3773
3774       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3775                                    ".rela.bss");
3776       BFD_ASSERT (s != NULL);
3777
3778       rela.r_offset = (h->root.u.def.value
3779                        + h->root.u.def.section->output_section->vma
3780                        + h->root.u.def.section->output_offset);
3781       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3782       rela.r_addend = 0;
3783       sparc_elf_append_rela (output_bfd, s, &rela);
3784     }
3785
3786   /* Mark some specially defined symbols as absolute.  On VxWorks,
3787      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3788      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
3789   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3790       || (!htab->is_vxworks
3791           && (h == htab->elf.hgot || h == htab->elf.hplt)))
3792     sym->st_shndx = SHN_ABS;
3793
3794   return TRUE;
3795 }
3796
3797 /* Finish up the dynamic sections.  */
3798
3799 static bfd_boolean
3800 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3801                   bfd *dynobj, asection *sdyn,
3802                   asection *splt ATTRIBUTE_UNUSED)
3803 {
3804   struct _bfd_sparc_elf_link_hash_table *htab;
3805   const struct elf_backend_data *bed;
3806   bfd_byte *dyncon, *dynconend;
3807   size_t dynsize;
3808   int stt_regidx = -1;
3809   bfd_boolean abi_64_p;
3810
3811   htab = _bfd_sparc_elf_hash_table (info);
3812   bed = get_elf_backend_data (output_bfd);
3813   dynsize = bed->s->sizeof_dyn;
3814   dynconend = sdyn->contents + sdyn->size;
3815   abi_64_p = ABI_64_P (output_bfd);
3816   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
3817     {
3818       Elf_Internal_Dyn dyn;
3819       const char *name;
3820       bfd_boolean size;
3821
3822       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
3823
3824       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3825         {
3826           /* On VxWorks, DT_RELASZ should not include the relocations
3827              in .rela.plt.  */
3828           if (htab->srelplt)
3829             {
3830               dyn.d_un.d_val -= htab->srelplt->size;
3831               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3832             }
3833         }
3834       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3835         {
3836           /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3837              not to the start of the PLT.  */
3838           if (htab->sgotplt)
3839             {
3840               dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3841                                 + htab->sgotplt->output_offset);
3842               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3843             }
3844         }
3845       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
3846         {
3847           if (stt_regidx == -1)
3848             {
3849               stt_regidx =
3850                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3851               if (stt_regidx == -1)
3852                 return FALSE;
3853             }
3854           dyn.d_un.d_val = stt_regidx++;
3855           bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3856         }
3857       else
3858         {
3859           switch (dyn.d_tag)
3860             {
3861             case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3862             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3863             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3864             default:          name = NULL; size = FALSE; break;
3865             }
3866
3867           if (name != NULL)
3868             {
3869               asection *s;
3870
3871               s = bfd_get_section_by_name (output_bfd, name);
3872               if (s == NULL)
3873                 dyn.d_un.d_val = 0;
3874               else
3875                 {
3876                   if (! size)
3877                     dyn.d_un.d_ptr = s->vma;
3878                   else
3879                     dyn.d_un.d_val = s->size;
3880                 }
3881               bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3882             }
3883         }
3884     }
3885   return TRUE;
3886 }
3887
3888 /* Install the first PLT entry in a VxWorks executable and make sure that
3889    .rela.plt.unloaded relocations have the correct symbol indexes.  */
3890
3891 static void
3892 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3893 {
3894   struct _bfd_sparc_elf_link_hash_table *htab;
3895   Elf_Internal_Rela rela;
3896   bfd_vma got_base;
3897   bfd_byte *loc;
3898
3899   htab = _bfd_sparc_elf_hash_table (info);
3900
3901   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
3902   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3903               + htab->elf.hgot->root.u.def.section->output_offset
3904               + htab->elf.hgot->root.u.def.value);
3905
3906   /* Install the initial PLT entry.  */
3907   bfd_put_32 (output_bfd,
3908               sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3909               htab->splt->contents);
3910   bfd_put_32 (output_bfd,
3911               sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3912               htab->splt->contents + 4);
3913   bfd_put_32 (output_bfd,
3914               sparc_vxworks_exec_plt0_entry[2],
3915               htab->splt->contents + 8);
3916   bfd_put_32 (output_bfd,
3917               sparc_vxworks_exec_plt0_entry[3],
3918               htab->splt->contents + 12);
3919   bfd_put_32 (output_bfd,
3920               sparc_vxworks_exec_plt0_entry[4],
3921               htab->splt->contents + 16);
3922
3923   loc = htab->srelplt2->contents;
3924
3925   /* Add an unloaded relocation for the initial entry's "sethi".  */
3926   rela.r_offset = (htab->splt->output_section->vma
3927                    + htab->splt->output_offset);
3928   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3929   rela.r_addend = 8;
3930   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3931   loc += sizeof (Elf32_External_Rela);
3932
3933   /* Likewise the following "or".  */
3934   rela.r_offset += 4;
3935   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3936   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3937   loc += sizeof (Elf32_External_Rela);
3938
3939   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
3940      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
3941      in which symbols were output.  */
3942   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
3943     {
3944       Elf_Internal_Rela rel;
3945
3946       /* The entry's initial "sethi" (against _G_O_T_).  */
3947       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
3948       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3949       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3950       loc += sizeof (Elf32_External_Rela);
3951
3952       /* The following "or" (also 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_LO10);
3955       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3956       loc += sizeof (Elf32_External_Rela);
3957
3958       /* The .got.plt entry (against _P_L_T_).  */
3959       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
3960       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3961       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3962       loc += sizeof (Elf32_External_Rela);
3963     }
3964 }
3965
3966 /* Install the first PLT entry in a VxWorks shared object.  */
3967
3968 static void
3969 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
3970 {
3971   struct _bfd_sparc_elf_link_hash_table *htab;
3972   unsigned int i;
3973
3974   htab = _bfd_sparc_elf_hash_table (info);
3975   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
3976     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
3977                 htab->splt->contents + i * 4);
3978 }
3979
3980 bfd_boolean
3981 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3982 {
3983   bfd *dynobj;
3984   asection *sdyn;
3985   struct _bfd_sparc_elf_link_hash_table *htab;
3986
3987   htab = _bfd_sparc_elf_hash_table (info);
3988   dynobj = htab->elf.dynobj;
3989
3990   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3991
3992   if (elf_hash_table (info)->dynamic_sections_created)
3993     {
3994       asection *splt;
3995
3996       splt = bfd_get_section_by_name (dynobj, ".plt");
3997       BFD_ASSERT (splt != NULL && sdyn != NULL);
3998
3999       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4000         return FALSE;
4001
4002       /* Initialize the contents of the .plt section.  */
4003       if (splt->size > 0)
4004         {
4005           if (htab->is_vxworks)
4006             {
4007               if (info->shared)
4008                 sparc_vxworks_finish_shared_plt (output_bfd, info);
4009               else
4010                 sparc_vxworks_finish_exec_plt (output_bfd, info);
4011             }
4012           else
4013             {
4014               memset (splt->contents, 0, htab->plt_header_size);
4015               if (!ABI_64_P (output_bfd))
4016                 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4017                             splt->contents + splt->size - 4);
4018             }
4019         }
4020
4021       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4022         = (htab->is_vxworks || !ABI_64_P (output_bfd))
4023           ? 0 : htab->plt_entry_size;
4024     }
4025
4026   /* Set the first entry in the global offset table to the address of
4027      the dynamic section.  */
4028   if (htab->sgot && htab->sgot->size > 0)
4029     {
4030       bfd_vma val = (sdyn ?
4031                      sdyn->output_section->vma + sdyn->output_offset :
4032                      0);
4033
4034       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4035     }
4036
4037   if (htab->sgot)
4038     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4039       SPARC_ELF_WORD_BYTES (htab);
4040
4041   return TRUE;
4042 }
4043
4044 \f
4045 /* Set the right machine number for a SPARC ELF file.  */
4046
4047 bfd_boolean
4048 _bfd_sparc_elf_object_p (bfd *abfd)
4049 {
4050   if (ABI_64_P (abfd))
4051     {
4052       unsigned long mach = bfd_mach_sparc_v9;
4053
4054       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4055         mach = bfd_mach_sparc_v9b;
4056       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4057         mach = bfd_mach_sparc_v9a;
4058       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4059     }
4060   else
4061     {
4062       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4063         {
4064           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4065             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4066                                               bfd_mach_sparc_v8plusb);
4067           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4068             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4069                                               bfd_mach_sparc_v8plusa);
4070           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4071             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4072                                               bfd_mach_sparc_v8plus);
4073           else
4074             return FALSE;
4075         }
4076       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4077         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4078                                           bfd_mach_sparc_sparclite_le);
4079       else
4080         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4081     }
4082 }
4083
4084 /* Return address for Ith PLT stub in section PLT, for relocation REL
4085    or (bfd_vma) -1 if it should not be included.  */
4086
4087 bfd_vma
4088 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4089 {
4090   if (ABI_64_P (plt->owner))
4091     {
4092       bfd_vma j;
4093
4094       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4095       if (i < PLT64_LARGE_THRESHOLD)
4096         return plt->vma + i * PLT64_ENTRY_SIZE;
4097
4098       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4099       i -= j;
4100       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4101     }
4102   else
4103     return rel->address;
4104 }