gold/sparc.cc

   1 // sparc.cc -- sparc target support for gold.
   2
   3 // Copyright 2008, 2009 Free Software Foundation, Inc.
   4 // Written by David S. Miller <davem@davemloft.net>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #include "gold.h"
  24
  25 #include <cstdlib>
  26 #include <cstdio>
  27 #include <cstring>
  28
  29 #include "elfcpp.h"
  30 #include "parameters.h"
  31 #include "reloc.h"
  32 #include "sparc.h"
  33 #include "object.h"
  34 #include "symtab.h"
  35 #include "layout.h"
  36 #include "output.h"
  37 #include "copy-relocs.h"
  38 #include "target.h"
  39 #include "target-reloc.h"
  40 #include "target-select.h"
  41 #include "tls.h"
  42 #include "errors.h"
  43 #include "gc.h"
  44
  45 namespace
  46 {
  47
  48 using namespace gold;
  49
  50 template<int size, bool big_endian>
  51 class Output_data_plt_sparc;
  52
  53 template<int size, bool big_endian>
  54 class Target_sparc : public Sized_target<size, big_endian>
  55 {
  56  public:
  57   typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
  58
  59   Target_sparc()
  60     : Sized_target<size, big_endian>(&sparc_info),
  61       got_(NULL), plt_(NULL), rela_dyn_(NULL),
  62       copy_relocs_(elfcpp::R_SPARC_COPY), dynbss_(NULL),
  63       got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL)
  64   {
  65   }
  66
  67   // Process the relocations to determine unreferenced sections for
  68   // garbage collection.
  69   void
  70   gc_process_relocs(Symbol_table* symtab,
  71                     Layout* layout,
  72                     Sized_relobj<size, big_endian>* object,
  73                     unsigned int data_shndx,
  74                     unsigned int sh_type,
  75                     const unsigned char* prelocs,
  76                     size_t reloc_count,
  77                     Output_section* output_section,
  78                     bool needs_special_offset_handling,
  79                     size_t local_symbol_count,
  80                     const unsigned char* plocal_symbols);
  81
  82   // Scan the relocations to look for symbol adjustments.
  83   void
  84   scan_relocs(Symbol_table* symtab,
  85               Layout* layout,
  86               Sized_relobj<size, big_endian>* object,
  87               unsigned int data_shndx,
  88               unsigned int sh_type,
  89               const unsigned char* prelocs,
  90               size_t reloc_count,
  91               Output_section* output_section,
  92               bool needs_special_offset_handling,
  93               size_t local_symbol_count,
  94               const unsigned char* plocal_symbols);
  95   // Finalize the sections.
  96   void
  97   do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
  98
  99   // Return the value to use for a dynamic which requires special
 100   // treatment.
 101   uint64_t
 102   do_dynsym_value(const Symbol*) const;
 103
 104   // Relocate a section.
 105   void
 106   relocate_section(const Relocate_info<size, big_endian>*,
 107                    unsigned int sh_type,
 108                    const unsigned char* prelocs,
 109                    size_t reloc_count,
 110                    Output_section* output_section,
 111                    bool needs_special_offset_handling,
 112                    unsigned char* view,
 113                    typename elfcpp::Elf_types<size>::Elf_Addr view_address,
 114                    section_size_type view_size,
 115                    const Reloc_symbol_changes*);
 116
 117   // Scan the relocs during a relocatable link.
 118   void
 119   scan_relocatable_relocs(Symbol_table* symtab,
 120                           Layout* layout,
 121                           Sized_relobj<size, big_endian>* object,
 122                           unsigned int data_shndx,
 123                           unsigned int sh_type,
 124                           const unsigned char* prelocs,
 125                           size_t reloc_count,
 126                           Output_section* output_section,
 127                           bool needs_special_offset_handling,
 128                           size_t local_symbol_count,
 129                           const unsigned char* plocal_symbols,
 130                           Relocatable_relocs*);
 131
 132   // Relocate a section during a relocatable link.
 133   void
 134   relocate_for_relocatable(const Relocate_info<size, big_endian>*,
 135                            unsigned int sh_type,
 136                            const unsigned char* prelocs,
 137                            size_t reloc_count,
 138                            Output_section* output_section,
 139                            off_t offset_in_output_section,
 140                            const Relocatable_relocs*,
 141                            unsigned char* view,
 142                            typename elfcpp::Elf_types<size>::Elf_Addr view_address,
 143                            section_size_type view_size,
 144                            unsigned char* reloc_view,
 145                            section_size_type reloc_view_size);
 146   // Return whether SYM is defined by the ABI.
 147   bool
 148   do_is_defined_by_abi(const Symbol* sym) const
 149   {
 150     // XXX Really need to support this better...
 151     if (sym->type() == elfcpp::STT_SPARC_REGISTER)
 152       return 1;
 153
 154     return strcmp(sym->name(), "___tls_get_addr") == 0;
 155   }
 156
 157   // Return whether there is a GOT section.
 158   bool
 159   has_got_section() const
 160   { return this->got_ != NULL; }
 161
 162   // Return the size of the GOT section.
 163   section_size_type
 164   got_size()
 165   {
 166     gold_assert(this->got_ != NULL);
 167     return this->got_->data_size();
 168   }
 169
 170  private:
 171
 172   // The class which scans relocations.
 173   class Scan
 174   {
 175   public:
 176     Scan()
 177       : issued_non_pic_error_(false)
 178     { }
 179
 180     inline void
 181     local(Symbol_table* symtab, Layout* layout, Target_sparc* target,
 182           Sized_relobj<size, big_endian>* object,
 183           unsigned int data_shndx,
 184           Output_section* output_section,
 185           const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
 186           const elfcpp::Sym<size, big_endian>& lsym);
 187
 188     inline void
 189     global(Symbol_table* symtab, Layout* layout, Target_sparc* target,
 190            Sized_relobj<size, big_endian>* object,
 191            unsigned int data_shndx,
 192            Output_section* output_section,
 193            const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
 194            Symbol* gsym);
 195
 196     inline bool
 197     local_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
 198                                         Target_sparc* ,
 199                                         Sized_relobj<size, big_endian>* ,
 200                                         unsigned int ,
 201                                         Output_section* ,
 202                                         const elfcpp::Rela<size, big_endian>& ,
 203                                         unsigned int ,
 204                                         const elfcpp::Sym<size, big_endian>&)
 205     { return false; }
 206
 207     inline bool
 208     global_reloc_may_be_function_pointer(Symbol_table* , Layout* ,
 209                                          Target_sparc* ,
 210                                          Sized_relobj<size, big_endian>* ,
 211                                          unsigned int ,
 212                                          Output_section* ,
 213                                          const elfcpp::Rela<size,
 214                                                             big_endian>& ,
 215                                          unsigned int , Symbol*)
 216     { return false; }
 217
 218
 219   private:
 220     static void
 221     unsupported_reloc_local(Sized_relobj<size, big_endian>*,
 222                             unsigned int r_type);
 223
 224     static void
 225     unsupported_reloc_global(Sized_relobj<size, big_endian>*,
 226                              unsigned int r_type, Symbol*);
 227
 228     static void
 229     generate_tls_call(Symbol_table* symtab, Layout* layout,
 230                       Target_sparc* target);
 231
 232     void
 233     check_non_pic(Relobj*, unsigned int r_type);
 234
 235     // Whether we have issued an error about a non-PIC compilation.
 236     bool issued_non_pic_error_;
 237   };
 238
 239   // The class which implements relocation.
 240   class Relocate
 241   {
 242    public:
 243     Relocate()
 244       : ignore_gd_add_(false)
 245     { }
 246
 247     ~Relocate()
 248     {
 249       if (this->ignore_gd_add_)
 250         {
 251           // FIXME: This needs to specify the location somehow.
 252           gold_error(_("missing expected TLS relocation"));
 253         }
 254     }
 255
 256     // Do a relocation.  Return false if the caller should not issue
 257     // any warnings about this relocation.
 258     inline bool
 259     relocate(const Relocate_info<size, big_endian>*, Target_sparc*,
 260              Output_section*, size_t relnum,
 261              const elfcpp::Rela<size, big_endian>&,
 262              unsigned int r_type, const Sized_symbol<size>*,
 263              const Symbol_value<size>*,
 264              unsigned char*,
 265              typename elfcpp::Elf_types<size>::Elf_Addr,
 266              section_size_type);
 267
 268    private:
 269     // Do a TLS relocation.
 270     inline void
 271     relocate_tls(const Relocate_info<size, big_endian>*, Target_sparc* target,
 272                  size_t relnum, const elfcpp::Rela<size, big_endian>&,
 273                  unsigned int r_type, const Sized_symbol<size>*,
 274                  const Symbol_value<size>*,
 275                  unsigned char*,
 276                  typename elfcpp::Elf_types<size>::Elf_Addr,
 277                  section_size_type);
 278
 279     // Ignore the next relocation which should be R_SPARC_TLS_GD_ADD
 280     bool ignore_gd_add_;
 281   };
 282
 283   // A class which returns the size required for a relocation type,
 284   // used while scanning relocs during a relocatable link.
 285   class Relocatable_size_for_reloc
 286   {
 287    public:
 288     unsigned int
 289     get_size_for_reloc(unsigned int, Relobj*);
 290   };
 291
 292   // Get the GOT section, creating it if necessary.
 293   Output_data_got<size, big_endian>*
 294   got_section(Symbol_table*, Layout*);
 295
 296   // Create a PLT entry for a global symbol.
 297   void
 298   make_plt_entry(Symbol_table*, Layout*, Symbol*);
 299
 300   // Create a GOT entry for the TLS module index.
 301   unsigned int
 302   got_mod_index_entry(Symbol_table* symtab, Layout* layout,
 303                       Sized_relobj<size, big_endian>* object);
 304
 305   // Return the gsym for "__tls_get_addr".  Cache if not already
 306   // cached.
 307   Symbol*
 308   tls_get_addr_sym(Symbol_table* symtab)
 309   {
 310     if (!this->tls_get_addr_sym_)
 311       this->tls_get_addr_sym_ = symtab->lookup("__tls_get_addr", NULL);
 312     gold_assert(this->tls_get_addr_sym_);
 313     return this->tls_get_addr_sym_;
 314   }
 315
 316   // Get the PLT section.
 317   const Output_data_plt_sparc<size, big_endian>*
 318   plt_section() const
 319   {
 320     gold_assert(this->plt_ != NULL);
 321     return this->plt_;
 322   }
 323
 324   // Get the dynamic reloc section, creating it if necessary.
 325   Reloc_section*
 326   rela_dyn_section(Layout*);
 327
 328   // Copy a relocation against a global symbol.
 329   void
 330   copy_reloc(Symbol_table* symtab, Layout* layout,
 331              Sized_relobj<size, big_endian>* object,
 332              unsigned int shndx, Output_section* output_section,
 333              Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
 334   {
 335     this->copy_relocs_.copy_reloc(symtab, layout,
 336                                   symtab->get_sized_symbol<size>(sym),
 337                                   object, shndx, output_section,
 338                                   reloc, this->rela_dyn_section(layout));
 339   }
 340
 341   // Information about this specific target which we pass to the
 342   // general Target structure.
 343   static Target::Target_info sparc_info;
 344
 345   // The types of GOT entries needed for this platform.
 346   enum Got_type
 347   {
 348     GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
 349     GOT_TYPE_TLS_OFFSET = 1,    // GOT entry for TLS offset
 350     GOT_TYPE_TLS_PAIR = 2,      // GOT entry for TLS module/offset pair
 351   };
 352
 353   // The GOT section.
 354   Output_data_got<size, big_endian>* got_;
 355   // The PLT section.
 356   Output_data_plt_sparc<size, big_endian>* plt_;
 357   // The dynamic reloc section.
 358   Reloc_section* rela_dyn_;
 359   // Relocs saved to avoid a COPY reloc.
 360   Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
 361   // Space for variables copied with a COPY reloc.
 362   Output_data_space* dynbss_;
 363   // Offset of the GOT entry for the TLS module index;
 364   unsigned int got_mod_index_offset_;
 365   // Cached pointer to __tls_get_addr symbol
 366   Symbol* tls_get_addr_sym_;
 367 };
 368
 369 template<>
 370 Target::Target_info Target_sparc<32, true>::sparc_info =
 371 {
 372   32,                   // size
 373   true,                 // is_big_endian
 374   elfcpp::EM_SPARC,     // machine_code
 375   false,                // has_make_symbol
 376   false,                // has_resolve
 377   false,                // has_code_fill
 378   true,                 // is_default_stack_executable
 379   '\0',                 // wrap_char
 380   "/usr/lib/ld.so.1",   // dynamic_linker
 381   0x00010000,           // default_text_segment_address
 382   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 383   8 * 1024,             // common_pagesize (overridable by -z common-page-size)
 384   elfcpp::SHN_UNDEF,    // small_common_shndx
 385   elfcpp::SHN_UNDEF,    // large_common_shndx
 386   0,                    // small_common_section_flags
 387   0,                    // large_common_section_flags
 388   NULL,                 // attributes_section
 389   NULL                  // attributes_vendor
 390 };
 391
 392 template<>
 393 Target::Target_info Target_sparc<64, true>::sparc_info =
 394 {
 395   64,                   // size
 396   true,                 // is_big_endian
 397   elfcpp::EM_SPARCV9,   // machine_code
 398   false,                // has_make_symbol
 399   false,                // has_resolve
 400   false,                // has_code_fill
 401   true,                 // is_default_stack_executable
 402   '\0',                 // wrap_char
 403   "/usr/lib/sparcv9/ld.so.1",   // dynamic_linker
 404   0x100000,             // default_text_segment_address
 405   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 406   8 * 1024,             // common_pagesize (overridable by -z common-page-size)
 407   elfcpp::SHN_UNDEF,    // small_common_shndx
 408   elfcpp::SHN_UNDEF,    // large_common_shndx
 409   0,                    // small_common_section_flags
 410   0,                    // large_common_section_flags
 411   NULL,                 // attributes_section
 412   NULL                  // attributes_vendor
 413 };
 414
 415 // We have to take care here, even when operating in little-endian
 416 // mode, sparc instructions are still big endian.
 417 template<int size, bool big_endian>
 418 class Sparc_relocate_functions
 419 {
 420 private:
 421   // Do a simple relocation with the addend in the relocation.
 422   template<int valsize>
 423   static inline void
 424   rela(unsigned char* view,
 425        unsigned int right_shift,
 426        typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
 427        typename elfcpp::Swap<size, big_endian>::Valtype value,
 428        typename elfcpp::Swap<size, big_endian>::Valtype addend)
 429   {
 430     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 431     Valtype* wv = reinterpret_cast<Valtype*>(view);
 432     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 433     Valtype reloc = ((value + addend) >> right_shift);
 434
 435     val &= ~dst_mask;
 436     reloc &= dst_mask;
 437
 438     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 439   }
 440
 441   // Do a simple relocation using a symbol value with the addend in
 442   // the relocation.
 443   template<int valsize>
 444   static inline void
 445   rela(unsigned char* view,
 446        unsigned int right_shift,
 447        typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
 448        const Sized_relobj<size, big_endian>* object,
 449        const Symbol_value<size>* psymval,
 450        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
 451   {
 452     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 453     Valtype* wv = reinterpret_cast<Valtype*>(view);
 454     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 455     Valtype reloc = (psymval->value(object, addend) >> right_shift);
 456
 457     val &= ~dst_mask;
 458     reloc &= dst_mask;
 459
 460     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 461   }
 462
 463   // Do a simple relocation using a symbol value with the addend in
 464   // the relocation, unaligned.
 465   template<int valsize>
 466   static inline void
 467   rela_ua(unsigned char* view,
 468           unsigned int right_shift, elfcpp::Elf_Xword dst_mask,
 469           const Sized_relobj<size, big_endian>* object,
 470           const Symbol_value<size>* psymval,
 471           typename elfcpp::Swap<size, big_endian>::Valtype addend)
 472   {
 473     typedef typename elfcpp::Swap_unaligned<valsize,
 474             big_endian>::Valtype Valtype;
 475     unsigned char* wv = view;
 476     Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
 477     Valtype reloc = (psymval->value(object, addend) >> right_shift);
 478
 479     val &= ~dst_mask;
 480     reloc &= dst_mask;
 481
 482     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc);
 483   }
 484
 485   // Do a simple PC relative relocation with a Symbol_value with the
 486   // addend in the relocation.
 487   template<int valsize>
 488   static inline void
 489   pcrela(unsigned char* view,
 490          unsigned int right_shift,
 491          typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
 492          const Sized_relobj<size, big_endian>* object,
 493          const Symbol_value<size>* psymval,
 494          typename elfcpp::Swap<size, big_endian>::Valtype addend,
 495          typename elfcpp::Elf_types<size>::Elf_Addr address)
 496   {
 497     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 498     Valtype* wv = reinterpret_cast<Valtype*>(view);
 499     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 500     Valtype reloc = ((psymval->value(object, addend) - address)
 501                      >> right_shift);
 502
 503     val &= ~dst_mask;
 504     reloc &= dst_mask;
 505
 506     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 507   }
 508
 509   template<int valsize>
 510   static inline void
 511   pcrela_unaligned(unsigned char* view,
 512                    const Sized_relobj<size, big_endian>* object,
 513                    const Symbol_value<size>* psymval,
 514                    typename elfcpp::Swap<size, big_endian>::Valtype addend,
 515                    typename elfcpp::Elf_types<size>::Elf_Addr address)
 516   {
 517     typedef typename elfcpp::Swap_unaligned<valsize,
 518             big_endian>::Valtype Valtype;
 519     unsigned char* wv = view;
 520     Valtype reloc = (psymval->value(object, addend) - address);
 521
 522     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc);
 523   }
 524
 525   typedef Sparc_relocate_functions<size, big_endian> This;
 526   typedef Sparc_relocate_functions<size, true> This_insn;
 527
 528 public:
 529   // R_SPARC_WDISP30: (Symbol + Addend - Address) >> 2
 530   static inline void
 531   wdisp30(unsigned char* view,
 532            const Sized_relobj<size, big_endian>* object,
 533            const Symbol_value<size>* psymval,
 534            typename elfcpp::Elf_types<size>::Elf_Addr addend,
 535            typename elfcpp::Elf_types<size>::Elf_Addr address)
 536   {
 537     This_insn::template pcrela<32>(view, 2, 0x3fffffff, object,
 538                                    psymval, addend, address);
 539   }
 540
 541   // R_SPARC_WDISP22: (Symbol + Addend - Address) >> 2
 542   static inline void
 543   wdisp22(unsigned char* view,
 544            const Sized_relobj<size, big_endian>* object,
 545            const Symbol_value<size>* psymval,
 546            typename elfcpp::Elf_types<size>::Elf_Addr addend,
 547            typename elfcpp::Elf_types<size>::Elf_Addr address)
 548   {
 549     This_insn::template pcrela<32>(view, 2, 0x003fffff, object,
 550                                    psymval, addend, address);
 551   }
 552
 553   // R_SPARC_WDISP19: (Symbol + Addend - Address) >> 2
 554   static inline void
 555   wdisp19(unsigned char* view,
 556           const Sized_relobj<size, big_endian>* object,
 557           const Symbol_value<size>* psymval,
 558           typename elfcpp::Elf_types<size>::Elf_Addr addend,
 559           typename elfcpp::Elf_types<size>::Elf_Addr address)
 560   {
 561     This_insn::template pcrela<32>(view, 2, 0x0007ffff, object,
 562                                    psymval, addend, address);
 563   }
 564
 565   // R_SPARC_WDISP16: (Symbol + Addend - Address) >> 2
 566   static inline void
 567   wdisp16(unsigned char* view,
 568           const Sized_relobj<size, big_endian>* object,
 569           const Symbol_value<size>* psymval,
 570           typename elfcpp::Elf_types<size>::Elf_Addr addend,
 571           typename elfcpp::Elf_types<size>::Elf_Addr address)
 572   {
 573     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
 574     Valtype* wv = reinterpret_cast<Valtype*>(view);
 575     Valtype val = elfcpp::Swap<32, true>::readval(wv);
 576     Valtype reloc = ((psymval->value(object, addend) - address)
 577                      >> 2);
 578
 579     // The relocation value is split between the low 14 bits,
 580     // and bits 20-21.
 581     val &= ~((0x3 << 20) | 0x3fff);
 582     reloc = (((reloc & 0xc000) << (20 - 14))
 583              | (reloc & 0x3ffff));
 584
 585     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
 586   }
 587
 588   // R_SPARC_PC22: (Symbol + Addend - Address) >> 10
 589   static inline void
 590   pc22(unsigned char* view,
 591        const Sized_relobj<size, big_endian>* object,
 592        const Symbol_value<size>* psymval,
 593        typename elfcpp::Elf_types<size>::Elf_Addr addend,
 594        typename elfcpp::Elf_types<size>::Elf_Addr address)
 595   {
 596     This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
 597                                    psymval, addend, address);
 598   }
 599
 600   // R_SPARC_PC10: (Symbol + Addend - Address) & 0x3ff
 601   static inline void
 602   pc10(unsigned char* view,
 603        const Sized_relobj<size, big_endian>* object,
 604        const Symbol_value<size>* psymval,
 605        typename elfcpp::Elf_types<size>::Elf_Addr addend,
 606        typename elfcpp::Elf_types<size>::Elf_Addr address)
 607   {
 608     This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
 609                                    psymval, addend, address);
 610   }
 611
 612   // R_SPARC_HI22: (Symbol + Addend) >> 10
 613   static inline void
 614   hi22(unsigned char* view,
 615        typename elfcpp::Elf_types<size>::Elf_Addr value,
 616        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 617   {
 618     This_insn::template rela<32>(view, 10, 0x003fffff, value, addend);
 619   }
 620
 621   // R_SPARC_HI22: (Symbol + Addend) >> 10
 622   static inline void
 623   hi22(unsigned char* view,
 624        const Sized_relobj<size, big_endian>* object,
 625        const Symbol_value<size>* psymval,
 626        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 627   {
 628     This_insn::template rela<32>(view, 10, 0x003fffff, object, psymval, addend);
 629   }
 630
 631   // R_SPARC_PCPLT22: (Symbol + Addend - Address) >> 10
 632   static inline void
 633   pcplt22(unsigned char* view,
 634           const Sized_relobj<size, big_endian>* object,
 635           const Symbol_value<size>* psymval,
 636           typename elfcpp::Elf_types<size>::Elf_Addr addend,
 637           typename elfcpp::Elf_types<size>::Elf_Addr address)
 638   {
 639     This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
 640                                    psymval, addend, address);
 641   }
 642
 643   // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
 644   static inline void
 645   lo10(unsigned char* view,
 646        typename elfcpp::Elf_types<size>::Elf_Addr value,
 647        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 648   {
 649     This_insn::template rela<32>(view, 0, 0x000003ff, value, addend);
 650   }
 651
 652   // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
 653   static inline void
 654   lo10(unsigned char* view,
 655        const Sized_relobj<size, big_endian>* object,
 656        const Symbol_value<size>* psymval,
 657        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 658   {
 659     This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
 660   }
 661
 662   // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
 663   static inline void
 664   lo10(unsigned char* view,
 665        const Sized_relobj<size, big_endian>* object,
 666        const Symbol_value<size>* psymval,
 667        typename elfcpp::Elf_types<size>::Elf_Addr addend,
 668        typename elfcpp::Elf_types<size>::Elf_Addr address)
 669   {
 670     This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
 671                                    psymval, addend, address);
 672   }
 673
 674   // R_SPARC_OLO10: ((Symbol + Addend) & 0x3ff) + Addend2
 675   static inline void
 676   olo10(unsigned char* view,
 677         const Sized_relobj<size, big_endian>* object,
 678         const Symbol_value<size>* psymval,
 679         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 680         typename elfcpp::Elf_types<size>::Elf_Addr addend2)
 681   {
 682     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
 683     Valtype* wv = reinterpret_cast<Valtype*>(view);
 684     Valtype val = elfcpp::Swap<32, true>::readval(wv);
 685     Valtype reloc = psymval->value(object, addend);
 686
 687     val &= ~0x1fff;
 688     reloc &= 0x3ff;
 689     reloc += addend2;
 690     reloc &= 0x1fff;
 691
 692     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
 693   }
 694
 695   // R_SPARC_22: (Symbol + Addend)
 696   static inline void
 697   rela32_22(unsigned char* view,
 698             const Sized_relobj<size, big_endian>* object,
 699             const Symbol_value<size>* psymval,
 700             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 701   {
 702     This_insn::template rela<32>(view, 0, 0x003fffff, object, psymval, addend);
 703   }
 704
 705   // R_SPARC_13: (Symbol + Addend)
 706   static inline void
 707   rela32_13(unsigned char* view,
 708             typename elfcpp::Elf_types<size>::Elf_Addr value,
 709             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 710   {
 711     This_insn::template rela<32>(view, 0, 0x00001fff, value, addend);
 712   }
 713
 714   // R_SPARC_13: (Symbol + Addend)
 715   static inline void
 716   rela32_13(unsigned char* view,
 717             const Sized_relobj<size, big_endian>* object,
 718             const Symbol_value<size>* psymval,
 719             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 720   {
 721     This_insn::template rela<32>(view, 0, 0x00001fff, object, psymval, addend);
 722   }
 723
 724   // R_SPARC_UA16: (Symbol + Addend)
 725   static inline void
 726   ua16(unsigned char* view,
 727        const Sized_relobj<size, big_endian>* object,
 728        const Symbol_value<size>* psymval,
 729        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 730   {
 731     This::template rela_ua<16>(view, 0, 0xffff, object, psymval, addend);
 732   }
 733
 734   // R_SPARC_UA32: (Symbol + Addend)
 735   static inline void
 736   ua32(unsigned char* view,
 737        const Sized_relobj<size, big_endian>* object,
 738        const Symbol_value<size>* psymval,
 739        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 740   {
 741     This::template rela_ua<32>(view, 0, 0xffffffff, object, psymval, addend);
 742   }
 743
 744   // R_SPARC_UA64: (Symbol + Addend)
 745   static inline void
 746   ua64(unsigned char* view,
 747        const Sized_relobj<size, big_endian>* object,
 748        const Symbol_value<size>* psymval,
 749        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 750   {
 751     This::template rela_ua<64>(view, 0, ~(elfcpp::Elf_Xword) 0,
 752                                object, psymval, addend);
 753   }
 754
 755   // R_SPARC_DISP8: (Symbol + Addend - Address)
 756   static inline void
 757   disp8(unsigned char* view,
 758         const Sized_relobj<size, big_endian>* object,
 759         const Symbol_value<size>* psymval,
 760         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 761         typename elfcpp::Elf_types<size>::Elf_Addr address)
 762   {
 763     This::template pcrela_unaligned<8>(view, object, psymval,
 764                                        addend, address);
 765   }
 766
 767   // R_SPARC_DISP16: (Symbol + Addend - Address)
 768   static inline void
 769   disp16(unsigned char* view,
 770          const Sized_relobj<size, big_endian>* object,
 771          const Symbol_value<size>* psymval,
 772          typename elfcpp::Elf_types<size>::Elf_Addr addend,
 773          typename elfcpp::Elf_types<size>::Elf_Addr address)
 774   {
 775     This::template pcrela_unaligned<16>(view, object, psymval,
 776                                         addend, address);
 777   }
 778
 779   // R_SPARC_DISP32: (Symbol + Addend - Address)
 780   static inline void
 781   disp32(unsigned char* view,
 782          const Sized_relobj<size, big_endian>* object,
 783          const Symbol_value<size>* psymval,
 784          typename elfcpp::Elf_types<size>::Elf_Addr addend,
 785          typename elfcpp::Elf_types<size>::Elf_Addr address)
 786   {
 787     This::template pcrela_unaligned<32>(view, object, psymval,
 788                                         addend, address);
 789   }
 790
 791   // R_SPARC_DISP64: (Symbol + Addend - Address)
 792   static inline void
 793   disp64(unsigned char* view,
 794          const Sized_relobj<size, big_endian>* object,
 795          const Symbol_value<size>* psymval,
 796          elfcpp::Elf_Xword addend,
 797          typename elfcpp::Elf_types<size>::Elf_Addr address)
 798   {
 799     This::template pcrela_unaligned<64>(view, object, psymval,
 800                                         addend, address);
 801   }
 802
 803   // R_SPARC_H44: (Symbol + Addend) >> 22
 804   static inline void
 805   h44(unsigned char* view,
 806       const Sized_relobj<size, big_endian>* object,
 807       const Symbol_value<size>* psymval,
 808       typename elfcpp::Elf_types<size>::Elf_Addr  addend)
 809   {
 810     This_insn::template rela<32>(view, 22, 0x003fffff, object, psymval, addend);
 811   }
 812
 813   // R_SPARC_M44: ((Symbol + Addend) >> 12) & 0x3ff
 814   static inline void
 815   m44(unsigned char* view,
 816       const Sized_relobj<size, big_endian>* object,
 817       const Symbol_value<size>* psymval,
 818       typename elfcpp::Elf_types<size>::Elf_Addr  addend)
 819   {
 820     This_insn::template rela<32>(view, 12, 0x000003ff, object, psymval, addend);
 821   }
 822
 823   // R_SPARC_L44: (Symbol + Addend) & 0xfff
 824   static inline void
 825   l44(unsigned char* view,
 826       const Sized_relobj<size, big_endian>* object,
 827       const Symbol_value<size>* psymval,
 828       typename elfcpp::Elf_types<size>::Elf_Addr  addend)
 829   {
 830     This_insn::template rela<32>(view, 0, 0x00000fff, object, psymval, addend);
 831   }
 832
 833   // R_SPARC_HH22: (Symbol + Addend) >> 42
 834   static inline void
 835   hh22(unsigned char* view,
 836        const Sized_relobj<size, big_endian>* object,
 837        const Symbol_value<size>* psymval,
 838        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 839   {
 840     This_insn::template rela<32>(view, 42, 0x003fffff, object, psymval, addend);
 841   }
 842
 843   // R_SPARC_PC_HH22: (Symbol + Addend - Address) >> 42
 844   static inline void
 845   pc_hh22(unsigned char* view,
 846           const Sized_relobj<size, big_endian>* object,
 847           const Symbol_value<size>* psymval,
 848           typename elfcpp::Elf_types<size>::Elf_Addr addend,
 849           typename elfcpp::Elf_types<size>::Elf_Addr address)
 850   {
 851     This_insn::template pcrela<32>(view, 42, 0x003fffff, object,
 852                                    psymval, addend, address);
 853   }
 854
 855   // R_SPARC_HM10: ((Symbol + Addend) >> 32) & 0x3ff
 856   static inline void
 857   hm10(unsigned char* view,
 858        const Sized_relobj<size, big_endian>* object,
 859        const Symbol_value<size>* psymval,
 860        typename elfcpp::Elf_types<size>::Elf_Addr addend)
 861   {
 862     This_insn::template rela<32>(view, 32, 0x000003ff, object, psymval, addend);
 863   }
 864
 865   // R_SPARC_PC_HM10: ((Symbol + Addend - Address) >> 32) & 0x3ff
 866   static inline void
 867   pc_hm10(unsigned char* view,
 868           const Sized_relobj<size, big_endian>* object,
 869           const Symbol_value<size>* psymval,
 870           typename elfcpp::Elf_types<size>::Elf_Addr addend,
 871           typename elfcpp::Elf_types<size>::Elf_Addr address)
 872   {
 873     This_insn::template pcrela<32>(view, 32, 0x000003ff, object,
 874                                    psymval, addend, address);
 875   }
 876
 877   // R_SPARC_11: (Symbol + Addend)
 878   static inline void
 879   rela32_11(unsigned char* view,
 880             const Sized_relobj<size, big_endian>* object,
 881             const Symbol_value<size>* psymval,
 882             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 883   {
 884     This_insn::template rela<32>(view, 0, 0x000007ff, object, psymval, addend);
 885   }
 886
 887   // R_SPARC_10: (Symbol + Addend)
 888   static inline void
 889   rela32_10(unsigned char* view,
 890             const Sized_relobj<size, big_endian>* object,
 891             const Symbol_value<size>* psymval,
 892             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 893   {
 894     This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
 895   }
 896
 897   // R_SPARC_7: (Symbol + Addend)
 898   static inline void
 899   rela32_7(unsigned char* view,
 900            const Sized_relobj<size, big_endian>* object,
 901            const Symbol_value<size>* psymval,
 902            typename elfcpp::Elf_types<size>::Elf_Addr addend)
 903   {
 904     This_insn::template rela<32>(view, 0, 0x0000007f, object, psymval, addend);
 905   }
 906
 907   // R_SPARC_6: (Symbol + Addend)
 908   static inline void
 909   rela32_6(unsigned char* view,
 910            const Sized_relobj<size, big_endian>* object,
 911            const Symbol_value<size>* psymval,
 912            typename elfcpp::Elf_types<size>::Elf_Addr addend)
 913   {
 914     This_insn::template rela<32>(view, 0, 0x0000003f, object, psymval, addend);
 915   }
 916
 917   // R_SPARC_5: (Symbol + Addend)
 918   static inline void
 919   rela32_5(unsigned char* view,
 920            const Sized_relobj<size, big_endian>* object,
 921            const Symbol_value<size>* psymval,
 922            typename elfcpp::Elf_types<size>::Elf_Addr addend)
 923   {
 924     This_insn::template rela<32>(view, 0, 0x0000001f, object, psymval, addend);
 925   }
 926
 927   // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10
 928   static inline void
 929   ldo_hix22(unsigned char* view,
 930             typename elfcpp::Elf_types<size>::Elf_Addr value,
 931             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 932   {
 933     This_insn::hi22(view, value, addend);
 934   }
 935
 936   // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff
 937   static inline void
 938   ldo_lox10(unsigned char* view,
 939             typename elfcpp::Elf_types<size>::Elf_Addr value,
 940             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 941   {
 942     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
 943     Valtype* wv = reinterpret_cast<Valtype*>(view);
 944     Valtype val = elfcpp::Swap<32, true>::readval(wv);
 945     Valtype reloc = (value + addend);
 946
 947     val &= ~0x1fff;
 948     reloc &= 0x3ff;
 949
 950     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
 951   }
 952
 953   // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10
 954   static inline void
 955   hix22(unsigned char* view,
 956         typename elfcpp::Elf_types<size>::Elf_Addr value,
 957         typename elfcpp::Elf_types<size>::Elf_Addr addend)
 958   {
 959     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
 960     Valtype* wv = reinterpret_cast<Valtype*>(view);
 961     Valtype val = elfcpp::Swap<32, true>::readval(wv);
 962     Valtype reloc = (value + addend);
 963
 964     val &= ~0x3fffff;
 965
 966     reloc ^= ~(Valtype)0;
 967     reloc >>= 10;
 968
 969     reloc &= 0x3fffff;
 970
 971     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
 972   }
 973
 974   // R_SPARC_HIX22: ((Symbol + Addend) ^ 0xffffffffffffffff) >> 10
 975   static inline void
 976   hix22(unsigned char* view,
 977         const Sized_relobj<size, big_endian>* object,
 978         const Symbol_value<size>* psymval,
 979         typename elfcpp::Elf_types<size>::Elf_Addr addend)
 980   {
 981     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
 982     Valtype* wv = reinterpret_cast<Valtype*>(view);
 983     Valtype val = elfcpp::Swap<32, true>::readval(wv);
 984     Valtype reloc = psymval->value(object, addend);
 985
 986     val &= ~0x3fffff;
 987
 988     reloc ^= ~(Valtype)0;
 989     reloc >>= 10;
 990
 991     reloc &= 0x3fffff;
 992
 993     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
 994   }
 995
 996
 997   // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00
 998   static inline void
 999   lox10(unsigned char* view,
1000         typename elfcpp::Elf_types<size>::Elf_Addr value,
1001         typename elfcpp::Elf_types<size>::Elf_Addr addend)
1002   {
1003     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
1004     Valtype* wv = reinterpret_cast<Valtype*>(view);
1005     Valtype val = elfcpp::Swap<32, true>::readval(wv);
1006     Valtype reloc = (value + addend);
1007
1008     val &= ~0x1fff;
1009     reloc &= 0x3ff;
1010     reloc |= 0x1c00;
1011
1012     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
1013   }
1014
1015   // R_SPARC_LOX10: ((Symbol + Addend) & 0x3ff) | 0x1c00
1016   static inline void
1017   lox10(unsigned char* view,
1018         const Sized_relobj<size, big_endian>* object,
1019         const Symbol_value<size>* psymval,
1020         typename elfcpp::Elf_types<size>::Elf_Addr addend)
1021   {
1022     typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
1023     Valtype* wv = reinterpret_cast<Valtype*>(view);
1024     Valtype val = elfcpp::Swap<32, true>::readval(wv);
1025     Valtype reloc = psymval->value(object, addend);
1026
1027     val &= ~0x1fff;
1028     reloc &= 0x3ff;
1029     reloc |= 0x1c00;
1030
1031     elfcpp::Swap<32, true>::writeval(wv, val | reloc);
1032   }
1033 };
1034
1035 // Get the GOT section, creating it if necessary.
1036
1037 template<int size, bool big_endian>
1038 Output_data_got<size, big_endian>*
1039 Target_sparc<size, big_endian>::got_section(Symbol_table* symtab,
1040                                             Layout* layout)
1041 {
1042   if (this->got_ == NULL)
1043     {
1044       gold_assert(symtab != NULL && layout != NULL);
1045
1046       this->got_ = new Output_data_got<size, big_endian>();
1047
1048       Output_section* os;
1049       os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1050                                            (elfcpp::SHF_ALLOC
1051                                             | elfcpp::SHF_WRITE),
1052                                            this->got_, false, true, false,
1053                                            false);
1054
1055       // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
1056       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1057                                     Symbol_table::PREDEFINED,
1058                                     this->got_,
1059                                     0, 0, elfcpp::STT_OBJECT,
1060                                     elfcpp::STB_LOCAL,
1061                                     elfcpp::STV_HIDDEN, 0,
1062                                     false, false);
1063     }
1064
1065   return this->got_;
1066 }
1067
1068 // Get the dynamic reloc section, creating it if necessary.
1069
1070 template<int size, bool big_endian>
1071 typename Target_sparc<size, big_endian>::Reloc_section*
1072 Target_sparc<size, big_endian>::rela_dyn_section(Layout* layout)
1073 {
1074   if (this->rela_dyn_ == NULL)
1075     {
1076       gold_assert(layout != NULL);
1077       this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
1078       layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1079                                       elfcpp::SHF_ALLOC, this->rela_dyn_, true,
1080                                       false, false, false);
1081     }
1082   return this->rela_dyn_;
1083 }
1084
1085 // A class to handle the PLT data.
1086
1087 template<int size, bool big_endian>
1088 class Output_data_plt_sparc : public Output_section_data
1089 {
1090  public:
1091   typedef Output_data_reloc<elfcpp::SHT_RELA, true,
1092                             size, big_endian> Reloc_section;
1093
1094   Output_data_plt_sparc(Layout*);
1095
1096   // Add an entry to the PLT.
1097   void add_entry(Symbol* gsym);
1098
1099   // Return the .rela.plt section data.
1100   const Reloc_section* rel_plt() const
1101   {
1102     return this->rel_;
1103   }
1104
1105  protected:
1106   void do_adjust_output_section(Output_section* os);
1107
1108   // Write to a map file.
1109   void
1110   do_print_to_mapfile(Mapfile* mapfile) const
1111   { mapfile->print_output_data(this, _("** PLT")); }
1112
1113  private:
1114   // The size of an entry in the PLT.
1115   static const int base_plt_entry_size = (size == 32 ? 12 : 32);
1116
1117   static const unsigned int plt_entries_per_block = 160;
1118   static const unsigned int plt_insn_chunk_size = 24;
1119   static const unsigned int plt_pointer_chunk_size = 8;
1120   static const unsigned int plt_block_size =
1121     (plt_entries_per_block
1122      * (plt_insn_chunk_size + plt_pointer_chunk_size));
1123
1124   // Set the final size.
1125   void
1126   set_final_data_size()
1127   {
1128     unsigned int full_count = this->count_ + 4;
1129     unsigned int extra = (size == 32 ? 4 : 0);
1130
1131     if (size == 32 || full_count < 32768)
1132       this->set_data_size((full_count * base_plt_entry_size) + extra);
1133     else
1134       {
1135         unsigned int ext_cnt = full_count - 32768;
1136
1137         this->set_data_size((32768 * base_plt_entry_size)
1138                             + (ext_cnt
1139                                * (plt_insn_chunk_size
1140                                   + plt_pointer_chunk_size)));
1141       }
1142   }
1143
1144   // Write out the PLT data.
1145   void
1146   do_write(Output_file*);
1147
1148   // The reloc section.
1149   Reloc_section* rel_;
1150   // The number of PLT entries.
1151   unsigned int count_;
1152 };
1153
1154 // Define the constants as required by C++ standard.
1155
1156 template<int size, bool big_endian>
1157 const int Output_data_plt_sparc<size, big_endian>::base_plt_entry_size;
1158
1159 template<int size, bool big_endian>
1160 const unsigned int
1161 Output_data_plt_sparc<size, big_endian>::plt_entries_per_block;
1162
1163 template<int size, bool big_endian>
1164 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_insn_chunk_size;
1165
1166 template<int size, bool big_endian>
1167 const unsigned int
1168 Output_data_plt_sparc<size, big_endian>::plt_pointer_chunk_size;
1169
1170 template<int size, bool big_endian>
1171 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_block_size;
1172
1173 // Create the PLT section.  The ordinary .got section is an argument,
1174 // since we need to refer to the start.
1175
1176 template<int size, bool big_endian>
1177 Output_data_plt_sparc<size, big_endian>::Output_data_plt_sparc(Layout* layout)
1178   : Output_section_data(size == 32 ? 4 : 8), count_(0)
1179 {
1180   this->rel_ = new Reloc_section(false);
1181   layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1182                                   elfcpp::SHF_ALLOC, this->rel_, true,
1183                                   false, false, false);
1184 }
1185
1186 template<int size, bool big_endian>
1187 void
1188 Output_data_plt_sparc<size, big_endian>::do_adjust_output_section(Output_section* os)
1189 {
1190   os->set_entsize(0);
1191 }
1192
1193 // Add an entry to the PLT.
1194
1195 template<int size, bool big_endian>
1196 void
1197 Output_data_plt_sparc<size, big_endian>::add_entry(Symbol* gsym)
1198 {
1199   gold_assert(!gsym->has_plt_offset());
1200
1201   unsigned int index = this->count_ + 4;
1202   section_offset_type plt_offset;
1203
1204   if (size == 32 || index < 32768)
1205     plt_offset = index * base_plt_entry_size;
1206   else
1207     {
1208         unsigned int ext_index = index - 32768;
1209
1210         plt_offset = (32768 * base_plt_entry_size)
1211           + ((ext_index / plt_entries_per_block)
1212              * plt_block_size)
1213           + ((ext_index % plt_entries_per_block)
1214              * plt_insn_chunk_size);
1215     }
1216
1217   gsym->set_plt_offset(plt_offset);
1218
1219   ++this->count_;
1220
1221   // Every PLT entry needs a reloc.
1222   gsym->set_needs_dynsym_entry();
1223   this->rel_->add_global(gsym, elfcpp::R_SPARC_JMP_SLOT, this,
1224                          plt_offset, 0);
1225
1226   // Note that we don't need to save the symbol.  The contents of the
1227   // PLT are independent of which symbols are used.  The symbols only
1228   // appear in the relocations.
1229 }
1230
1231 static const unsigned int sparc_nop = 0x01000000;
1232 static const unsigned int sparc_sethi_g1 = 0x03000000;
1233 static const unsigned int sparc_branch_always = 0x30800000;
1234 static const unsigned int sparc_branch_always_pt = 0x30680000;
1235 static const unsigned int sparc_mov = 0x80100000;
1236 static const unsigned int sparc_mov_g0_o0 = 0x90100000;
1237 static const unsigned int sparc_mov_o7_g5 = 0x8a10000f;
1238 static const unsigned int sparc_call_plus_8 = 0x40000002;
1239 static const unsigned int sparc_ldx_o7_imm_g1 = 0xc25be000;
1240 static const unsigned int sparc_jmpl_o7_g1_g1 = 0x83c3c001;
1241 static const unsigned int sparc_mov_g5_o7 = 0x9e100005;
1242
1243 // Write out the PLT.
1244
1245 template<int size, bool big_endian>
1246 void
1247 Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of)
1248 {
1249   const off_t offset = this->offset();
1250   const section_size_type oview_size =
1251     convert_to_section_size_type(this->data_size());
1252   unsigned char* const oview = of->get_output_view(offset, oview_size);
1253   unsigned char* pov = oview;
1254
1255   memset(pov, 0, base_plt_entry_size * 4);
1256   pov += base_plt_entry_size * 4;
1257
1258   unsigned int plt_offset = base_plt_entry_size * 4;
1259   const unsigned int count = this->count_;
1260
1261   if (size == 64)
1262     {
1263       unsigned int limit;
1264
1265       limit = (count > 32768 ? 32768 : count);
1266
1267       for (unsigned int i = 0; i < limit; ++i)
1268         {
1269           elfcpp::Swap<32, true>::writeval(pov + 0x00,
1270                                            sparc_sethi_g1 + plt_offset);
1271           elfcpp::Swap<32, true>::writeval(pov + 0x04,
1272                                            sparc_branch_always_pt +
1273                                            (((base_plt_entry_size -
1274                                               (plt_offset + 4)) >> 2) &
1275                                             0x7ffff));
1276           elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1277           elfcpp::Swap<32, true>::writeval(pov + 0x0c, sparc_nop);
1278           elfcpp::Swap<32, true>::writeval(pov + 0x10, sparc_nop);
1279           elfcpp::Swap<32, true>::writeval(pov + 0x14, sparc_nop);
1280           elfcpp::Swap<32, true>::writeval(pov + 0x18, sparc_nop);
1281           elfcpp::Swap<32, true>::writeval(pov + 0x1c, sparc_nop);
1282
1283           pov += base_plt_entry_size;
1284           plt_offset += base_plt_entry_size;
1285         }
1286
1287       if (count > 32768)
1288         {
1289           unsigned int ext_cnt = count - 32768;
1290           unsigned int blks = ext_cnt / plt_entries_per_block;
1291
1292           for (unsigned int i = 0; i < blks; ++i)
1293             {
1294               unsigned int data_off = (plt_entries_per_block
1295                                        * plt_insn_chunk_size) - 4;
1296
1297               for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1298                 {
1299                   elfcpp::Swap<32, true>::writeval(pov + 0x00,
1300                                                    sparc_mov_o7_g5);
1301                   elfcpp::Swap<32, true>::writeval(pov + 0x04,
1302                                                    sparc_call_plus_8);
1303                   elfcpp::Swap<32, true>::writeval(pov + 0x08,
1304                                                    sparc_nop);
1305                   elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1306                                                    sparc_ldx_o7_imm_g1 +
1307                                                    (data_off & 0x1fff));
1308                   elfcpp::Swap<32, true>::writeval(pov + 0x10,
1309                                                    sparc_jmpl_o7_g1_g1);
1310                   elfcpp::Swap<32, true>::writeval(pov + 0x14,
1311                                                    sparc_mov_g5_o7);
1312
1313                   elfcpp::Swap<64, big_endian>::writeval(
1314                                 pov + 0x4 + data_off,
1315                                 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1316
1317                   pov += plt_insn_chunk_size;
1318                   data_off -= 16;
1319                 }
1320             }
1321
1322           unsigned int sub_blk_cnt = ext_cnt % plt_entries_per_block;
1323           for (unsigned int i = 0; i < sub_blk_cnt; ++i)
1324             {
1325               unsigned int data_off = (sub_blk_cnt
1326                                        * plt_insn_chunk_size) - 4;
1327
1328               for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1329                 {
1330                   elfcpp::Swap<32, true>::writeval(pov + 0x00,
1331                                                    sparc_mov_o7_g5);
1332                   elfcpp::Swap<32, true>::writeval(pov + 0x04,
1333                                                    sparc_call_plus_8);
1334                   elfcpp::Swap<32, true>::writeval(pov + 0x08,
1335                                                    sparc_nop);
1336                   elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1337                                                    sparc_ldx_o7_imm_g1 +
1338                                                    (data_off & 0x1fff));
1339                   elfcpp::Swap<32, true>::writeval(pov + 0x10,
1340                                                    sparc_jmpl_o7_g1_g1);
1341                   elfcpp::Swap<32, true>::writeval(pov + 0x14,
1342                                                    sparc_mov_g5_o7);
1343
1344                   elfcpp::Swap<64, big_endian>::writeval(
1345                                 pov + 0x4 + data_off,
1346                                 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1347
1348                   pov += plt_insn_chunk_size;
1349                   data_off -= 16;
1350                 }
1351             }
1352         }
1353     }
1354   else
1355     {
1356       for (unsigned int i = 0; i < count; ++i)
1357         {
1358           elfcpp::Swap<32, true>::writeval(pov + 0x00,
1359                                            sparc_sethi_g1 + plt_offset);
1360           elfcpp::Swap<32, true>::writeval(pov + 0x04,
1361                                            sparc_branch_always +
1362                                            (((- (plt_offset + 4)) >> 2) &
1363                                             0x003fffff));
1364           elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1365
1366           pov += base_plt_entry_size;
1367           plt_offset += base_plt_entry_size;
1368         }
1369
1370       elfcpp::Swap<32, true>::writeval(pov, sparc_nop);
1371       pov += 4;
1372     }
1373
1374   gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1375
1376   of->write_output_view(offset, oview_size, oview);
1377 }
1378
1379 // Create a PLT entry for a global symbol.
1380
1381 template<int size, bool big_endian>
1382 void
1383 Target_sparc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
1384                                                Layout* layout,
1385                                                Symbol* gsym)
1386 {
1387   if (gsym->has_plt_offset())
1388     return;
1389
1390   if (this->plt_ == NULL)
1391     {
1392       // Create the GOT sections first.
1393       this->got_section(symtab, layout);
1394
1395       // Ensure that .rela.dyn always appears before .rela.plt  This is
1396       // necessary due to how, on Sparc and some other targets, .rela.dyn
1397       // needs to include .rela.plt in it's range.
1398       this->rela_dyn_section(layout);
1399
1400       this->plt_ = new Output_data_plt_sparc<size, big_endian>(layout);
1401       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1402                                       (elfcpp::SHF_ALLOC
1403                                        | elfcpp::SHF_EXECINSTR
1404                                        | elfcpp::SHF_WRITE),
1405                                       this->plt_, false, false, false, false);
1406
1407       // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
1408       symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
1409                                     Symbol_table::PREDEFINED,
1410                                     this->plt_,
1411                                     0, 0, elfcpp::STT_OBJECT,
1412                                     elfcpp::STB_LOCAL,
1413                                     elfcpp::STV_HIDDEN, 0,
1414                                     false, false);
1415     }
1416
1417   this->plt_->add_entry(gsym);
1418 }
1419
1420 // Create a GOT entry for the TLS module index.
1421
1422 template<int size, bool big_endian>
1423 unsigned int
1424 Target_sparc<size, big_endian>::got_mod_index_entry(Symbol_table* symtab,
1425                                                     Layout* layout,
1426                                                     Sized_relobj<size, big_endian>* object)
1427 {
1428   if (this->got_mod_index_offset_ == -1U)
1429     {
1430       gold_assert(symtab != NULL && layout != NULL && object != NULL);
1431       Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1432       Output_data_got<size, big_endian>* got;
1433       unsigned int got_offset;
1434
1435       got = this->got_section(symtab, layout);
1436       got_offset = got->add_constant(0);
1437       rela_dyn->add_local(object, 0,
1438                           (size == 64 ?
1439                            elfcpp::R_SPARC_TLS_DTPMOD64 :
1440                            elfcpp::R_SPARC_TLS_DTPMOD32), got,
1441                           got_offset, 0);
1442       got->add_constant(0);
1443       this->got_mod_index_offset_ = got_offset;
1444     }
1445   return this->got_mod_index_offset_;
1446 }
1447
1448 // Optimize the TLS relocation type based on what we know about the
1449 // symbol.  IS_FINAL is true if the final address of this symbol is
1450 // known at link time.
1451
1452 static tls::Tls_optimization
1453 optimize_tls_reloc(bool is_final, int r_type)
1454 {
1455   // If we are generating a shared library, then we can't do anything
1456   // in the linker.
1457   if (parameters->options().shared())
1458     return tls::TLSOPT_NONE;
1459
1460   switch (r_type)
1461     {
1462     case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1463     case elfcpp::R_SPARC_TLS_GD_LO10:
1464     case elfcpp::R_SPARC_TLS_GD_ADD:
1465     case elfcpp::R_SPARC_TLS_GD_CALL:
1466       // These are General-Dynamic which permits fully general TLS
1467       // access.  Since we know that we are generating an executable,
1468       // we can convert this to Initial-Exec.  If we also know that
1469       // this is a local symbol, we can further switch to Local-Exec.
1470       if (is_final)
1471         return tls::TLSOPT_TO_LE;
1472       return tls::TLSOPT_TO_IE;
1473
1474     case elfcpp::R_SPARC_TLS_LDM_HI22:  // Local-dynamic
1475     case elfcpp::R_SPARC_TLS_LDM_LO10:
1476     case elfcpp::R_SPARC_TLS_LDM_ADD:
1477     case elfcpp::R_SPARC_TLS_LDM_CALL:
1478       // This is Local-Dynamic, which refers to a local symbol in the
1479       // dynamic TLS block.  Since we know that we generating an
1480       // executable, we can switch to Local-Exec.
1481       return tls::TLSOPT_TO_LE;
1482
1483     case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1484     case elfcpp::R_SPARC_TLS_LDO_LOX10:
1485     case elfcpp::R_SPARC_TLS_LDO_ADD:
1486       // Another type of Local-Dynamic relocation.
1487       return tls::TLSOPT_TO_LE;
1488
1489     case elfcpp::R_SPARC_TLS_IE_HI22:   // Initial-exec
1490     case elfcpp::R_SPARC_TLS_IE_LO10:
1491     case elfcpp::R_SPARC_TLS_IE_LD:
1492     case elfcpp::R_SPARC_TLS_IE_LDX:
1493     case elfcpp::R_SPARC_TLS_IE_ADD:
1494       // These are Initial-Exec relocs which get the thread offset
1495       // from the GOT.  If we know that we are linking against the
1496       // local symbol, we can switch to Local-Exec, which links the
1497       // thread offset into the instruction.
1498       if (is_final)
1499         return tls::TLSOPT_TO_LE;
1500       return tls::TLSOPT_NONE;
1501
1502     case elfcpp::R_SPARC_TLS_LE_HIX22:  // Local-exec
1503     case elfcpp::R_SPARC_TLS_LE_LOX10:
1504       // When we already have Local-Exec, there is nothing further we
1505       // can do.
1506       return tls::TLSOPT_NONE;
1507
1508     default:
1509       gold_unreachable();
1510     }
1511 }
1512
1513 // Generate a PLT entry slot for a call to __tls_get_addr
1514 template<int size, bool big_endian>
1515 void
1516 Target_sparc<size, big_endian>::Scan::generate_tls_call(Symbol_table* symtab,
1517                                                         Layout* layout,
1518                                                         Target_sparc<size, big_endian>* target)
1519 {
1520   Symbol* gsym = target->tls_get_addr_sym(symtab);
1521
1522   target->make_plt_entry(symtab, layout, gsym);
1523 }
1524
1525 // Report an unsupported relocation against a local symbol.
1526
1527 template<int size, bool big_endian>
1528 void
1529 Target_sparc<size, big_endian>::Scan::unsupported_reloc_local(
1530                         Sized_relobj<size, big_endian>* object,
1531                         unsigned int r_type)
1532 {
1533   gold_error(_("%s: unsupported reloc %u against local symbol"),
1534              object->name().c_str(), r_type);
1535 }
1536
1537 // We are about to emit a dynamic relocation of type R_TYPE.  If the
1538 // dynamic linker does not support it, issue an error.
1539
1540 template<int size, bool big_endian>
1541 void
1542 Target_sparc<size, big_endian>::Scan::check_non_pic(Relobj* object, unsigned int r_type)
1543 {
1544   gold_assert(r_type != elfcpp::R_SPARC_NONE);
1545
1546   if (size == 64)
1547     {
1548       switch (r_type)
1549         {
1550           // These are the relocation types supported by glibc for sparc 64-bit.
1551         case elfcpp::R_SPARC_RELATIVE:
1552         case elfcpp::R_SPARC_COPY:
1553         case elfcpp::R_SPARC_64:
1554         case elfcpp::R_SPARC_GLOB_DAT:
1555         case elfcpp::R_SPARC_JMP_SLOT:
1556         case elfcpp::R_SPARC_TLS_DTPMOD64:
1557         case elfcpp::R_SPARC_TLS_DTPOFF64:
1558         case elfcpp::R_SPARC_TLS_TPOFF64:
1559         case elfcpp::R_SPARC_TLS_LE_HIX22:
1560         case elfcpp::R_SPARC_TLS_LE_LOX10:
1561         case elfcpp::R_SPARC_8:
1562         case elfcpp::R_SPARC_16:
1563         case elfcpp::R_SPARC_DISP8:
1564         case elfcpp::R_SPARC_DISP16:
1565         case elfcpp::R_SPARC_DISP32:
1566         case elfcpp::R_SPARC_WDISP30:
1567         case elfcpp::R_SPARC_LO10:
1568         case elfcpp::R_SPARC_HI22:
1569         case elfcpp::R_SPARC_OLO10:
1570         case elfcpp::R_SPARC_H44:
1571         case elfcpp::R_SPARC_M44:
1572         case elfcpp::R_SPARC_L44:
1573         case elfcpp::R_SPARC_HH22:
1574         case elfcpp::R_SPARC_HM10:
1575         case elfcpp::R_SPARC_LM22:
1576         case elfcpp::R_SPARC_UA16:
1577         case elfcpp::R_SPARC_UA32:
1578         case elfcpp::R_SPARC_UA64:
1579           return;
1580
1581         default:
1582           break;
1583         }
1584     }
1585   else
1586     {
1587       switch (r_type)
1588         {
1589           // These are the relocation types supported by glibc for sparc 32-bit.
1590         case elfcpp::R_SPARC_RELATIVE:
1591         case elfcpp::R_SPARC_COPY:
1592         case elfcpp::R_SPARC_GLOB_DAT:
1593         case elfcpp::R_SPARC_32:
1594         case elfcpp::R_SPARC_JMP_SLOT:
1595         case elfcpp::R_SPARC_TLS_DTPMOD32:
1596         case elfcpp::R_SPARC_TLS_DTPOFF32:
1597         case elfcpp::R_SPARC_TLS_TPOFF32:
1598         case elfcpp::R_SPARC_TLS_LE_HIX22:
1599         case elfcpp::R_SPARC_TLS_LE_LOX10:
1600         case elfcpp::R_SPARC_8:
1601         case elfcpp::R_SPARC_16:
1602         case elfcpp::R_SPARC_DISP8:
1603         case elfcpp::R_SPARC_DISP16:
1604         case elfcpp::R_SPARC_DISP32:
1605         case elfcpp::R_SPARC_LO10:
1606         case elfcpp::R_SPARC_WDISP30:
1607         case elfcpp::R_SPARC_HI22:
1608         case elfcpp::R_SPARC_UA16:
1609         case elfcpp::R_SPARC_UA32:
1610           return;
1611
1612         default:
1613           break;
1614         }
1615     }
1616
1617   // This prevents us from issuing more than one error per reloc
1618   // section.  But we can still wind up issuing more than one
1619   // error per object file.
1620   if (this->issued_non_pic_error_)
1621     return;
1622   gold_assert(parameters->options().output_is_position_independent());
1623   object->error(_("requires unsupported dynamic reloc; "
1624                   "recompile with -fPIC"));
1625   this->issued_non_pic_error_ = true;
1626   return;
1627 }
1628
1629 // Scan a relocation for a local symbol.
1630
1631 template<int size, bool big_endian>
1632 inline void
1633 Target_sparc<size, big_endian>::Scan::local(
1634                         Symbol_table* symtab,
1635                         Layout* layout,
1636                         Target_sparc<size, big_endian>* target,
1637                         Sized_relobj<size, big_endian>* object,
1638                         unsigned int data_shndx,
1639                         Output_section* output_section,
1640                         const elfcpp::Rela<size, big_endian>& reloc,
1641                         unsigned int r_type,
1642                         const elfcpp::Sym<size, big_endian>& lsym)
1643 {
1644   unsigned int orig_r_type = r_type;
1645
1646   r_type &= 0xff;
1647   switch (r_type)
1648     {
1649     case elfcpp::R_SPARC_NONE:
1650     case elfcpp::R_SPARC_REGISTER:
1651     case elfcpp::R_SPARC_GNU_VTINHERIT:
1652     case elfcpp::R_SPARC_GNU_VTENTRY:
1653       break;
1654
1655     case elfcpp::R_SPARC_64:
1656     case elfcpp::R_SPARC_32:
1657       // If building a shared library (or a position-independent
1658       // executable), we need to create a dynamic relocation for
1659       // this location. The relocation applied at link time will
1660       // apply the link-time value, so we flag the location with
1661       // an R_SPARC_RELATIVE relocation so the dynamic loader can
1662       // relocate it easily.
1663       if (parameters->options().output_is_position_independent())
1664         {
1665           Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1666           unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1667           rela_dyn->add_local_relative(object, r_sym, elfcpp::R_SPARC_RELATIVE,
1668                                        output_section, data_shndx,
1669                                        reloc.get_r_offset(),
1670                                        reloc.get_r_addend());
1671         }
1672       break;
1673
1674     case elfcpp::R_SPARC_HIX22:
1675     case elfcpp::R_SPARC_LOX10:
1676     case elfcpp::R_SPARC_H44:
1677     case elfcpp::R_SPARC_M44:
1678     case elfcpp::R_SPARC_L44:
1679     case elfcpp::R_SPARC_HH22:
1680     case elfcpp::R_SPARC_HM10:
1681     case elfcpp::R_SPARC_LM22:
1682     case elfcpp::R_SPARC_UA64:
1683     case elfcpp::R_SPARC_UA32:
1684     case elfcpp::R_SPARC_UA16:
1685     case elfcpp::R_SPARC_HI22:
1686     case elfcpp::R_SPARC_LO10:
1687     case elfcpp::R_SPARC_OLO10:
1688     case elfcpp::R_SPARC_16:
1689     case elfcpp::R_SPARC_11:
1690     case elfcpp::R_SPARC_10:
1691     case elfcpp::R_SPARC_8:
1692     case elfcpp::R_SPARC_7:
1693     case elfcpp::R_SPARC_6:
1694     case elfcpp::R_SPARC_5:
1695       // If building a shared library (or a position-independent
1696       // executable), we need to create a dynamic relocation for
1697       // this location.
1698       if (parameters->options().output_is_position_independent())
1699         {
1700           Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1701           unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1702
1703           check_non_pic(object, r_type);
1704           if (lsym.get_st_type() != elfcpp::STT_SECTION)
1705             {
1706               rela_dyn->add_local(object, r_sym, orig_r_type, output_section,
1707                                   data_shndx, reloc.get_r_offset(),
1708                                   reloc.get_r_addend());
1709             }
1710           else
1711             {
1712               gold_assert(lsym.get_st_value() == 0);
1713               rela_dyn->add_symbolless_local_addend(object, r_sym, orig_r_type,
1714                                                     output_section, data_shndx,
1715                                                     reloc.get_r_offset(),
1716                                                     reloc.get_r_addend());
1717             }
1718         }
1719       break;
1720
1721     case elfcpp::R_SPARC_WDISP30:
1722     case elfcpp::R_SPARC_WDISP22:
1723     case elfcpp::R_SPARC_WDISP19:
1724     case elfcpp::R_SPARC_WDISP16:
1725     case elfcpp::R_SPARC_DISP8:
1726     case elfcpp::R_SPARC_DISP16:
1727     case elfcpp::R_SPARC_DISP32:
1728     case elfcpp::R_SPARC_DISP64:
1729     case elfcpp::R_SPARC_PC10:
1730     case elfcpp::R_SPARC_PC22:
1731       break;
1732
1733     case elfcpp::R_SPARC_GOTDATA_OP:
1734     case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
1735     case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
1736     case elfcpp::R_SPARC_GOT10:
1737     case elfcpp::R_SPARC_GOT13:
1738     case elfcpp::R_SPARC_GOT22:
1739       {
1740         // The symbol requires a GOT entry.
1741         Output_data_got<size, big_endian>* got;
1742         unsigned int r_sym;
1743
1744         got = target->got_section(symtab, layout);
1745         r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1746
1747         // If we are generating a shared object, we need to add a
1748         // dynamic relocation for this symbol's GOT entry.
1749         if (parameters->options().output_is_position_independent())
1750           {
1751             if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
1752               {
1753                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1754                 unsigned int off;
1755
1756                 off = got->add_constant(0);
1757                 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
1758                 rela_dyn->add_local_relative(object, r_sym,
1759                                              elfcpp::R_SPARC_RELATIVE,
1760                                              got, off, 0);
1761               }
1762           }
1763         else
1764           got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1765       }
1766       break;
1767
1768       // These are initial TLS relocs, which are expected when
1769       // linking.
1770     case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1771     case elfcpp::R_SPARC_TLS_GD_LO10:
1772     case elfcpp::R_SPARC_TLS_GD_ADD:
1773     case elfcpp::R_SPARC_TLS_GD_CALL:
1774     case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic
1775     case elfcpp::R_SPARC_TLS_LDM_LO10:
1776     case elfcpp::R_SPARC_TLS_LDM_ADD:
1777     case elfcpp::R_SPARC_TLS_LDM_CALL:
1778     case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1779     case elfcpp::R_SPARC_TLS_LDO_LOX10:
1780     case elfcpp::R_SPARC_TLS_LDO_ADD:
1781     case elfcpp::R_SPARC_TLS_IE_HI22:   // Initial-exec
1782     case elfcpp::R_SPARC_TLS_IE_LO10:
1783     case elfcpp::R_SPARC_TLS_IE_LD:
1784     case elfcpp::R_SPARC_TLS_IE_LDX:
1785     case elfcpp::R_SPARC_TLS_IE_ADD:
1786     case elfcpp::R_SPARC_TLS_LE_HIX22:  // Local-exec
1787     case elfcpp::R_SPARC_TLS_LE_LOX10:
1788       {
1789         bool output_is_shared = parameters->options().shared();
1790         const tls::Tls_optimization optimized_type
1791             = optimize_tls_reloc(!output_is_shared, r_type);
1792         switch (r_type)
1793           {
1794           case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1795           case elfcpp::R_SPARC_TLS_GD_LO10:
1796           case elfcpp::R_SPARC_TLS_GD_ADD:
1797           case elfcpp::R_SPARC_TLS_GD_CALL:
1798             if (optimized_type == tls::TLSOPT_NONE)
1799               {
1800                 // Create a pair of GOT entries for the module index and
1801                 // dtv-relative offset.
1802                 Output_data_got<size, big_endian>* got
1803                     = target->got_section(symtab, layout);
1804                 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1805                 unsigned int shndx = lsym.get_st_shndx();
1806                 bool is_ordinary;
1807                 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1808                 if (!is_ordinary)
1809                   object->error(_("local symbol %u has bad shndx %u"),
1810                                 r_sym, shndx);
1811                 else
1812                   got->add_local_pair_with_rela(object, r_sym,
1813                                                 lsym.get_st_shndx(),
1814                                                 GOT_TYPE_TLS_PAIR,
1815                                                 target->rela_dyn_section(layout),
1816                                                 (size == 64
1817                                                  ? elfcpp::R_SPARC_TLS_DTPMOD64
1818                                                  : elfcpp::R_SPARC_TLS_DTPMOD32),
1819                                                  0);
1820                 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
1821                   generate_tls_call(symtab, layout, target);
1822               }
1823             else if (optimized_type != tls::TLSOPT_TO_LE)
1824               unsupported_reloc_local(object, r_type);
1825             break;
1826
1827           case elfcpp::R_SPARC_TLS_LDM_HI22 :   // Local-dynamic
1828           case elfcpp::R_SPARC_TLS_LDM_LO10:
1829           case elfcpp::R_SPARC_TLS_LDM_ADD:
1830           case elfcpp::R_SPARC_TLS_LDM_CALL:
1831             if (optimized_type == tls::TLSOPT_NONE)
1832               {
1833                 // Create a GOT entry for the module index.
1834                 target->got_mod_index_entry(symtab, layout, object);
1835
1836                 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
1837                   generate_tls_call(symtab, layout, target);
1838               }
1839             else if (optimized_type != tls::TLSOPT_TO_LE)
1840               unsupported_reloc_local(object, r_type);
1841             break;
1842
1843           case elfcpp::R_SPARC_TLS_LDO_HIX22:   // Alternate local-dynamic
1844           case elfcpp::R_SPARC_TLS_LDO_LOX10:
1845           case elfcpp::R_SPARC_TLS_LDO_ADD:
1846             break;
1847
1848           case elfcpp::R_SPARC_TLS_IE_HI22:     // Initial-exec
1849           case elfcpp::R_SPARC_TLS_IE_LO10:
1850           case elfcpp::R_SPARC_TLS_IE_LD:
1851           case elfcpp::R_SPARC_TLS_IE_LDX:
1852           case elfcpp::R_SPARC_TLS_IE_ADD:
1853             layout->set_has_static_tls();
1854             if (optimized_type == tls::TLSOPT_NONE)
1855               {
1856                 // Create a GOT entry for the tp-relative offset.
1857                 Output_data_got<size, big_endian>* got
1858                   = target->got_section(symtab, layout);
1859                 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1860
1861                 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_OFFSET))
1862                   {
1863                     Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1864                     unsigned int off = got->add_constant(0);
1865
1866                     object->set_local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET, off);
1867
1868                     rela_dyn->add_symbolless_local_addend(object, r_sym,
1869                                                           (size == 64 ?
1870                                                            elfcpp::R_SPARC_TLS_TPOFF64 :
1871                                                            elfcpp::R_SPARC_TLS_TPOFF32),
1872                                                           got, off, 0);
1873                   }
1874               }
1875             else if (optimized_type != tls::TLSOPT_TO_LE)
1876               unsupported_reloc_local(object, r_type);
1877             break;
1878
1879           case elfcpp::R_SPARC_TLS_LE_HIX22:    // Local-exec
1880           case elfcpp::R_SPARC_TLS_LE_LOX10:
1881             layout->set_has_static_tls();
1882             if (output_is_shared)
1883               {
1884                 // We need to create a dynamic relocation.
1885                 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
1886                 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1887                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1888                 rela_dyn->add_symbolless_local_addend(object, r_sym, r_type,
1889                                                       output_section, data_shndx,
1890                                                       reloc.get_r_offset(), 0);
1891               }
1892             break;
1893           }
1894       }
1895       break;
1896
1897       // These are relocations which should only be seen by the
1898       // dynamic linker, and should never be seen here.
1899     case elfcpp::R_SPARC_COPY:
1900     case elfcpp::R_SPARC_GLOB_DAT:
1901     case elfcpp::R_SPARC_JMP_SLOT:
1902     case elfcpp::R_SPARC_RELATIVE:
1903     case elfcpp::R_SPARC_TLS_DTPMOD64:
1904     case elfcpp::R_SPARC_TLS_DTPMOD32:
1905     case elfcpp::R_SPARC_TLS_DTPOFF64:
1906     case elfcpp::R_SPARC_TLS_DTPOFF32:
1907     case elfcpp::R_SPARC_TLS_TPOFF64:
1908     case elfcpp::R_SPARC_TLS_TPOFF32:
1909       gold_error(_("%s: unexpected reloc %u in object file"),
1910                  object->name().c_str(), r_type);
1911       break;
1912
1913     default:
1914       unsupported_reloc_local(object, r_type);
1915       break;
1916     }
1917 }
1918
1919 // Report an unsupported relocation against a global symbol.
1920
1921 template<int size, bool big_endian>
1922 void
1923 Target_sparc<size, big_endian>::Scan::unsupported_reloc_global(
1924                         Sized_relobj<size, big_endian>* object,
1925                         unsigned int r_type,
1926                         Symbol* gsym)
1927 {
1928   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1929              object->name().c_str(), r_type, gsym->demangled_name().c_str());
1930 }
1931
1932 // Scan a relocation for a global symbol.
1933
1934 template<int size, bool big_endian>
1935 inline void
1936 Target_sparc<size, big_endian>::Scan::global(
1937                                 Symbol_table* symtab,
1938                                 Layout* layout,
1939                                 Target_sparc<size, big_endian>* target,
1940                                 Sized_relobj<size, big_endian>* object,
1941                                 unsigned int data_shndx,
1942                                 Output_section* output_section,
1943                                 const elfcpp::Rela<size, big_endian>& reloc,
1944                                 unsigned int r_type,
1945                                 Symbol* gsym)
1946 {
1947   unsigned int orig_r_type = r_type;
1948
1949   // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
1950   // section.  We check here to avoid creating a dynamic reloc against
1951   // _GLOBAL_OFFSET_TABLE_.
1952   if (!target->has_got_section()
1953       && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
1954     target->got_section(symtab, layout);
1955
1956   r_type &= 0xff;
1957   switch (r_type)
1958     {
1959     case elfcpp::R_SPARC_NONE:
1960     case elfcpp::R_SPARC_REGISTER:
1961     case elfcpp::R_SPARC_GNU_VTINHERIT:
1962     case elfcpp::R_SPARC_GNU_VTENTRY:
1963       break;
1964
1965     case elfcpp::R_SPARC_PLT64:
1966     case elfcpp::R_SPARC_PLT32:
1967     case elfcpp::R_SPARC_HIPLT22:
1968     case elfcpp::R_SPARC_LOPLT10:
1969     case elfcpp::R_SPARC_PCPLT32:
1970     case elfcpp::R_SPARC_PCPLT22:
1971     case elfcpp::R_SPARC_PCPLT10:
1972     case elfcpp::R_SPARC_WPLT30:
1973       // If the symbol is fully resolved, this is just a PC32 reloc.
1974       // Otherwise we need a PLT entry.
1975       if (gsym->final_value_is_known())
1976         break;
1977       // If building a shared library, we can also skip the PLT entry
1978       // if the symbol is defined in the output file and is protected
1979       // or hidden.
1980       if (gsym->is_defined()
1981           && !gsym->is_from_dynobj()
1982           && !gsym->is_preemptible())
1983         break;
1984       target->make_plt_entry(symtab, layout, gsym);
1985       break;
1986
1987     case elfcpp::R_SPARC_DISP8:
1988     case elfcpp::R_SPARC_DISP16:
1989     case elfcpp::R_SPARC_DISP32:
1990     case elfcpp::R_SPARC_DISP64:
1991     case elfcpp::R_SPARC_PC_HH22:
1992     case elfcpp::R_SPARC_PC_HM10:
1993     case elfcpp::R_SPARC_PC_LM22:
1994     case elfcpp::R_SPARC_PC10:
1995     case elfcpp::R_SPARC_PC22:
1996     case elfcpp::R_SPARC_WDISP30:
1997     case elfcpp::R_SPARC_WDISP22:
1998     case elfcpp::R_SPARC_WDISP19:
1999     case elfcpp::R_SPARC_WDISP16:
2000       {
2001         if (gsym->needs_plt_entry())
2002           target->make_plt_entry(symtab, layout, gsym);
2003         // Make a dynamic relocation if necessary.
2004         int flags = Symbol::NON_PIC_REF;
2005         if (gsym->type() == elfcpp::STT_FUNC)
2006           flags |= Symbol::FUNCTION_CALL;
2007         if (gsym->needs_dynamic_reloc(flags))
2008           {
2009             if (gsym->may_need_copy_reloc())
2010               {
2011                 target->copy_reloc(symtab, layout, object,
2012                                    data_shndx, output_section, gsym,
2013                                    reloc);
2014               }
2015             else
2016               {
2017                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2018                 check_non_pic(object, r_type);
2019                 rela_dyn->add_global(gsym, orig_r_type, output_section, object,
2020                                      data_shndx, reloc.get_r_offset(),
2021                                      reloc.get_r_addend());
2022               }
2023           }
2024       }
2025       break;
2026
2027     case elfcpp::R_SPARC_UA64:
2028     case elfcpp::R_SPARC_64:
2029     case elfcpp::R_SPARC_HIX22:
2030     case elfcpp::R_SPARC_LOX10:
2031     case elfcpp::R_SPARC_H44:
2032     case elfcpp::R_SPARC_M44:
2033     case elfcpp::R_SPARC_L44:
2034     case elfcpp::R_SPARC_HH22:
2035     case elfcpp::R_SPARC_HM10:
2036     case elfcpp::R_SPARC_LM22:
2037     case elfcpp::R_SPARC_HI22:
2038     case elfcpp::R_SPARC_LO10:
2039     case elfcpp::R_SPARC_OLO10:
2040     case elfcpp::R_SPARC_UA32:
2041     case elfcpp::R_SPARC_32:
2042     case elfcpp::R_SPARC_UA16:
2043     case elfcpp::R_SPARC_16:
2044     case elfcpp::R_SPARC_11:
2045     case elfcpp::R_SPARC_10:
2046     case elfcpp::R_SPARC_8:
2047     case elfcpp::R_SPARC_7:
2048     case elfcpp::R_SPARC_6:
2049     case elfcpp::R_SPARC_5:
2050       {
2051         // Make a PLT entry if necessary.
2052         if (gsym->needs_plt_entry())
2053           {
2054             target->make_plt_entry(symtab, layout, gsym);
2055             // Since this is not a PC-relative relocation, we may be
2056             // taking the address of a function. In that case we need to
2057             // set the entry in the dynamic symbol table to the address of
2058             // the PLT entry.
2059             if (gsym->is_from_dynobj() && !parameters->options().shared())
2060               gsym->set_needs_dynsym_value();
2061           }
2062         // Make a dynamic relocation if necessary.
2063         if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF))
2064           {
2065             unsigned int r_off = reloc.get_r_offset();
2066
2067             // The assembler can sometimes emit unaligned relocations
2068             // for dwarf2 cfi directives.
2069             switch (r_type)
2070               {
2071               case elfcpp::R_SPARC_16:
2072                 if (r_off & 0x1)
2073                   orig_r_type = r_type = elfcpp::R_SPARC_UA16;
2074                 break;
2075               case elfcpp::R_SPARC_32:
2076                 if (r_off & 0x3)
2077                   orig_r_type = r_type = elfcpp::R_SPARC_UA32;
2078                 break;
2079               case elfcpp::R_SPARC_64:
2080                 if (r_off & 0x7)
2081                   orig_r_type = r_type = elfcpp::R_SPARC_UA64;
2082                 break;
2083               case elfcpp::R_SPARC_UA16:
2084                 if (!(r_off & 0x1))
2085                   orig_r_type = r_type = elfcpp::R_SPARC_16;
2086                 break;
2087               case elfcpp::R_SPARC_UA32:
2088                 if (!(r_off & 0x3))
2089                   orig_r_type = r_type = elfcpp::R_SPARC_32;
2090                 break;
2091               case elfcpp::R_SPARC_UA64:
2092                 if (!(r_off & 0x7))
2093                   orig_r_type = r_type = elfcpp::R_SPARC_64;
2094                 break;
2095               }
2096
2097             if (gsym->may_need_copy_reloc())
2098               {
2099                 target->copy_reloc(symtab, layout, object,
2100                                    data_shndx, output_section, gsym, reloc);
2101               }
2102             else if ((r_type == elfcpp::R_SPARC_32
2103                       || r_type == elfcpp::R_SPARC_64)
2104                      && gsym->can_use_relative_reloc(false))
2105               {
2106                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2107                 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
2108                                               output_section, object,
2109                                               data_shndx, reloc.get_r_offset(),
2110                                               reloc.get_r_addend());
2111               }
2112             else
2113               {
2114                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2115
2116                 check_non_pic(object, r_type);
2117                 if (gsym->is_from_dynobj()
2118                     || gsym->is_undefined()
2119                     || gsym->is_preemptible())
2120                   rela_dyn->add_global(gsym, orig_r_type, output_section,
2121                                        object, data_shndx,
2122                                        reloc.get_r_offset(),
2123                                        reloc.get_r_addend());
2124                 else
2125                   rela_dyn->add_symbolless_global_addend(gsym, orig_r_type,
2126                                                          output_section,
2127                                                          object, data_shndx,
2128                                                          reloc.get_r_offset(),
2129                                                          reloc.get_r_addend());
2130               }
2131           }
2132       }
2133       break;
2134
2135     case elfcpp::R_SPARC_GOTDATA_OP:
2136     case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2137     case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2138     case elfcpp::R_SPARC_GOT10:
2139     case elfcpp::R_SPARC_GOT13:
2140     case elfcpp::R_SPARC_GOT22:
2141       {
2142         // The symbol requires a GOT entry.
2143         Output_data_got<size, big_endian>* got;
2144
2145         got = target->got_section(symtab, layout);
2146         if (gsym->final_value_is_known())
2147           got->add_global(gsym, GOT_TYPE_STANDARD);
2148         else
2149           {
2150             // If this symbol is not fully resolved, we need to add a
2151             // dynamic relocation for it.
2152             Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2153             if (gsym->is_from_dynobj()
2154                 || gsym->is_undefined()
2155                 || gsym->is_preemptible())
2156               got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
2157                                         elfcpp::R_SPARC_GLOB_DAT);
2158             else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
2159               {
2160                 unsigned int off = got->add_constant(0);
2161
2162                 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
2163                 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
2164                                               got, off, 0);
2165               }
2166           }
2167       }
2168       break;
2169
2170       // These are initial tls relocs, which are expected when
2171       // linking.
2172     case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
2173     case elfcpp::R_SPARC_TLS_GD_LO10:
2174     case elfcpp::R_SPARC_TLS_GD_ADD:
2175     case elfcpp::R_SPARC_TLS_GD_CALL:
2176     case elfcpp::R_SPARC_TLS_LDM_HI22:  // Local-dynamic
2177     case elfcpp::R_SPARC_TLS_LDM_LO10:
2178     case elfcpp::R_SPARC_TLS_LDM_ADD:
2179     case elfcpp::R_SPARC_TLS_LDM_CALL:
2180     case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
2181     case elfcpp::R_SPARC_TLS_LDO_LOX10:
2182     case elfcpp::R_SPARC_TLS_LDO_ADD:
2183     case elfcpp::R_SPARC_TLS_LE_HIX22:
2184     case elfcpp::R_SPARC_TLS_LE_LOX10:
2185     case elfcpp::R_SPARC_TLS_IE_HI22:   // Initial-exec
2186     case elfcpp::R_SPARC_TLS_IE_LO10:
2187     case elfcpp::R_SPARC_TLS_IE_LD:
2188     case elfcpp::R_SPARC_TLS_IE_LDX:
2189     case elfcpp::R_SPARC_TLS_IE_ADD:
2190       {
2191         const bool is_final = gsym->final_value_is_known();
2192         const tls::Tls_optimization optimized_type
2193             = optimize_tls_reloc(is_final, r_type);
2194         switch (r_type)
2195           {
2196           case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
2197           case elfcpp::R_SPARC_TLS_GD_LO10:
2198           case elfcpp::R_SPARC_TLS_GD_ADD:
2199           case elfcpp::R_SPARC_TLS_GD_CALL:
2200             if (optimized_type == tls::TLSOPT_NONE)
2201               {
2202                 // Create a pair of GOT entries for the module index and
2203                 // dtv-relative offset.
2204                 Output_data_got<size, big_endian>* got
2205                     = target->got_section(symtab, layout);
2206                 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_PAIR,
2207                                                target->rela_dyn_section(layout),
2208                                                (size == 64 ?
2209                                                 elfcpp::R_SPARC_TLS_DTPMOD64 :
2210                                                 elfcpp::R_SPARC_TLS_DTPMOD32),
2211                                                (size == 64 ?
2212                                                 elfcpp::R_SPARC_TLS_DTPOFF64 :
2213                                                 elfcpp::R_SPARC_TLS_DTPOFF32));
2214
2215                 // Emit R_SPARC_WPLT30 against "__tls_get_addr"
2216                 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
2217                   generate_tls_call(symtab, layout, target);
2218               }
2219             else if (optimized_type == tls::TLSOPT_TO_IE)
2220               {
2221                 // Create a GOT entry for the tp-relative offset.
2222                 Output_data_got<size, big_endian>* got
2223                     = target->got_section(symtab, layout);
2224                 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2225                                           target->rela_dyn_section(layout),
2226                                           (size == 64 ?
2227                                            elfcpp::R_SPARC_TLS_TPOFF64 :
2228                                            elfcpp::R_SPARC_TLS_TPOFF32));
2229               }
2230             else if (optimized_type != tls::TLSOPT_TO_LE)
2231               unsupported_reloc_global(object, r_type, gsym);
2232             break;
2233
2234           case elfcpp::R_SPARC_TLS_LDM_HI22:    // Local-dynamic
2235           case elfcpp::R_SPARC_TLS_LDM_LO10:
2236           case elfcpp::R_SPARC_TLS_LDM_ADD:
2237           case elfcpp::R_SPARC_TLS_LDM_CALL:
2238             if (optimized_type == tls::TLSOPT_NONE)
2239               {
2240                 // Create a GOT entry for the module index.
2241                 target->got_mod_index_entry(symtab, layout, object);
2242
2243                 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
2244                   generate_tls_call(symtab, layout, target);
2245               }
2246             else if (optimized_type != tls::TLSOPT_TO_LE)
2247               unsupported_reloc_global(object, r_type, gsym);
2248             break;
2249
2250           case elfcpp::R_SPARC_TLS_LDO_HIX22:   // Alternate local-dynamic
2251           case elfcpp::R_SPARC_TLS_LDO_LOX10:
2252           case elfcpp::R_SPARC_TLS_LDO_ADD:
2253             break;
2254
2255           case elfcpp::R_SPARC_TLS_LE_HIX22:
2256           case elfcpp::R_SPARC_TLS_LE_LOX10:
2257             layout->set_has_static_tls();
2258             if (parameters->options().shared())
2259               {
2260                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2261                 rela_dyn->add_symbolless_global_addend(gsym, orig_r_type,
2262                                                        output_section, object,
2263                                                        data_shndx, reloc.get_r_offset(),
2264                                                        0);
2265               }
2266             break;
2267
2268           case elfcpp::R_SPARC_TLS_IE_HI22:     // Initial-exec
2269           case elfcpp::R_SPARC_TLS_IE_LO10:
2270           case elfcpp::R_SPARC_TLS_IE_LD:
2271           case elfcpp::R_SPARC_TLS_IE_LDX:
2272           case elfcpp::R_SPARC_TLS_IE_ADD:
2273             layout->set_has_static_tls();
2274             if (optimized_type == tls::TLSOPT_NONE)
2275               {
2276                 // Create a GOT entry for the tp-relative offset.
2277                 Output_data_got<size, big_endian>* got
2278                   = target->got_section(symtab, layout);
2279                 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2280                                           target->rela_dyn_section(layout),
2281                                           (size == 64 ?
2282                                            elfcpp::R_SPARC_TLS_TPOFF64 :
2283                                            elfcpp::R_SPARC_TLS_TPOFF32));
2284               }
2285             else if (optimized_type != tls::TLSOPT_TO_LE)
2286               unsupported_reloc_global(object, r_type, gsym);
2287             break;
2288           }
2289       }
2290       break;
2291
2292       // These are relocations which should only be seen by the
2293       // dynamic linker, and should never be seen here.
2294     case elfcpp::R_SPARC_COPY:
2295     case elfcpp::R_SPARC_GLOB_DAT:
2296     case elfcpp::R_SPARC_JMP_SLOT:
2297     case elfcpp::R_SPARC_RELATIVE:
2298     case elfcpp::R_SPARC_TLS_DTPMOD64:
2299     case elfcpp::R_SPARC_TLS_DTPMOD32:
2300     case elfcpp::R_SPARC_TLS_DTPOFF64:
2301     case elfcpp::R_SPARC_TLS_DTPOFF32:
2302     case elfcpp::R_SPARC_TLS_TPOFF64:
2303     case elfcpp::R_SPARC_TLS_TPOFF32:
2304       gold_error(_("%s: unexpected reloc %u in object file"),
2305                  object->name().c_str(), r_type);
2306       break;
2307
2308     default:
2309       unsupported_reloc_global(object, r_type, gsym);
2310       break;
2311     }
2312 }
2313
2314 // Process relocations for gc.
2315
2316 template<int size, bool big_endian>
2317 void
2318 Target_sparc<size, big_endian>::gc_process_relocs(
2319                         Symbol_table* symtab,
2320                         Layout* layout,
2321                         Sized_relobj<size, big_endian>* object,
2322                         unsigned int data_shndx,
2323                         unsigned int,
2324                         const unsigned char* prelocs,
2325                         size_t reloc_count,
2326                         Output_section* output_section,
2327                         bool needs_special_offset_handling,
2328                         size_t local_symbol_count,
2329                         const unsigned char* plocal_symbols)
2330 {
2331   typedef Target_sparc<size, big_endian> Sparc;
2332   typedef typename Target_sparc<size, big_endian>::Scan Scan;
2333
2334   gold::gc_process_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
2335     symtab,
2336     layout,
2337     this,
2338     object,
2339     data_shndx,
2340     prelocs,
2341     reloc_count,
2342     output_section,
2343     needs_special_offset_handling,
2344     local_symbol_count,
2345     plocal_symbols);
2346 }
2347
2348 // Scan relocations for a section.
2349
2350 template<int size, bool big_endian>
2351 void
2352 Target_sparc<size, big_endian>::scan_relocs(
2353                         Symbol_table* symtab,
2354                         Layout* layout,
2355                         Sized_relobj<size, big_endian>* object,
2356                         unsigned int data_shndx,
2357                         unsigned int sh_type,
2358                         const unsigned char* prelocs,
2359                         size_t reloc_count,
2360                         Output_section* output_section,
2361                         bool needs_special_offset_handling,
2362                         size_t local_symbol_count,
2363                         const unsigned char* plocal_symbols)
2364 {
2365   typedef Target_sparc<size, big_endian> Sparc;
2366   typedef typename Target_sparc<size, big_endian>::Scan Scan;
2367
2368   if (sh_type == elfcpp::SHT_REL)
2369     {
2370       gold_error(_("%s: unsupported REL reloc section"),
2371                  object->name().c_str());
2372       return;
2373     }
2374
2375   gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
2376     symtab,
2377     layout,
2378     this,
2379     object,
2380     data_shndx,
2381     prelocs,
2382     reloc_count,
2383     output_section,
2384     needs_special_offset_handling,
2385     local_symbol_count,
2386     plocal_symbols);
2387 }
2388
2389 // Finalize the sections.
2390
2391 template<int size, bool big_endian>
2392 void
2393 Target_sparc<size, big_endian>::do_finalize_sections(
2394     Layout* layout,
2395     const Input_objects*,
2396     Symbol_table*)
2397 {
2398   // Fill in some more dynamic tags.
2399   const Reloc_section* rel_plt = (this->plt_ == NULL
2400                                   ? NULL
2401                                   : this->plt_->rel_plt());
2402   layout->add_target_dynamic_tags(false, this->plt_, rel_plt,
2403                                   this->rela_dyn_, true, true);
2404
2405   // Emit any relocs we saved in an attempt to avoid generating COPY
2406   // relocs.
2407   if (this->copy_relocs_.any_saved_relocs())
2408     this->copy_relocs_.emit(this->rela_dyn_section(layout));
2409 }
2410
2411 // Perform a relocation.
2412
2413 template<int size, bool big_endian>
2414 inline bool
2415 Target_sparc<size, big_endian>::Relocate::relocate(
2416                         const Relocate_info<size, big_endian>* relinfo,
2417                         Target_sparc* target,
2418                         Output_section*,
2419                         size_t relnum,
2420                         const elfcpp::Rela<size, big_endian>& rela,
2421                         unsigned int r_type,
2422                         const Sized_symbol<size>* gsym,
2423                         const Symbol_value<size>* psymval,
2424                         unsigned char* view,
2425                         typename elfcpp::Elf_types<size>::Elf_Addr address,
2426                         section_size_type view_size)
2427 {
2428   r_type &= 0xff;
2429
2430   if (this->ignore_gd_add_)
2431     {
2432       if (r_type != elfcpp::R_SPARC_TLS_GD_ADD)
2433         gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2434                                _("missing expected TLS relocation"));
2435       else
2436         {
2437           this->ignore_gd_add_ = false;
2438           return false;
2439         }
2440     }
2441
2442   typedef Sparc_relocate_functions<size, big_endian> Reloc;
2443
2444   // Pick the value to use for symbols defined in shared objects.
2445   Symbol_value<size> symval;
2446   if (gsym != NULL
2447       && gsym->use_plt_offset(r_type == elfcpp::R_SPARC_DISP8
2448                               || r_type == elfcpp::R_SPARC_DISP16
2449                               || r_type == elfcpp::R_SPARC_DISP32
2450                               || r_type == elfcpp::R_SPARC_DISP64
2451                               || r_type == elfcpp::R_SPARC_PC_HH22
2452                               || r_type == elfcpp::R_SPARC_PC_HM10
2453                               || r_type == elfcpp::R_SPARC_PC_LM22
2454                               || r_type == elfcpp::R_SPARC_PC10
2455                               || r_type == elfcpp::R_SPARC_PC22
2456                               || r_type == elfcpp::R_SPARC_WDISP30
2457                               || r_type == elfcpp::R_SPARC_WDISP22
2458                               || r_type == elfcpp::R_SPARC_WDISP19
2459                               || r_type == elfcpp::R_SPARC_WDISP16))
2460     {
2461       elfcpp::Elf_Xword value;
2462
2463       value = target->plt_section()->address() + gsym->plt_offset();
2464
2465       symval.set_output_value(value);
2466
2467       psymval = &symval;
2468     }
2469
2470   const Sized_relobj<size, big_endian>* object = relinfo->object;
2471   const elfcpp::Elf_Xword addend = rela.get_r_addend();
2472
2473   // Get the GOT offset if needed.  Unlike i386 and x86_64, our GOT
2474   // pointer points to the beginning, not the end, of the table.
2475   // So we just use the plain offset.
2476   bool have_got_offset = false;
2477   unsigned int got_offset = 0;
2478   switch (r_type)
2479     {
2480     case elfcpp::R_SPARC_GOTDATA_OP:
2481     case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2482     case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2483     case elfcpp::R_SPARC_GOT10:
2484     case elfcpp::R_SPARC_GOT13:
2485     case elfcpp::R_SPARC_GOT22:
2486       if (gsym != NULL)
2487         {
2488           gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2489           got_offset = gsym->got_offset(GOT_TYPE_STANDARD);
2490         }
2491       else
2492         {
2493           unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2494           gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2495           got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
2496         }
2497       have_got_offset = true;
2498       break;
2499
2500     default:
2501       break;
2502     }
2503
2504   switch (r_type)
2505     {
2506     case elfcpp::R_SPARC_NONE:
2507     case elfcpp::R_SPARC_REGISTER:
2508     case elfcpp::R_SPARC_GNU_VTINHERIT:
2509     case elfcpp::R_SPARC_GNU_VTENTRY:
2510       break;
2511
2512     case elfcpp::R_SPARC_8:
2513       Relocate_functions<size, big_endian>::rela8(view, object,
2514                                                   psymval, addend);
2515       break;
2516
2517     case elfcpp::R_SPARC_16:
2518       if (rela.get_r_offset() & 0x1)
2519         {
2520           // The assembler can sometimes emit unaligned relocations
2521           // for dwarf2 cfi directives.
2522           Reloc::ua16(view, object, psymval, addend);
2523         }
2524       else
2525         Relocate_functions<size, big_endian>::rela16(view, object,
2526                                                      psymval, addend);
2527       break;
2528
2529     case elfcpp::R_SPARC_32:
2530       if (!parameters->options().output_is_position_independent())
2531         {
2532           if (rela.get_r_offset() & 0x3)
2533             {
2534               // The assembler can sometimes emit unaligned relocations
2535               // for dwarf2 cfi directives.
2536               Reloc::ua32(view, object, psymval, addend);
2537             }
2538           else
2539             Relocate_functions<size, big_endian>::rela32(view, object,
2540                                                          psymval, addend);
2541         }
2542       break;
2543
2544     case elfcpp::R_SPARC_DISP8:
2545       Reloc::disp8(view, object, psymval, addend, address);
2546       break;
2547
2548     case elfcpp::R_SPARC_DISP16:
2549       Reloc::disp16(view, object, psymval, addend, address);
2550       break;
2551
2552     case elfcpp::R_SPARC_DISP32:
2553       Reloc::disp32(view, object, psymval, addend, address);
2554       break;
2555
2556     case elfcpp::R_SPARC_DISP64:
2557       Reloc::disp64(view, object, psymval, addend, address);
2558       break;
2559
2560     case elfcpp::R_SPARC_WDISP30:
2561     case elfcpp::R_SPARC_WPLT30:
2562       Reloc::wdisp30(view, object, psymval, addend, address);
2563       break;
2564
2565     case elfcpp::R_SPARC_WDISP22:
2566       Reloc::wdisp22(view, object, psymval, addend, address);
2567       break;
2568
2569     case elfcpp::R_SPARC_WDISP19:
2570       Reloc::wdisp19(view, object, psymval, addend, address);
2571       break;
2572
2573     case elfcpp::R_SPARC_WDISP16:
2574       Reloc::wdisp16(view, object, psymval, addend, address);
2575       break;
2576
2577     case elfcpp::R_SPARC_HI22:
2578       Reloc::hi22(view, object, psymval, addend);
2579       break;
2580
2581     case elfcpp::R_SPARC_22:
2582       Reloc::rela32_22(view, object, psymval, addend);
2583       break;
2584
2585     case elfcpp::R_SPARC_13:
2586       Reloc::rela32_13(view, object, psymval, addend);
2587       break;
2588
2589     case elfcpp::R_SPARC_LO10:
2590       Reloc::lo10(view, object, psymval, addend);
2591       break;
2592
2593     case elfcpp::R_SPARC_GOT10:
2594       Reloc::lo10(view, got_offset, addend);
2595       break;
2596
2597     case elfcpp::R_SPARC_GOTDATA_OP:
2598       break;
2599
2600     case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2601     case elfcpp::R_SPARC_GOT13:
2602       Reloc::rela32_13(view, got_offset, addend);
2603       break;
2604
2605     case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2606     case elfcpp::R_SPARC_GOT22:
2607       Reloc::hi22(view, got_offset, addend);
2608       break;
2609
2610     case elfcpp::R_SPARC_PC10:
2611       Reloc::pc10(view, object, psymval, addend, address);
2612       break;
2613
2614     case elfcpp::R_SPARC_PC22:
2615       Reloc::pc22(view, object, psymval, addend, address);
2616       break;
2617
2618     case elfcpp::R_SPARC_TLS_DTPOFF32:
2619     case elfcpp::R_SPARC_UA32:
2620       Reloc::ua32(view, object, psymval, addend);
2621       break;
2622
2623     case elfcpp::R_SPARC_PLT64:
2624       Relocate_functions<size, big_endian>::rela64(view, object,
2625                                                    psymval, addend);
2626       break;
2627
2628     case elfcpp::R_SPARC_PLT32:
2629       Relocate_functions<size, big_endian>::rela32(view, object,
2630                                                    psymval, addend);
2631       break;
2632
2633     case elfcpp::R_SPARC_HIPLT22:
2634       Reloc::hi22(view, object, psymval, addend);
2635       break;
2636
2637     case elfcpp::R_SPARC_LOPLT10:
2638       Reloc::lo10(view, object, psymval, addend);
2639       break;
2640
2641     case elfcpp::R_SPARC_PCPLT32:
2642       Reloc::disp32(view, object, psymval, addend, address);
2643       break;
2644
2645     case elfcpp::R_SPARC_PCPLT22:
2646       Reloc::pcplt22(view, object, psymval, addend, address);
2647       break;
2648
2649     case elfcpp::R_SPARC_PCPLT10:
2650       Reloc::lo10(view, object, psymval, addend, address);
2651       break;
2652
2653     case elfcpp::R_SPARC_64:
2654       if (!parameters->options().output_is_position_independent())
2655         {
2656           if (rela.get_r_offset() & 0x7)
2657             {
2658               // The assembler can sometimes emit unaligned relocations
2659               // for dwarf2 cfi directives.
2660               Reloc::ua64(view, object, psymval, addend);
2661             }
2662           else
2663             Relocate_functions<size, big_endian>::rela64(view, object,
2664                                                          psymval, addend);
2665         }
2666       break;
2667
2668     case elfcpp::R_SPARC_OLO10:
2669       {
2670         unsigned int addend2 = rela.get_r_info() & 0xffffffff;
2671         addend2 = ((addend2 >> 8) ^ 0x800000) - 0x800000;
2672         Reloc::olo10(view, object, psymval, addend, addend2);
2673       }
2674       break;
2675
2676     case elfcpp::R_SPARC_HH22:
2677       Reloc::hh22(view, object, psymval, addend);
2678       break;
2679
2680     case elfcpp::R_SPARC_PC_HH22:
2681       Reloc::pc_hh22(view, object, psymval, addend, address);
2682       break;
2683
2684     case elfcpp::R_SPARC_HM10:
2685       Reloc::hm10(view, object, psymval, addend);
2686       break;
2687
2688     case elfcpp::R_SPARC_PC_HM10:
2689       Reloc::pc_hm10(view, object, psymval, addend, address);
2690       break;
2691
2692     case elfcpp::R_SPARC_LM22:
2693       Reloc::hi22(view, object, psymval, addend);
2694       break;
2695
2696     case elfcpp::R_SPARC_PC_LM22:
2697       Reloc::pcplt22(view, object, psymval, addend, address);
2698       break;
2699
2700     case elfcpp::R_SPARC_11:
2701       Reloc::rela32_11(view, object, psymval, addend);
2702       break;
2703
2704     case elfcpp::R_SPARC_10:
2705       Reloc::rela32_10(view, object, psymval, addend);
2706       break;
2707
2708     case elfcpp::R_SPARC_7:
2709       Reloc::rela32_7(view, object, psymval, addend);
2710       break;
2711
2712     case elfcpp::R_SPARC_6:
2713       Reloc::rela32_6(view, object, psymval, addend);
2714       break;
2715
2716     case elfcpp::R_SPARC_5:
2717       Reloc::rela32_5(view, object, psymval, addend);
2718       break;
2719
2720     case elfcpp::R_SPARC_HIX22:
2721       Reloc::hix22(view, object, psymval, addend);
2722       break;
2723
2724     case elfcpp::R_SPARC_LOX10:
2725       Reloc::lox10(view, object, psymval, addend);
2726       break;
2727
2728     case elfcpp::R_SPARC_H44:
2729       Reloc::h44(view, object, psymval, addend);
2730       break;
2731
2732     case elfcpp::R_SPARC_M44:
2733       Reloc::m44(view, object, psymval, addend);
2734       break;
2735
2736     case elfcpp::R_SPARC_L44:
2737       Reloc::l44(view, object, psymval, addend);
2738       break;
2739
2740     case elfcpp::R_SPARC_TLS_DTPOFF64:
2741     case elfcpp::R_SPARC_UA64:
2742       Reloc::ua64(view, object, psymval, addend);
2743       break;
2744
2745     case elfcpp::R_SPARC_UA16:
2746       Reloc::ua16(view, object, psymval, addend);
2747       break;
2748
2749     case elfcpp::R_SPARC_TLS_GD_HI22:
2750     case elfcpp::R_SPARC_TLS_GD_LO10:
2751     case elfcpp::R_SPARC_TLS_GD_ADD:
2752     case elfcpp::R_SPARC_TLS_GD_CALL:
2753     case elfcpp::R_SPARC_TLS_LDM_HI22:
2754     case elfcpp::R_SPARC_TLS_LDM_LO10:
2755     case elfcpp::R_SPARC_TLS_LDM_ADD:
2756     case elfcpp::R_SPARC_TLS_LDM_CALL:
2757     case elfcpp::R_SPARC_TLS_LDO_HIX22:
2758     case elfcpp::R_SPARC_TLS_LDO_LOX10:
2759     case elfcpp::R_SPARC_TLS_LDO_ADD:
2760     case elfcpp::R_SPARC_TLS_IE_HI22:
2761     case elfcpp::R_SPARC_TLS_IE_LO10:
2762     case elfcpp::R_SPARC_TLS_IE_LD:
2763     case elfcpp::R_SPARC_TLS_IE_LDX:
2764     case elfcpp::R_SPARC_TLS_IE_ADD:
2765     case elfcpp::R_SPARC_TLS_LE_HIX22:
2766     case elfcpp::R_SPARC_TLS_LE_LOX10:
2767       this->relocate_tls(relinfo, target, relnum, rela,
2768                          r_type, gsym, psymval, view,
2769                          address, view_size);
2770       break;
2771
2772     case elfcpp::R_SPARC_COPY:
2773     case elfcpp::R_SPARC_GLOB_DAT:
2774     case elfcpp::R_SPARC_JMP_SLOT:
2775     case elfcpp::R_SPARC_RELATIVE:
2776       // These are outstanding tls relocs, which are unexpected when
2777       // linking.
2778     case elfcpp::R_SPARC_TLS_DTPMOD64:
2779     case elfcpp::R_SPARC_TLS_DTPMOD32:
2780     case elfcpp::R_SPARC_TLS_TPOFF64:
2781     case elfcpp::R_SPARC_TLS_TPOFF32:
2782       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2783                              _("unexpected reloc %u in object file"),
2784                              r_type);
2785       break;
2786
2787     default:
2788       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2789                              _("unsupported reloc %u"),
2790                              r_type);
2791       break;
2792     }
2793
2794   return true;
2795 }
2796
2797 // Perform a TLS relocation.
2798
2799 template<int size, bool big_endian>
2800 inline void
2801 Target_sparc<size, big_endian>::Relocate::relocate_tls(
2802                         const Relocate_info<size, big_endian>* relinfo,
2803                         Target_sparc<size, big_endian>* target,
2804                         size_t relnum,
2805                         const elfcpp::Rela<size, big_endian>& rela,
2806                         unsigned int r_type,
2807                         const Sized_symbol<size>* gsym,
2808                         const Symbol_value<size>* psymval,
2809                         unsigned char* view,
2810                         typename elfcpp::Elf_types<size>::Elf_Addr address,
2811                         section_size_type)
2812 {
2813   Output_segment* tls_segment = relinfo->layout->tls_segment();
2814   typedef Sparc_relocate_functions<size, big_endian> Reloc;
2815   const Sized_relobj<size, big_endian>* object = relinfo->object;
2816   typedef typename elfcpp::Swap<32, true>::Valtype Insntype;
2817
2818   const elfcpp::Elf_Xword addend = rela.get_r_addend();
2819   typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0);
2820
2821   const bool is_final =
2822     (gsym == NULL
2823      ? !parameters->options().output_is_position_independent()
2824      : gsym->final_value_is_known());
2825   const tls::Tls_optimization optimized_type
2826       = optimize_tls_reloc(is_final, r_type);
2827
2828   switch (r_type)
2829     {
2830     case elfcpp::R_SPARC_TLS_GD_HI22:
2831     case elfcpp::R_SPARC_TLS_GD_LO10:
2832     case elfcpp::R_SPARC_TLS_GD_ADD:
2833     case elfcpp::R_SPARC_TLS_GD_CALL:
2834       if (optimized_type == tls::TLSOPT_TO_LE)
2835         {
2836           Insntype* wv = reinterpret_cast<Insntype*>(view);
2837           Insntype val;
2838
2839           value -= tls_segment->memsz();
2840
2841           switch (r_type)
2842             {
2843             case elfcpp::R_SPARC_TLS_GD_HI22:
2844               // TLS_GD_HI22 --> TLS_LE_HIX22
2845               Reloc::hix22(view, value, addend);
2846               break;
2847
2848             case elfcpp::R_SPARC_TLS_GD_LO10:
2849               // TLS_GD_LO10 --> TLS_LE_LOX10
2850               Reloc::lox10(view, value, addend);
2851               break;
2852
2853             case elfcpp::R_SPARC_TLS_GD_ADD:
2854               // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3
2855               val = elfcpp::Swap<32, true>::readval(wv);
2856               val = (val & ~0x7c000) | 0x1c000;
2857               elfcpp::Swap<32, true>::writeval(wv, val);
2858               break;
2859             case elfcpp::R_SPARC_TLS_GD_CALL:
2860               // call __tls_get_addr --> nop
2861               elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2862               break;
2863             }
2864           break;
2865         }
2866       else
2867         {
2868           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2869                                    ? GOT_TYPE_TLS_OFFSET
2870                                    : GOT_TYPE_TLS_PAIR);
2871           if (gsym != NULL)
2872             {
2873               gold_assert(gsym->has_got_offset(got_type));
2874               value = gsym->got_offset(got_type);
2875             }
2876           else
2877             {
2878               unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2879               gold_assert(object->local_has_got_offset(r_sym, got_type));
2880               value = object->local_got_offset(r_sym, got_type);
2881             }
2882           if (optimized_type == tls::TLSOPT_TO_IE)
2883             {
2884               Insntype* wv = reinterpret_cast<Insntype*>(view);
2885               Insntype val;
2886
2887               switch (r_type)
2888                 {
2889                 case elfcpp::R_SPARC_TLS_GD_HI22:
2890                   // TLS_GD_HI22 --> TLS_IE_HI22
2891                   Reloc::hi22(view, value, addend);
2892                   break;
2893
2894                 case elfcpp::R_SPARC_TLS_GD_LO10:
2895                   // TLS_GD_LO10 --> TLS_IE_LO10
2896                   Reloc::lo10(view, value, addend);
2897                   break;
2898
2899                 case elfcpp::R_SPARC_TLS_GD_ADD:
2900                   // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3
2901                   val = elfcpp::Swap<32, true>::readval(wv);
2902
2903                   if (size == 64)
2904                     val |= 0xc0580000;
2905                   else
2906                     val |= 0xc0000000;
2907
2908                   elfcpp::Swap<32, true>::writeval(wv, val);
2909                   break;
2910
2911                 case elfcpp::R_SPARC_TLS_GD_CALL:
2912                   // The compiler can put the TLS_GD_ADD instruction
2913                   // into the delay slot of the call.  If so, we need
2914                   // to transpose the two instructions so that the
2915                   // the new sequence works properly.
2916                   //
2917                   // The test we use is if the instruction in the
2918                   // delay slot is an add with destination register
2919                   // equal to %o0
2920                   val = elfcpp::Swap<32, true>::readval(wv + 1);
2921                   if ((val & 0x81f80000) == 0x80000000
2922                       && ((val >> 25) & 0x1f) == 0x8)
2923                     {
2924                       if (size == 64)
2925                         val |= 0xc0580000;
2926                       else
2927                         val |= 0xc0000000;
2928
2929                       elfcpp::Swap<32, true>::writeval(wv, val);
2930
2931                       wv += 1;
2932                       this->ignore_gd_add_ = true;
2933                     }
2934
2935                   // call __tls_get_addr --> add %g7, %o0, %o0
2936                   elfcpp::Swap<32, true>::writeval(wv, 0x9001c008);
2937                   break;
2938                 }
2939               break;
2940             }
2941           else if (optimized_type == tls::TLSOPT_NONE)
2942             {
2943               switch (r_type)
2944                 {
2945                 case elfcpp::R_SPARC_TLS_GD_HI22:
2946                   Reloc::hi22(view, value, addend);
2947                   break;
2948                 case elfcpp::R_SPARC_TLS_GD_LO10:
2949                   Reloc::lo10(view, value, addend);
2950                   break;
2951                 case elfcpp::R_SPARC_TLS_GD_ADD:
2952                   break;
2953                 case elfcpp::R_SPARC_TLS_GD_CALL:
2954                   {
2955                     Symbol_value<size> symval;
2956                     elfcpp::Elf_Xword value;
2957                     Symbol* tsym;
2958
2959                     tsym = target->tls_get_addr_sym_;
2960                     gold_assert(tsym);
2961                     value = (target->plt_section()->address() +
2962                              tsym->plt_offset());
2963                     symval.set_output_value(value);
2964                     Reloc::wdisp30(view, object, &symval, addend, address);
2965                   }
2966                   break;
2967                 }
2968               break;
2969             }
2970         }
2971       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2972                              _("unsupported reloc %u"),
2973                              r_type);
2974       break;
2975
2976     case elfcpp::R_SPARC_TLS_LDM_HI22:
2977     case elfcpp::R_SPARC_TLS_LDM_LO10:
2978     case elfcpp::R_SPARC_TLS_LDM_ADD:
2979     case elfcpp::R_SPARC_TLS_LDM_CALL:
2980       if (optimized_type == tls::TLSOPT_TO_LE)
2981         {
2982           Insntype* wv = reinterpret_cast<Insntype*>(view);
2983
2984           switch (r_type)
2985             {
2986             case elfcpp::R_SPARC_TLS_LDM_HI22:
2987             case elfcpp::R_SPARC_TLS_LDM_LO10:
2988             case elfcpp::R_SPARC_TLS_LDM_ADD:
2989               elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2990               break;
2991
2992             case elfcpp::R_SPARC_TLS_LDM_CALL:
2993               elfcpp::Swap<32, true>::writeval(wv, sparc_mov_g0_o0);
2994               break;
2995             }
2996           break;
2997         }
2998       else if (optimized_type == tls::TLSOPT_NONE)
2999         {
3000           // Relocate the field with the offset of the GOT entry for
3001           // the module index.
3002           unsigned int got_offset;
3003
3004           got_offset = target->got_mod_index_entry(NULL, NULL, NULL);
3005           switch (r_type)
3006             {
3007             case elfcpp::R_SPARC_TLS_LDM_HI22:
3008               Reloc::hi22(view, got_offset, addend);
3009               break;
3010             case elfcpp::R_SPARC_TLS_LDM_LO10:
3011               Reloc::lo10(view, got_offset, addend);
3012               break;
3013             case elfcpp::R_SPARC_TLS_LDM_ADD:
3014               break;
3015             case elfcpp::R_SPARC_TLS_LDM_CALL:
3016               {
3017                 Symbol_value<size> symval;
3018                 elfcpp::Elf_Xword value;
3019                 Symbol* tsym;
3020
3021                 tsym = target->tls_get_addr_sym_;
3022                 gold_assert(tsym);
3023                 value = (target->plt_section()->address() +
3024                          tsym->plt_offset());
3025                 symval.set_output_value(value);
3026                 Reloc::wdisp30(view, object, &symval, addend, address);
3027               }
3028               break;
3029             }
3030           break;
3031         }
3032       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3033                              _("unsupported reloc %u"),
3034                              r_type);
3035       break;
3036
3037       // These relocs can appear in debugging sections, in which case
3038       // we won't see the TLS_LDM relocs.  The local_dynamic_type
3039       // field tells us this.
3040     case elfcpp::R_SPARC_TLS_LDO_HIX22:
3041       if (optimized_type == tls::TLSOPT_TO_LE)
3042         {
3043           value -= tls_segment->memsz();
3044           Reloc::hix22(view, value, addend);
3045         }
3046       else
3047         Reloc::ldo_hix22(view, value, addend);
3048       break;
3049     case elfcpp::R_SPARC_TLS_LDO_LOX10:
3050       if (optimized_type == tls::TLSOPT_TO_LE)
3051         {
3052           value -= tls_segment->memsz();
3053           Reloc::lox10(view, value, addend);
3054         }
3055       else
3056         Reloc::ldo_lox10(view, value, addend);
3057       break;
3058     case elfcpp::R_SPARC_TLS_LDO_ADD:
3059       if (optimized_type == tls::TLSOPT_TO_LE)
3060         {
3061           Insntype* wv = reinterpret_cast<Insntype*>(view);
3062           Insntype val;
3063
3064           // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3
3065           val = elfcpp::Swap<32, true>::readval(wv);
3066           val = (val & ~0x7c000) | 0x1c000;
3067           elfcpp::Swap<32, true>::writeval(wv, val);
3068         }
3069       break;
3070
3071       // When optimizing IE --> LE, the only relocation that is handled
3072       // differently is R_SPARC_TLS_IE_LD, it is rewritten from
3073       // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is
3074       // rs2 and rd are the same.
3075     case elfcpp::R_SPARC_TLS_IE_LD:
3076     case elfcpp::R_SPARC_TLS_IE_LDX:
3077       if (optimized_type == tls::TLSOPT_TO_LE)
3078         {
3079           Insntype* wv = reinterpret_cast<Insntype*>(view);
3080           Insntype val = elfcpp::Swap<32, true>::readval(wv);
3081           Insntype rs2 = val & 0x1f;
3082           Insntype rd = (val >> 25) & 0x1f;
3083
3084           if (rs2 == rd)
3085             val = sparc_nop;
3086           else
3087             val = sparc_mov | (val & 0x3e00001f);
3088
3089           elfcpp::Swap<32, true>::writeval(wv, val);
3090         }
3091       break;
3092
3093     case elfcpp::R_SPARC_TLS_IE_HI22:
3094     case elfcpp::R_SPARC_TLS_IE_LO10:
3095       if (optimized_type == tls::TLSOPT_TO_LE)
3096         {
3097           value -= tls_segment->memsz();
3098           switch (r_type)
3099             {
3100             case elfcpp::R_SPARC_TLS_IE_HI22:
3101               // IE_HI22 --> LE_HIX22
3102               Reloc::hix22(view, value, addend);
3103               break;
3104             case elfcpp::R_SPARC_TLS_IE_LO10:
3105               // IE_LO10 --> LE_LOX10
3106               Reloc::lox10(view, value, addend);
3107               break;
3108             }
3109           break;
3110         }
3111       else if (optimized_type == tls::TLSOPT_NONE)
3112         {
3113           // Relocate the field with the offset of the GOT entry for
3114           // the tp-relative offset of the symbol.
3115           if (gsym != NULL)
3116             {
3117               gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3118               value = gsym->got_offset(GOT_TYPE_TLS_OFFSET);
3119             }
3120           else
3121             {
3122               unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3123               gold_assert(object->local_has_got_offset(r_sym,
3124                                                        GOT_TYPE_TLS_OFFSET));
3125               value = object->local_got_offset(r_sym,
3126                                                GOT_TYPE_TLS_OFFSET);
3127             }
3128           switch (r_type)
3129             {
3130             case elfcpp::R_SPARC_TLS_IE_HI22:
3131               Reloc::hi22(view, value, addend);
3132               break;
3133             case elfcpp::R_SPARC_TLS_IE_LO10:
3134               Reloc::lo10(view, value, addend);
3135               break;
3136             }
3137           break;
3138         }
3139       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3140                              _("unsupported reloc %u"),
3141                              r_type);
3142       break;
3143
3144     case elfcpp::R_SPARC_TLS_IE_ADD:
3145       // This seems to be mainly so that we can find the addition
3146       // instruction if there is one.  There doesn't seem to be any
3147       // actual relocation to apply.
3148       break;
3149
3150     case elfcpp::R_SPARC_TLS_LE_HIX22:
3151       // If we're creating a shared library, a dynamic relocation will
3152       // have been created for this location, so do not apply it now.
3153       if (!parameters->options().shared())
3154         {
3155           value -= tls_segment->memsz();
3156           Reloc::hix22(view, value, addend);
3157         }
3158       break;
3159
3160     case elfcpp::R_SPARC_TLS_LE_LOX10:
3161       // If we're creating a shared library, a dynamic relocation will
3162       // have been created for this location, so do not apply it now.
3163       if (!parameters->options().shared())
3164         {
3165           value -= tls_segment->memsz();
3166           Reloc::lox10(view, value, addend);
3167         }
3168       break;
3169     }
3170 }
3171
3172 // Relocate section data.
3173
3174 template<int size, bool big_endian>
3175 void
3176 Target_sparc<size, big_endian>::relocate_section(
3177                         const Relocate_info<size, big_endian>* relinfo,
3178                         unsigned int sh_type,
3179                         const unsigned char* prelocs,
3180                         size_t reloc_count,
3181                         Output_section* output_section,
3182                         bool needs_special_offset_handling,
3183                         unsigned char* view,
3184                         typename elfcpp::Elf_types<size>::Elf_Addr address,
3185                         section_size_type view_size,
3186                         const Reloc_symbol_changes* reloc_symbol_changes)
3187 {
3188   typedef Target_sparc<size, big_endian> Sparc;
3189   typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate;
3190
3191   gold_assert(sh_type == elfcpp::SHT_RELA);
3192
3193   gold::relocate_section<size, big_endian, Sparc, elfcpp::SHT_RELA,
3194     Sparc_relocate>(
3195     relinfo,
3196     this,
3197     prelocs,
3198     reloc_count,
3199     output_section,
3200     needs_special_offset_handling,
3201     view,
3202     address,
3203     view_size,
3204     reloc_symbol_changes);
3205 }
3206
3207 // Return the size of a relocation while scanning during a relocatable
3208 // link.
3209
3210 template<int size, bool big_endian>
3211 unsigned int
3212 Target_sparc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
3213     unsigned int,
3214     Relobj*)
3215 {
3216   // We are always SHT_RELA, so we should never get here.
3217   gold_unreachable();
3218   return 0;
3219 }
3220
3221 // Scan the relocs during a relocatable link.
3222
3223 template<int size, bool big_endian>
3224 void
3225 Target_sparc<size, big_endian>::scan_relocatable_relocs(
3226                         Symbol_table* symtab,
3227                         Layout* layout,
3228                         Sized_relobj<size, big_endian>* object,
3229                         unsigned int data_shndx,
3230                         unsigned int sh_type,
3231                         const unsigned char* prelocs,
3232                         size_t reloc_count,
3233                         Output_section* output_section,
3234                         bool needs_special_offset_handling,
3235                         size_t local_symbol_count,
3236                         const unsigned char* plocal_symbols,
3237                         Relocatable_relocs* rr)
3238 {
3239   gold_assert(sh_type == elfcpp::SHT_RELA);
3240
3241   typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
3242     Relocatable_size_for_reloc> Scan_relocatable_relocs;
3243
3244   gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
3245       Scan_relocatable_relocs>(
3246     symtab,
3247     layout,
3248     object,
3249     data_shndx,
3250     prelocs,
3251     reloc_count,
3252     output_section,
3253     needs_special_offset_handling,
3254     local_symbol_count,
3255     plocal_symbols,
3256     rr);
3257 }
3258
3259 // Relocate a section during a relocatable link.
3260
3261 template<int size, bool big_endian>
3262 void
3263 Target_sparc<size, big_endian>::relocate_for_relocatable(
3264     const Relocate_info<size, big_endian>* relinfo,
3265     unsigned int sh_type,
3266     const unsigned char* prelocs,
3267     size_t reloc_count,
3268     Output_section* output_section,
3269     off_t offset_in_output_section,
3270     const Relocatable_relocs* rr,
3271     unsigned char* view,
3272     typename elfcpp::Elf_types<size>::Elf_Addr view_address,
3273     section_size_type view_size,
3274     unsigned char* reloc_view,
3275     section_size_type reloc_view_size)
3276 {
3277   gold_assert(sh_type == elfcpp::SHT_RELA);
3278
3279   gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>(
3280     relinfo,
3281     prelocs,
3282     reloc_count,
3283     output_section,
3284     offset_in_output_section,
3285     rr,
3286     view,
3287     view_address,
3288     view_size,
3289     reloc_view,
3290     reloc_view_size);
3291 }
3292
3293 // Return the value to use for a dynamic which requires special
3294 // treatment.  This is how we support equality comparisons of function
3295 // pointers across shared library boundaries, as described in the
3296 // processor specific ABI supplement.
3297
3298 template<int size, bool big_endian>
3299 uint64_t
3300 Target_sparc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
3301 {
3302   gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3303   return this->plt_section()->address() + gsym->plt_offset();
3304 }
3305
3306 // The selector for sparc object files.
3307
3308 template<int size, bool big_endian>
3309 class Target_selector_sparc : public Target_selector
3310 {
3311 public:
3312   Target_selector_sparc()
3313     : Target_selector(elfcpp::EM_NONE, size, big_endian,
3314                       (size == 64 ? "elf64-sparc" : "elf32-sparc"))
3315   { }
3316
3317   Target* do_recognize(int machine, int, int)
3318   {
3319     switch (size)
3320       {
3321       case 64:
3322         if (machine != elfcpp::EM_SPARCV9)
3323           return NULL;
3324         break;
3325
3326       case 32:
3327         if (machine != elfcpp::EM_SPARC
3328             && machine != elfcpp::EM_SPARC32PLUS)
3329           return NULL;
3330         break;
3331
3332       default:
3333         return NULL;
3334       }
3335
3336     return this->instantiate_target();
3337   }
3338
3339   Target* do_instantiate_target()
3340   { return new Target_sparc<size, big_endian>(); }
3341 };
3342
3343 Target_selector_sparc<32, true> target_selector_sparc32;
3344 Target_selector_sparc<64, true> target_selector_sparc64;
3345
3346 } // End anonymous namespace.