gold/powerpc.cc

   1 // powerpc.cc -- powerpc target support for gold.
   2
   3 // Copyright 2008 Free Software Foundation, Inc.
   4 // Written by David S. Miller <davem@davemloft.net>
   5 //        and David Edelsohn <edelsohn@gnu.org>
   6
   7 // This file is part of gold.
   8
   9 // This program is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU General Public License as published by
  11 // the Free Software Foundation; either version 3 of the License, or
  12 // (at your option) any later version.
  13
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22 // MA 02110-1301, USA.
  23
  24 #include "gold.h"
  25
  26 #include "elfcpp.h"
  27 #include "parameters.h"
  28 #include "reloc.h"
  29 #include "powerpc.h"
  30 #include "object.h"
  31 #include "symtab.h"
  32 #include "layout.h"
  33 #include "output.h"
  34 #include "copy-relocs.h"
  35 #include "target.h"
  36 #include "target-reloc.h"
  37 #include "target-select.h"
  38 #include "tls.h"
  39 #include "errors.h"
  40
  41 namespace
  42 {
  43
  44 using namespace gold;
  45
  46 template<int size, bool big_endian>
  47 class Output_data_plt_powerpc;
  48
  49 template<int size, bool big_endian>
  50 class Target_powerpc : public Sized_target<size, big_endian>
  51 {
  52  public:
  53   typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
  54
  55   Target_powerpc()
  56     : Sized_target<size, big_endian>(&powerpc_info),
  57       got_(NULL), got2_(NULL), toc_(NULL),
  58       plt_(NULL), rela_dyn_(NULL),
  59       copy_relocs_(elfcpp::R_POWERPC_COPY),
  60       dynbss_(NULL), got_mod_index_offset_(-1U)
  61   {
  62   }
  63
  64   // Scan the relocations to look for symbol adjustments.
  65   void
  66   scan_relocs(const General_options& options,
  67               Symbol_table* symtab,
  68               Layout* layout,
  69               Sized_relobj<size, big_endian>* object,
  70               unsigned int data_shndx,
  71               unsigned int sh_type,
  72               const unsigned char* prelocs,
  73               size_t reloc_count,
  74               Output_section* output_section,
  75               bool needs_special_offset_handling,
  76               size_t local_symbol_count,
  77               const unsigned char* plocal_symbols);
  78   // Finalize the sections.
  79   void
  80   do_finalize_sections(Layout*);
  81
  82   // Return the value to use for a dynamic which requires special
  83   // treatment.
  84   uint64_t
  85   do_dynsym_value(const Symbol*) const;
  86
  87   // Relocate a section.
  88   void
  89   relocate_section(const Relocate_info<size, big_endian>*,
  90                    unsigned int sh_type,
  91                    const unsigned char* prelocs,
  92                    size_t reloc_count,
  93                    Output_section* output_section,
  94                    bool needs_special_offset_handling,
  95                    unsigned char* view,
  96                    typename elfcpp::Elf_types<size>::Elf_Addr view_address,
  97                    section_size_type view_size);
  98
  99   // Scan the relocs during a relocatable link.
 100   void
 101   scan_relocatable_relocs(const General_options& options,
 102                           Symbol_table* symtab,
 103                           Layout* layout,
 104                           Sized_relobj<size, big_endian>* object,
 105                           unsigned int data_shndx,
 106                           unsigned int sh_type,
 107                           const unsigned char* prelocs,
 108                           size_t reloc_count,
 109                           Output_section* output_section,
 110                           bool needs_special_offset_handling,
 111                           size_t local_symbol_count,
 112                           const unsigned char* plocal_symbols,
 113                           Relocatable_relocs*);
 114
 115   // Relocate a section during a relocatable link.
 116   void
 117   relocate_for_relocatable(const Relocate_info<size, big_endian>*,
 118                            unsigned int sh_type,
 119                            const unsigned char* prelocs,
 120                            size_t reloc_count,
 121                            Output_section* output_section,
 122                            off_t offset_in_output_section,
 123                            const Relocatable_relocs*,
 124                            unsigned char* view,
 125                            typename elfcpp::Elf_types<size>::Elf_Addr view_address,
 126                            section_size_type view_size,
 127                            unsigned char* reloc_view,
 128                            section_size_type reloc_view_size);
 129
 130   // Return whether SYM is defined by the ABI.
 131   bool
 132   do_is_defined_by_abi(Symbol* sym) const
 133   {
 134     return strcmp(sym->name(), "___tls_get_addr") == 0;
 135   }
 136
 137   // Return the size of the GOT section.
 138   section_size_type
 139   got_size()
 140   {
 141     gold_assert(this->got_ != NULL);
 142     return this->got_->data_size();
 143   }
 144
 145  private:
 146
 147   // The class which scans relocations.
 148   class Scan
 149   {
 150   public:
 151     Scan()
 152       : issued_non_pic_error_(false)
 153     { }
 154
 155     inline void
 156     local(const General_options& options, Symbol_table* symtab,
 157           Layout* layout, Target_powerpc* target,
 158           Sized_relobj<size, big_endian>* object,
 159           unsigned int data_shndx,
 160           Output_section* output_section,
 161           const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
 162           const elfcpp::Sym<size, big_endian>& lsym);
 163
 164     inline void
 165     global(const General_options& options, Symbol_table* symtab,
 166            Layout* layout, Target_powerpc* target,
 167            Sized_relobj<size, big_endian>* object,
 168            unsigned int data_shndx,
 169            Output_section* output_section,
 170            const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
 171            Symbol* gsym);
 172
 173   private:
 174     static void
 175     unsupported_reloc_local(Sized_relobj<size, big_endian>*,
 176                             unsigned int r_type);
 177
 178     static void
 179     unsupported_reloc_global(Sized_relobj<size, big_endian>*,
 180                              unsigned int r_type, Symbol*);
 181
 182     static void
 183     generate_tls_call(Symbol_table* symtab, Layout* layout,
 184                       Target_powerpc* target);
 185
 186     void
 187     check_non_pic(Relobj*, unsigned int r_type);
 188
 189     // Whether we have issued an error about a non-PIC compilation.
 190     bool issued_non_pic_error_;
 191   };
 192
 193   // The class which implements relocation.
 194   class Relocate
 195   {
 196    public:
 197     // Do a relocation.  Return false if the caller should not issue
 198     // any warnings about this relocation.
 199     inline bool
 200     relocate(const Relocate_info<size, big_endian>*, Target_powerpc*,
 201              size_t relnum, const elfcpp::Rela<size, big_endian>&,
 202              unsigned int r_type, const Sized_symbol<size>*,
 203              const Symbol_value<size>*,
 204              unsigned char*,
 205              typename elfcpp::Elf_types<size>::Elf_Addr,
 206              section_size_type);
 207
 208    private:
 209     // Do a TLS relocation.
 210     inline void
 211     relocate_tls(const Relocate_info<size, big_endian>*,
 212                  Target_powerpc* target,
 213                  size_t relnum, const elfcpp::Rela<size, big_endian>&,
 214                  unsigned int r_type, const Sized_symbol<size>*,
 215                  const Symbol_value<size>*,
 216                  unsigned char*,
 217                  typename elfcpp::Elf_types<size>::Elf_Addr,
 218                  section_size_type);
 219   };
 220
 221   // A class which returns the size required for a relocation type,
 222   // used while scanning relocs during a relocatable link.
 223   class Relocatable_size_for_reloc
 224   {
 225    public:
 226     unsigned int
 227     get_size_for_reloc(unsigned int, Relobj*);
 228   };
 229
 230   // Get the GOT section, creating it if necessary.
 231   Output_data_got<size, big_endian>*
 232   got_section(Symbol_table*, Layout*);
 233
 234   Output_data_space*
 235   got2_section() const
 236   {
 237     gold_assert (this->got2_ != NULL);
 238     return this->got2_;
 239   }
 240
 241   // Get the TOC section.
 242   Output_data_space*
 243   toc_section() const
 244   {
 245     gold_assert (this->toc_ != NULL);
 246     return this->toc_;
 247   }
 248
 249   // Create a PLT entry for a global symbol.
 250   void
 251   make_plt_entry(Symbol_table*, Layout*, Symbol*);
 252
 253   // Create a GOT entry for the TLS module index.
 254   unsigned int
 255   got_mod_index_entry(Symbol_table* symtab, Layout* layout,
 256                       Sized_relobj<size, big_endian>* object);
 257
 258   // Get the PLT section.
 259   const Output_data_plt_powerpc<size, big_endian>*
 260   plt_section() const
 261   {
 262     gold_assert(this->plt_ != NULL);
 263     return this->plt_;
 264   }
 265
 266   // Get the dynamic reloc section, creating it if necessary.
 267   Reloc_section*
 268   rela_dyn_section(Layout*);
 269
 270   // Return true if the symbol may need a COPY relocation.
 271   // References from an executable object to non-function symbols
 272   // defined in a dynamic object may need a COPY relocation.
 273   bool
 274   may_need_copy_reloc(Symbol* gsym)
 275   {
 276     return (!parameters->options().shared()
 277             && gsym->is_from_dynobj()
 278             && gsym->type() != elfcpp::STT_FUNC);
 279   }
 280
 281   // Copy a relocation against a global symbol.
 282   void
 283   copy_reloc(Symbol_table* symtab, Layout* layout,
 284              Sized_relobj<size, big_endian>* object,
 285              unsigned int shndx, Output_section* output_section,
 286              Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
 287   {
 288     this->copy_relocs_.copy_reloc(symtab, layout,
 289                                   symtab->get_sized_symbol<size>(sym),
 290                                   object, shndx, output_section,
 291                                   reloc, this->rela_dyn_section(layout));
 292   }
 293
 294   // Information about this specific target which we pass to the
 295   // general Target structure.
 296   static Target::Target_info powerpc_info;
 297
 298   // The types of GOT entries needed for this platform.
 299   enum Got_type
 300   {
 301     GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
 302     GOT_TYPE_TLS_OFFSET = 1,    // GOT entry for TLS offset
 303     GOT_TYPE_TLS_PAIR = 2,      // GOT entry for TLS module/offset pair
 304   };
 305
 306   // The GOT section.
 307   Output_data_got<size, big_endian>* got_;
 308   // The GOT2 section.
 309   Output_data_space* got2_;
 310   // The TOC section.
 311   Output_data_space* toc_;
 312   // The PLT section.
 313   Output_data_plt_powerpc<size, big_endian>* plt_;
 314   // The dynamic reloc section.
 315   Reloc_section* rela_dyn_;
 316   // Relocs saved to avoid a COPY reloc.
 317   Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
 318   // Space for variables copied with a COPY reloc.
 319   Output_data_space* dynbss_;
 320   // Offset of the GOT entry for the TLS module index;
 321   unsigned int got_mod_index_offset_;
 322 };
 323
 324 template<>
 325 Target::Target_info Target_powerpc<32, true>::powerpc_info =
 326 {
 327   32,                   // size
 328   true,                 // is_big_endian
 329   elfcpp::EM_PPC,       // machine_code
 330   false,                // has_make_symbol
 331   false,                // has_resolve
 332   false,                // has_code_fill
 333   true,                 // is_default_stack_executable
 334   '\0',                 // wrap_char
 335   "/usr/lib/ld.so.1",   // dynamic_linker
 336   0x10000000,           // default_text_segment_address
 337   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 338   4 * 1024              // common_pagesize (overridable by -z common-page-size)
 339 };
 340
 341 template<>
 342 Target::Target_info Target_powerpc<32, false>::powerpc_info =
 343 {
 344   32,                   // size
 345   false,                // is_big_endian
 346   elfcpp::EM_PPC,       // machine_code
 347   false,                // has_make_symbol
 348   false,                // has_resolve
 349   false,                // has_code_fill
 350   true,                 // is_default_stack_executable
 351   '\0',                 // wrap_char
 352   "/usr/lib/ld.so.1",   // dynamic_linker
 353   0x10000000,           // default_text_segment_address
 354   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 355   4 * 1024              // common_pagesize (overridable by -z common-page-size)
 356 };
 357
 358 template<>
 359 Target::Target_info Target_powerpc<64, true>::powerpc_info =
 360 {
 361   64,                   // size
 362   true,                 // is_big_endian
 363   elfcpp::EM_PPC64,     // machine_code
 364   false,                // has_make_symbol
 365   false,                // has_resolve
 366   false,                // has_code_fill
 367   true,                 // is_default_stack_executable
 368   '\0',                 // wrap_char
 369   "/usr/lib/ld.so.1",   // dynamic_linker
 370   0x10000000,           // default_text_segment_address
 371   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 372   8 * 1024              // common_pagesize (overridable by -z common-page-size)
 373 };
 374
 375 template<>
 376 Target::Target_info Target_powerpc<64, false>::powerpc_info =
 377 {
 378   64,                   // size
 379   false,                // is_big_endian
 380   elfcpp::EM_PPC64,     // machine_code
 381   false,                // has_make_symbol
 382   false,                // has_resolve
 383   false,                // has_code_fill
 384   true,                 // is_default_stack_executable
 385   '\0',                 // wrap_char
 386   "/usr/lib/ld.so.1",   // dynamic_linker
 387   0x10000000,           // default_text_segment_address
 388   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
 389   8 * 1024              // common_pagesize (overridable by -z common-page-size)
 390 };
 391
 392 template<int size, bool big_endian>
 393 class Powerpc_relocate_functions
 394 {
 395 private:
 396   // Do a simple relocation with the addend in the relocation.
 397   template<int valsize>
 398   static inline void
 399   rela(unsigned char* view,
 400        unsigned int right_shift,
 401        elfcpp::Elf_Xword dst_mask,
 402        typename elfcpp::Swap<size, big_endian>::Valtype value,
 403        typename elfcpp::Swap<size, big_endian>::Valtype addend)
 404   {
 405     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 406     Valtype* wv = reinterpret_cast<Valtype*>(view);
 407     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 408     Valtype reloc = ((value + addend) >> right_shift);
 409
 410     val &= ~dst_mask;
 411     reloc &= dst_mask;
 412
 413     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 414   }
 415
 416   // Do a simple relocation using a symbol value with the addend in
 417   // the relocation.
 418   template<int valsize>
 419   static inline void
 420   rela(unsigned char* view,
 421        unsigned int right_shift,
 422        elfcpp::Elf_Xword dst_mask,
 423        const Sized_relobj<size, big_endian>* object,
 424        const Symbol_value<size>* psymval,
 425        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
 426   {
 427     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 428     Valtype* wv = reinterpret_cast<Valtype*>(view);
 429     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 430     Valtype reloc = (psymval->value(object, addend) >> right_shift);
 431
 432     val &= ~dst_mask;
 433     reloc &= dst_mask;
 434
 435     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 436   }
 437
 438   // Do a simple relocation using a symbol value with the addend in
 439   // the relocation, unaligned.
 440   template<int valsize>
 441   static inline void
 442   rela_ua(unsigned char* view, unsigned int right_shift,
 443           elfcpp::Elf_Xword dst_mask,
 444           const Sized_relobj<size, big_endian>* object,
 445           const Symbol_value<size>* psymval,
 446           typename elfcpp::Swap<size, big_endian>::Valtype addend)
 447   {
 448     typedef typename elfcpp::Swap_unaligned<valsize,
 449             big_endian>::Valtype Valtype;
 450     unsigned char* wv = view;
 451     Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
 452     Valtype reloc = (psymval->value(object, addend) >> right_shift);
 453
 454     val &= ~dst_mask;
 455     reloc &= dst_mask;
 456
 457     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc);
 458   }
 459
 460   // Do a simple PC relative relocation with a Symbol_value with the
 461   // addend in the relocation.
 462   template<int valsize>
 463   static inline void
 464   pcrela(unsigned char* view, unsigned int right_shift,
 465          elfcpp::Elf_Xword dst_mask,
 466          const Sized_relobj<size, big_endian>* object,
 467          const Symbol_value<size>* psymval,
 468          typename elfcpp::Swap<size, big_endian>::Valtype addend,
 469          typename elfcpp::Elf_types<size>::Elf_Addr address)
 470   {
 471     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
 472     Valtype* wv = reinterpret_cast<Valtype*>(view);
 473     Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
 474     Valtype reloc = ((psymval->value(object, addend) - address)
 475                      >> right_shift);
 476
 477     val &= ~dst_mask;
 478     reloc &= dst_mask;
 479
 480     elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
 481   }
 482
 483   template<int valsize>
 484   static inline void
 485   pcrela_unaligned(unsigned char* view,
 486                    const Sized_relobj<size, big_endian>* object,
 487                    const Symbol_value<size>* psymval,
 488                    typename elfcpp::Swap<size, big_endian>::Valtype addend,
 489                    typename elfcpp::Elf_types<size>::Elf_Addr address)
 490   {
 491     typedef typename elfcpp::Swap_unaligned<valsize,
 492             big_endian>::Valtype Valtype;
 493     unsigned char* wv = view;
 494     Valtype reloc = (psymval->value(object, addend) - address);
 495
 496     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc);
 497   }
 498
 499   typedef Powerpc_relocate_functions<size, big_endian> This;
 500   typedef Relocate_functions<size, big_endian> This_reloc;
 501 public:
 502   // R_POWERPC_REL32: (Symbol + Addend - Address)
 503   static inline void
 504   rel32(unsigned char* view,
 505         const Sized_relobj<size, big_endian>* object,
 506         const Symbol_value<size>* psymval,
 507         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 508         typename elfcpp::Elf_types<size>::Elf_Addr address)
 509   { This_reloc::pcrela32(view, object, psymval, addend, address); }
 510
 511   // R_POWERPC_REL24: (Symbol + Addend - Address) & 0x3fffffc
 512   static inline void
 513   rel24(unsigned char* view,
 514         const Sized_relobj<size, big_endian>* object,
 515         const Symbol_value<size>* psymval,
 516         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 517         typename elfcpp::Elf_types<size>::Elf_Addr address)
 518   {
 519     This::template pcrela<32>(view, 0, 0x03fffffc, object,
 520                               psymval, addend, address);
 521   }
 522
 523   // R_POWERPC_REL14: (Symbol + Addend - Address) & 0xfffc
 524   static inline void
 525   rel14(unsigned char* view,
 526         const Sized_relobj<size, big_endian>* object,
 527         const Symbol_value<size>* psymval,
 528         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 529         typename elfcpp::Elf_types<size>::Elf_Addr address)
 530   {
 531     This::template pcrela<32>(view, 0, 0x0000fffc, object,
 532                               psymval, addend, address);
 533   }
 534
 535   // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff
 536   static inline void
 537   addr16(unsigned char* view,
 538          typename elfcpp::Elf_types<size>::Elf_Addr value,
 539          typename elfcpp::Elf_types<size>::Elf_Addr addend)
 540   { This_reloc::rela16(view, value, addend); }
 541
 542   static inline void
 543   addr16(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   { This_reloc::rela16(view, object, psymval, addend); }
 548
 549   // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc
 550   static inline void
 551   addr16_ds(unsigned char* view,
 552             typename elfcpp::Elf_types<size>::Elf_Addr value,
 553             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 554   {
 555     This::template rela<16>(view, 0, 0xfffc, value, addend);
 556   }
 557
 558   // R_POWERPC_ADDR16_LO: (Symbol + Addend) & 0xffff
 559   static inline void
 560   addr16_lo(unsigned char* view,
 561          typename elfcpp::Elf_types<size>::Elf_Addr value,
 562          typename elfcpp::Elf_types<size>::Elf_Addr addend)
 563   { This_reloc::rela16(view, value, addend); }
 564
 565   static inline void
 566   addr16_lo(unsigned char* view,
 567             const Sized_relobj<size, big_endian>* object,
 568             const Symbol_value<size>* psymval,
 569             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 570   { This_reloc::rela16(view, object, psymval, addend); }
 571
 572   // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff
 573   static inline void
 574   addr16_hi(unsigned char* view,
 575             typename elfcpp::Elf_types<size>::Elf_Addr value,
 576             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 577   {
 578     This::template rela<16>(view, 16, 0xffff, value, addend);
 579   }
 580
 581   static inline void
 582   addr16_hi(unsigned char* view,
 583             const Sized_relobj<size, big_endian>* object,
 584             const Symbol_value<size>* psymval,
 585             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 586   {
 587     This::template rela<16>(view, 16, 0xffff, object, psymval, addend);
 588   }
 589
 590   // R_POWERPC_ADDR16_HA: Same as R_POWERPC_ADDR16_HI except that if the
 591   //                      final value of the low 16 bits of the
 592   //                      relocation is negative, add one.
 593   static inline void
 594   addr16_ha(unsigned char* view,
 595             typename elfcpp::Elf_types<size>::Elf_Addr value,
 596             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 597   {
 598     typename elfcpp::Elf_types<size>::Elf_Addr reloc;
 599
 600     reloc = value + addend;
 601
 602     if (reloc & 0x8000)
 603       reloc += 0x10000;
 604     reloc >>= 16;
 605
 606     elfcpp::Swap<16, big_endian>::writeval(view, reloc);
 607   }
 608
 609   static inline void
 610   addr16_ha(unsigned char* view,
 611             const Sized_relobj<size, big_endian>* object,
 612             const Symbol_value<size>* psymval,
 613             typename elfcpp::Elf_types<size>::Elf_Addr addend)
 614   {
 615     typename elfcpp::Elf_types<size>::Elf_Addr reloc;
 616
 617     reloc = psymval->value(object, addend);
 618
 619     if (reloc & 0x8000)
 620       reloc += 0x10000;
 621     reloc >>= 16;
 622
 623     elfcpp::Swap<16, big_endian>::writeval(view, reloc);
 624   }
 625
 626   // R_PPC_REL16: (Symbol + Addend - Address) & 0xffff
 627   static inline void
 628   rel16(unsigned char* view,
 629         const Sized_relobj<size, big_endian>* object,
 630         const Symbol_value<size>* psymval,
 631         typename elfcpp::Elf_types<size>::Elf_Addr addend,
 632         typename elfcpp::Elf_types<size>::Elf_Addr address)
 633   { This_reloc::pcrela16(view, object, psymval, addend, address); }
 634
 635   // R_PPC_REL16_LO: (Symbol + Addend - Address) & 0xffff
 636   static inline void
 637   rel16_lo(unsigned char* view,
 638            const Sized_relobj<size, big_endian>* object,
 639            const Symbol_value<size>* psymval,
 640            typename elfcpp::Elf_types<size>::Elf_Addr addend,
 641            typename elfcpp::Elf_types<size>::Elf_Addr address)
 642   { This_reloc::pcrela16(view, object, psymval, addend, address); }
 643
 644   // R_PPC_REL16_HI: ((Symbol + Addend - Address) >> 16) & 0xffff
 645   static inline void
 646   rel16_hi(unsigned char* view,
 647            const Sized_relobj<size, big_endian>* object,
 648            const Symbol_value<size>* psymval,
 649            typename elfcpp::Elf_types<size>::Elf_Addr addend,
 650            typename elfcpp::Elf_types<size>::Elf_Addr address)
 651   {
 652     This::template pcrela<16>(view, 16, 0xffff, object,
 653                               psymval, addend, address);
 654   }
 655
 656   // R_PPC_REL16_HA: Same as R_PPC_REL16_HI except that if the
 657   //                 final value of the low 16 bits of the
 658   //                 relocation is negative, add one.
 659   static inline void
 660   rel16_ha(unsigned char* view,
 661            const Sized_relobj<size, big_endian>* object,
 662            const Symbol_value<size>* psymval,
 663            typename elfcpp::Elf_types<size>::Elf_Addr addend,
 664            typename elfcpp::Elf_types<size>::Elf_Addr address)
 665   {
 666     typedef typename elfcpp::Swap<16, true>::Valtype Valtype;
 667     Valtype* wv = reinterpret_cast<Valtype*>(view);
 668     Valtype val = elfcpp::Swap<16, true>::readval(wv);
 669     typename elfcpp::Elf_types<size>::Elf_Addr reloc;
 670
 671     reloc = (psymval->value(object, addend) - address);
 672     if (reloc & 0x8000)
 673       reloc += 0x10000;
 674     reloc >>= 16;
 675
 676     val &= ~static_cast<Valtype>(0xffff);
 677     reloc &= static_cast<Valtype>(0xffff);
 678
 679     elfcpp::Swap<16, true>::writeval(wv, val | reloc);
 680   }
 681 };
 682
 683 // Get the GOT section, creating it if necessary.
 684
 685 template<int size, bool big_endian>
 686 Output_data_got<size, big_endian>*
 687 Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab,
 688                                               Layout* layout)
 689 {
 690   if (this->got_ == NULL)
 691     {
 692       gold_assert(symtab != NULL && layout != NULL);
 693
 694       this->got_ = new Output_data_got<size, big_endian>();
 695
 696       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
 697                                       elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
 698                                       this->got_);
 699
 700       // Create the GOT2 or TOC in the .got section.
 701       if (size == 32)
 702         {
 703           this->got2_ = new Output_data_space(4, "** GOT2");
 704           layout->add_output_section_data(".got2", elfcpp::SHT_PROGBITS,
 705                                           elfcpp::SHF_ALLOC
 706                                           | elfcpp::SHF_WRITE,
 707                                           this->got2_);
 708         }
 709       else
 710         {
 711           this->toc_ = new Output_data_space(8, "** TOC");
 712           layout->add_output_section_data(".toc", elfcpp::SHT_PROGBITS,
 713                                           elfcpp::SHF_ALLOC
 714                                           | elfcpp::SHF_WRITE,
 715                                           this->toc_);
 716         }
 717
 718       // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
 719       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
 720                                     this->got_,
 721                                     0, 0, elfcpp::STT_OBJECT,
 722                                     elfcpp::STB_LOCAL,
 723                                     elfcpp::STV_HIDDEN, 0,
 724                                     false, false);
 725     }
 726
 727   return this->got_;
 728 }
 729
 730 // Get the dynamic reloc section, creating it if necessary.
 731
 732 template<int size, bool big_endian>
 733 typename Target_powerpc<size, big_endian>::Reloc_section*
 734 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout)
 735 {
 736   if (this->rela_dyn_ == NULL)
 737     {
 738       gold_assert(layout != NULL);
 739       this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
 740       layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
 741                                       elfcpp::SHF_ALLOC, this->rela_dyn_);
 742     }
 743   return this->rela_dyn_;
 744 }
 745
 746 // A class to handle the PLT data.
 747
 748 template<int size, bool big_endian>
 749 class Output_data_plt_powerpc : public Output_section_data
 750 {
 751  public:
 752   typedef Output_data_reloc<elfcpp::SHT_RELA, true,
 753                             size, big_endian> Reloc_section;
 754
 755   Output_data_plt_powerpc(Layout*);
 756
 757   // Add an entry to the PLT.
 758   void add_entry(Symbol* gsym);
 759
 760   // Return the .rela.plt section data.
 761   const Reloc_section* rel_plt() const
 762  {
 763     return this->rel_;
 764   }
 765
 766  protected:
 767   void do_adjust_output_section(Output_section* os);
 768
 769  private:
 770   // The size of an entry in the PLT.
 771   static const int base_plt_entry_size = (size == 32 ? 16 : 24);
 772
 773   // Set the final size.
 774   void
 775   set_final_data_size()
 776   {
 777     unsigned int full_count = this->count_ + 4;
 778
 779     this->set_data_size(full_count * base_plt_entry_size);
 780   }
 781
 782   // Write out the PLT data.
 783   void
 784   do_write(Output_file*);
 785
 786   // The reloc section.
 787   Reloc_section* rel_;
 788   // The number of PLT entries.
 789   unsigned int count_;
 790 };
 791
 792 // Create the PLT section.  The ordinary .got section is an argument,
 793 // since we need to refer to the start.
 794
 795 template<int size, bool big_endian>
 796 Output_data_plt_powerpc<size, big_endian>::Output_data_plt_powerpc(Layout* layout)
 797   : Output_section_data(size == 32 ? 4 : 8), count_(0)
 798 {
 799   this->rel_ = new Reloc_section(false);
 800   layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
 801                                   elfcpp::SHF_ALLOC, this->rel_);
 802 }
 803
 804 template<int size, bool big_endian>
 805 void
 806 Output_data_plt_powerpc<size, big_endian>::do_adjust_output_section(Output_section* os)
 807 {
 808   os->set_entsize(0);
 809 }
 810
 811 // Add an entry to the PLT.
 812
 813 template<int size, bool big_endian>
 814 void
 815 Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym)
 816 {
 817   gold_assert(!gsym->has_plt_offset());
 818   unsigned int index = this->count_+ + 4;
 819   section_offset_type plt_offset;
 820
 821   if (index < 8192)
 822     plt_offset = index * base_plt_entry_size;
 823   else
 824     gold_unreachable();
 825
 826   gsym->set_plt_offset(plt_offset);
 827
 828   ++this->count_;
 829
 830   gsym->set_needs_dynsym_entry();
 831   this->rel_->add_global(gsym, elfcpp::R_POWERPC_JMP_SLOT, this,
 832                          plt_offset, 0);
 833 }
 834
 835 static const unsigned int addis_11_11     = 0x3d6b0000;
 836 static const unsigned int addis_11_30     = 0x3d7e0000;
 837 static const unsigned int addis_12_12     = 0x3d8c0000;
 838 static const unsigned int addi_11_11      = 0x396b0000;
 839 static const unsigned int add_0_11_11     = 0x7c0b5a14;
 840 static const unsigned int add_11_0_11     = 0x7d605a14;
 841 static const unsigned int b               = 0x48000000;
 842 static const unsigned int bcl_20_31       = 0x429f0005;
 843 static const unsigned int bctr            = 0x4e800420;
 844 static const unsigned int lis_11          = 0x3d600000;
 845 static const unsigned int lis_12          = 0x3d800000;
 846 static const unsigned int lwzu_0_12       = 0x840c0000;
 847 static const unsigned int lwz_0_12        = 0x800c0000;
 848 static const unsigned int lwz_11_11       = 0x816b0000;
 849 static const unsigned int lwz_11_30       = 0x817e0000;
 850 static const unsigned int lwz_12_12       = 0x818c0000;
 851 static const unsigned int mflr_0          = 0x7c0802a6;
 852 static const unsigned int mflr_12         = 0x7d8802a6;
 853 static const unsigned int mtctr_0         = 0x7c0903a6;
 854 static const unsigned int mtctr_11        = 0x7d6903a6;
 855 static const unsigned int mtlr_0          = 0x7c0803a6;
 856 static const unsigned int nop             = 0x60000000;
 857 static const unsigned int sub_11_11_12    = 0x7d6c5850;
 858
 859 static const unsigned int addis_r12_r2    = 0x3d820000;  /* addis %r12,%r2,xxx@ha     */
 860 static const unsigned int std_r2_40r1     = 0xf8410028;  /* std   %r2,40(%r1)         */
 861 static const unsigned int ld_r11_0r12     = 0xe96c0000;  /* ld    %r11,xxx+0@l(%r12)  */
 862 static const unsigned int ld_r2_0r12      = 0xe84c0000;  /* ld    %r2,xxx+8@l(%r12)   */
 863                                                          /* ld    %r11,xxx+16@l(%r12) */
 864
 865
 866 // Write out the PLT.
 867
 868 template<int size, bool big_endian>
 869 void
 870 Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of)
 871 {
 872   const off_t offset = this->offset();
 873   const section_size_type oview_size =
 874     convert_to_section_size_type(this->data_size());
 875   unsigned char* const oview = of->get_output_view(offset, oview_size);
 876   unsigned char* pov = oview;
 877
 878   memset(pov, 0, base_plt_entry_size * 4);
 879   pov += base_plt_entry_size * 4;
 880
 881   unsigned int plt_offset = base_plt_entry_size * 4;
 882   const unsigned int count = this->count_;
 883
 884   if (size == 64)
 885     {
 886       for (unsigned int i = 0; i < count; i++)
 887         {
 888         }
 889     }
 890   else
 891     {
 892       for (unsigned int i = 0; i < count; i++)
 893         {
 894           elfcpp::Swap<32, true>::writeval(pov + 0x00,
 895                                            lwz_11_30 + plt_offset);
 896           elfcpp::Swap<32, true>::writeval(pov + 0x04, mtctr_11);
 897           elfcpp::Swap<32, true>::writeval(pov + 0x08, bctr);
 898           elfcpp::Swap<32, true>::writeval(pov + 0x0c, nop);
 899           pov += base_plt_entry_size;
 900           plt_offset += base_plt_entry_size;
 901         }
 902     }
 903
 904   gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
 905
 906   of->write_output_view(offset, oview_size, oview);
 907 }
 908
 909 // Create a PLT entry for a global symbol.
 910
 911 template<int size, bool big_endian>
 912 void
 913 Target_powerpc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
 914                                                  Layout* layout,
 915                                                  Symbol* gsym)
 916 {
 917   if (gsym->has_plt_offset())
 918     return;
 919
 920   if (this->plt_ == NULL)
 921     {
 922       // Create the GOT section first.
 923       this->got_section(symtab, layout);
 924
 925       this->plt_ = new Output_data_plt_powerpc<size, big_endian>(layout);
 926       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
 927                                       (elfcpp::SHF_ALLOC
 928                                        | elfcpp::SHF_EXECINSTR
 929                                        | elfcpp::SHF_WRITE),
 930                                       this->plt_);
 931
 932       // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
 933       symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
 934                                     this->plt_,
 935                                     0, 0, elfcpp::STT_OBJECT,
 936                                     elfcpp::STB_LOCAL,
 937                                     elfcpp::STV_HIDDEN, 0,
 938                                     false, false);
 939     }
 940
 941   this->plt_->add_entry(gsym);
 942 }
 943
 944 // Create a GOT entry for the TLS module index.
 945
 946 template<int size, bool big_endian>
 947 unsigned int
 948 Target_powerpc<size, big_endian>::got_mod_index_entry(Symbol_table* symtab,
 949                                                       Layout* layout,
 950                                                       Sized_relobj<size, big_endian>* object)
 951 {
 952   if (this->got_mod_index_offset_ == -1U)
 953     {
 954       gold_assert(symtab != NULL && layout != NULL && object != NULL);
 955       Reloc_section* rela_dyn = this->rela_dyn_section(layout);
 956       Output_data_got<size, big_endian>* got;
 957       unsigned int got_offset;
 958
 959       got = this->got_section(symtab, layout);
 960       got_offset = got->add_constant(0);
 961       rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got,
 962                           got_offset, 0);
 963       got->add_constant(0);
 964       this->got_mod_index_offset_ = got_offset;
 965     }
 966   return this->got_mod_index_offset_;
 967 }
 968
 969 // Optimize the TLS relocation type based on what we know about the
 970 // symbol.  IS_FINAL is true if the final address of this symbol is
 971 // known at link time.
 972
 973 static tls::Tls_optimization
 974 optimize_tls_reloc(bool /* is_final */, int r_type)
 975 {
 976   // If we are generating a shared library, then we can't do anything
 977   // in the linker.
 978   if (parameters->options().shared())
 979     return tls::TLSOPT_NONE;
 980   switch (r_type)
 981     {
 982       // XXX
 983     default:
 984       gold_unreachable();
 985     }
 986 }
 987
 988 // Report an unsupported relocation against a local symbol.
 989
 990 template<int size, bool big_endian>
 991 void
 992 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local(
 993                         Sized_relobj<size, big_endian>* object,
 994                         unsigned int r_type)
 995 {
 996   gold_error(_("%s: unsupported reloc %u against local symbol"),
 997              object->name().c_str(), r_type);
 998 }
 999
