bfd/elfxx-sparc.c

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