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