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 (dynobj, ".rela.got");
 833   if (htab->srelgot == NULL
 834       || ! bfd_set_section_flags (dynobj, htab->srelgot, SEC_ALLOC
 835                                                          | SEC_LOAD
 836                                                          | SEC_HAS_CONTENTS
 837                                                          | SEC_IN_MEMORY
 838                                                          | SEC_LINKER_CREATED
 839                                                          | SEC_READONLY)
 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                       sreloc = bfd_make_section (dynobj, name);
1349                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1350                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1351                       if ((sec->flags & SEC_ALLOC) != 0)
1352                         flags |= SEC_ALLOC | SEC_LOAD;
1353                       if (sreloc == NULL
1354                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
1355                           || ! bfd_set_section_alignment (dynobj, sreloc,
1356                                                           htab->word_align_power))
1357                         return FALSE;
1358                     }
1359                   elf_section_data (sec)->sreloc = sreloc;
1360                 }
1361
1362               /* If this is a global symbol, we count the number of
1363                  relocations we need for this symbol.  */
1364               if (h != NULL)
1365                 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1366               else
1367                 {
1368                   /* Track dynamic relocs needed for local syms too.
1369                      We really need local syms available to do this
1370                      easily.  Oh well.  */
1371
1372                   asection *s;
1373                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1374                                                  sec, r_symndx);
1375                   if (s == NULL)
1376                     return FALSE;
1377
1378                   head = ((struct _bfd_sparc_elf_dyn_relocs **)
1379                           &elf_section_data (s)->local_dynrel);
1380                 }
1381
1382               p = *head;
1383               if (p == NULL || p->sec != sec)
1384                 {
1385                   bfd_size_type amt = sizeof *p;
1386                   p = ((struct _bfd_sparc_elf_dyn_relocs *)
1387                        bfd_alloc (htab->elf.dynobj, amt));
1388                   if (p == NULL)
1389                     return FALSE;
1390                   p->next = *head;
1391                   *head = p;
1392                   p->sec = sec;
1393                   p->count = 0;
1394                   p->pc_count = 0;
1395                 }
1396
1397               p->count += 1;
1398               if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1399                 p->pc_count += 1;
1400             }
1401
1402           break;
1403
1404         case R_SPARC_GNU_VTINHERIT:
1405           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1406             return FALSE;
1407           break;
1408
1409         case R_SPARC_GNU_VTENTRY:
1410           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1411             return FALSE;
1412           break;
1413
1414         case R_SPARC_REGISTER:
1415           /* Nothing to do.  */
1416           break;
1417
1418         default:
1419           break;
1420         }
1421     }
1422
1423   return TRUE;
1424 }
1425 \f
1426 asection *
1427 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1428                              struct bfd_link_info *info,
1429                              Elf_Internal_Rela *rel,
1430                              struct elf_link_hash_entry *h,
1431                              Elf_Internal_Sym *sym)
1432 {
1433   if (h != NULL)
1434     {
1435       struct _bfd_sparc_elf_link_hash_table *htab;
1436
1437       htab = _bfd_sparc_elf_hash_table (info);
1438       switch (SPARC_ELF_R_TYPE (rel->r_info))
1439       {
1440       case R_SPARC_GNU_VTINHERIT:
1441       case R_SPARC_GNU_VTENTRY:
1442         break;
1443
1444       default:
1445         switch (h->root.type)
1446           {
1447           case bfd_link_hash_defined:
1448           case bfd_link_hash_defweak:
1449             return h->root.u.def.section;
1450
1451           case bfd_link_hash_common:
1452             return h->root.u.c.p->section;
1453
1454           default:
1455             break;
1456           }
1457       }
1458     }
1459   else
1460     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1461
1462   return NULL;
1463 }
1464
1465 /* Update the got entry reference counts for the section being removed.  */
1466 bfd_boolean
1467 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1468                               asection *sec, const Elf_Internal_Rela *relocs)
1469 {
1470   struct _bfd_sparc_elf_link_hash_table *htab;
1471   Elf_Internal_Shdr *symtab_hdr;
1472   struct elf_link_hash_entry **sym_hashes;
1473   bfd_signed_vma *local_got_refcounts;
1474   const Elf_Internal_Rela *rel, *relend;
1475
1476   elf_section_data (sec)->local_dynrel = NULL;
1477
1478   htab = _bfd_sparc_elf_hash_table (info);
1479   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1480   sym_hashes = elf_sym_hashes (abfd);
1481   local_got_refcounts = elf_local_got_refcounts (abfd);
1482
1483   relend = relocs + sec->reloc_count;
1484   for (rel = relocs; rel < relend; rel++)
1485     {
1486       unsigned long r_symndx;
1487       unsigned int r_type;
1488       struct elf_link_hash_entry *h = NULL;
1489
1490       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1491       if (r_symndx >= symtab_hdr->sh_info)
1492         {
1493           struct _bfd_sparc_elf_link_hash_entry *eh;
1494           struct _bfd_sparc_elf_dyn_relocs **pp;
1495           struct _bfd_sparc_elf_dyn_relocs *p;
1496
1497           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1498           while (h->root.type == bfd_link_hash_indirect
1499                  || h->root.type == bfd_link_hash_warning)
1500             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1501           eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1502           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1503             if (p->sec == sec)
1504               {
1505                 /* Everything must go for SEC.  */
1506                 *pp = p->next;
1507                 break;
1508               }
1509         }
1510
1511       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1512       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1513       switch (r_type)
1514         {
1515         case R_SPARC_TLS_LDM_HI22:
1516         case R_SPARC_TLS_LDM_LO10:
1517           if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1518             _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1519           break;
1520
1521         case R_SPARC_TLS_GD_HI22:
1522         case R_SPARC_TLS_GD_LO10:
1523         case R_SPARC_TLS_IE_HI22:
1524         case R_SPARC_TLS_IE_LO10:
1525         case R_SPARC_GOT10:
1526         case R_SPARC_GOT13:
1527         case R_SPARC_GOT22:
1528           if (h != NULL)
1529             {
1530               if (h->got.refcount > 0)
1531                 h->got.refcount--;
1532             }
1533           else
1534             {
1535               if (local_got_refcounts[r_symndx] > 0)
1536                 local_got_refcounts[r_symndx]--;
1537             }
1538           break;
1539
1540         case R_SPARC_PC10:
1541         case R_SPARC_PC22:
1542         case R_SPARC_PC_HH22:
1543         case R_SPARC_PC_HM10:
1544         case R_SPARC_PC_LM22:
1545           if (h != NULL
1546               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1547             break;
1548           /* Fall through.  */
1549
1550         case R_SPARC_DISP8:
1551         case R_SPARC_DISP16:
1552         case R_SPARC_DISP32:
1553         case R_SPARC_DISP64:
1554         case R_SPARC_WDISP30:
1555         case R_SPARC_WDISP22:
1556         case R_SPARC_WDISP19:
1557         case R_SPARC_WDISP16:
1558         case R_SPARC_8:
1559         case R_SPARC_16:
1560         case R_SPARC_32:
1561         case R_SPARC_HI22:
1562         case R_SPARC_22:
1563         case R_SPARC_13:
1564         case R_SPARC_LO10:
1565         case R_SPARC_UA16:
1566         case R_SPARC_UA32:
1567         case R_SPARC_PLT32:
1568         case R_SPARC_10:
1569         case R_SPARC_11:
1570         case R_SPARC_64:
1571         case R_SPARC_OLO10:
1572         case R_SPARC_HH22:
1573         case R_SPARC_HM10:
1574         case R_SPARC_LM22:
1575         case R_SPARC_7:
1576         case R_SPARC_5:
1577         case R_SPARC_6:
1578         case R_SPARC_HIX22:
1579         case R_SPARC_LOX10:
1580         case R_SPARC_H44:
1581         case R_SPARC_M44:
1582         case R_SPARC_L44:
1583         case R_SPARC_UA64:
1584           if (info->shared)
1585             break;
1586           /* Fall through.  */
1587
1588         case R_SPARC_WPLT30:
1589           if (h != NULL)
1590             {
1591               if (h->plt.refcount > 0)
1592                 h->plt.refcount--;
1593             }
1594           break;
1595
1596         default:
1597           break;
1598         }
1599     }
1600
1601   return TRUE;
1602 }
1603
1604 /* Adjust a symbol defined by a dynamic object and referenced by a
1605    regular object.  The current definition is in some section of the
1606    dynamic object, but we're not including those sections.  We have to
1607    change the definition to something the rest of the link can
1608    understand.  */
1609
1610 bfd_boolean
1611 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1612                                      struct elf_link_hash_entry *h)
1613 {
1614   struct _bfd_sparc_elf_link_hash_table *htab;
1615   struct _bfd_sparc_elf_link_hash_entry * eh;
1616   struct _bfd_sparc_elf_dyn_relocs *p;
1617   asection *s;
1618   unsigned int power_of_two;
1619
1620   htab = _bfd_sparc_elf_hash_table (info);
1621
1622   /* Make sure we know what is going on here.  */
1623   BFD_ASSERT (htab->elf.dynobj != NULL
1624               && (h->needs_plt
1625                   || h->u.weakdef != NULL
1626                   || (h->def_dynamic
1627                       && h->ref_regular
1628                       && !h->def_regular)));
1629
1630   /* If this is a function, put it in the procedure linkage table.  We
1631      will fill in the contents of the procedure linkage table later
1632      (although we could actually do it here).  The STT_NOTYPE
1633      condition is a hack specifically for the Oracle libraries
1634      delivered for Solaris; for some inexplicable reason, they define
1635      some of their functions as STT_NOTYPE when they really should be
1636      STT_FUNC.  */
1637   if (h->type == STT_FUNC
1638       || h->needs_plt
1639       || (h->type == STT_NOTYPE
1640           && (h->root.type == bfd_link_hash_defined
1641               || h->root.type == bfd_link_hash_defweak)
1642           && (h->root.u.def.section->flags & SEC_CODE) != 0))
1643     {
1644       if (h->plt.refcount <= 0
1645           || (! info->shared
1646               && !h->def_dynamic
1647               && !h->ref_dynamic
1648               && h->root.type != bfd_link_hash_undefweak
1649               && h->root.type != bfd_link_hash_undefined))
1650         {
1651           /* This case can occur if we saw a WPLT30 reloc in an input
1652              file, but the symbol was never referred to by a dynamic
1653              object, or if all references were garbage collected.  In
1654              such a case, we don't actually need to build a procedure
1655              linkage table, and we can just do a WDISP30 reloc instead.  */
1656           h->plt.offset = (bfd_vma) -1;
1657           h->needs_plt = 0;
1658         }
1659
1660       return TRUE;
1661     }
1662   else
1663     h->plt.offset = (bfd_vma) -1;
1664
1665   /* If this is a weak symbol, and there is a real definition, the
1666      processor independent code will have arranged for us to see the
1667      real definition first, and we can just use the same value.  */
1668   if (h->u.weakdef != NULL)
1669     {
1670       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1671                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1672       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1673       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1674       return TRUE;
1675     }
1676
1677   /* This is a reference to a symbol defined by a dynamic object which
1678      is not a function.  */
1679
1680   /* If we are creating a shared library, we must presume that the
1681      only references to the symbol are via the global offset table.
1682      For such cases we need not do anything here; the relocations will
1683      be handled correctly by relocate_section.  */
1684   if (info->shared)
1685     return TRUE;
1686
1687   /* If there are no references to this symbol that do not use the
1688      GOT, we don't need to generate a copy reloc.  */
1689   if (!h->non_got_ref)
1690     return TRUE;
1691
1692   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1693   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1694     {
1695       s = p->sec->output_section;
1696       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1697         break;
1698     }
1699
1700   /* If we didn't find any dynamic relocs in read-only sections, then
1701      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1702   if (p == NULL)
1703     {
1704       h->non_got_ref = 0;
1705       return TRUE;
1706     }
1707
1708   /* We must allocate the symbol in our .dynbss section, which will
1709      become part of the .bss section of the executable.  There will be
1710      an entry for this symbol in the .dynsym section.  The dynamic
1711      object will contain position independent code, so all references
1712      from the dynamic object to this symbol will go through the global
1713      offset table.  The dynamic linker will use the .dynsym entry to
1714      determine the address it must put in the global offset table, so
1715      both the dynamic object and the regular object will refer to the
1716      same memory location for the variable.  */
1717
1718   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1719      to copy the initial value out of the dynamic object and into the
1720      runtime process image.  We need to remember the offset into the
1721      .rel.bss section we are going to use.  */
1722   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1723     {
1724       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1725       h->needs_copy = 1;
1726     }
1727
1728   /* We need to figure out the alignment required for this symbol.  I
1729      have no idea how ELF linkers handle this.  */
1730   power_of_two = bfd_log2 (h->size);
1731   if (power_of_two > htab->align_power_max)
1732     power_of_two = htab->align_power_max;
1733
1734   /* Apply the required alignment.  */
1735   s = htab->sdynbss;
1736   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1737   if (power_of_two > bfd_get_section_alignment (dynobj, s))
1738     {
1739       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1740         return FALSE;
1741     }
1742
1743   /* Define the symbol as being at this point in the section.  */
1744   h->root.u.def.section = s;
1745   h->root.u.def.value = s->size;
1746
1747   /* Increment the section size to make room for the symbol.  */
1748   s->size += h->size;
1749
1750   return TRUE;
1751 }
1752
1753 /* Allocate space in .plt, .got and associated reloc sections for
1754    dynamic relocs.  */
1755
1756 static bfd_boolean
1757 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1758 {
1759   struct bfd_link_info *info;
1760   struct _bfd_sparc_elf_link_hash_table *htab;
1761   struct _bfd_sparc_elf_link_hash_entry *eh;
1762   struct _bfd_sparc_elf_dyn_relocs *p;
1763
1764   if (h->root.type == bfd_link_hash_indirect)
1765     return TRUE;
1766
1767   if (h->root.type == bfd_link_hash_warning)
1768     /* When warning symbols are created, they **replace** the "real"
1769        entry in the hash table, thus we never get to see the real
1770        symbol in a hash traversal.  So look at it now.  */
1771     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1772
1773   info = (struct bfd_link_info *) inf;
1774   htab = _bfd_sparc_elf_hash_table (info);
1775
1776   if (htab->elf.dynamic_sections_created
1777       && h->plt.refcount > 0)
1778     {
1779       /* Make sure this symbol is output as a dynamic symbol.
1780          Undefined weak syms won't yet be marked as dynamic.  */
1781       if (h->dynindx == -1
1782           && !h->forced_local)
1783         {
1784           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1785             return FALSE;
1786         }
1787
1788       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1789         {
1790           asection *s = htab->splt;
1791
1792           /* The first four entries in .plt is reserved.  */
1793           if (s->size == 0)
1794             s->size = (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1795                        PLT64_HEADER_SIZE : PLT32_HEADER_SIZE);
1796
1797           /* The procedure linkage table size is bounded by the magnitude
1798              of the offset we can describe in the entry.  */
1799           if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1800                           (((bfd_vma)1 << 31) << 1) : 0x400000))
1801             {
1802               bfd_set_error (bfd_error_bad_value);
1803               return FALSE;
1804             }
1805
1806           if (SPARC_ELF_WORD_BYTES(htab) == 8
1807               && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1808             {
1809               bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1810
1811
1812               off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1813
1814               h->plt.offset = (s->size - (off * 8));
1815             }
1816           else
1817             h->plt.offset = s->size;
1818
1819           /* If this symbol is not defined in a regular file, and we are
1820              not generating a shared library, then set the symbol to this
1821              location in the .plt.  This is required to make function
1822              pointers compare as equal between the normal executable and
1823              the shared library.  */
1824           if (! info->shared
1825               && !h->def_regular)
1826             {
1827               h->root.u.def.section = s;
1828               h->root.u.def.value = h->plt.offset;
1829             }
1830
1831           /* Make room for this entry.  */
1832           s->size += (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1833                       PLT64_ENTRY_SIZE : PLT32_ENTRY_SIZE);
1834
1835           /* We also need to make an entry in the .rela.plt section.  */
1836           htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1837         }
1838       else
1839         {
1840           h->plt.offset = (bfd_vma) -1;
1841           h->needs_plt = 0;
1842         }
1843     }
1844   else
1845     {
1846       h->plt.offset = (bfd_vma) -1;
1847       h->needs_plt = 0;
1848     }
1849
1850   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1851      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1852   if (h->got.refcount > 0
1853       && !info->shared
1854       && h->dynindx == -1
1855       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1856     h->got.offset = (bfd_vma) -1;
1857   else if (h->got.refcount > 0)
1858     {
1859       asection *s;
1860       bfd_boolean dyn;
1861       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1862
1863       /* Make sure this symbol is output as a dynamic symbol.
1864          Undefined weak syms won't yet be marked as dynamic.  */
1865       if (h->dynindx == -1
1866           && !h->forced_local)
1867         {
1868           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1869             return FALSE;
1870         }
1871
1872       s = htab->sgot;
1873       h->got.offset = s->size;
1874       s->size += SPARC_ELF_WORD_BYTES (htab);
1875       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1876       if (tls_type == GOT_TLS_GD)
1877         s->size += SPARC_ELF_WORD_BYTES (htab);
1878       dyn = htab->elf.dynamic_sections_created;
1879       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1880          R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1881          global.  */
1882       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1883           || tls_type == GOT_TLS_IE)
1884         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1885       else if (tls_type == GOT_TLS_GD)
1886         htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
1887       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1888         htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1889     }
1890   else
1891     h->got.offset = (bfd_vma) -1;
1892
1893   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1894   if (eh->dyn_relocs == NULL)
1895     return TRUE;
1896
1897   /* In the shared -Bsymbolic case, discard space allocated for
1898      dynamic pc-relative relocs against symbols which turn out to be
1899      defined in regular objects.  For the normal shared case, discard
1900      space for pc-relative relocs that have become local due to symbol
1901      visibility changes.  */
1902
1903   if (info->shared)
1904     {
1905       if (h->def_regular
1906           && (h->forced_local
1907               || info->symbolic))
1908         {
1909           struct _bfd_sparc_elf_dyn_relocs **pp;
1910
1911           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1912             {
1913               p->count -= p->pc_count;
1914               p->pc_count = 0;
1915               if (p->count == 0)
1916                 *pp = p->next;
1917               else
1918                 pp = &p->next;
1919             }
1920         }
1921     }
1922   else
1923     {
1924       /* For the non-shared case, discard space for relocs against
1925          symbols which turn out to need copy relocs or are not
1926          dynamic.  */
1927
1928       if (!h->non_got_ref
1929           && ((h->def_dynamic
1930                && !h->def_regular)
1931               || (htab->elf.dynamic_sections_created
1932                   && (h->root.type == bfd_link_hash_undefweak
1933                       || h->root.type == bfd_link_hash_undefined))))
1934         {
1935           /* Make sure this symbol is output as a dynamic symbol.
1936              Undefined weak syms won't yet be marked as dynamic.  */
1937           if (h->dynindx == -1
1938               && !h->forced_local)
1939             {
1940               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1941                 return FALSE;
1942             }
1943
1944           /* If that succeeded, we know we'll be keeping all the
1945              relocs.  */
1946           if (h->dynindx != -1)
1947             goto keep;
1948         }
1949
1950       eh->dyn_relocs = NULL;
1951
1952     keep: ;
1953     }
1954
1955   /* Finally, allocate space.  */
1956   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1957     {
1958       asection *sreloc = elf_section_data (p->sec)->sreloc;
1959       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
1960     }
1961
1962   return TRUE;
1963 }
1964
1965 /* Find any dynamic relocs that apply to read-only sections.  */
1966
1967 static bfd_boolean
1968 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1969 {
1970   struct _bfd_sparc_elf_link_hash_entry *eh;
1971   struct _bfd_sparc_elf_dyn_relocs *p;
1972
1973   if (h->root.type == bfd_link_hash_warning)
1974     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1975
1976   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1977   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1978     {
1979       asection *s = p->sec->output_section;
1980
1981       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1982         {
1983           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1984
1985           info->flags |= DF_TEXTREL;
1986
1987           /* Not an error, just cut short the traversal.  */
1988           return FALSE;
1989         }
1990     }
1991   return TRUE;
1992 }
1993
1994 /* Return true if the dynamic symbol for a given section should be
1995    omitted when creating a shared library.  */
1996
1997 bfd_boolean
1998 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
1999                                     struct bfd_link_info *info,
2000                                     asection *p)
2001 {
2002   /* We keep the .got section symbol so that explicit relocations
2003      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2004      can be turned into relocations against the .got symbol.  */
2005   if (strcmp (p->name, ".got") == 0)
2006     return FALSE;
2007
2008   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2009 }
2010
2011 /* Set the sizes of the dynamic sections.  */
2012
2013 bfd_boolean
2014 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2015                                       struct bfd_link_info *info)
2016 {
2017   struct _bfd_sparc_elf_link_hash_table *htab;
2018   bfd *dynobj;
2019   asection *s;
2020   bfd *ibfd;
2021
2022   htab = _bfd_sparc_elf_hash_table (info);
2023   dynobj = htab->elf.dynobj;
2024   BFD_ASSERT (dynobj != NULL);
2025
2026   if (elf_hash_table (info)->dynamic_sections_created)
2027     {
2028       /* Set the contents of the .interp section to the interpreter.  */
2029       if (info->executable)
2030         {
2031           s = bfd_get_section_by_name (dynobj, ".interp");
2032           BFD_ASSERT (s != NULL);
2033           s->size = htab->dynamic_interpreter_size;
2034           s->contents = (unsigned char *) htab->dynamic_interpreter;
2035         }
2036     }
2037
2038   /* Set up .got offsets for local syms, and space for local dynamic
2039      relocs.  */
2040   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2041     {
2042       bfd_signed_vma *local_got;
2043       bfd_signed_vma *end_local_got;
2044       char *local_tls_type;
2045       bfd_size_type locsymcount;
2046       Elf_Internal_Shdr *symtab_hdr;
2047       asection *srel;
2048
2049       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2050         continue;
2051
2052       for (s = ibfd->sections; s != NULL; s = s->next)
2053         {
2054           struct _bfd_sparc_elf_dyn_relocs *p;
2055
2056           for (p = *((struct _bfd_sparc_elf_dyn_relocs **)
2057                      &elf_section_data (s)->local_dynrel);
2058                p != NULL;
2059                p = p->next)
2060             {
2061               if (!bfd_is_abs_section (p->sec)
2062                   && bfd_is_abs_section (p->sec->output_section))
2063                 {
2064                   /* Input section has been discarded, either because
2065                      it is a copy of a linkonce section or due to
2066                      linker script /DISCARD/, so we'll be discarding
2067                      the relocs too.  */
2068                 }
2069               else if (p->count != 0)
2070                 {
2071                   srel = elf_section_data (p->sec)->sreloc;
2072                   srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2073                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2074                     info->flags |= DF_TEXTREL;
2075                 }
2076             }
2077         }
2078
2079       local_got = elf_local_got_refcounts (ibfd);
2080       if (!local_got)
2081         continue;
2082
2083       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2084       locsymcount = symtab_hdr->sh_info;
2085       end_local_got = local_got + locsymcount;
2086       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2087       s = htab->sgot;
2088       srel = htab->srelgot;
2089       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2090         {
2091           if (*local_got > 0)
2092             {
2093               *local_got = s->size;
2094               s->size += SPARC_ELF_WORD_BYTES (htab);
2095               if (*local_tls_type == GOT_TLS_GD)
2096                 s->size += SPARC_ELF_WORD_BYTES (htab);
2097               if (info->shared
2098                   || *local_tls_type == GOT_TLS_GD
2099                   || *local_tls_type == GOT_TLS_IE)
2100                 srel->size += SPARC_ELF_RELA_BYTES (htab);
2101             }
2102           else
2103             *local_got = (bfd_vma) -1;
2104         }
2105     }
2106
2107   if (htab->tls_ldm_got.refcount > 0)
2108     {
2109       /* Allocate 2 got entries and 1 dynamic reloc for
2110          R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2111       htab->tls_ldm_got.offset = htab->sgot->size;
2112       htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2113       htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2114     }
2115   else
2116     htab->tls_ldm_got.offset = -1;
2117
2118   /* Allocate global sym .plt and .got entries, and space for global
2119      sym dynamic relocs.  */
2120   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2121
2122   if (! ABI_64_P (output_bfd)
2123       && elf_hash_table (info)->dynamic_sections_created)
2124     {
2125       /* Make space for the trailing nop in .plt.  */
2126       if (htab->splt->size > 0)
2127         htab->splt->size += 1 * SPARC_INSN_BYTES;
2128
2129       /* If the .got section is more than 0x1000 bytes, we add
2130          0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2131          bit relocations have a greater chance of working.
2132
2133          FIXME: Make this optimization work for 64-bit too.  */
2134       if (htab->sgot->size >= 0x1000
2135           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2136         elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2137     }
2138
2139   /* The check_relocs and adjust_dynamic_symbol entry points have
2140      determined the sizes of the various dynamic sections.  Allocate
2141      memory for them.  */
2142   for (s = dynobj->sections; s != NULL; s = s->next)
2143     {
2144       const char *name;
2145       bfd_boolean strip = FALSE;
2146
2147       if ((s->flags & SEC_LINKER_CREATED) == 0)
2148         continue;
2149
2150       /* It's OK to base decisions on the section name, because none
2151          of the dynobj section names depend upon the input files.  */
2152       name = bfd_get_section_name (dynobj, s);
2153
2154       if (strncmp (name, ".rela", 5) == 0)
2155         {
2156           if (s->size == 0)
2157             {
2158               /* If we don't need this section, strip it from the
2159                  output file.  This is to handle .rela.bss and
2160                  .rel.plt.  We must create it in
2161                  create_dynamic_sections, because it must be created
2162                  before the linker maps input sections to output
2163                  sections.  The linker does that before
2164                  adjust_dynamic_symbol is called, and it is that
2165                  function which decides whether anything needs to go
2166                  into these sections.  */
2167               strip = TRUE;
2168             }
2169           else
2170             {
2171               /* We use the reloc_count field as a counter if we need
2172                  to copy relocs into the output file.  */
2173               s->reloc_count = 0;
2174             }
2175         }
2176       else if (s != htab->splt && s != htab->sgot)
2177         {
2178           /* It's not one of our sections, so don't allocate space.  */
2179           continue;
2180         }
2181
2182       if (strip)
2183         {
2184           s->flags |= SEC_EXCLUDE;
2185           continue;
2186         }
2187
2188       /* Allocate memory for the section contents.  Zero the memory
2189          for the benefit of .rela.plt, which has 4 unused entries
2190          at the beginning, and we don't want garbage.  */
2191       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2192       if (s->contents == NULL && s->size != 0)
2193         return FALSE;
2194     }
2195
2196   if (elf_hash_table (info)->dynamic_sections_created)
2197     {
2198       /* Add some entries to the .dynamic section.  We fill in the
2199          values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2200          must add the entries now so that we get the correct size for
2201          the .dynamic section.  The DT_DEBUG entry is filled in by the
2202          dynamic linker and used by the debugger.  */
2203 #define add_dynamic_entry(TAG, VAL) \
2204   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2205
2206       if (info->executable)
2207         {
2208           if (!add_dynamic_entry (DT_DEBUG, 0))
2209             return FALSE;
2210         }
2211
2212       if (htab->srelplt->size != 0)
2213         {
2214           if (!add_dynamic_entry (DT_PLTGOT, 0)
2215               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2216               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2217               || !add_dynamic_entry (DT_JMPREL, 0))
2218             return FALSE;
2219         }
2220
2221       if (!add_dynamic_entry (DT_RELA, 0)
2222           || !add_dynamic_entry (DT_RELASZ, 0)
2223           || !add_dynamic_entry (DT_RELAENT,
2224                                  SPARC_ELF_RELA_BYTES (htab)))
2225         return FALSE;
2226
2227       /* If any dynamic relocs apply to a read-only section,
2228          then we need a DT_TEXTREL entry.  */
2229       if ((info->flags & DF_TEXTREL) == 0)
2230         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2231                                 (PTR) info);
2232
2233       if (info->flags & DF_TEXTREL)
2234         {
2235           if (!add_dynamic_entry (DT_TEXTREL, 0))
2236             return FALSE;
2237         }
2238
2239       if (ABI_64_P (output_bfd))
2240         {
2241           int reg;
2242           struct _bfd_sparc_elf_app_reg * app_regs;
2243           struct elf_strtab_hash *dynstr;
2244           struct elf_link_hash_table *eht = elf_hash_table (info);
2245
2246           /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2247              entries if needed.  */
2248           app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2249           dynstr = eht->dynstr;
2250
2251           for (reg = 0; reg < 4; reg++)
2252             if (app_regs [reg].name != NULL)
2253               {
2254                 struct elf_link_local_dynamic_entry *entry, *e;
2255
2256                 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2257                   return FALSE;
2258
2259                 entry = (struct elf_link_local_dynamic_entry *)
2260                   bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2261                 if (entry == NULL)
2262                   return FALSE;
2263
2264                 /* We cheat here a little bit: the symbol will not be local, so we
2265                    put it at the end of the dynlocal linked list.  We will fix it
2266                    later on, as we have to fix other fields anyway.  */
2267                 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2268                 entry->isym.st_size = 0;
2269                 if (*app_regs [reg].name != '\0')
2270                   entry->isym.st_name
2271                     = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2272                 else
2273                   entry->isym.st_name = 0;
2274                 entry->isym.st_other = 0;
2275                 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2276                                                    STT_REGISTER);
2277                 entry->isym.st_shndx = app_regs [reg].shndx;
2278                 entry->next = NULL;
2279                 entry->input_bfd = output_bfd;
2280                 entry->input_indx = -1;
2281
2282                 if (eht->dynlocal == NULL)
2283                   eht->dynlocal = entry;
2284                 else
2285                   {
2286                     for (e = eht->dynlocal; e->next; e = e->next)
2287                       ;
2288                     e->next = entry;
2289                   }
2290                 eht->dynsymcount++;
2291               }
2292         }
2293     }
2294 #undef add_dynamic_entry
2295
2296   return TRUE;
2297 }
2298 \f
2299 bfd_boolean
2300 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2301 {
2302   struct _bfd_sparc_elf_section_data *sdata;
2303   bfd_size_type amt = sizeof (*sdata);
2304
2305   sdata = (struct _bfd_sparc_elf_section_data *) bfd_zalloc (abfd, amt);
2306   if (sdata == NULL)
2307     return FALSE;
2308   sec->used_by_bfd = (PTR) sdata;
2309
2310   return _bfd_elf_new_section_hook (abfd, sec);
2311 }
2312
2313 bfd_boolean
2314 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2315                               struct bfd_section *section,
2316                               struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2317                               bfd_boolean *again)
2318 {
2319   *again = FALSE;
2320   sec_do_relax (section) = 1;
2321   return TRUE;
2322 }
2323 \f
2324 /* Return the base VMA address which should be subtracted from real addresses
2325    when resolving @dtpoff relocation.
2326    This is PT_TLS segment p_vaddr.  */
2327
2328 static bfd_vma
2329 dtpoff_base (struct bfd_link_info *info)
2330 {
2331   /* If tls_sec is NULL, we should have signalled an error already.  */
2332   if (elf_hash_table (info)->tls_sec == NULL)
2333     return 0;
2334   return elf_hash_table (info)->tls_sec->vma;
2335 }
2336
2337 /* Return the relocation value for @tpoff relocation
2338    if STT_TLS virtual address is ADDRESS.  */
2339
2340 static bfd_vma
2341 tpoff (struct bfd_link_info *info, bfd_vma address)
2342 {
2343   struct elf_link_hash_table *htab = elf_hash_table (info);
2344
2345   /* If tls_sec is NULL, we should have signalled an error already.  */
2346   if (htab->tls_sec == NULL)
2347     return 0;
2348   return address - htab->tls_size - htab->tls_sec->vma;
2349 }
2350
2351 /* Relocate a SPARC ELF section.  */
2352
2353 bfd_boolean
2354 _bfd_sparc_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2355                                  bfd *input_bfd, asection *input_section,
2356                                  bfd_byte *contents, Elf_Internal_Rela *relocs,
2357                                  Elf_Internal_Sym *local_syms, asection **local_sections)
2358 {
2359   struct _bfd_sparc_elf_link_hash_table *htab;
2360   Elf_Internal_Shdr *symtab_hdr;
2361   struct elf_link_hash_entry **sym_hashes;
2362   bfd_vma *local_got_offsets;
2363   bfd_vma got_base;
2364   asection *sreloc;
2365   Elf_Internal_Rela *rel;
2366   Elf_Internal_Rela *relend;
2367   int num_relocs;
2368
2369   if (info->relocatable)
2370     return TRUE;
2371
2372   htab = _bfd_sparc_elf_hash_table (info);
2373   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2374   sym_hashes = elf_sym_hashes (input_bfd);
2375   local_got_offsets = elf_local_got_offsets (input_bfd);
2376
2377   if (elf_hash_table (info)->hgot == NULL)
2378     got_base = 0;
2379   else
2380     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2381
2382   sreloc = elf_section_data (input_section)->sreloc;
2383
2384   rel = relocs;
2385   if (ABI_64_P (output_bfd))
2386     num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2387   else
2388     num_relocs = input_section->reloc_count;
2389   relend = relocs + num_relocs;
2390   for (; rel < relend; rel++)
2391     {
2392       int r_type, tls_type;
2393       reloc_howto_type *howto;
2394       unsigned long r_symndx;
2395       struct elf_link_hash_entry *h;
2396       Elf_Internal_Sym *sym;
2397       asection *sec;
2398       bfd_vma relocation, off;
2399       bfd_reloc_status_type r;
2400       bfd_boolean is_plt = FALSE;
2401       bfd_boolean unresolved_reloc;
2402
2403       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2404       if (r_type == R_SPARC_GNU_VTINHERIT
2405           || r_type == R_SPARC_GNU_VTENTRY)
2406         continue;
2407
2408       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2409         {
2410           bfd_set_error (bfd_error_bad_value);
2411           return FALSE;
2412         }
2413       howto = _bfd_sparc_elf_howto_table + r_type;
2414
2415       /* This is a final link.  */
2416       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2417       h = NULL;
2418       sym = NULL;
2419       sec = NULL;
2420       unresolved_reloc = FALSE;
2421       if (r_symndx < symtab_hdr->sh_info)
2422         {
2423           sym = local_syms + r_symndx;
2424           sec = local_sections[r_symndx];
2425           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2426         }
2427       else
2428         {
2429           bfd_boolean warned;
2430
2431           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2432                                    r_symndx, symtab_hdr, sym_hashes,
2433                                    h, sec, relocation,
2434                                    unresolved_reloc, warned);
2435           if (warned)
2436             {
2437               /* To avoid generating warning messages about truncated
2438                  relocations, set the relocation's address to be the same as
2439                  the start of this section.  */
2440               if (input_section->output_section != NULL)
2441                 relocation = input_section->output_section->vma;
2442               else
2443                 relocation = 0;
2444             }
2445         }
2446
2447       switch (r_type)
2448         {
2449         case R_SPARC_GOT10:
2450         case R_SPARC_GOT13:
2451         case R_SPARC_GOT22:
2452           /* Relocation is to the entry for this symbol in the global
2453              offset table.  */
2454           if (htab->sgot == NULL)
2455             abort ();
2456
2457           if (h != NULL)
2458             {
2459               bfd_boolean dyn;
2460
2461               off = h->got.offset;
2462               BFD_ASSERT (off != (bfd_vma) -1);
2463               dyn = elf_hash_table (info)->dynamic_sections_created;
2464
2465               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2466                   || (info->shared
2467                       && (info->symbolic
2468                           || h->dynindx == -1
2469                           || h->forced_local)
2470                       && h->def_regular))
2471                 {
2472                   /* This is actually a static link, or it is a
2473                      -Bsymbolic link and the symbol is defined
2474                      locally, or the symbol was forced to be local
2475                      because of a version file.  We must initialize
2476                      this entry in the global offset table.  Since the
2477                      offset must always be a multiple of 8 for 64-bit
2478                      and 4 for 32-bit, we use the least significant bit
2479                      to record whether we have initialized it already.
2480
2481                      When doing a dynamic link, we create a .rela.got
2482                      relocation entry to initialize the value.  This
2483                      is done in the finish_dynamic_symbol routine.  */
2484                   if ((off & 1) != 0)
2485                     off &= ~1;
2486                   else
2487                     {
2488                       SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2489                                           htab->sgot->contents + off);
2490                       h->got.offset |= 1;
2491                     }
2492                 }
2493               else
2494                 unresolved_reloc = FALSE;
2495             }
2496           else
2497             {
2498               BFD_ASSERT (local_got_offsets != NULL
2499                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
2500
2501               off = local_got_offsets[r_symndx];
2502
2503               /* The offset must always be a multiple of 8 on 64-bit and
2504                  4 on 32-bit.  We use the least significant bit to record
2505                  whether we have already processed this entry.  */
2506               if ((off & 1) != 0)
2507                 off &= ~1;
2508               else
2509                 {
2510
2511                   if (info->shared)
2512                     {
2513                       asection *s;
2514                       Elf_Internal_Rela outrel;
2515
2516                       /* We need to generate a R_SPARC_RELATIVE reloc
2517                          for the dynamic linker.  */
2518                       s = htab->srelgot;
2519                       BFD_ASSERT (s != NULL);
2520
2521                       outrel.r_offset = (htab->sgot->output_section->vma
2522                                          + htab->sgot->output_offset
2523                                          + off);
2524                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2525                                                         0, R_SPARC_RELATIVE);
2526                       outrel.r_addend = relocation;
2527                       relocation = 0;
2528                       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &outrel);
2529                     }
2530
2531                   SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2532                                       htab->sgot->contents + off);
2533                   local_got_offsets[r_symndx] |= 1;
2534                 }
2535             }
2536           relocation = htab->sgot->output_offset + off - got_base;
2537           break;
2538
2539         case R_SPARC_PLT32:
2540         case R_SPARC_PLT64:
2541           if (h == NULL || h->plt.offset == (bfd_vma) -1)
2542             {
2543               r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2544               goto r_sparc_plt32;
2545             }
2546           /* Fall through.  */
2547
2548         case R_SPARC_WPLT30:
2549         case R_SPARC_HIPLT22:
2550         case R_SPARC_LOPLT10:
2551         case R_SPARC_PCPLT32:
2552         case R_SPARC_PCPLT22:
2553         case R_SPARC_PCPLT10:
2554         r_sparc_wplt30:
2555           /* Relocation is to the entry for this symbol in the
2556              procedure linkage table.  */
2557
2558           if (! ABI_64_P (output_bfd))
2559             {
2560               /* The Solaris native assembler will generate a WPLT30 reloc
2561                  for a local symbol if you assemble a call from one
2562                  section to another when using -K pic.  We treat it as
2563                  WDISP30.  */
2564               if (h == NULL)
2565                 break;
2566             }
2567           else
2568             {
2569               BFD_ASSERT (h != NULL);
2570             }
2571
2572           if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2573             {
2574               /* We didn't make a PLT entry for this symbol.  This
2575                  happens when statically linking PIC code, or when
2576                  using -Bsymbolic.  */
2577               break;
2578             }
2579
2580           relocation = (htab->splt->output_section->vma
2581                         + htab->splt->output_offset
2582                         + h->plt.offset);
2583           unresolved_reloc = FALSE;
2584           if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2585             {
2586               r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2587               is_plt = TRUE;
2588               goto r_sparc_plt32;
2589             }
2590           break;
2591
2592         case R_SPARC_PC10:
2593         case R_SPARC_PC22:
2594         case R_SPARC_PC_HH22:
2595         case R_SPARC_PC_HM10:
2596         case R_SPARC_PC_LM22:
2597           if (h != NULL
2598               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2599             break;
2600           /* Fall through.  */
2601         case R_SPARC_DISP8:
2602         case R_SPARC_DISP16:
2603         case R_SPARC_DISP32:
2604         case R_SPARC_DISP64:
2605         case R_SPARC_WDISP30:
2606         case R_SPARC_WDISP22:
2607         case R_SPARC_WDISP19:
2608         case R_SPARC_WDISP16:
2609         case R_SPARC_8:
2610         case R_SPARC_16:
2611         case R_SPARC_32:
2612         case R_SPARC_HI22:
2613         case R_SPARC_22:
2614         case R_SPARC_13:
2615         case R_SPARC_LO10:
2616         case R_SPARC_UA16:
2617         case R_SPARC_UA32:
2618         case R_SPARC_10:
2619         case R_SPARC_11:
2620         case R_SPARC_64:
2621         case R_SPARC_OLO10:
2622         case R_SPARC_HH22:
2623         case R_SPARC_HM10:
2624         case R_SPARC_LM22:
2625         case R_SPARC_7:
2626         case R_SPARC_5:
2627         case R_SPARC_6:
2628         case R_SPARC_HIX22:
2629         case R_SPARC_LOX10:
2630         case R_SPARC_H44:
2631         case R_SPARC_M44:
2632         case R_SPARC_L44:
2633         case R_SPARC_UA64:
2634         r_sparc_plt32:
2635           /* r_symndx will be zero only for relocs against symbols
2636              from removed linkonce sections, or sections discarded by
2637              a linker script.  */
2638           if (r_symndx == 0
2639               || (input_section->flags & SEC_ALLOC) == 0)
2640             break;
2641
2642           if ((info->shared
2643                && (h == NULL
2644                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2645                    || h->root.type != bfd_link_hash_undefweak)
2646                && (! howto->pc_relative
2647                    || (h != NULL
2648                        && h->dynindx != -1
2649                        && (! info->symbolic
2650                            || !h->def_regular))))
2651               || (!info->shared
2652                   && h != NULL
2653                   && h->dynindx != -1
2654                   && !h->non_got_ref
2655                   && ((h->def_dynamic
2656                        && !h->def_regular)
2657                       || h->root.type == bfd_link_hash_undefweak
2658                       || h->root.type == bfd_link_hash_undefined)))
2659             {
2660               Elf_Internal_Rela outrel;
2661               bfd_boolean skip, relocate = FALSE;
2662
2663               /* When generating a shared object, these relocations
2664                  are copied into the output file to be resolved at run
2665                  time.  */
2666
2667               BFD_ASSERT (sreloc != NULL);
2668
2669               skip = FALSE;
2670
2671               outrel.r_offset =
2672                 _bfd_elf_section_offset (output_bfd, info, input_section,
2673                                          rel->r_offset);
2674               if (outrel.r_offset == (bfd_vma) -1)
2675                 skip = TRUE;
2676               else if (outrel.r_offset == (bfd_vma) -2)
2677                 skip = TRUE, relocate = TRUE;
2678               outrel.r_offset += (input_section->output_section->vma
2679                                   + input_section->output_offset);
2680
2681               /* Optimize unaligned reloc usage now that we know where
2682                  it finally resides.  */
2683               switch (r_type)
2684                 {
2685                 case R_SPARC_16:
2686                   if (outrel.r_offset & 1)
2687                     r_type = R_SPARC_UA16;
2688                   break;
2689                 case R_SPARC_UA16:
2690                   if (!(outrel.r_offset & 1))
2691                     r_type = R_SPARC_16;
2692                   break;
2693                 case R_SPARC_32:
2694                   if (outrel.r_offset & 3)
2695                     r_type = R_SPARC_UA32;
2696                   break;
2697                 case R_SPARC_UA32:
2698                   if (!(outrel.r_offset & 3))
2699                     r_type = R_SPARC_32;
2700                   break;
2701                 case R_SPARC_64:
2702                   if (outrel.r_offset & 7)
2703                     r_type = R_SPARC_UA64;
2704                   break;
2705                 case R_SPARC_UA64:
2706                   if (!(outrel.r_offset & 7))
2707                     r_type = R_SPARC_64;
2708                   break;
2709                 case R_SPARC_DISP8:
2710                 case R_SPARC_DISP16:
2711                 case R_SPARC_DISP32:
2712                 case R_SPARC_DISP64:
2713                   /* If the symbol is not dynamic, we should not keep
2714                      a dynamic relocation.  But an .rela.* slot has been
2715                      allocated for it, output R_SPARC_NONE.
2716                      FIXME: Add code tracking needed dynamic relocs as
2717                      e.g. i386 has.  */
2718                   if (h->dynindx == -1)
2719                     skip = TRUE, relocate = TRUE;
2720                   break;
2721                 }
2722
2723               if (skip)
2724                 memset (&outrel, 0, sizeof outrel);
2725               /* h->dynindx may be -1 if the symbol was marked to
2726                  become local.  */
2727               else if (h != NULL && ! is_plt
2728                        && ((! info->symbolic && h->dynindx != -1)
2729                            || !h->def_regular))
2730                 {
2731                   BFD_ASSERT (h->dynindx != -1);
2732                   outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2733                   outrel.r_addend = rel->r_addend;
2734                 }
2735               else
2736                 {
2737                   if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2738                     {
2739                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2740                                                         0, R_SPARC_RELATIVE);
2741                       outrel.r_addend = relocation + rel->r_addend;
2742                     }
2743                   else
2744                     {
2745                       long indx;
2746
2747                       if (is_plt)
2748                         sec = htab->splt;
2749
2750                       if (bfd_is_abs_section (sec))
2751                         indx = 0;
2752                       else if (sec == NULL || sec->owner == NULL)
2753                         {
2754                           bfd_set_error (bfd_error_bad_value);
2755                           return FALSE;
2756                         }
2757                       else
2758                         {
2759                           asection *osec;
2760
2761                           osec = sec->output_section;
2762                           indx = elf_section_data (osec)->dynindx;
2763
2764                           /* FIXME: we really should be able to link non-pic
2765                              shared libraries.  */
2766                           if (indx == 0)
2767                             {
2768                               BFD_FAIL ();
2769                               (*_bfd_error_handler)
2770                                 (_("%B: probably compiled without -fPIC?"),
2771                                  input_bfd);
2772                               bfd_set_error (bfd_error_bad_value);
2773                               return FALSE;
2774                             }
2775                         }
2776
2777                       outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, r_type);
2778                       outrel.r_addend = relocation + rel->r_addend;
2779                     }
2780                 }
2781
2782               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2783
2784               /* This reloc will be computed at runtime, so there's no
2785                  need to do anything now.  */
2786               if (! relocate)
2787                 continue;
2788             }
2789           break;
2790
2791         case R_SPARC_TLS_GD_HI22:
2792           if (! ABI_64_P (input_bfd)
2793               && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2794             {
2795               /* R_SPARC_REV32 used the same reloc number as
2796                  R_SPARC_TLS_GD_HI22.  */
2797               r_type = R_SPARC_REV32;
2798               break;
2799             }
2800           /* Fall through */
2801
2802         case R_SPARC_TLS_GD_LO10:
2803         case R_SPARC_TLS_IE_HI22:
2804         case R_SPARC_TLS_IE_LO10:
2805           r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2806           tls_type = GOT_UNKNOWN;
2807           if (h == NULL && local_got_offsets)
2808             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2809           else if (h != NULL)
2810             {
2811               tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2812               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2813                 switch (SPARC_ELF_R_TYPE (rel->r_info))
2814                   {
2815                   case R_SPARC_TLS_GD_HI22:
2816                   case R_SPARC_TLS_IE_HI22:
2817                     r_type = R_SPARC_TLS_LE_HIX22;
2818                     break;
2819                   default:
2820                     r_type = R_SPARC_TLS_LE_LOX10;
2821                     break;
2822                   }
2823             }
2824           if (tls_type == GOT_TLS_IE)
2825             switch (r_type)
2826               {
2827               case R_SPARC_TLS_GD_HI22:
2828                 r_type = R_SPARC_TLS_IE_HI22;
2829                 break;
2830               case R_SPARC_TLS_GD_LO10:
2831                 r_type = R_SPARC_TLS_IE_LO10;
2832                 break;
2833               }
2834
2835           if (r_type == R_SPARC_TLS_LE_HIX22)
2836             {
2837               relocation = tpoff (info, relocation);
2838               break;
2839             }
2840           if (r_type == R_SPARC_TLS_LE_LOX10)
2841             {
2842               /* Change add into xor.  */
2843               relocation = tpoff (info, relocation);
2844               bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2845                                                    contents + rel->r_offset)
2846                                        | 0x80182000), contents + rel->r_offset);
2847               break;
2848             }
2849
2850           if (h != NULL)
2851             {
2852               off = h->got.offset;
2853               h->got.offset |= 1;
2854             }
2855           else
2856             {
2857               BFD_ASSERT (local_got_offsets != NULL);
2858               off = local_got_offsets[r_symndx];
2859               local_got_offsets[r_symndx] |= 1;
2860             }
2861
2862         r_sparc_tlsldm:
2863           if (htab->sgot == NULL)
2864             abort ();
2865
2866           if ((off & 1) != 0)
2867             off &= ~1;
2868           else
2869             {
2870               Elf_Internal_Rela outrel;
2871               int dr_type, indx;
2872
2873               if (htab->srelgot == NULL)
2874                 abort ();
2875
2876               SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
2877               outrel.r_offset = (htab->sgot->output_section->vma
2878                                  + htab->sgot->output_offset + off);
2879               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2880               if (r_type == R_SPARC_TLS_IE_HI22
2881                   || r_type == R_SPARC_TLS_IE_LO10)
2882                 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
2883               else
2884                 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
2885               if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
2886                 outrel.r_addend = relocation - dtpoff_base (info);
2887               else
2888                 outrel.r_addend = 0;
2889               outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
2890               SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
2891
2892               if (r_type == R_SPARC_TLS_GD_HI22
2893                   || r_type == R_SPARC_TLS_GD_LO10)
2894                 {
2895                   if (indx == 0)
2896                     {
2897                       BFD_ASSERT (! unresolved_reloc);
2898                       SPARC_ELF_PUT_WORD (htab, output_bfd,
2899                                           relocation - dtpoff_base (info),
2900                                           (htab->sgot->contents + off
2901                                            + SPARC_ELF_WORD_BYTES (htab)));
2902                     }
2903                   else
2904                     {
2905                       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
2906                                           (htab->sgot->contents + off
2907                                            + SPARC_ELF_WORD_BYTES (htab)));
2908                       outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
2909                                                         SPARC_ELF_DTPOFF_RELOC (htab));
2910                       outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
2911                       SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
2912                     }
2913                 }
2914               else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
2915                 {
2916                   SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
2917                                       (htab->sgot->contents + off
2918                                        + SPARC_ELF_WORD_BYTES (htab)));
2919                 }
2920             }
2921
2922           if (off >= (bfd_vma) -2)
2923             abort ();
2924
2925           relocation = htab->sgot->output_offset + off - got_base;
2926           unresolved_reloc = FALSE;
2927           howto = _bfd_sparc_elf_howto_table + r_type;
2928           break;
2929
2930         case R_SPARC_TLS_LDM_HI22:
2931         case R_SPARC_TLS_LDM_LO10:
2932           if (! info->shared)
2933             {
2934               bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2935               continue;
2936             }
2937           off = htab->tls_ldm_got.offset;
2938           htab->tls_ldm_got.offset |= 1;
2939           goto r_sparc_tlsldm;
2940
2941         case R_SPARC_TLS_LDO_HIX22:
2942         case R_SPARC_TLS_LDO_LOX10:
2943           if (info->shared)
2944             {
2945               relocation -= dtpoff_base (info);
2946               break;
2947             }
2948
2949           r_type = (r_type == R_SPARC_TLS_LDO_HIX22
2950                     ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
2951           /* Fall through.  */
2952
2953         case R_SPARC_TLS_LE_HIX22:
2954         case R_SPARC_TLS_LE_LOX10:
2955           if (info->shared)
2956             {
2957               Elf_Internal_Rela outrel;
2958               bfd_boolean skip, relocate = FALSE;
2959
2960               BFD_ASSERT (sreloc != NULL);
2961               skip = FALSE;
2962               outrel.r_offset =
2963                 _bfd_elf_section_offset (output_bfd, info, input_section,
2964                                          rel->r_offset);
2965               if (outrel.r_offset == (bfd_vma) -1)
2966                 skip = TRUE;
2967               else if (outrel.r_offset == (bfd_vma) -2)
2968                 skip = TRUE, relocate = TRUE;
2969               outrel.r_offset += (input_section->output_section->vma
2970                                   + input_section->output_offset);
2971               if (skip)
2972                 memset (&outrel, 0, sizeof outrel);
2973               else
2974                 {
2975                   outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
2976                   outrel.r_addend = relocation - dtpoff_base (info)
2977                                     + rel->r_addend;
2978                 }
2979
2980               SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2981               continue;
2982             }
2983           relocation = tpoff (info, relocation);
2984           break;
2985
2986         case R_SPARC_TLS_LDM_CALL:
2987           if (! info->shared)
2988             {
2989               /* mov %g0, %o0 */
2990               bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2991               continue;
2992             }
2993           /* Fall through */
2994
2995         case R_SPARC_TLS_GD_CALL:
2996           tls_type = GOT_UNKNOWN;
2997           if (h == NULL && local_got_offsets)
2998             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2999           else if (h != NULL)
3000             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3001           if (! info->shared
3002               || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3003             {
3004               bfd_vma insn;
3005
3006               if (!info->shared && (h == NULL || h->dynindx == -1))
3007                 {
3008                   /* GD -> LE */
3009                   bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3010                   continue;
3011                 }
3012
3013               /* GD -> IE */
3014               if (rel + 1 < relend
3015                   && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3016                   && rel[1].r_offset == rel->r_offset + 4
3017                   && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3018                   && (((insn = bfd_get_32 (input_bfd,
3019                                            contents + rel[1].r_offset))
3020                        >> 25) & 0x1f) == 8)
3021                 {
3022                   /* We have
3023                      call __tls_get_addr, %tgd_call(foo)
3024                       add %reg1, %reg2, %o0, %tgd_add(foo)
3025                      and change it into IE:
3026                      {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3027                      add %g7, %o0, %o0, %tie_add(foo).
3028                      add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3029                      ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3030                      ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3031                   bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3032                               contents + rel->r_offset);
3033                   bfd_put_32 (output_bfd, 0x9001c008,
3034                               contents + rel->r_offset + 4);
3035                   rel++;
3036                   continue;
3037                 }
3038
3039               bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3040               continue;
3041             }
3042
3043           h = (struct elf_link_hash_entry *)
3044               bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3045                                     FALSE, TRUE);
3046           BFD_ASSERT (h != NULL);
3047           r_type = R_SPARC_WPLT30;
3048           howto = _bfd_sparc_elf_howto_table + r_type;
3049           goto r_sparc_wplt30;
3050
3051         case R_SPARC_TLS_GD_ADD:
3052           tls_type = GOT_UNKNOWN;
3053           if (h == NULL && local_got_offsets)
3054             tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3055           else if (h != NULL)
3056             tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3057           if (! info->shared || tls_type == GOT_TLS_IE)
3058             {
3059               /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3060                  changed into IE:
3061                  {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3062                  or LE:
3063                  add %g7, %reg2, %reg3.  */
3064               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3065               if ((h != NULL && h->dynindx != -1) || info->shared)
3066                 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3067               else
3068                 relocation = (insn & ~0x7c000) | 0x1c000;
3069               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3070             }
3071           continue;
3072
3073         case R_SPARC_TLS_LDM_ADD:
3074           if (! info->shared)
3075             bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3076           continue;
3077
3078         case R_SPARC_TLS_LDO_ADD:
3079           if (! info->shared)
3080             {
3081               /* Change rs1 into %g7.  */
3082               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3083               insn = (insn & ~0x7c000) | 0x1c000;
3084               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3085             }
3086           continue;
3087
3088         case R_SPARC_TLS_IE_LD:
3089         case R_SPARC_TLS_IE_LDX:
3090           if (! info->shared && (h == NULL || h->dynindx == -1))
3091             {
3092               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3093               int rs2 = insn & 0x1f;
3094               int rd = (insn >> 25) & 0x1f;
3095
3096               if (rs2 == rd)
3097                 relocation = SPARC_NOP;
3098               else
3099                 relocation = 0x80100000 | (insn & 0x3e00001f);
3100               bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3101             }
3102           continue;
3103
3104         case R_SPARC_TLS_IE_ADD:
3105           /* Totally useless relocation.  */
3106           continue;
3107
3108         case R_SPARC_TLS_DTPOFF32:
3109         case R_SPARC_TLS_DTPOFF64:
3110           relocation -= dtpoff_base (info);
3111           break;
3112
3113         default:
3114           break;
3115         }
3116
3117       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3118          because such sections are not SEC_ALLOC and thus ld.so will
3119          not process them.  */
3120       if (unresolved_reloc
3121           && !((input_section->flags & SEC_DEBUGGING) != 0
3122                && h->def_dynamic))
3123         (*_bfd_error_handler)
3124           (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3125            input_bfd,
3126            input_section,
3127            (long) rel->r_offset,
3128            h->root.root.string);
3129
3130       r = bfd_reloc_continue;
3131       if (r_type == R_SPARC_OLO10)
3132         {
3133             bfd_vma x;
3134
3135             if (! ABI_64_P (output_bfd))
3136               abort ();
3137
3138             relocation += rel->r_addend;
3139             relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3140
3141             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3142             x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3143             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3144
3145             r = bfd_check_overflow (howto->complain_on_overflow,
3146                                     howto->bitsize, howto->rightshift,
3147                                     bfd_arch_bits_per_address (input_bfd),
3148                                     relocation);
3149         }
3150       else if (r_type == R_SPARC_WDISP16)
3151         {
3152           bfd_vma x;
3153
3154           relocation += rel->r_addend;
3155           relocation -= (input_section->output_section->vma
3156                          + input_section->output_offset);
3157           relocation -= rel->r_offset;
3158
3159           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3160           x |= ((((relocation >> 2) & 0xc000) << 6)
3161                 | ((relocation >> 2) & 0x3fff));
3162           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3163
3164           r = bfd_check_overflow (howto->complain_on_overflow,
3165                                   howto->bitsize, howto->rightshift,
3166                                   bfd_arch_bits_per_address (input_bfd),
3167                                   relocation);
3168         }
3169       else if (r_type == R_SPARC_REV32)
3170         {
3171           bfd_vma x;
3172
3173           relocation = relocation + rel->r_addend;
3174
3175           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3176           x = x + relocation;
3177           bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3178           r = bfd_reloc_ok;
3179         }
3180       else if (r_type == R_SPARC_TLS_LDO_HIX22
3181                || r_type == R_SPARC_TLS_LE_HIX22)
3182         {
3183           bfd_vma x;
3184
3185           relocation += rel->r_addend;
3186           if (r_type == R_SPARC_TLS_LE_HIX22)
3187             relocation ^= MINUS_ONE;
3188
3189           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3190           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3191           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3192           r = bfd_reloc_ok;
3193         }
3194       else if (r_type == R_SPARC_TLS_LDO_LOX10
3195                || r_type == R_SPARC_TLS_LE_LOX10)
3196         {
3197           bfd_vma x;
3198
3199           relocation += rel->r_addend;
3200           relocation &= 0x3ff;
3201           if (r_type == R_SPARC_TLS_LE_LOX10)
3202             relocation |= 0x1c00;
3203
3204           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3205           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3206           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3207
3208           r = bfd_reloc_ok;
3209         }
3210       else if (r_type == R_SPARC_HIX22)
3211         {
3212           bfd_vma x;
3213
3214           relocation += rel->r_addend;
3215           relocation = relocation ^ MINUS_ONE;
3216
3217           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3218           x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3219           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3220
3221           r = bfd_check_overflow (howto->complain_on_overflow,
3222                                   howto->bitsize, howto->rightshift,
3223                                   bfd_arch_bits_per_address (input_bfd),
3224                                   relocation);
3225         }
3226       else if (r_type == R_SPARC_LOX10)
3227         {
3228           bfd_vma x;
3229
3230           relocation += rel->r_addend;
3231           relocation = (relocation & 0x3ff) | 0x1c00;
3232
3233           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3234           x = (x & ~(bfd_vma) 0x1fff) | relocation;
3235           bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3236
3237           r = bfd_reloc_ok;
3238         }
3239       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3240                && sec_do_relax (input_section)
3241                && rel->r_offset + 4 < input_section->size)
3242         {
3243 #define G0              0
3244 #define O7              15
3245 #define XCC             (2 << 20)
3246 #define COND(x)         (((x)&0xf)<<25)
3247 #define CONDA           COND(0x8)
3248 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3249 #define INSN_BA         (F2(0,2) | CONDA)
3250 #define INSN_OR         F3(2, 0x2, 0)
3251 #define INSN_NOP        F2(0,4)
3252
3253           bfd_vma x, y;
3254
3255           /* If the instruction is a call with either:
3256              restore
3257              arithmetic instruction with rd == %o7
3258              where rs1 != %o7 and rs2 if it is register != %o7
3259              then we can optimize if the call destination is near
3260              by changing the call into a branch always.  */
3261           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3262           y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3263           if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3264             {
3265               if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3266                    || ((y & OP3(0x28)) == 0 /* arithmetic */
3267                        && (y & RD(~0)) == RD(O7)))
3268                   && (y & RS1(~0)) != RS1(O7)
3269                   && ((y & F3I(~0))
3270                       || (y & RS2(~0)) != RS2(O7)))
3271                 {
3272                   bfd_vma reloc;
3273
3274                   reloc = relocation + rel->r_addend - rel->r_offset;
3275                   reloc -= (input_section->output_section->vma
3276                             + input_section->output_offset);
3277
3278                   /* Ensure the branch fits into simm22.  */
3279                   if ((reloc & 3) == 0
3280                       && ((reloc & ~(bfd_vma)0x7fffff) == 0
3281                           || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3282                     {
3283                       reloc >>= 2;
3284
3285                       /* Check whether it fits into simm19.  */
3286                       if (((reloc & 0x3c0000) == 0
3287                            || (reloc & 0x3c0000) == 0x3c0000)
3288                           && (ABI_64_P (output_bfd)
3289                               || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3290                         x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3291                       else
3292                         x = INSN_BA | (reloc & 0x3fffff); /* ba */
3293                       bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3294                       r = bfd_reloc_ok;
3295                       if (rel->r_offset >= 4
3296                           && (y & (0xffffffff ^ RS1(~0)))
3297                              == (INSN_OR | RD(O7) | RS2(G0)))
3298                         {
3299                           bfd_vma z;
3300                           unsigned int reg;
3301
3302                           z = bfd_get_32 (input_bfd,
3303                                           contents + rel->r_offset - 4);
3304                           if ((z & (0xffffffff ^ RD(~0)))
3305                               != (INSN_OR | RS1(O7) | RS2(G0)))
3306                             break;
3307
3308                           /* The sequence was
3309                              or %o7, %g0, %rN
3310                              call foo
3311                              or %rN, %g0, %o7
3312
3313                              If call foo was replaced with ba, replace
3314                              or %rN, %g0, %o7 with nop.  */
3315
3316                           reg = (y & RS1(~0)) >> 14;
3317                           if (reg != ((z & RD(~0)) >> 25)
3318                               || reg == G0 || reg == O7)
3319                             break;
3320
3321                           bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3322                                       contents + rel->r_offset + 4);
3323                         }
3324
3325                     }
3326                 }
3327             }
3328         }
3329
3330       if (r == bfd_reloc_continue)
3331         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3332                                       contents, rel->r_offset,
3333                                       relocation, rel->r_addend);
3334
3335       if (r != bfd_reloc_ok)
3336         {
3337           switch (r)
3338             {
3339             default:
3340             case bfd_reloc_outofrange:
3341               abort ();
3342             case bfd_reloc_overflow:
3343               {
3344                 const char *name;
3345
3346                 if (h != NULL)
3347                   name = NULL;
3348                 else
3349                   {
3350                     name = bfd_elf_string_from_elf_section (input_bfd,
3351                                                             symtab_hdr->sh_link,
3352                                                             sym->st_name);
3353                     if (name == NULL)
3354                       return FALSE;
3355                     if (*name == '\0')
3356                       name = bfd_section_name (input_bfd, sec);
3357                   }
3358                 if (! ((*info->callbacks->reloc_overflow)
3359                        (info, (h ? &h->root : NULL), name, howto->name,
3360                         (bfd_vma) 0, input_bfd, input_section,
3361                         rel->r_offset)))
3362                   return FALSE;
3363               }
3364               break;
3365             }
3366         }
3367     }
3368
3369   return TRUE;
3370 }
3371
3372 /* Finish up dynamic symbol handling.  We set the contents of various
3373    dynamic sections here.  */
3374
3375 bfd_boolean
3376 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3377                                       struct bfd_link_info *info,
3378                                       struct elf_link_hash_entry *h,
3379                                       Elf_Internal_Sym *sym)
3380 {
3381   bfd *dynobj;
3382   struct _bfd_sparc_elf_link_hash_table *htab;
3383
3384   htab = _bfd_sparc_elf_hash_table (info);
3385   dynobj = htab->elf.dynobj;
3386
3387   if (h->plt.offset != (bfd_vma) -1)
3388     {
3389       asection *splt;
3390       asection *srela;
3391       Elf_Internal_Rela rela;
3392       bfd_byte *loc;
3393       bfd_vma r_offset;
3394       int rela_index;
3395
3396       /* This symbol has an entry in the PLT.  Set it up.  */
3397
3398       BFD_ASSERT (h->dynindx != -1);
3399
3400       splt = htab->splt;
3401       srela = htab->srelplt;
3402       BFD_ASSERT (splt != NULL && srela != NULL);
3403
3404       /* Fill in the entry in the procedure linkage table.  */
3405       rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3406                                               h->plt.offset, splt->size,
3407                                               &r_offset);
3408
3409       /* Fill in the entry in the .rela.plt section.  */
3410       rela.r_offset = r_offset
3411         + (splt->output_section->vma + splt->output_offset);
3412       if (! ABI_64_P (output_bfd)
3413           || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3414         {
3415           rela.r_addend = 0;
3416         }
3417       else
3418         {
3419           rela.r_addend = -(h->plt.offset + 4)
3420                           -(splt->output_section->vma + splt->output_offset);
3421         }
3422       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3423
3424       /* Adjust for the first 4 reserved elements in the .plt section
3425          when setting the offset in the .rela.plt section.
3426          Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3427          thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3428
3429       loc = srela->contents;
3430 #ifdef BFD64
3431       if (ABI_64_P (output_bfd))
3432         {
3433           loc += rela_index * sizeof (Elf64_External_Rela);
3434           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3435         }
3436       else
3437 #endif
3438         {
3439           loc += rela_index * sizeof (Elf32_External_Rela);
3440           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3441         }
3442
3443       if (!h->def_regular)
3444         {
3445           /* Mark the symbol as undefined, rather than as defined in
3446              the .plt section.  Leave the value alone.  */
3447           sym->st_shndx = SHN_UNDEF;
3448           /* If the symbol is weak, we do need to clear the value.
3449              Otherwise, the PLT entry would provide a definition for
3450              the symbol even if the symbol wasn't defined anywhere,
3451              and so the symbol would never be NULL.  */
3452           if (!h->ref_regular_nonweak)
3453             sym->st_value = 0;
3454         }
3455     }
3456
3457   if (h->got.offset != (bfd_vma) -1
3458       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3459       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3460     {
3461       asection *sgot;
3462       asection *srela;
3463       Elf_Internal_Rela rela;
3464
3465       /* This symbol has an entry in the GOT.  Set it up.  */
3466
3467       sgot = htab->sgot;
3468       srela = htab->srelgot;
3469       BFD_ASSERT (sgot != NULL && srela != NULL);
3470
3471       rela.r_offset = (sgot->output_section->vma
3472                        + sgot->output_offset
3473                        + (h->got.offset &~ (bfd_vma) 1));
3474
3475       /* If this is a -Bsymbolic link, and the symbol is defined
3476          locally, we just want to emit a RELATIVE reloc.  Likewise if
3477          the symbol was forced to be local because of a version file.
3478          The entry in the global offset table will already have been
3479          initialized in the relocate_section function.  */
3480       if (info->shared
3481           && (info->symbolic || h->dynindx == -1)
3482           && h->def_regular)
3483         {
3484           asection *sec = h->root.u.def.section;
3485           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3486           rela.r_addend = (h->root.u.def.value
3487                            + sec->output_section->vma
3488                            + sec->output_offset);
3489         }
3490       else
3491         {
3492           rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3493           rela.r_addend = 0;
3494         }
3495
3496       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3497                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3498       SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3499     }
3500
3501   if (h->needs_copy)
3502     {
3503       asection *s;
3504       Elf_Internal_Rela rela;
3505
3506       /* This symbols needs a copy reloc.  Set it up.  */
3507       BFD_ASSERT (h->dynindx != -1);
3508
3509       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3510                                    ".rela.bss");
3511       BFD_ASSERT (s != NULL);
3512
3513       rela.r_offset = (h->root.u.def.value
3514                        + h->root.u.def.section->output_section->vma
3515                        + h->root.u.def.section->output_offset);
3516       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3517       rela.r_addend = 0;
3518       SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3519     }
3520
3521   /* Mark some specially defined symbols as absolute.  */
3522   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3523       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3524       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3525     sym->st_shndx = SHN_ABS;
3526
3527   return TRUE;
3528 }
3529
3530 /* Finish up the dynamic sections.  */
3531
3532 #ifdef BFD64
3533 static bfd_boolean
3534 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3535                     bfd *dynobj, asection *sdyn,
3536                     asection *splt ATTRIBUTE_UNUSED)
3537 {
3538   Elf64_External_Dyn *dyncon, *dynconend;
3539   int stt_regidx = -1;
3540
3541   dyncon = (Elf64_External_Dyn *) sdyn->contents;
3542   dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3543   for (; dyncon < dynconend; dyncon++)
3544     {
3545       Elf_Internal_Dyn dyn;
3546       const char *name;
3547       bfd_boolean size;
3548
3549       bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3550
3551       switch (dyn.d_tag)
3552         {
3553         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3554         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3555         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3556         case DT_SPARC_REGISTER:
3557           if (stt_regidx == -1)
3558             {
3559               stt_regidx =
3560                 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3561               if (stt_regidx == -1)
3562                 return FALSE;
3563             }
3564           dyn.d_un.d_val = stt_regidx++;
3565           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3566           /* fallthrough */
3567         default:          name = NULL; size = FALSE; break;
3568         }
3569
3570       if (name != NULL)
3571         {
3572           asection *s;
3573
3574           s = bfd_get_section_by_name (output_bfd, name);
3575           if (s == NULL)
3576             dyn.d_un.d_val = 0;
3577           else
3578             {
3579               if (! size)
3580                 dyn.d_un.d_ptr = s->vma;
3581               else
3582                 dyn.d_un.d_val = s->size;
3583             }
3584           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3585         }
3586     }
3587   return TRUE;
3588 }
3589 #endif
3590
3591 static bfd_boolean
3592 sparc32_finish_dyn (bfd *output_bfd,
3593                     struct bfd_link_info *info ATTRIBUTE_UNUSED,
3594                     bfd *dynobj, asection *sdyn,
3595                     asection *splt ATTRIBUTE_UNUSED)
3596 {
3597   Elf32_External_Dyn *dyncon, *dynconend;
3598
3599   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3600   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3601   for (; dyncon < dynconend; dyncon++)
3602     {
3603       Elf_Internal_Dyn dyn;
3604       const char *name;
3605       bfd_boolean size;
3606
3607       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3608
3609       switch (dyn.d_tag)
3610         {
3611         case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3612         case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3613         case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3614         default:          name = NULL; size = FALSE; break;
3615         }
3616
3617       if (name != NULL)
3618         {
3619           asection *s;
3620
3621           s = bfd_get_section_by_name (output_bfd, name);
3622           if (s == NULL)
3623             dyn.d_un.d_val = 0;
3624           else
3625             {
3626               if (! size)
3627                 dyn.d_un.d_ptr = s->vma;
3628               else
3629                 dyn.d_un.d_val = s->size;
3630             }
3631           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3632         }
3633     }
3634   return TRUE;
3635 }
3636
3637 bfd_boolean
3638 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3639 {
3640   bfd *dynobj;
3641   asection *sdyn;
3642   struct _bfd_sparc_elf_link_hash_table *htab;
3643
3644   htab = _bfd_sparc_elf_hash_table (info);
3645   dynobj = htab->elf.dynobj;
3646
3647   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3648
3649   if (elf_hash_table (info)->dynamic_sections_created)
3650     {
3651       asection *splt;
3652       bfd_boolean ret;
3653
3654       splt = bfd_get_section_by_name (dynobj, ".plt");
3655       BFD_ASSERT (splt != NULL && sdyn != NULL);
3656
3657 #ifdef BFD64
3658       if (ABI_64_P (output_bfd))
3659         ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3660       else
3661 #endif
3662         ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3663
3664       if (ret != TRUE)
3665         return ret;
3666
3667       /* Initialize the contents of the .plt section.  */
3668       if (splt->size > 0)
3669         {
3670           if (ABI_64_P (output_bfd))
3671             memset (splt->contents, 0, 4 * PLT64_ENTRY_SIZE);
3672           else
3673             {
3674               memset (splt->contents, 0, 4 * PLT32_ENTRY_SIZE);
3675               bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3676                           splt->contents + splt->size - 4);
3677             }
3678         }
3679
3680       elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3681         (ABI_64_P (output_bfd) ? PLT64_ENTRY_SIZE : PLT32_ENTRY_SIZE);
3682     }
3683
3684   /* Set the first entry in the global offset table to the address of
3685      the dynamic section.  */
3686   if (htab->sgot && htab->sgot->size > 0)
3687     {
3688       bfd_vma val = (sdyn ?
3689                      sdyn->output_section->vma + sdyn->output_offset :
3690                      0);
3691
3692       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
3693     }
3694
3695   if (htab->sgot)
3696     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
3697       SPARC_ELF_WORD_BYTES (htab);
3698
3699   return TRUE;
3700 }
3701
3702 \f
3703 /* Set the right machine number for a SPARC ELF file.  */
3704
3705 bfd_boolean
3706 _bfd_sparc_elf_object_p (bfd *abfd)
3707 {
3708   if (ABI_64_P (abfd))
3709     {
3710       unsigned long mach = bfd_mach_sparc_v9;
3711
3712       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3713         mach = bfd_mach_sparc_v9b;
3714       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3715         mach = bfd_mach_sparc_v9a;
3716       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3717     }
3718   else
3719     {
3720       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3721         {
3722           if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3723             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3724                                               bfd_mach_sparc_v8plusb);
3725           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3726             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3727                                               bfd_mach_sparc_v8plusa);
3728           else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3729             return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3730                                               bfd_mach_sparc_v8plus);
3731           else
3732             return FALSE;
3733         }
3734       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3735         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3736                                           bfd_mach_sparc_sparclite_le);
3737       else
3738         return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3739     }
3740 }
3741
3742 /* Return address for Ith PLT stub in section PLT, for relocation REL
3743    or (bfd_vma) -1 if it should not be included.  */
3744
3745 bfd_vma
3746 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
3747 {
3748   if (ABI_64_P (plt->owner))
3749     {
3750       bfd_vma j;
3751
3752       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
3753       if (i < PLT64_LARGE_THRESHOLD)
3754         return plt->vma + i * PLT64_ENTRY_SIZE;
3755
3756       j = (i - PLT64_LARGE_THRESHOLD) % 160;
3757       i -= j;
3758       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
3759     }
3760   else
3761     return rel->address;
3762 }