bfd/elfxx-sparc.c

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