1000 // We are about to emit a dynamic relocation of type R_TYPE.  If the
1001 // dynamic linker does not support it, issue an error.
1002
1003 template<int size, bool big_endian>
1004 void
1005 Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object,
1006                                                       unsigned int r_type)
1007 {
1008   gold_assert(r_type != elfcpp::R_POWERPC_NONE);
1009
1010   // These are the relocation types supported by glibc for both 32-bit
1011   // and 64-bit powerpc.
1012   switch (r_type)
1013     {
1014     case elfcpp::R_POWERPC_RELATIVE:
1015     case elfcpp::R_POWERPC_GLOB_DAT:
1016     case elfcpp::R_POWERPC_DTPMOD:
1017     case elfcpp::R_POWERPC_DTPREL:
1018     case elfcpp::R_POWERPC_TPREL:
1019     case elfcpp::R_POWERPC_JMP_SLOT:
1020     case elfcpp::R_POWERPC_COPY:
1021     case elfcpp::R_POWERPC_ADDR32:
1022     case elfcpp::R_POWERPC_ADDR24:
1023     case elfcpp::R_POWERPC_REL24:
1024       return;
1025
1026     default:
1027       break;
1028     }
1029
1030   if (size == 64)
1031     {
1032       switch (r_type)
1033         {
1034           // These are the relocation types supported only on 64-bit.
1035         case elfcpp::R_PPC64_ADDR64:
1036         case elfcpp::R_PPC64_TPREL16_LO_DS:
1037         case elfcpp::R_PPC64_TPREL16_DS:
1038         case elfcpp::R_POWERPC_TPREL16:
1039         case elfcpp::R_POWERPC_TPREL16_LO:
1040         case elfcpp::R_POWERPC_TPREL16_HI:
1041         case elfcpp::R_POWERPC_TPREL16_HA:
1042         case elfcpp::R_PPC64_TPREL16_HIGHER:
1043         case elfcpp::R_PPC64_TPREL16_HIGHEST:
1044         case elfcpp::R_PPC64_TPREL16_HIGHERA:
1045         case elfcpp::R_PPC64_TPREL16_HIGHESTA:
1046         case elfcpp::R_PPC64_ADDR16_LO_DS:
1047         case elfcpp::R_POWERPC_ADDR16_LO:
1048         case elfcpp::R_POWERPC_ADDR16_HI:
1049         case elfcpp::R_POWERPC_ADDR16_HA:
1050         case elfcpp::R_POWERPC_ADDR30:
1051         case elfcpp::R_PPC64_UADDR64:
1052         case elfcpp::R_POWERPC_UADDR32:
1053         case elfcpp::R_POWERPC_ADDR16:
1054         case elfcpp::R_POWERPC_UADDR16:
1055         case elfcpp::R_PPC64_ADDR16_DS:
1056         case elfcpp::R_PPC64_ADDR16_HIGHER:
1057         case elfcpp::R_PPC64_ADDR16_HIGHEST:
1058         case elfcpp::R_PPC64_ADDR16_HIGHERA:
1059         case elfcpp::R_PPC64_ADDR16_HIGHESTA:
1060         case elfcpp::R_POWERPC_ADDR14_BRTAKEN:
1061         case elfcpp::R_POWERPC_ADDR14_BRNTAKEN:
1062         case elfcpp::R_POWERPC_REL32:
1063         case elfcpp::R_PPC64_REL64:
1064           return;
1065
1066         default:
1067           break;
1068         }
1069     }
1070   else
1071     {
1072       switch (r_type)
1073         {
1074           // These are the relocation types supported only on 32-bit.
1075
1076         default:
1077           break;
1078         }
1079     }
1080
1081   // This prevents us from issuing more than one error per reloc
1082   // section.  But we can still wind up issuing more than one
1083   // error per object file.
1084   if (this->issued_non_pic_error_)
1085     return;
1086   object->error(_("requires unsupported dynamic reloc; "
1087                   "recompile with -fPIC"));
1088   this->issued_non_pic_error_ = true;
1089   return;
1090 }
1091
1092 // Scan a relocation for a local symbol.
1093
1094 template<int size, bool big_endian>
1095 inline void
1096 Target_powerpc<size, big_endian>::Scan::local(
1097                         const General_options&,
1098                         Symbol_table* symtab,
1099                         Layout* layout,
1100                         Target_powerpc<size, big_endian>* target,
1101                         Sized_relobj<size, big_endian>* object,
1102                         unsigned int data_shndx,
1103                         Output_section* output_section,
1104                         const elfcpp::Rela<size, big_endian>& reloc,
1105                         unsigned int r_type,
1106                         const elfcpp::Sym<size, big_endian>& lsym)
1107 {
1108   switch (r_type)
1109     {
1110     case elfcpp::R_POWERPC_NONE:
1111     case elfcpp::R_POWERPC_GNU_VTINHERIT:
1112     case elfcpp::R_POWERPC_GNU_VTENTRY:
1113       break;
1114
1115     case elfcpp::R_PPC64_ADDR64:
1116     case elfcpp::R_POWERPC_ADDR32:
1117     case elfcpp::R_POWERPC_ADDR16_HA:
1118     case elfcpp::R_POWERPC_ADDR16_LO:
1119       // If building a shared library (or a position-independent
1120       // executable), we need to create a dynamic relocation for
1121       // this location.
1122       if (parameters->options().output_is_position_independent())
1123         {
1124           Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1125
1126           check_non_pic(object, r_type);
1127           if (lsym.get_st_type() != elfcpp::STT_SECTION)
1128             {
1129               unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1130               rela_dyn->add_local(object, r_sym, r_type, output_section,
1131                                   data_shndx, reloc.get_r_offset(),
1132                                   reloc.get_r_addend());
1133             }
1134           else
1135             {
1136               unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1137               gold_assert(lsym.get_st_value() == 0);
1138               rela_dyn->add_local_relative(object, r_sym, r_type,
1139                                            output_section, data_shndx,
1140                                            reloc.get_r_offset(),
1141                                            reloc.get_r_addend());
1142             }
1143         }
1144       break;
1145
1146     case elfcpp::R_POWERPC_REL24:
1147     case elfcpp::R_PPC_LOCAL24PC:
1148     case elfcpp::R_POWERPC_REL32:
1149     case elfcpp::R_PPC_REL16_LO:
1150     case elfcpp::R_PPC_REL16_HA:
1151       break;
1152
1153     case elfcpp::R_POWERPC_GOT16:
1154     case elfcpp::R_POWERPC_GOT16_LO:
1155     case elfcpp::R_POWERPC_GOT16_HI:
1156     case elfcpp::R_POWERPC_GOT16_HA:
1157     case elfcpp::R_PPC64_TOC16:
1158     case elfcpp::R_PPC64_TOC16_LO:
1159     case elfcpp::R_PPC64_TOC16_HI:
1160     case elfcpp::R_PPC64_TOC16_HA:
1161     case elfcpp::R_PPC64_TOC16_DS:
1162     case elfcpp::R_PPC64_TOC16_LO_DS:
1163       {
1164         // The symbol requires a GOT entry.
1165         Output_data_got<size, big_endian>* got;
1166         unsigned int r_sym;
1167
1168         got = target->got_section(symtab, layout);
1169         r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1170
1171         // If we are generating a shared object, we need to add a
1172         // dynamic relocation for this symbol's GOT entry.
1173         if (parameters->options().output_is_position_independent())
1174           {
1175             if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
1176               {
1177                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1178                 unsigned int off;
1179
1180                 off = got->add_constant(0);
1181                 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
1182                 rela_dyn->add_local_relative(object, r_sym,
1183                                              elfcpp::R_POWERPC_RELATIVE,
1184                                              got, off, 0);
1185               }
1186           }
1187         else
1188           got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1189       }
1190       break;
1191
1192     case elfcpp::R_PPC64_TOC:
1193       // We need a GOT section.
1194       target->got_section(symtab, layout);
1195       break;
1196
1197       // These are relocations which should only be seen by the
1198       // dynamic linker, and should never be seen here.
1199     case elfcpp::R_POWERPC_COPY:
1200     case elfcpp::R_POWERPC_GLOB_DAT:
1201     case elfcpp::R_POWERPC_JMP_SLOT:
1202     case elfcpp::R_POWERPC_RELATIVE:
1203     case elfcpp::R_POWERPC_DTPMOD:
1204       gold_error(_("%s: unexpected reloc %u in object file"),
1205                  object->name().c_str(), r_type);
1206       break;
1207
1208     default:
1209       unsupported_reloc_local(object, r_type);
1210       break;
1211     }
1212 }
1213
1214 // Report an unsupported relocation against a global symbol.
1215
1216 template<int size, bool big_endian>
1217 void
1218 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global(
1219                         Sized_relobj<size, big_endian>* object,
1220                         unsigned int r_type,
1221                         Symbol* gsym)
1222 {
1223   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1224              object->name().c_str(), r_type, gsym->demangled_name().c_str());
1225 }
1226
1227 // Scan a relocation for a global symbol.
1228
1229 template<int size, bool big_endian>
1230 inline void
1231 Target_powerpc<size, big_endian>::Scan::global(
1232                                 const General_options&,
1233                                 Symbol_table* symtab,
1234                                 Layout* layout,
1235                                 Target_powerpc<size, big_endian>* target,
1236                                 Sized_relobj<size, big_endian>* object,
1237                                 unsigned int data_shndx,
1238                                 Output_section* output_section,
1239                                 const elfcpp::Rela<size, big_endian>& reloc,
1240                                 unsigned int r_type,
1241                                 Symbol* gsym)
1242 {
1243   switch (r_type)
1244     {
1245     case elfcpp::R_POWERPC_NONE:
1246     case elfcpp::R_POWERPC_GNU_VTINHERIT:
1247     case elfcpp::R_POWERPC_GNU_VTENTRY:
1248       break;
1249
1250     case elfcpp::R_PPC_PLTREL24:
1251       // If the symbol is fully resolved, this is just a PC32 reloc.
1252       // Otherwise we need a PLT entry.
1253       if (gsym->final_value_is_known())
1254         break;
1255       // If building a shared library, we can also skip the PLT entry
1256       // if the symbol is defined in the output file and is protected
1257       // or hidden.
1258       if (gsym->is_defined()
1259           && !gsym->is_from_dynobj()
1260           && !gsym->is_preemptible())
1261         break;
1262       target->make_plt_entry(symtab, layout, gsym);
1263       break;
1264
1265     case elfcpp::R_POWERPC_ADDR16:
1266     case elfcpp::R_POWERPC_ADDR16_LO:
1267     case elfcpp::R_POWERPC_ADDR16_HI:
1268     case elfcpp::R_POWERPC_ADDR16_HA:
1269     case elfcpp::R_POWERPC_ADDR32:
1270     case elfcpp::R_PPC64_ADDR64:
1271       {
1272         // Make a PLT entry if necessary.
1273         if (gsym->needs_plt_entry())
1274           {
1275             target->make_plt_entry(symtab, layout, gsym);
1276             // Since this is not a PC-relative relocation, we may be
1277             // taking the address of a function. In that case we need to
1278             // set the entry in the dynamic symbol table to the address of
1279             // the PLT entry.
1280             if (gsym->is_from_dynobj() && !parameters->options().shared())
1281               gsym->set_needs_dynsym_value();
1282           }
1283         // Make a dynamic relocation if necessary.
1284         if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF))
1285           {
1286             if (target->may_need_copy_reloc(gsym))
1287               {
1288                 target->copy_reloc(symtab, layout, object,
1289                                    data_shndx, output_section, gsym, reloc);
1290               }
1291             else if ((r_type == elfcpp::R_POWERPC_ADDR32
1292                       || r_type == elfcpp::R_PPC64_ADDR64)
1293                      && gsym->can_use_relative_reloc(false))
1294               {
1295                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1296                 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE,
1297                                               output_section, object,
1298                                               data_shndx, reloc.get_r_offset(),
1299                                               reloc.get_r_addend());
1300               }
1301             else
1302               {
1303                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1304
1305                 check_non_pic(object, r_type);
1306                 if (gsym->is_from_dynobj()
1307                     || gsym->is_undefined()
1308                     || gsym->is_preemptible())
1309                   rela_dyn->add_global(gsym, r_type, output_section,
1310                                        object, data_shndx,
1311                                        reloc.get_r_offset(),
1312                                        reloc.get_r_addend());
1313                 else
1314                   rela_dyn->add_global_relative(gsym, r_type,
1315                                                 output_section, object,
1316                                                 data_shndx,
1317                                                 reloc.get_r_offset(),
1318                                                 reloc.get_r_addend());
1319               }
1320           }
1321       }
1322       break;
1323
1324     case elfcpp::R_POWERPC_REL24:
1325     case elfcpp::R_PPC_LOCAL24PC:
1326     case elfcpp::R_PPC_REL16:
1327     case elfcpp::R_PPC_REL16_LO:
1328     case elfcpp::R_PPC_REL16_HI:
1329     case elfcpp::R_PPC_REL16_HA:
1330       {
1331         if (gsym->needs_plt_entry())
1332           target->make_plt_entry(symtab, layout, gsym);
1333         // Make a dynamic relocation if necessary.
1334         int flags = Symbol::NON_PIC_REF;
1335         if (gsym->type() == elfcpp::STT_FUNC)
1336           flags |= Symbol::FUNCTION_CALL;
1337         if (gsym->needs_dynamic_reloc(flags))
1338           {
1339             if (target->may_need_copy_reloc(gsym))
1340               {
1341                 target->copy_reloc(symtab, layout, object,
1342                                    data_shndx, output_section, gsym,
1343                                    reloc);
1344               }
1345             else
1346               {
1347                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1348                 check_non_pic(object, r_type);
1349                 rela_dyn->add_global(gsym, r_type, output_section, object,
1350                                      data_shndx, reloc.get_r_offset(),
1351                                      reloc.get_r_addend());
1352               }
1353           }
1354       }
1355       break;
1356
1357     case elfcpp::R_POWERPC_GOT16:
1358     case elfcpp::R_POWERPC_GOT16_LO:
1359     case elfcpp::R_POWERPC_GOT16_HI:
1360     case elfcpp::R_POWERPC_GOT16_HA:
1361     case elfcpp::R_PPC64_TOC16:
1362     case elfcpp::R_PPC64_TOC16_LO:
1363     case elfcpp::R_PPC64_TOC16_HI:
1364     case elfcpp::R_PPC64_TOC16_HA:
1365     case elfcpp::R_PPC64_TOC16_DS:
1366     case elfcpp::R_PPC64_TOC16_LO_DS:
1367       {
1368         // The symbol requires a GOT entry.
1369         Output_data_got<size, big_endian>* got;
1370
1371         got = target->got_section(symtab, layout);
1372         if (gsym->final_value_is_known())
1373           got->add_global(gsym, GOT_TYPE_STANDARD);
1374         else
1375           {
1376             // If this symbol is not fully resolved, we need to add a
1377             // dynamic relocation for it.
1378             Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1379             if (gsym->is_from_dynobj()
1380                 || gsym->is_undefined()
1381                 || gsym->is_preemptible())
1382               got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
1383                                         elfcpp::R_POWERPC_GLOB_DAT);
1384             else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
1385               {
1386                 unsigned int off = got->add_constant(0);
1387
1388                 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
1389                 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE,
1390                                               got, off, 0);
1391               }
1392           }
1393       }
1394       break;
1395
1396     case elfcpp::R_PPC64_TOC:
1397       // We need a GOT section.
1398       target->got_section(symtab, layout);
1399       break;
1400
1401     case elfcpp::R_POWERPC_GOT_TPREL16:
1402     case elfcpp::R_POWERPC_TLS:
1403       // XXX TLS
1404       break;
1405
1406       // These are relocations which should only be seen by the
1407       // dynamic linker, and should never be seen here.
1408     case elfcpp::R_POWERPC_COPY:
1409     case elfcpp::R_POWERPC_GLOB_DAT:
1410     case elfcpp::R_POWERPC_JMP_SLOT:
1411     case elfcpp::R_POWERPC_RELATIVE:
1412     case elfcpp::R_POWERPC_DTPMOD:
1413       gold_error(_("%s: unexpected reloc %u in object file"),
1414                  object->name().c_str(), r_type);
1415       break;
1416
1417     default:
1418       unsupported_reloc_global(object, r_type, gsym);
1419       break;
1420     }
1421 }
1422
1423 // Scan relocations for a section.
1424
1425 template<int size, bool big_endian>
1426 void
1427 Target_powerpc<size, big_endian>::scan_relocs(
1428                         const General_options& options,
1429                         Symbol_table* symtab,
1430                         Layout* layout,
1431                         Sized_relobj<size, big_endian>* object,
1432                         unsigned int data_shndx,
1433                         unsigned int sh_type,
1434                         const unsigned char* prelocs,
1435                         size_t reloc_count,
1436                         Output_section* output_section,
1437                         bool needs_special_offset_handling,
1438                         size_t local_symbol_count,
1439                         const unsigned char* plocal_symbols)
1440 {
1441   typedef Target_powerpc<size, big_endian> Powerpc;
1442   typedef typename Target_powerpc<size, big_endian>::Scan Scan;
1443   static Output_data_space* sdata;
1444
1445   if (sh_type == elfcpp::SHT_REL)
1446     {
1447       gold_error(_("%s: unsupported REL reloc section"),
1448                  object->name().c_str());
1449       return;
1450     }
1451
1452   // Define _SDA_BASE_ at the start of the .sdata section.
1453   if (sdata == NULL)
1454   {
1455     // layout->find_output_section(".sdata") == NULL
1456     sdata = new Output_data_space(4, "** sdata");
1457     Output_section* os = layout->add_output_section_data(".sdata", 0,
1458                                                          elfcpp::SHF_ALLOC
1459                                                          | elfcpp::SHF_WRITE,
1460                                                          sdata);
1461     symtab->define_in_output_data("_SDA_BASE_", NULL,
1462                                   os,
1463                                   32768, 0,
1464                                   elfcpp::STT_OBJECT,
1465                                   elfcpp::STB_LOCAL,
1466                                   elfcpp::STV_HIDDEN, 0,
1467                                   false, false);
1468   }
1469
1470   gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>(
1471     options,
1472     symtab,
1473     layout,
1474     this,
1475     object,
1476     data_shndx,
1477     prelocs,
1478     reloc_count,
1479     output_section,
1480     needs_special_offset_handling,
1481     local_symbol_count,
1482     plocal_symbols);
1483 }
1484
1485 // Finalize the sections.
1486
1487 template<int size, bool big_endian>
1488 void
1489 Target_powerpc<size, big_endian>::do_finalize_sections(Layout* layout)
1490 {
1491   // Fill in some more dynamic tags.
1492   Output_data_dynamic* const odyn = layout->dynamic_data();
1493   if (odyn != NULL)
1494     {
1495       if (this->plt_ != NULL)
1496         {
1497           const Output_data* od = this->plt_->rel_plt();
1498           odyn->add_section_size(elfcpp::DT_PLTRELSZ, od);
1499           odyn->add_section_address(elfcpp::DT_JMPREL, od);
1500           odyn->add_constant(elfcpp::DT_PLTREL, elfcpp::DT_RELA);
1501
1502           odyn->add_section_address(elfcpp::DT_PLTGOT, this->plt_);
1503         }
1504
1505       if (this->rela_dyn_ != NULL)
1506         {
1507           const Output_data* od = this->rela_dyn_;
1508           odyn->add_section_address(elfcpp::DT_RELA, od);
1509           odyn->add_section_size(elfcpp::DT_RELASZ, od);
1510           odyn->add_constant(elfcpp::DT_RELAENT,
1511                              elfcpp::Elf_sizes<size>::rela_size);
1512         }
1513
1514       if (!parameters->options().shared())
1515         {
1516           // The value of the DT_DEBUG tag is filled in by the dynamic
1517           // linker at run time, and used by the debugger.
1518           odyn->add_constant(elfcpp::DT_DEBUG, 0);
1519         }
1520     }
1521
1522   // Emit any relocs we saved in an attempt to avoid generating COPY
1523   // relocs.
1524   if (this->copy_relocs_.any_saved_relocs())
1525     this->copy_relocs_.emit(this->rela_dyn_section(layout));
1526 }
1527
1528 // Perform a relocation.
1529
1530 template<int size, bool big_endian>
1531 inline bool
1532 Target_powerpc<size, big_endian>::Relocate::relocate(
1533                         const Relocate_info<size, big_endian>* relinfo,
1534                         Target_powerpc* target,
1535                         size_t relnum,
1536                         const elfcpp::Rela<size, big_endian>& rela,
1537                         unsigned int r_type,
1538                         const Sized_symbol<size>* gsym,
1539                         const Symbol_value<size>* psymval,
1540                         unsigned char* view,
1541                         typename elfcpp::Elf_types<size>::Elf_Addr address,
1542                         section_size_type /* view_size */)
1543 {
1544   const unsigned int toc_base_offset = 0x8000;
1545   typedef Powerpc_relocate_functions<size, big_endian> Reloc;
1546
1547   // Pick the value to use for symbols defined in shared objects.
1548   Symbol_value<size> symval;
1549   if (gsym != NULL
1550       && gsym->use_plt_offset(r_type == elfcpp::R_POWERPC_REL24
1551                               || r_type == elfcpp::R_PPC_LOCAL24PC
1552                               || r_type == elfcpp::R_PPC_REL16
1553                               || r_type == elfcpp::R_PPC_REL16_LO
1554                               || r_type == elfcpp::R_PPC_REL16_HI
1555                               || r_type == elfcpp::R_PPC_REL16_HA))
1556     {
1557       elfcpp::Elf_Xword value;
1558
1559       value = target->plt_section()->address() + gsym->plt_offset();
1560
1561       symval.set_output_value(value);
1562
1563       psymval = &symval;
1564     }
1565
1566   const Sized_relobj<size, big_endian>* object = relinfo->object;
1567   elfcpp::Elf_Xword addend = rela.get_r_addend();
1568
1569   // Get the GOT offset if needed.  Unlike i386 and x86_64, our GOT
1570   // pointer points to the beginning, not the end, of the table.
1571   // So we just use the plain offset.
1572   bool have_got_offset = false;
1573   unsigned int got_offset = 0;
1574   unsigned int got2_offset = 0;
1575   switch (r_type)
1576     {
1577     case elfcpp::R_PPC64_TOC16:
1578     case elfcpp::R_PPC64_TOC16_LO:
1579     case elfcpp::R_PPC64_TOC16_HI:
1580     case elfcpp::R_PPC64_TOC16_HA:
1581     case elfcpp::R_PPC64_TOC16_DS:
1582     case elfcpp::R_PPC64_TOC16_LO_DS:
1583         // Subtract the TOC base address.
1584         addend -= target->toc_section()->address() + toc_base_offset;
1585         /* FALLTHRU */
1586
1587     case elfcpp::R_POWERPC_GOT16:
1588     case elfcpp::R_POWERPC_GOT16_LO:
1589     case elfcpp::R_POWERPC_GOT16_HI:
1590     case elfcpp::R_POWERPC_GOT16_HA:
1591     case elfcpp::R_PPC64_GOT16_DS:
1592     case elfcpp::R_PPC64_GOT16_LO_DS:
1593       if (gsym != NULL)
1594         {
1595           gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
1596           got_offset = gsym->got_offset(GOT_TYPE_STANDARD);
1597         }
1598       else
1599         {
1600           unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
1601           gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
1602           got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1603         }
1604       have_got_offset = true;
1605       break;
1606
1607       // R_PPC_PLTREL24 is rather special.  If non-zero,
1608       // the addend specifies the GOT pointer offset within .got2.
1609     case elfcpp::R_PPC_PLTREL24:
1610       if (addend >= 32768)
1611         {
1612           Output_data_space* got2;
1613           got2 = target->got2_section();
1614           got2_offset = got2->offset();
1615           addend += got2_offset;
1616         }
1617       have_got_offset = true;
1618       break;
1619
1620     default:
1621       break;
1622     }
1623
1624   switch (r_type)
1625     {
1626     case elfcpp::R_POWERPC_NONE:
1627     case elfcpp::R_POWERPC_GNU_VTINHERIT:
1628     case elfcpp::R_POWERPC_GNU_VTENTRY:
1629       break;
1630
1631     case elfcpp::R_POWERPC_REL32:
1632       Reloc::rel32(view, object, psymval, addend, address);
1633       break;
1634
1635     case elfcpp::R_POWERPC_REL24:
1636       Reloc::rel24(view, object, psymval, addend, address);
1637       break;
1638
1639     case elfcpp::R_POWERPC_REL14:
1640       Reloc::rel14(view, object, psymval, addend, address);
1641       break;
1642
1643     case elfcpp::R_PPC_PLTREL24:
1644       Reloc::rel24(view, object, psymval, addend, address);
1645       break;
1646
1647     case elfcpp::R_PPC_LOCAL24PC:
1648       Reloc::rel24(view, object, psymval, addend, address);
1649       break;
1650
1651     case elfcpp::R_PPC64_ADDR64:
1652       if (!parameters->options().output_is_position_independent())
1653         Relocate_functions<size, big_endian>::rela64(view, object,
1654                                                      psymval, addend);
1655       break;
1656
1657     case elfcpp::R_POWERPC_ADDR32:
1658       if (!parameters->options().output_is_position_independent())
1659         Relocate_functions<size, big_endian>::rela32(view, object,
1660                                                      psymval, addend);
1661       break;
1662
1663     case elfcpp::R_POWERPC_ADDR16_LO:
1664       Reloc::addr16_lo(view, object, psymval, addend);
1665       break;
1666
1667     case elfcpp::R_POWERPC_ADDR16_HI:
1668       Reloc::addr16_hi(view, object, psymval, addend);
1669       break;
1670
1671     case elfcpp::R_POWERPC_ADDR16_HA:
1672       Reloc::addr16_ha(view, object, psymval, addend);
1673       break;
1674
1675     case elfcpp::R_PPC_REL16_LO:
1676       Reloc::rel16_lo(view, object, psymval, addend, address);
1677       break;
1678
1679     case elfcpp::R_PPC_REL16_HI:
1680       Reloc::rel16_lo(view, object, psymval, addend, address);
1681       break;
1682
1683     case elfcpp::R_PPC_REL16_HA:
1684       Reloc::rel16_lo(view, object, psymval, addend, address);
1685       break;
1686
1687     case elfcpp::R_POWERPC_GOT16:
1688       Reloc::addr16(view, got_offset, addend);
1689       break;
1690
1691     case elfcpp::R_POWERPC_GOT16_LO:
1692       Reloc::addr16_lo(view, got_offset, addend);
1693       break;
1694
1695     case elfcpp::R_POWERPC_GOT16_HI:
1696       Reloc::addr16_hi(view, got_offset, addend);
1697       break;
1698
1699     case elfcpp::R_POWERPC_GOT16_HA:
1700       Reloc::addr16_ha(view, got_offset, addend);
1701       break;
1702
1703     case elfcpp::R_PPC64_TOC16:
1704       Reloc::addr16(view, got_offset, addend);
1705       break;
1706
1707     case elfcpp::R_PPC64_TOC16_LO:
1708       Reloc::addr16_lo(view, got_offset, addend);
1709       break;
1710
1711     case elfcpp::R_PPC64_TOC16_HI:
1712       Reloc::addr16_hi(view, got_offset, addend);
1713       break;
1714
1715     case elfcpp::R_PPC64_TOC16_HA:
1716       Reloc::addr16_ha(view, got_offset, addend);
1717       break;
1718
1719     case elfcpp::R_PPC64_TOC16_DS:
1720     case elfcpp::R_PPC64_TOC16_LO_DS:
1721       Reloc::addr16_ds(view, got_offset, addend);
1722       break;
1723
1724     case elfcpp::R_PPC64_TOC:
1725       {
1726         elfcpp::Elf_types<64>::Elf_Addr value;
1727         value = target->toc_section()->address() + toc_base_offset;
1728         Relocate_functions<64, false>::rela64(view, value, addend);
1729       }
1730       break;
1731
1732     case elfcpp::R_POWERPC_COPY:
1733     case elfcpp::R_POWERPC_GLOB_DAT:
1734     case elfcpp::R_POWERPC_JMP_SLOT:
1735     case elfcpp::R_POWERPC_RELATIVE:
1736       // This is an outstanding tls reloc, which is unexpected when
1737       // linking.
1738     case elfcpp::R_POWERPC_DTPMOD:
1739       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
1740                              _("unexpected reloc %u in object file"),
1741                              r_type);
1742       break;
1743
1744     default:
1745       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
1746                              _("unsupported reloc %u"),
1747                              r_type);
1748       break;
1749     }
1750
1751   return true;
1752 }
1753
1754 // Perform a TLS relocation.
1755
1756 template<int size, bool big_endian>
1757 inline void
1758 Target_powerpc<size, big_endian>::Relocate::relocate_tls(
1759                         const Relocate_info<size, big_endian>* relinfo,
1760                         Target_powerpc<size, big_endian>* target,
1761                         size_t relnum,
1762                         const elfcpp::Rela<size, big_endian>& rela,
1763                         unsigned int r_type,
1764                         const Sized_symbol<size>* gsym,
1765                         const Symbol_value<size>* psymval,
1766                         unsigned char* view,
1767                         typename elfcpp::Elf_types<size>::Elf_Addr address,
1768                         section_size_type)
1769 {
1770   Output_segment* tls_segment = relinfo->layout->tls_segment();
1771   typedef Powerpc_relocate_functions<size, big_endian> Reloc;
1772   const Sized_relobj<size, big_endian>* object = relinfo->object;
1773
1774   const elfcpp::Elf_Xword addend = rela.get_r_addend();
1775   typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0);
1776
1777   const bool is_final =
1778     (gsym == NULL
1779      ? !parameters->options().output_is_position_independent()
1780      : gsym->final_value_is_known());
1781   const tls::Tls_optimization optimized_type
1782       = optimize_tls_reloc(is_final, r_type);
1783
1784   switch (r_type)
1785     {
1786       // XXX
1787     }
1788 }
1789
1790 // Relocate section data.
1791
1792 template<int size, bool big_endian>
1793 void
1794 Target_powerpc<size, big_endian>::relocate_section(
1795                         const Relocate_info<size, big_endian>* relinfo,
1796                         unsigned int sh_type,
1797                         const unsigned char* prelocs,
1798                         size_t reloc_count,
1799                         Output_section* output_section,
1800                         bool needs_special_offset_handling,
1801                         unsigned char* view,
1802                         typename elfcpp::Elf_types<size>::Elf_Addr address,
1803                         section_size_type view_size)
1804 {
1805   typedef Target_powerpc<size, big_endian> Powerpc;
1806   typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate;
1807
1808   gold_assert(sh_type == elfcpp::SHT_RELA);
1809
1810   gold::relocate_section<size, big_endian, Powerpc, elfcpp::SHT_RELA,
1811     Powerpc_relocate>(
1812     relinfo,
1813     this,
1814     prelocs,
1815     reloc_count,
1816     output_section,
1817     needs_special_offset_handling,
1818     view,
1819     address,
1820     view_size);
1821 }
1822
1823 // Return the size of a relocation while scanning during a relocatable
1824 // link.
1825
1826 template<int size, bool big_endian>
1827 unsigned int
1828 Target_powerpc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
1829     unsigned int,
1830     Relobj*)
1831 {
1832   // We are always SHT_RELA, so we should never get here.
1833   gold_unreachable();
1834   return 0;
1835 }
1836
1837 // Scan the relocs during a relocatable link.
1838
1839 template<int size, bool big_endian>
1840 void
1841 Target_powerpc<size, big_endian>::scan_relocatable_relocs(
1842                         const General_options& options,
1843                         Symbol_table* symtab,
1844                         Layout* layout,
1845                         Sized_relobj<size, big_endian>* object,
1846                         unsigned int data_shndx,
1847                         unsigned int sh_type,
1848                         const unsigned char* prelocs,
1849                         size_t reloc_count,
1850                         Output_section* output_section,
1851                         bool needs_special_offset_handling,
1852                         size_t local_symbol_count,
1853                         const unsigned char* plocal_symbols,
1854                         Relocatable_relocs* rr)
1855 {
1856   gold_assert(sh_type == elfcpp::SHT_RELA);
1857
1858   typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
1859     Relocatable_size_for_reloc> Scan_relocatable_relocs;
1860
1861   gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
1862       Scan_relocatable_relocs>(
1863     options,
1864     symtab,
1865     layout,
1866     object,
1867     data_shndx,
1868     prelocs,
1869     reloc_count,
1870     output_section,
1871     needs_special_offset_handling,
1872     local_symbol_count,
1873     plocal_symbols,
1874     rr);
1875 }
1876
1877 // Relocate a section during a relocatable link.
1878
1879 template<int size, bool big_endian>
1880 void
1881 Target_powerpc<size, big_endian>::relocate_for_relocatable(
1882     const Relocate_info<size, big_endian>* relinfo,
1883     unsigned int sh_type,
1884     const unsigned char* prelocs,
1885     size_t reloc_count,
1886     Output_section* output_section,
1887     off_t offset_in_output_section,
1888     const Relocatable_relocs* rr,
1889     unsigned char* view,
1890     typename elfcpp::Elf_types<size>::Elf_Addr view_address,
1891     section_size_type view_size,
1892     unsigned char* reloc_view,
1893     section_size_type reloc_view_size)
1894 {
1895   gold_assert(sh_type == elfcpp::SHT_RELA);
1896
1897   gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>(
1898     relinfo,
1899     prelocs,
1900     reloc_count,
1901     output_section,
1902     offset_in_output_section,
1903     rr,
1904     view,
1905     view_address,
1906     view_size,
1907     reloc_view,
1908     reloc_view_size);
1909 }
1910
1911 // Return the value to use for a dynamic which requires special
1912 // treatment.  This is how we support equality comparisons of function
1913 // pointers across shared library boundaries, as described in the
1914 // processor specific ABI supplement.
1915
1916 template<int size, bool big_endian>
1917 uint64_t
1918 Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
1919 {
1920   gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
1921   return this->plt_section()->address() + gsym->plt_offset();
1922 }
1923
1924 // The selector for powerpc object files.
1925
1926 template<int size, bool big_endian>
1927 class Target_selector_powerpc : public Target_selector
1928 {
1929 public:
1930   Target_selector_powerpc()
1931     : Target_selector(elfcpp::EM_NONE, size, big_endian,
1932                       (size == 64 ?
1933                        (big_endian ? "elf64-powerpc" : "elf64-powerpcle") :
1934                        (big_endian ? "elf32-powerpc" : "elf32-powerpcle")))
1935   { }
1936
1937   Target* instantiated_target_;
1938
1939   Target* do_recognize(int machine, int, int)
1940   {
1941     switch (size)
1942       {
1943       case 64:
1944         if (machine != elfcpp::EM_PPC64)
1945           return NULL;
1946         break;
1947
1948       case 32:
1949         if (machine != elfcpp::EM_PPC)
1950           return NULL;
1951         break;
1952
1953       default:
1954         return NULL;
1955       }
1956
1957     return do_instantiate_target();
1958   }
1959
1960   Target* do_instantiate_target()
1961   {
1962     if (this->instantiated_target_ == NULL)
1963       this->instantiated_target_ = new Target_powerpc<size, big_endian>();
1964     return this->instantiated_target_;
1965   }
1966 };
1967
1968 Target_selector_powerpc<32, true> target_selector_ppc32;
1969 Target_selector_powerpc<32, false> target_selector_ppc32le;
1970 Target_selector_powerpc<64, true> target_selector_ppc64;
1971 Target_selector_powerpc<64, false> target_selector_ppc64le;
1972
1973 } // End anonymous namespace.