bfd/elfxx-sparc.c

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