gold/x86_64.cc

   1 // x86_64.cc -- x86_64 target support for gold.
   2
   3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   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 <cstring>
  26
  27 #include "elfcpp.h"
  28 #include "parameters.h"
  29 #include "reloc.h"
  30 #include "x86_64.h"
  31 #include "object.h"
  32 #include "symtab.h"
  33 #include "layout.h"
  34 #include "output.h"
  35 #include "copy-relocs.h"
  36 #include "target.h"
  37 #include "target-reloc.h"
  38 #include "target-select.h"
  39 #include "tls.h"
  40 #include "freebsd.h"
  41 #include "gc.h"
  42 #include "icf.h"
  43
  44 namespace
  45 {
  46
  47 using namespace gold;
  48
  49 // A class to handle the PLT data.
  50
  51 class Output_data_plt_x86_64 : public Output_section_data
  52 {
  53  public:
  54   typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
  55
  56   Output_data_plt_x86_64(Symbol_table* symtab, Layout* layout,
  57                          Output_data_got<64, false>* got,
  58                          Output_data_space* got_plt)
  59     : Output_section_data(8), tlsdesc_rel_(NULL), got_(got), got_plt_(got_plt),
  60       count_(0), tlsdesc_got_offset_(-1U), free_list_()
  61   { this->init(symtab, layout); }
  62
  63   Output_data_plt_x86_64(Symbol_table* symtab, Layout* layout,
  64                          Output_data_got<64, false>* got,
  65                          Output_data_space* got_plt,
  66                          unsigned int plt_count)
  67     : Output_section_data((plt_count + 1) * plt_entry_size, 8, false),
  68       tlsdesc_rel_(NULL), got_(got), got_plt_(got_plt),
  69       count_(plt_count), tlsdesc_got_offset_(-1U), free_list_()
  70   {
  71     this->init(symtab, layout);
  72
  73     // Initialize the free list and reserve the first entry.
  74     this->free_list_.init((plt_count + 1) * plt_entry_size, false);
  75     this->free_list_.remove(0, plt_entry_size);
  76   }
  77
  78   // Initialize the PLT section.
  79   void
  80   init(Symbol_table* symtab, Layout* layout);
  81
  82   // Add an entry to the PLT.
  83   void
  84   add_entry(Symbol* gsym);
  85
  86   // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
  87   unsigned int
  88   add_local_ifunc_entry(Sized_relobj_file<64, false>* relobj,
  89                         unsigned int local_sym_index);
  90
  91   // Add the relocation for a PLT entry.
  92   void
  93   add_relocation(Symbol* gsym, unsigned int got_offset);
  94
  95   // Add the reserved TLSDESC_PLT entry to the PLT.
  96   void
  97   reserve_tlsdesc_entry(unsigned int got_offset)
  98   { this->tlsdesc_got_offset_ = got_offset; }
  99
 100   // Return true if a TLSDESC_PLT entry has been reserved.
 101   bool
 102   has_tlsdesc_entry() const
 103   { return this->tlsdesc_got_offset_ != -1U; }
 104
 105   // Return the GOT offset for the reserved TLSDESC_PLT entry.
 106   unsigned int
 107   get_tlsdesc_got_offset() const
 108   { return this->tlsdesc_got_offset_; }
 109
 110   // Return the offset of the reserved TLSDESC_PLT entry.
 111   unsigned int
 112   get_tlsdesc_plt_offset() const
 113   { return (this->count_ + 1) * plt_entry_size; }
 114
 115   // Return the .rela.plt section data.
 116   Reloc_section*
 117   rela_plt()
 118   { return this->rel_; }
 119
 120   // Return where the TLSDESC relocations should go.
 121   Reloc_section*
 122   rela_tlsdesc(Layout*);
 123
 124   // Return the number of PLT entries.
 125   unsigned int
 126   entry_count() const
 127   { return this->count_; }
 128
 129   // Return the offset of the first non-reserved PLT entry.
 130   static unsigned int
 131   first_plt_entry_offset()
 132   { return plt_entry_size; }
 133
 134   // Return the size of a PLT entry.
 135   static unsigned int
 136   get_plt_entry_size()
 137   { return plt_entry_size; }
 138
 139   // Reserve a slot in the PLT for an existing symbol in an incremental update.
 140   void
 141   reserve_slot(unsigned int plt_index)
 142   {
 143     this->free_list_.remove((plt_index + 1) * plt_entry_size,
 144                             (plt_index + 2) * plt_entry_size);
 145   }
 146
 147  protected:
 148   void
 149   do_adjust_output_section(Output_section* os);
 150
 151   // Write to a map file.
 152   void
 153   do_print_to_mapfile(Mapfile* mapfile) const
 154   { mapfile->print_output_data(this, _("** PLT")); }
 155
 156  private:
 157   // The size of an entry in the PLT.
 158   static const int plt_entry_size = 16;
 159
 160   // The first entry in the PLT.
 161   // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
 162   // procedure linkage table for both programs and shared objects."
 163   static unsigned char first_plt_entry[plt_entry_size];
 164
 165   // Other entries in the PLT for an executable.
 166   static unsigned char plt_entry[plt_entry_size];
 167
 168   // The reserved TLSDESC entry in the PLT for an executable.
 169   static unsigned char tlsdesc_plt_entry[plt_entry_size];
 170
 171   // Set the final size.
 172   void
 173   set_final_data_size();
 174
 175   // Write out the PLT data.
 176   void
 177   do_write(Output_file*);
 178
 179   // The reloc section.
 180   Reloc_section* rel_;
 181   // The TLSDESC relocs, if necessary.  These must follow the regular
 182   // PLT relocs.
 183   Reloc_section* tlsdesc_rel_;
 184   // The .got section.
 185   Output_data_got<64, false>* got_;
 186   // The .got.plt section.
 187   Output_data_space* got_plt_;
 188   // The number of PLT entries.
 189   unsigned int count_;
 190   // Offset of the reserved TLSDESC_GOT entry when needed.
 191   unsigned int tlsdesc_got_offset_;
 192   // List of available regions within the section, for incremental
 193   // update links.
 194   Free_list free_list_;
 195 };
 196
 197 // The x86_64 target class.
 198 // See the ABI at
 199 //   http://www.x86-64.org/documentation/abi.pdf
 200 // TLS info comes from
 201 //   http://people.redhat.com/drepper/tls.pdf
 202 //   http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
 203
 204 class Target_x86_64 : public Sized_target<64, false>
 205 {
 206  public:
 207   // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures
 208   // uses only Elf64_Rela relocation entries with explicit addends."
 209   typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
 210
 211   Target_x86_64()
 212     : Sized_target<64, false>(&x86_64_info),
 213       got_(NULL), plt_(NULL), got_plt_(NULL), got_tlsdesc_(NULL),
 214       global_offset_table_(NULL), rela_dyn_(NULL),
 215       copy_relocs_(elfcpp::R_X86_64_COPY), dynbss_(NULL),
 216       got_mod_index_offset_(-1U), tlsdesc_reloc_info_(),
 217       tls_base_symbol_defined_(false)
 218   { }
 219
 220   // Hook for a new output section.
 221   void
 222   do_new_output_section(Output_section*) const;
 223
 224   // Scan the relocations to look for symbol adjustments.
 225   void
 226   gc_process_relocs(Symbol_table* symtab,
 227                     Layout* layout,
 228                     Sized_relobj_file<64, false>* object,
 229                     unsigned int data_shndx,
 230                     unsigned int sh_type,
 231                     const unsigned char* prelocs,
 232                     size_t reloc_count,
 233                     Output_section* output_section,
 234                     bool needs_special_offset_handling,
 235                     size_t local_symbol_count,
 236                     const unsigned char* plocal_symbols);
 237
 238   // Scan the relocations to look for symbol adjustments.
 239   void
 240   scan_relocs(Symbol_table* symtab,
 241               Layout* layout,
 242               Sized_relobj_file<64, false>* object,
 243               unsigned int data_shndx,
 244               unsigned int sh_type,
 245               const unsigned char* prelocs,
 246               size_t reloc_count,
 247               Output_section* output_section,
 248               bool needs_special_offset_handling,
 249               size_t local_symbol_count,
 250               const unsigned char* plocal_symbols);
 251
 252   // Finalize the sections.
 253   void
 254   do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
 255
 256   // Return the value to use for a dynamic which requires special
 257   // treatment.
 258   uint64_t
 259   do_dynsym_value(const Symbol*) const;
 260
 261   // Relocate a section.
 262   void
 263   relocate_section(const Relocate_info<64, false>*,
 264                    unsigned int sh_type,
 265                    const unsigned char* prelocs,
 266                    size_t reloc_count,
 267                    Output_section* output_section,
 268                    bool needs_special_offset_handling,
 269                    unsigned char* view,
 270                    elfcpp::Elf_types<64>::Elf_Addr view_address,
 271                    section_size_type view_size,
 272                    const Reloc_symbol_changes*);
 273
 274   // Scan the relocs during a relocatable link.
 275   void
 276   scan_relocatable_relocs(Symbol_table* symtab,
 277                           Layout* layout,
 278                           Sized_relobj_file<64, false>* object,
 279                           unsigned int data_shndx,
 280                           unsigned int sh_type,
 281                           const unsigned char* prelocs,
 282                           size_t reloc_count,
 283                           Output_section* output_section,
 284                           bool needs_special_offset_handling,
 285                           size_t local_symbol_count,
 286                           const unsigned char* plocal_symbols,
 287                           Relocatable_relocs*);
 288
 289   // Relocate a section during a relocatable link.
 290   void
 291   relocate_for_relocatable(const Relocate_info<64, false>*,
 292                            unsigned int sh_type,
 293                            const unsigned char* prelocs,
 294                            size_t reloc_count,
 295                            Output_section* output_section,
 296                            off_t offset_in_output_section,
 297                            const Relocatable_relocs*,
 298                            unsigned char* view,
 299                            elfcpp::Elf_types<64>::Elf_Addr view_address,
 300                            section_size_type view_size,
 301                            unsigned char* reloc_view,
 302                            section_size_type reloc_view_size);
 303
 304   // Return a string used to fill a code section with nops.
 305   std::string
 306   do_code_fill(section_size_type length) const;
 307
 308   // Return whether SYM is defined by the ABI.
 309   bool
 310   do_is_defined_by_abi(const Symbol* sym) const
 311   { return strcmp(sym->name(), "__tls_get_addr") == 0; }
 312
 313   // Return the symbol index to use for a target specific relocation.
 314   // The only target specific relocation is R_X86_64_TLSDESC for a
 315   // local symbol, which is an absolute reloc.
 316   unsigned int
 317   do_reloc_symbol_index(void*, unsigned int r_type) const
 318   {
 319     gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
 320     return 0;
 321   }
 322
 323   // Return the addend to use for a target specific relocation.
 324   uint64_t
 325   do_reloc_addend(void* arg, unsigned int r_type, uint64_t addend) const;
 326
 327   // Return the PLT section.
 328   Output_data*
 329   do_plt_section_for_global(const Symbol*) const
 330   { return this->plt_section(); }
 331
 332   Output_data*
 333   do_plt_section_for_local(const Relobj*, unsigned int) const
 334   { return this->plt_section(); }
 335
 336   // This function should be defined in targets that can use relocation
 337   // types to determine (implemented in local_reloc_may_be_function_pointer
 338   // and global_reloc_may_be_function_pointer)
 339   // if a function's pointer is taken.  ICF uses this in safe mode to only
 340   // fold those functions whose pointer is defintely not taken.  For x86_64
 341   // pie binaries, safe ICF cannot be done by looking at relocation types.
 342   bool
 343   do_can_check_for_function_pointers() const
 344   { return !parameters->options().pie(); }
 345
 346   // Adjust -fsplit-stack code which calls non-split-stack code.
 347   void
 348   do_calls_non_split(Relobj* object, unsigned int shndx,
 349                      section_offset_type fnoffset, section_size_type fnsize,
 350                      unsigned char* view, section_size_type view_size,
 351                      std::string* from, std::string* to) const;
 352
 353   // Return the size of the GOT section.
 354   section_size_type
 355   got_size() const
 356   {
 357     gold_assert(this->got_ != NULL);
 358     return this->got_->data_size();
 359   }
 360
 361   // Return the number of entries in the GOT.
 362   unsigned int
 363   got_entry_count() const
 364   {
 365     if (this->got_ == NULL)
 366       return 0;
 367     return this->got_size() / 8;
 368   }
 369
 370   // Return the number of entries in the PLT.
 371   unsigned int
 372   plt_entry_count() const;
 373
 374   // Return the offset of the first non-reserved PLT entry.
 375   unsigned int
 376   first_plt_entry_offset() const;
 377
 378   // Return the size of each PLT entry.
 379   unsigned int
 380   plt_entry_size() const;
 381
 382   // Create the GOT section for an incremental update.
 383   Output_data_got<64, false>*
 384   init_got_plt_for_update(Symbol_table* symtab,
 385                           Layout* layout,
 386                           unsigned int got_count,
 387                           unsigned int plt_count);
 388
 389   // Reserve a GOT entry for a local symbol, and regenerate any
 390   // necessary dynamic relocations.
 391   void
 392   reserve_local_got_entry(unsigned int got_index,
 393                           Sized_relobj<64, false>* obj,
 394                           unsigned int r_sym,
 395                           unsigned int got_type);
 396
 397   // Reserve a GOT entry for a global symbol, and regenerate any
 398   // necessary dynamic relocations.
 399   void
 400   reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
 401                            unsigned int got_type);
 402
 403   // Register an existing PLT entry for a global symbol.
 404   void
 405   register_global_plt_entry(unsigned int plt_index, Symbol* gsym);
 406
 407   // Force a COPY relocation for a given symbol.
 408   void
 409   emit_copy_reloc(Symbol_table*, Symbol*, Output_section*, off_t);
 410
 411   // Apply an incremental relocation.
 412   void
 413   apply_relocation(const Relocate_info<64, false>* relinfo,
 414                    elfcpp::Elf_types<64>::Elf_Addr r_offset,
 415                    unsigned int r_type,
 416                    elfcpp::Elf_types<64>::Elf_Swxword r_addend,
 417                    const Symbol* gsym,
 418                    unsigned char* view,
 419                    elfcpp::Elf_types<64>::Elf_Addr address,
 420                    section_size_type view_size);
 421
 422   // Add a new reloc argument, returning the index in the vector.
 423   size_t
 424   add_tlsdesc_info(Sized_relobj_file<64, false>* object, unsigned int r_sym)
 425   {
 426     this->tlsdesc_reloc_info_.push_back(Tlsdesc_info(object, r_sym));
 427     return this->tlsdesc_reloc_info_.size() - 1;
 428   }
 429
 430  private:
 431   // The class which scans relocations.
 432   class Scan
 433   {
 434   public:
 435     Scan()
 436       : issued_non_pic_error_(false)
 437     { }
 438
 439     static inline int
 440     get_reference_flags(unsigned int r_type);
 441
 442     inline void
 443     local(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
 444           Sized_relobj_file<64, false>* object,
 445           unsigned int data_shndx,
 446           Output_section* output_section,
 447           const elfcpp::Rela<64, false>& reloc, unsigned int r_type,
 448           const elfcpp::Sym<64, false>& lsym);
 449
 450     inline void
 451     global(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
 452            Sized_relobj_file<64, false>* object,
 453            unsigned int data_shndx,
 454            Output_section* output_section,
 455            const elfcpp::Rela<64, false>& reloc, unsigned int r_type,
 456            Symbol* gsym);
 457
 458     inline bool
 459     local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
 460                                         Target_x86_64* target,
 461                                         Sized_relobj_file<64, false>* object,
 462                                         unsigned int data_shndx,
 463                                         Output_section* output_section,
 464                                         const elfcpp::Rela<64, false>& reloc,
 465                                         unsigned int r_type,
 466                                         const elfcpp::Sym<64, false>& lsym);
 467
 468     inline bool
 469     global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
 470                                          Target_x86_64* target,
 471                                          Sized_relobj_file<64, false>* object,
 472                                          unsigned int data_shndx,
 473                                          Output_section* output_section,
 474                                          const elfcpp::Rela<64, false>& reloc,
 475                                          unsigned int r_type,
 476                                          Symbol* gsym);
 477
 478   private:
 479     static void
 480     unsupported_reloc_local(Sized_relobj_file<64, false>*, unsigned int r_type);
 481
 482     static void
 483     unsupported_reloc_global(Sized_relobj_file<64, false>*, unsigned int r_type,
 484                              Symbol*);
 485
 486     void
 487     check_non_pic(Relobj*, unsigned int r_type, Symbol*);
 488
 489     inline bool
 490     possible_function_pointer_reloc(unsigned int r_type);
 491
 492     bool
 493     reloc_needs_plt_for_ifunc(Sized_relobj_file<64, false>*,
 494                               unsigned int r_type);
 495
 496     // Whether we have issued an error about a non-PIC compilation.
 497     bool issued_non_pic_error_;
 498   };
 499
 500   // The class which implements relocation.
 501   class Relocate
 502   {
 503    public:
 504     Relocate()
 505       : skip_call_tls_get_addr_(false)
 506     { }
 507
 508     ~Relocate()
 509     {
 510       if (this->skip_call_tls_get_addr_)
 511         {
 512           // FIXME: This needs to specify the location somehow.
 513           gold_error(_("missing expected TLS relocation"));
 514         }
 515     }
 516
 517     // Do a relocation.  Return false if the caller should not issue
 518     // any warnings about this relocation.
 519     inline bool
 520     relocate(const Relocate_info<64, false>*, Target_x86_64*, Output_section*,
 521              size_t relnum, const elfcpp::Rela<64, false>&,
 522              unsigned int r_type, const Sized_symbol<64>*,
 523              const Symbol_value<64>*,
 524              unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,
 525              section_size_type);
 526
 527    private:
 528     // Do a TLS relocation.
 529     inline void
 530     relocate_tls(const Relocate_info<64, false>*, Target_x86_64*,
 531                  size_t relnum, const elfcpp::Rela<64, false>&,
 532                  unsigned int r_type, const Sized_symbol<64>*,
 533                  const Symbol_value<64>*,
 534                  unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,
 535                  section_size_type);
 536
 537     // Do a TLS General-Dynamic to Initial-Exec transition.
 538     inline void
 539     tls_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,
 540                  Output_segment* tls_segment,
 541                  const elfcpp::Rela<64, false>&, unsigned int r_type,
 542                  elfcpp::Elf_types<64>::Elf_Addr value,
 543                  unsigned char* view,
 544                  elfcpp::Elf_types<64>::Elf_Addr,
 545                  section_size_type view_size);
 546
 547     // Do a TLS General-Dynamic to Local-Exec transition.
 548     inline void
 549     tls_gd_to_le(const Relocate_info<64, false>*, size_t relnum,
 550                  Output_segment* tls_segment,
 551                  const elfcpp::Rela<64, false>&, unsigned int r_type,
 552                  elfcpp::Elf_types<64>::Elf_Addr value,
 553                  unsigned char* view,
 554                  section_size_type view_size);
 555
 556     // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
 557     inline void
 558     tls_desc_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,
 559                       Output_segment* tls_segment,
 560                       const elfcpp::Rela<64, false>&, unsigned int r_type,
 561                       elfcpp::Elf_types<64>::Elf_Addr value,
 562                       unsigned char* view,
 563                       elfcpp::Elf_types<64>::Elf_Addr,
 564                       section_size_type view_size);
 565
 566     // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
 567     inline void
 568     tls_desc_gd_to_le(const Relocate_info<64, false>*, size_t relnum,
 569                       Output_segment* tls_segment,
 570                       const elfcpp::Rela<64, false>&, unsigned int r_type,
 571                       elfcpp::Elf_types<64>::Elf_Addr value,
 572                       unsigned char* view,
 573                       section_size_type view_size);
 574
 575     // Do a TLS Local-Dynamic to Local-Exec transition.
 576     inline void
 577     tls_ld_to_le(const Relocate_info<64, false>*, size_t relnum,
 578                  Output_segment* tls_segment,
 579                  const elfcpp::Rela<64, false>&, unsigned int r_type,
 580                  elfcpp::Elf_types<64>::Elf_Addr value,
 581                  unsigned char* view,
 582                  section_size_type view_size);
 583
 584     // Do a TLS Initial-Exec to Local-Exec transition.
 585     static inline void
 586     tls_ie_to_le(const Relocate_info<64, false>*, size_t relnum,
 587                  Output_segment* tls_segment,
 588                  const elfcpp::Rela<64, false>&, unsigned int r_type,
 589                  elfcpp::Elf_types<64>::Elf_Addr value,
 590                  unsigned char* view,
 591                  section_size_type view_size);
 592
 593     // This is set if we should skip the next reloc, which should be a
 594     // PLT32 reloc against ___tls_get_addr.
 595     bool skip_call_tls_get_addr_;
 596   };
 597
 598   // A class which returns the size required for a relocation type,
 599   // used while scanning relocs during a relocatable link.
 600   class Relocatable_size_for_reloc
 601   {
 602    public:
 603     unsigned int
 604     get_size_for_reloc(unsigned int, Relobj*);
 605   };
 606
 607   // Adjust TLS relocation type based on the options and whether this
 608   // is a local symbol.
 609   static tls::Tls_optimization
 610   optimize_tls_reloc(bool is_final, int r_type);
 611
 612   // Get the GOT section, creating it if necessary.
 613   Output_data_got<64, false>*
 614   got_section(Symbol_table*, Layout*);
 615
 616   // Get the GOT PLT section.
 617   Output_data_space*
 618   got_plt_section() const
 619   {
 620     gold_assert(this->got_plt_ != NULL);
 621     return this->got_plt_;
 622   }
 623
 624   // Get the GOT section for TLSDESC entries.
 625   Output_data_got<64, false>*
 626   got_tlsdesc_section() const
 627   {
 628     gold_assert(this->got_tlsdesc_ != NULL);
 629     return this->got_tlsdesc_;
 630   }
 631
 632   // Create the PLT section.
 633   void
 634   make_plt_section(Symbol_table* symtab, Layout* layout);
 635
 636   // Create a PLT entry for a global symbol.
 637   void
 638   make_plt_entry(Symbol_table*, Layout*, Symbol*);
 639
 640   // Create a PLT entry for a local STT_GNU_IFUNC symbol.
 641   void
 642   make_local_ifunc_plt_entry(Symbol_table*, Layout*,
 643                              Sized_relobj_file<64, false>* relobj,
 644                              unsigned int local_sym_index);
 645
 646   // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
 647   void
 648   define_tls_base_symbol(Symbol_table*, Layout*);
 649
 650   // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
 651   void
 652   reserve_tlsdesc_entries(Symbol_table* symtab, Layout* layout);
 653
 654   // Create a GOT entry for the TLS module index.
 655   unsigned int
 656   got_mod_index_entry(Symbol_table* symtab, Layout* layout,
 657                       Sized_relobj_file<64, false>* object);
 658
 659   // Get the PLT section.
 660   Output_data_plt_x86_64*
 661   plt_section() const
 662   {
 663     gold_assert(this->plt_ != NULL);
 664     return this->plt_;
 665   }
 666
 667   // Get the dynamic reloc section, creating it if necessary.
 668   Reloc_section*
 669   rela_dyn_section(Layout*);
 670
 671   // Get the section to use for TLSDESC relocations.
 672   Reloc_section*
 673   rela_tlsdesc_section(Layout*) const;
 674
 675   // Add a potential copy relocation.
 676   void
 677   copy_reloc(Symbol_table* symtab, Layout* layout,
 678              Sized_relobj_file<64, false>* object,
 679              unsigned int shndx, Output_section* output_section,
 680              Symbol* sym, const elfcpp::Rela<64, false>& reloc)
 681   {
 682     this->copy_relocs_.copy_reloc(symtab, layout,
 683                                   symtab->get_sized_symbol<64>(sym),
 684                                   object, shndx, output_section,
 685                                   reloc, this->rela_dyn_section(layout));
 686   }
 687
 688   // Information about this specific target which we pass to the
 689   // general Target structure.
 690   static const Target::Target_info x86_64_info;
 691
 692   // The types of GOT entries needed for this platform.
 693   // These values are exposed to the ABI in an incremental link.
 694   // Do not renumber existing values without changing the version
 695   // number of the .gnu_incremental_inputs section.
 696   enum Got_type
 697   {
 698     GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
 699     GOT_TYPE_TLS_OFFSET = 1,    // GOT entry for TLS offset
 700     GOT_TYPE_TLS_PAIR = 2,      // GOT entry for TLS module/offset pair
 701     GOT_TYPE_TLS_DESC = 3       // GOT entry for TLS_DESC pair
 702   };
 703
 704   // This type is used as the argument to the target specific
 705   // relocation routines.  The only target specific reloc is
 706   // R_X86_64_TLSDESC against a local symbol.
 707   struct Tlsdesc_info
 708   {
 709     Tlsdesc_info(Sized_relobj_file<64, false>* a_object, unsigned int a_r_sym)
 710       : object(a_object), r_sym(a_r_sym)
 711     { }
 712
 713     // The object in which the local symbol is defined.
 714     Sized_relobj_file<64, false>* object;
 715     // The local symbol index in the object.
 716     unsigned int r_sym;
 717   };
 718
 719   // The GOT section.
 720   Output_data_got<64, false>* got_;
 721   // The PLT section.
 722   Output_data_plt_x86_64* plt_;
 723   // The GOT PLT section.
 724   Output_data_space* got_plt_;
 725   // The GOT section for TLSDESC relocations.
 726   Output_data_got<64, false>* got_tlsdesc_;
 727   // The _GLOBAL_OFFSET_TABLE_ symbol.
 728   Symbol* global_offset_table_;
 729   // The dynamic reloc section.
 730   Reloc_section* rela_dyn_;
 731   // Relocs saved to avoid a COPY reloc.
 732   Copy_relocs<elfcpp::SHT_RELA, 64, false> copy_relocs_;
 733   // Space for variables copied with a COPY reloc.
 734   Output_data_space* dynbss_;
 735   // Offset of the GOT entry for the TLS module index.
 736   unsigned int got_mod_index_offset_;
 737   // We handle R_X86_64_TLSDESC against a local symbol as a target
 738   // specific relocation.  Here we store the object and local symbol
 739   // index for the relocation.
 740   std::vector<Tlsdesc_info> tlsdesc_reloc_info_;
 741   // True if the _TLS_MODULE_BASE_ symbol has been defined.
 742   bool tls_base_symbol_defined_;
 743 };
 744
 745 const Target::Target_info Target_x86_64::x86_64_info =
 746 {
 747   64,                   // size
 748   false,                // is_big_endian
 749   elfcpp::EM_X86_64,    // machine_code
 750   false,                // has_make_symbol
 751   false,                // has_resolve
 752   true,                 // has_code_fill
 753   true,                 // is_default_stack_executable
 754   true,                 // can_icf_inline_merge_sections
 755   '\0',                 // wrap_char
 756   "/lib/ld64.so.1",     // program interpreter
 757   0x400000,             // default_text_segment_address
 758   0x1000,               // abi_pagesize (overridable by -z max-page-size)
 759   0x1000,               // common_pagesize (overridable by -z common-page-size)
 760   elfcpp::SHN_UNDEF,    // small_common_shndx
 761   elfcpp::SHN_X86_64_LCOMMON,   // large_common_shndx
 762   0,                    // small_common_section_flags
 763   elfcpp::SHF_X86_64_LARGE,     // large_common_section_flags
 764   NULL,                 // attributes_section
 765   NULL                  // attributes_vendor
 766 };
 767
 768 // This is called when a new output section is created.  This is where
 769 // we handle the SHF_X86_64_LARGE.
 770
 771 void
 772 Target_x86_64::do_new_output_section(Output_section* os) const
 773 {
 774   if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)
 775     os->set_is_large_section();
 776 }
 777
 778 // Get the GOT section, creating it if necessary.
 779
 780 Output_data_got<64, false>*
 781 Target_x86_64::got_section(Symbol_table* symtab, Layout* layout)
 782 {
 783   if (this->got_ == NULL)
 784     {
 785       gold_assert(symtab != NULL && layout != NULL);
 786
 787       this->got_ = new Output_data_got<64, false>();
 788
 789       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
 790                                       (elfcpp::SHF_ALLOC
 791                                        | elfcpp::SHF_WRITE),
 792                                       this->got_, ORDER_RELRO_LAST,
 793                                       true);
 794
 795       this->got_plt_ = new Output_data_space(8, "** GOT PLT");
 796       layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
 797                                       (elfcpp::SHF_ALLOC
 798                                        | elfcpp::SHF_WRITE),
 799                                       this->got_plt_, ORDER_NON_RELRO_FIRST,
 800                                       false);
 801
 802       // The first three entries are reserved.
 803       this->got_plt_->set_current_data_size(3 * 8);
 804
 805       // Those bytes can go into the relro segment.
 806       layout->increase_relro(3 * 8);
 807
 808       // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
 809       this->global_offset_table_ =
 810         symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
 811                                       Symbol_table::PREDEFINED,
 812                                       this->got_plt_,
 813                                       0, 0, elfcpp::STT_OBJECT,
 814                                       elfcpp::STB_LOCAL,
 815                                       elfcpp::STV_HIDDEN, 0,
 816                                       false, false);
 817
 818       // If there are any TLSDESC relocations, they get GOT entries in
 819       // .got.plt after the jump slot entries.
 820       this->got_tlsdesc_ = new Output_data_got<64, false>();
 821       layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
 822                                       (elfcpp::SHF_ALLOC
 823                                        | elfcpp::SHF_WRITE),
 824                                       this->got_tlsdesc_,
 825                                       ORDER_NON_RELRO_FIRST, false);
 826     }
 827
 828   return this->got_;
 829 }
 830
 831 // Get the dynamic reloc section, creating it if necessary.
 832
 833 Target_x86_64::Reloc_section*
 834 Target_x86_64::rela_dyn_section(Layout* layout)
 835 {
 836   if (this->rela_dyn_ == NULL)
 837     {
 838       gold_assert(layout != NULL);
 839       this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
 840       layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
 841                                       elfcpp::SHF_ALLOC, this->rela_dyn_,
 842                                       ORDER_DYNAMIC_RELOCS, false);
 843     }
 844   return this->rela_dyn_;
 845 }
 846
 847 // Initialize the PLT section.
 848
 849 void
 850 Output_data_plt_x86_64::init(Symbol_table* symtab, Layout* layout)
 851 {
 852   this->rel_ = new Reloc_section(false);
 853   layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
 854                                   elfcpp::SHF_ALLOC, this->rel_,
 855                                   ORDER_DYNAMIC_PLT_RELOCS, false);
 856
 857   if (parameters->doing_static_link())
 858     {
 859       // A statically linked executable will only have a .rela.plt
 860       // section to hold R_X86_64_IRELATIVE relocs for STT_GNU_IFUNC
 861       // symbols.  The library will use these symbols to locate the
 862       // IRELATIVE relocs at program startup time.
 863       symtab->define_in_output_data("__rela_iplt_start", NULL,
 864                                     Symbol_table::PREDEFINED,
 865                                     this->rel_, 0, 0, elfcpp::STT_NOTYPE,
 866                                     elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
 867                                     0, false, true);
 868       symtab->define_in_output_data("__rela_iplt_end", NULL,
 869                                     Symbol_table::PREDEFINED,
 870                                     this->rel_, 0, 0, elfcpp::STT_NOTYPE,
 871                                     elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
 872                                     0, true, true);
 873     }
 874 }
 875
 876 void
 877 Output_data_plt_x86_64::do_adjust_output_section(Output_section* os)
 878 {
 879   os->set_entsize(plt_entry_size);
 880 }
 881
 882 // Add an entry to the PLT.
 883
 884 void
 885 Output_data_plt_x86_64::add_entry(Symbol* gsym)
 886 {
 887   gold_assert(!gsym->has_plt_offset());
 888
 889   unsigned int plt_index;
 890   off_t plt_offset;
 891   section_offset_type got_offset;
 892
 893   if (!this->is_data_size_valid())
 894     {
 895       // Note that when setting the PLT offset we skip the initial
 896       // reserved PLT entry.
 897       plt_index = this->count_ + 1;
 898       plt_offset = plt_index * plt_entry_size;
 899
 900       ++this->count_;
 901
 902       got_offset = (plt_index - 1 + 3) * 8;
 903       gold_assert(got_offset == this->got_plt_->current_data_size());
 904
 905       // Every PLT entry needs a GOT entry which points back to the PLT
 906       // entry (this will be changed by the dynamic linker, normally
 907       // lazily when the function is called).
 908       this->got_plt_->set_current_data_size(got_offset + 8);
 909     }
 910   else
 911     {
 912       // For incremental updates, find an available slot.
 913       plt_offset = this->free_list_.allocate(plt_entry_size, plt_entry_size, 0);
 914       if (plt_offset == -1)
 915         gold_fallback(_("out of patch space (PLT);"
 916                         " relink with --incremental-full"));
 917
 918       // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset
 919       // can be calculated from the PLT index, adjusting for the three
 920       // reserved entries at the beginning of the GOT.
 921       plt_index = plt_offset / plt_entry_size - 1;
 922       got_offset = (plt_index - 1 + 3) * 8;
 923     }
 924
 925   gsym->set_plt_offset(plt_offset);
 926
 927   // Every PLT entry needs a reloc.
 928   this->add_relocation(gsym, got_offset);
 929
 930   // Note that we don't need to save the symbol.  The contents of the
 931   // PLT are independent of which symbols are used.  The symbols only
 932   // appear in the relocations.
 933 }
 934
 935 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.  Return
 936 // the PLT offset.
 937
 938 unsigned int
 939 Output_data_plt_x86_64::add_local_ifunc_entry(
 940     Sized_relobj_file<64, false>* relobj,
 941     unsigned int local_sym_index)
 942 {
 943   unsigned int plt_offset = (this->count_ + 1) * plt_entry_size;
 944   ++this->count_;
 945
 946   section_offset_type got_offset = this->got_plt_->current_data_size();
 947
 948   // Every PLT entry needs a GOT entry which points back to the PLT
 949   // entry.
 950   this->got_plt_->set_current_data_size(got_offset + 8);
 951
 952   // Every PLT entry needs a reloc.
 953   this->rel_->add_symbolless_local_addend(relobj, local_sym_index,
 954                                           elfcpp::R_X86_64_IRELATIVE,
 955                                           this->got_plt_, got_offset, 0);
 956
 957   return plt_offset;
 958 }
 959
 960 // Add the relocation for a PLT entry.
 961
 962 void
 963 Output_data_plt_x86_64::add_relocation(Symbol* gsym, unsigned int got_offset)
 964 {
 965   if (gsym->type() == elfcpp::STT_GNU_IFUNC
 966       && gsym->can_use_relative_reloc(false))
 967     this->rel_->add_symbolless_global_addend(gsym, elfcpp::R_X86_64_IRELATIVE,
 968                                              this->got_plt_, got_offset, 0);
 969   else
 970     {
 971       gsym->set_needs_dynsym_entry();
 972       this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,
 973                              got_offset, 0);
 974     }
 975 }
 976
 977 // Return where the TLSDESC relocations should go, creating it if
 978 // necessary.  These follow the JUMP_SLOT relocations.
 979
 980 Output_data_plt_x86_64::Reloc_section*
 981 Output_data_plt_x86_64::rela_tlsdesc(Layout* layout)
 982 {
 983   if (this->tlsdesc_rel_ == NULL)
 984     {
 985       this->tlsdesc_rel_ = new Reloc_section(false);
 986       layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
 987                                       elfcpp::SHF_ALLOC, this->tlsdesc_rel_,
 988                                       ORDER_DYNAMIC_PLT_RELOCS, false);
 989       gold_assert(this->tlsdesc_rel_->output_section() ==
 990                   this->rel_->output_section());
 991     }
 992   return this->tlsdesc_rel_;
 993 }
 994
 995 // Set the final size.
 996 void
 997 Output_data_plt_x86_64::set_final_data_size()
 998 {
 999   unsigned int count = this->count_;
1000   if (this->has_tlsdesc_entry())
1001     ++count;
1002   this->set_data_size((count + 1) * plt_entry_size);
1003 }
1004
1005 // The first entry in the PLT for an executable.
1006
1007 unsigned char Output_data_plt_x86_64::first_plt_entry[plt_entry_size] =
1008 {
1009   // From AMD64 ABI Draft 0.98, page 76
1010   0xff, 0x35,   // pushq contents of memory address
1011   0, 0, 0, 0,   // replaced with address of .got + 8
1012   0xff, 0x25,   // jmp indirect
1013   0, 0, 0, 0,   // replaced with address of .got + 16
1014   0x90, 0x90, 0x90, 0x90   // noop (x4)
1015 };
1016
1017 // Subsequent entries in the PLT for an executable.
1018
1019 unsigned char Output_data_plt_x86_64::plt_entry[plt_entry_size] =
1020 {
1021   // From AMD64 ABI Draft 0.98, page 76
1022   0xff, 0x25,   // jmpq indirect
1023   0, 0, 0, 0,   // replaced with address of symbol in .got
1024   0x68,         // pushq immediate
1025   0, 0, 0, 0,   // replaced with offset into relocation table
1026   0xe9,         // jmpq relative
1027   0, 0, 0, 0    // replaced with offset to start of .plt
1028 };
1029
1030 // The reserved TLSDESC entry in the PLT for an executable.
1031
1032 unsigned char Output_data_plt_x86_64::tlsdesc_plt_entry[plt_entry_size] =
1033 {
1034   // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32
1035   // and AMD64/EM64T", Version 0.9.4 (2005-10-10).
1036   0xff, 0x35,   // pushq x(%rip)
1037   0, 0, 0, 0,   // replaced with address of linkmap GOT entry (at PLTGOT + 8)
1038   0xff, 0x25,   // jmpq *y(%rip)
1039   0, 0, 0, 0,   // replaced with offset of reserved TLSDESC_GOT entry
1040   0x0f, 0x1f,   // nop
1041   0x40, 0
1042 };
1043
1044 // Write out the PLT.  This uses the hand-coded instructions above,
1045 // and adjusts them as needed.  This is specified by the AMD64 ABI.
1046
1047 void
1048 Output_data_plt_x86_64::do_write(Output_file* of)
1049 {
1050   const off_t offset = this->offset();
1051   const section_size_type oview_size =
1052     convert_to_section_size_type(this->data_size());
1053   unsigned char* const oview = of->get_output_view(offset, oview_size);
1054
1055   const off_t got_file_offset = this->got_plt_->offset();
1056   const section_size_type got_size =
1057     convert_to_section_size_type(this->got_plt_->data_size());
1058   unsigned char* const got_view = of->get_output_view(got_file_offset,
1059                                                       got_size);
1060
1061   unsigned char* pov = oview;
1062
1063   // The base address of the .plt section.
1064   elfcpp::Elf_types<64>::Elf_Addr plt_address = this->address();
1065   // The base address of the .got section.
1066   elfcpp::Elf_types<64>::Elf_Addr got_base = this->got_->address();
1067   // The base address of the PLT portion of the .got section,
1068   // which is where the GOT pointer will point, and where the
1069   // three reserved GOT entries are located.
1070   elfcpp::Elf_types<64>::Elf_Addr got_address = this->got_plt_->address();
1071
1072   memcpy(pov, first_plt_entry, plt_entry_size);
1073   // We do a jmp relative to the PC at the end of this instruction.
1074   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1075                                               (got_address + 8
1076                                                - (plt_address + 6)));
1077   elfcpp::Swap<32, false>::writeval(pov + 8,
1078                                     (got_address + 16
1079                                      - (plt_address + 12)));
1080   pov += plt_entry_size;
1081
1082   unsigned char* got_pov = got_view;
1083
1084   memset(got_pov, 0, 24);
1085   got_pov += 24;
1086
1087   unsigned int plt_offset = plt_entry_size;
1088   unsigned int got_offset = 24;
1089   const unsigned int count = this->count_;
1090   for (unsigned int plt_index = 0;
1091        plt_index < count;
1092        ++plt_index,
1093          pov += plt_entry_size,
1094          got_pov += 8,
1095          plt_offset += plt_entry_size,
1096          got_offset += 8)
1097     {
1098       // Set and adjust the PLT entry itself.
1099       memcpy(pov, plt_entry, plt_entry_size);
1100       elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1101                                                   (got_address + got_offset
1102                                                    - (plt_address + plt_offset
1103                                                       + 6)));
1104
1105       elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_index);
1106       elfcpp::Swap<32, false>::writeval(pov + 12,
1107                                         - (plt_offset + plt_entry_size));
1108
1109       // Set the entry in the GOT.
1110       elfcpp::Swap<64, false>::writeval(got_pov, plt_address + plt_offset + 6);
1111     }
1112
1113   if (this->has_tlsdesc_entry())
1114     {
1115       // Set and adjust the reserved TLSDESC PLT entry.
1116       unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset();
1117       memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
1118       elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1119                                                   (got_address + 8
1120                                                    - (plt_address + plt_offset
1121                                                       + 6)));
1122       elfcpp::Swap_unaligned<32, false>::writeval(pov + 8,
1123                                                   (got_base
1124                                                    + tlsdesc_got_offset
1125                                                    - (plt_address + plt_offset
1126                                                       + 12)));
1127       pov += plt_entry_size;
1128     }
1129
1130   gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1131   gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
1132
1133   of->write_output_view(offset, oview_size, oview);
1134   of->write_output_view(got_file_offset, got_size, got_view);
1135 }
1136
1137 // Create the PLT section.
1138
1139 void
1140 Target_x86_64::make_plt_section(Symbol_table* symtab, Layout* layout)
1141 {
1142   if (this->plt_ == NULL)
1143     {
1144       // Create the GOT sections first.
1145       this->got_section(symtab, layout);
1146
1147       this->plt_ = new Output_data_plt_x86_64(symtab, layout, this->got_,
1148                                               this->got_plt_);
1149       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1150                                       (elfcpp::SHF_ALLOC
1151                                        | elfcpp::SHF_EXECINSTR),
1152                                       this->plt_, ORDER_PLT, false);
1153
1154       // Make the sh_info field of .rela.plt point to .plt.
1155       Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1156       rela_plt_os->set_info_section(this->plt_->output_section());
1157     }
1158 }
1159
1160 // Return the section for TLSDESC relocations.
1161
1162 Target_x86_64::Reloc_section*
1163 Target_x86_64::rela_tlsdesc_section(Layout* layout) const
1164 {
1165   return this->plt_section()->rela_tlsdesc(layout);
1166 }
1167
1168 // Create a PLT entry for a global symbol.
1169
1170 void
1171 Target_x86_64::make_plt_entry(Symbol_table* symtab, Layout* layout,
1172                               Symbol* gsym)
1173 {
1174   if (gsym->has_plt_offset())
1175     return;
1176
1177   if (this->plt_ == NULL)
1178     this->make_plt_section(symtab, layout);
1179
1180   this->plt_->add_entry(gsym);
1181 }
1182
1183 // Make a PLT entry for a local STT_GNU_IFUNC symbol.
1184
1185 void
1186 Target_x86_64::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout,
1187                                           Sized_relobj_file<64, false>* relobj,
1188                                           unsigned int local_sym_index)
1189 {
1190   if (relobj->local_has_plt_offset(local_sym_index))
1191     return;
1192   if (this->plt_ == NULL)
1193     this->make_plt_section(symtab, layout);
1194   unsigned int plt_offset = this->plt_->add_local_ifunc_entry(relobj,
1195                                                               local_sym_index);
1196   relobj->set_local_plt_offset(local_sym_index, plt_offset);
1197 }
1198
1199 // Return the number of entries in the PLT.
1200
1201 unsigned int
1202 Target_x86_64::plt_entry_count() const
1203 {
1204   if (this->plt_ == NULL)
1205     return 0;
1206   return this->plt_->entry_count();
1207 }
1208
1209 // Return the offset of the first non-reserved PLT entry.
1210
1211 unsigned int
1212 Target_x86_64::first_plt_entry_offset() const
1213 {
1214   return Output_data_plt_x86_64::first_plt_entry_offset();
1215 }
1216
1217 // Return the size of each PLT entry.
1218
1219 unsigned int
1220 Target_x86_64::plt_entry_size() const
1221 {
1222   return Output_data_plt_x86_64::get_plt_entry_size();
1223 }
1224
1225 // Create the GOT and PLT sections for an incremental update.
1226
1227 Output_data_got<64, false>*
1228 Target_x86_64::init_got_plt_for_update(Symbol_table* symtab,
1229                                        Layout* layout,
1230                                        unsigned int got_count,
1231                                        unsigned int plt_count)
1232 {
1233   gold_assert(this->got_ == NULL);
1234
1235   this->got_ = new Output_data_got<64, false>(got_count * 8);
1236   layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1237                                   (elfcpp::SHF_ALLOC
1238                                    | elfcpp::SHF_WRITE),
1239                                   this->got_, ORDER_RELRO_LAST,
1240                                   true);
1241
1242   // Add the three reserved entries.
1243   this->got_plt_ = new Output_data_space((plt_count + 3) * 8, 8, "** GOT PLT");
1244   layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1245                                   (elfcpp::SHF_ALLOC
1246                                    | elfcpp::SHF_WRITE),
1247                                   this->got_plt_, ORDER_NON_RELRO_FIRST,
1248                                   false);
1249
1250   // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1251   this->global_offset_table_ =
1252     symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1253                                   Symbol_table::PREDEFINED,
1254                                   this->got_plt_,
1255                                   0, 0, elfcpp::STT_OBJECT,
1256                                   elfcpp::STB_LOCAL,
1257                                   elfcpp::STV_HIDDEN, 0,
1258                                   false, false);
1259
1260   // If there are any TLSDESC relocations, they get GOT entries in
1261   // .got.plt after the jump slot entries.
1262   // FIXME: Get the count for TLSDESC entries.
1263   this->got_tlsdesc_ = new Output_data_got<64, false>(0);
1264   layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1265                                   elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1266                                   this->got_tlsdesc_,
1267                                   ORDER_NON_RELRO_FIRST, false);
1268
1269   // Create the PLT section.
1270   this->plt_ = new Output_data_plt_x86_64(symtab, layout, this->got_,
1271                                           this->got_plt_, plt_count);
1272   layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1273                                   elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
1274                                   this->plt_, ORDER_PLT, false);
1275
1276   // Make the sh_info field of .rela.plt point to .plt.
1277   Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1278   rela_plt_os->set_info_section(this->plt_->output_section());
1279
1280   // Create the rela_dyn section.
1281   this->rela_dyn_section(layout);
1282
1283   return this->got_;
1284 }
1285
1286 // Reserve a GOT entry for a local symbol, and regenerate any
1287 // necessary dynamic relocations.
1288
1289 void
1290 Target_x86_64::reserve_local_got_entry(
1291     unsigned int got_index,
1292     Sized_relobj<64, false>* obj,
1293     unsigned int r_sym,
1294     unsigned int got_type)
1295 {
1296   unsigned int got_offset = got_index * 8;
1297   Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1298
1299   this->got_->reserve_local(got_index, obj, r_sym, got_type);
1300   switch (got_type)
1301     {
1302     case GOT_TYPE_STANDARD:
1303       if (parameters->options().output_is_position_independent())
1304         rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_X86_64_RELATIVE,
1305                                      this->got_, got_offset, 0);
1306       break;
1307     case GOT_TYPE_TLS_OFFSET:
1308       rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_TPOFF64,
1309                           this->got_, got_offset, 0);
1310       break;
1311     case GOT_TYPE_TLS_PAIR:
1312       this->got_->reserve_slot(got_index + 1);
1313       rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_DTPMOD64,
1314                           this->got_, got_offset, 0);
1315       break;
1316     case GOT_TYPE_TLS_DESC:
1317       gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
1318       // this->got_->reserve_slot(got_index + 1);
1319       // rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1320       //                               this->got_, got_offset, 0);
1321       break;
1322     default:
1323       gold_unreachable();
1324     }
1325 }
1326
1327 // Reserve a GOT entry for a global symbol, and regenerate any
1328 // necessary dynamic relocations.
1329
1330 void
1331 Target_x86_64::reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
1332                                         unsigned int got_type)
1333 {
1334   unsigned int got_offset = got_index * 8;
1335   Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1336
1337   this->got_->reserve_global(got_index, gsym, got_type);
1338   switch (got_type)
1339     {
1340     case GOT_TYPE_STANDARD:
1341       if (!gsym->final_value_is_known())
1342         {
1343           if (gsym->is_from_dynobj()
1344               || gsym->is_undefined()
1345               || gsym->is_preemptible()
1346               || gsym->type() == elfcpp::STT_GNU_IFUNC)
1347             rela_dyn->add_global(gsym, elfcpp::R_X86_64_GLOB_DAT,
1348                                  this->got_, got_offset, 0);
1349           else
1350             rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
1351                                           this->got_, got_offset, 0);
1352         }
1353       break;
1354     case GOT_TYPE_TLS_OFFSET:
1355       rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TPOFF64,
1356                                     this->got_, got_offset, 0);
1357       break;
1358     case GOT_TYPE_TLS_PAIR:
1359       this->got_->reserve_slot(got_index + 1);
1360       rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPMOD64,
1361                                     this->got_, got_offset, 0);
1362       rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPOFF64,
1363                                     this->got_, got_offset + 8, 0);
1364       break;
1365     case GOT_TYPE_TLS_DESC:
1366       this->got_->reserve_slot(got_index + 1);
1367       rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TLSDESC,
1368                                     this->got_, got_offset, 0);
1369       break;
1370     default:
1371       gold_unreachable();
1372     }
1373 }
1374
1375 // Register an existing PLT entry for a global symbol.
1376
1377 void
1378 Target_x86_64::register_global_plt_entry(unsigned int plt_index,
1379                                          Symbol* gsym)
1380 {
1381   gold_assert(this->plt_ != NULL);
1382   gold_assert(!gsym->has_plt_offset());
1383
1384   this->plt_->reserve_slot(plt_index);
1385
1386   gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size());
1387
1388   unsigned int got_offset = (plt_index + 3) * 8;
1389   this->plt_->add_relocation(gsym, got_offset);
1390 }
1391
1392 // Force a COPY relocation for a given symbol.
1393
1394 void
1395 Target_x86_64::emit_copy_reloc(
1396     Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset)
1397 {
1398   this->copy_relocs_.emit_copy_reloc(symtab,
1399                                      symtab->get_sized_symbol<64>(sym),
1400                                      os,
1401                                      offset,
1402                                      this->rela_dyn_section(NULL));
1403 }
1404
1405 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
1406
1407 void
1408 Target_x86_64::define_tls_base_symbol(Symbol_table* symtab, Layout* layout)
1409 {
1410   if (this->tls_base_symbol_defined_)
1411     return;
1412
1413   Output_segment* tls_segment = layout->tls_segment();
1414   if (tls_segment != NULL)
1415     {
1416       bool is_exec = parameters->options().output_is_executable();
1417       symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
1418                                        Symbol_table::PREDEFINED,
1419                                        tls_segment, 0, 0,
1420                                        elfcpp::STT_TLS,
1421                                        elfcpp::STB_LOCAL,
1422                                        elfcpp::STV_HIDDEN, 0,
1423                                        (is_exec
1424                                         ? Symbol::SEGMENT_END
1425                                         : Symbol::SEGMENT_START),
1426                                        true);
1427     }
1428   this->tls_base_symbol_defined_ = true;
1429 }
1430
1431 // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
1432
1433 void
1434 Target_x86_64::reserve_tlsdesc_entries(Symbol_table* symtab,
1435                                              Layout* layout)
1436 {
1437   if (this->plt_ == NULL)
1438     this->make_plt_section(symtab, layout);
1439
1440   if (!this->plt_->has_tlsdesc_entry())
1441     {
1442       // Allocate the TLSDESC_GOT entry.
1443       Output_data_got<64, false>* got = this->got_section(symtab, layout);
1444       unsigned int got_offset = got->add_constant(0);
1445
1446       // Allocate the TLSDESC_PLT entry.
1447       this->plt_->reserve_tlsdesc_entry(got_offset);
1448     }
1449 }
1450
1451 // Create a GOT entry for the TLS module index.
1452
1453 unsigned int
1454 Target_x86_64::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
1455                                    Sized_relobj_file<64, false>* object)
1456 {
1457   if (this->got_mod_index_offset_ == -1U)
1458     {
1459       gold_assert(symtab != NULL && layout != NULL && object != NULL);
1460       Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1461       Output_data_got<64, false>* got = this->got_section(symtab, layout);
1462       unsigned int got_offset = got->add_constant(0);
1463       rela_dyn->add_local(object, 0, elfcpp::R_X86_64_DTPMOD64, got,
1464                           got_offset, 0);
1465       got->add_constant(0);
1466       this->got_mod_index_offset_ = got_offset;
1467     }
1468   return this->got_mod_index_offset_;
1469 }
1470
1471 // Optimize the TLS relocation type based on what we know about the
1472 // symbol.  IS_FINAL is true if the final address of this symbol is
1473 // known at link time.
1474
1475 tls::Tls_optimization
1476 Target_x86_64::optimize_tls_reloc(bool is_final, int r_type)
1477 {
1478   // If we are generating a shared library, then we can't do anything
1479   // in the linker.
1480   if (parameters->options().shared())
1481     return tls::TLSOPT_NONE;
1482
1483   switch (r_type)
1484     {
1485     case elfcpp::R_X86_64_TLSGD:
1486     case elfcpp::R_X86_64_GOTPC32_TLSDESC:
1487     case elfcpp::R_X86_64_TLSDESC_CALL:
1488       // These are General-Dynamic which permits fully general TLS
1489       // access.  Since we know that we are generating an executable,
1490       // we can convert this to Initial-Exec.  If we also know that
1491       // this is a local symbol, we can further switch to Local-Exec.
1492       if (is_final)
1493         return tls::TLSOPT_TO_LE;
1494       return tls::TLSOPT_TO_IE;
1495
1496     case elfcpp::R_X86_64_TLSLD:
1497       // This is Local-Dynamic, which refers to a local symbol in the
1498       // dynamic TLS block.  Since we know that we generating an
1499       // executable, we can switch to Local-Exec.
1500       return tls::TLSOPT_TO_LE;
1501
1502     case elfcpp::R_X86_64_DTPOFF32:
1503     case elfcpp::R_X86_64_DTPOFF64:
1504       // Another Local-Dynamic reloc.
1505       return tls::TLSOPT_TO_LE;
1506
1507     case elfcpp::R_X86_64_GOTTPOFF:
1508       // These are Initial-Exec relocs which get the thread offset
1509       // from the GOT.  If we know that we are linking against the
1510       // local symbol, we can switch to Local-Exec, which links the
1511       // thread offset into the instruction.
1512       if (is_final)
1513         return tls::TLSOPT_TO_LE;
1514       return tls::TLSOPT_NONE;
1515
1516     case elfcpp::R_X86_64_TPOFF32:
1517       // When we already have Local-Exec, there is nothing further we
1518       // can do.
1519       return tls::TLSOPT_NONE;
1520
1521     default:
1522       gold_unreachable();
1523     }
1524 }
1525
1526 // Get the Reference_flags for a particular relocation.
1527
1528 int
1529 Target_x86_64::Scan::get_reference_flags(unsigned int r_type)
1530 {
1531   switch (r_type)
1532     {
1533     case elfcpp::R_X86_64_NONE:
1534     case elfcpp::R_X86_64_GNU_VTINHERIT:
1535     case elfcpp::R_X86_64_GNU_VTENTRY:
1536     case elfcpp::R_X86_64_GOTPC32:
1537     case elfcpp::R_X86_64_GOTPC64:
1538       // No symbol reference.
1539       return 0;
1540
1541     case elfcpp::R_X86_64_64:
1542     case elfcpp::R_X86_64_32:
1543     case elfcpp::R_X86_64_32S:
1544     case elfcpp::R_X86_64_16:
1545     case elfcpp::R_X86_64_8:
1546       return Symbol::ABSOLUTE_REF;
1547
1548     case elfcpp::R_X86_64_PC64:
1549     case elfcpp::R_X86_64_PC32:
1550     case elfcpp::R_X86_64_PC16:
1551     case elfcpp::R_X86_64_PC8:
1552     case elfcpp::R_X86_64_GOTOFF64:
1553       return Symbol::RELATIVE_REF;
1554
1555     case elfcpp::R_X86_64_PLT32:
1556     case elfcpp::R_X86_64_PLTOFF64:
1557       return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
1558
1559     case elfcpp::R_X86_64_GOT64:
1560     case elfcpp::R_X86_64_GOT32:
1561     case elfcpp::R_X86_64_GOTPCREL64:
1562     case elfcpp::R_X86_64_GOTPCREL:
1563     case elfcpp::R_X86_64_GOTPLT64:
1564       // Absolute in GOT.
1565       return Symbol::ABSOLUTE_REF;
1566
1567     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
1568     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
1569     case elfcpp::R_X86_64_TLSDESC_CALL:
1570     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
1571     case elfcpp::R_X86_64_DTPOFF32:
1572     case elfcpp::R_X86_64_DTPOFF64:
1573     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
1574     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
1575       return Symbol::TLS_REF;
1576
1577     case elfcpp::R_X86_64_COPY:
1578     case elfcpp::R_X86_64_GLOB_DAT:
1579     case elfcpp::R_X86_64_JUMP_SLOT:
1580     case elfcpp::R_X86_64_RELATIVE:
1581     case elfcpp::R_X86_64_IRELATIVE:
1582     case elfcpp::R_X86_64_TPOFF64:
1583     case elfcpp::R_X86_64_DTPMOD64:
1584     case elfcpp::R_X86_64_TLSDESC:
1585     case elfcpp::R_X86_64_SIZE32:
1586     case elfcpp::R_X86_64_SIZE64:
1587     default:
1588       // Not expected.  We will give an error later.
1589       return 0;
1590     }
1591 }
1592
1593 // Report an unsupported relocation against a local symbol.
1594
1595 void
1596 Target_x86_64::Scan::unsupported_reloc_local(
1597      Sized_relobj_file<64, false>* object,
1598      unsigned int r_type)
1599 {
1600   gold_error(_("%s: unsupported reloc %u against local symbol"),
1601              object->name().c_str(), r_type);
1602 }
1603
1604 // We are about to emit a dynamic relocation of type R_TYPE.  If the
1605 // dynamic linker does not support it, issue an error.  The GNU linker
1606 // only issues a non-PIC error for an allocated read-only section.
1607 // Here we know the section is allocated, but we don't know that it is
1608 // read-only.  But we check for all the relocation types which the
1609 // glibc dynamic linker supports, so it seems appropriate to issue an
1610 // error even if the section is not read-only.  If GSYM is not NULL,
1611 // it is the symbol the relocation is against; if it is NULL, the
1612 // relocation is against a local symbol.
1613
1614 void
1615 Target_x86_64::Scan::check_non_pic(Relobj* object, unsigned int r_type,
1616                                    Symbol* gsym)
1617 {
1618   switch (r_type)
1619     {
1620       // These are the relocation types supported by glibc for x86_64
1621       // which should always work.
1622     case elfcpp::R_X86_64_RELATIVE:
1623     case elfcpp::R_X86_64_IRELATIVE:
1624     case elfcpp::R_X86_64_GLOB_DAT:
1625     case elfcpp::R_X86_64_JUMP_SLOT:
1626     case elfcpp::R_X86_64_DTPMOD64:
1627     case elfcpp::R_X86_64_DTPOFF64:
1628     case elfcpp::R_X86_64_TPOFF64:
1629     case elfcpp::R_X86_64_64:
1630     case elfcpp::R_X86_64_COPY:
1631       return;
1632
1633       // glibc supports these reloc types, but they can overflow.
1634     case elfcpp::R_X86_64_PC32:
1635       // A PC relative reference is OK against a local symbol or if
1636       // the symbol is defined locally.
1637       if (gsym == NULL
1638           || (!gsym->is_from_dynobj()
1639               && !gsym->is_undefined()
1640               && !gsym->is_preemptible()))
1641         return;
1642       /* Fall through.  */
1643     case elfcpp::R_X86_64_32:
1644       if (this->issued_non_pic_error_)
1645         return;
1646       gold_assert(parameters->options().output_is_position_independent());
1647       if (gsym == NULL)
1648         object->error(_("requires dynamic R_X86_64_32 reloc which may "
1649                         "overflow at runtime; recompile with -fPIC"));
1650       else
1651         object->error(_("requires dynamic %s reloc against '%s' which may "
1652                         "overflow at runtime; recompile with -fPIC"),
1653                       (r_type == elfcpp::R_X86_64_32
1654                        ? "R_X86_64_32"
1655                        : "R_X86_64_PC32"),
1656                       gsym->name());
1657       this->issued_non_pic_error_ = true;
1658       return;
1659
1660     default:
1661       // This prevents us from issuing more than one error per reloc
1662       // section.  But we can still wind up issuing more than one
1663       // error per object file.
1664       if (this->issued_non_pic_error_)
1665         return;
1666       gold_assert(parameters->options().output_is_position_independent());
1667       object->error(_("requires unsupported dynamic reloc %u; "
1668                       "recompile with -fPIC"),
1669                     r_type);
1670       this->issued_non_pic_error_ = true;
1671       return;
1672
1673     case elfcpp::R_X86_64_NONE:
1674       gold_unreachable();
1675     }
1676 }
1677
1678 // Return whether we need to make a PLT entry for a relocation of the
1679 // given type against a STT_GNU_IFUNC symbol.
1680
1681 bool
1682 Target_x86_64::Scan::reloc_needs_plt_for_ifunc(
1683      Sized_relobj_file<64, false>* object,
1684      unsigned int r_type)
1685 {
1686   int flags = Scan::get_reference_flags(r_type);
1687   if (flags & Symbol::TLS_REF)
1688     gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
1689                object->name().c_str(), r_type);
1690   return flags != 0;
1691 }
1692
1693 // Scan a relocation for a local symbol.
1694
1695 inline void
1696 Target_x86_64::Scan::local(Symbol_table* symtab,
1697                            Layout* layout,
1698                            Target_x86_64* target,
1699                            Sized_relobj_file<64, false>* object,
1700                            unsigned int data_shndx,
1701                            Output_section* output_section,
1702                            const elfcpp::Rela<64, false>& reloc,
1703                            unsigned int r_type,
1704                            const elfcpp::Sym<64, false>& lsym)
1705 {
1706   // A local STT_GNU_IFUNC symbol may require a PLT entry.
1707   if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC
1708       && this->reloc_needs_plt_for_ifunc(object, r_type))
1709     {
1710       unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1711       target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
1712     }
1713
1714   switch (r_type)
1715     {
1716     case elfcpp::R_X86_64_NONE:
1717     case elfcpp::R_X86_64_GNU_VTINHERIT:
1718     case elfcpp::R_X86_64_GNU_VTENTRY:
1719       break;
1720
1721     case elfcpp::R_X86_64_64:
1722       // If building a shared library (or a position-independent
1723       // executable), we need to create a dynamic relocation for this
1724       // location.  The relocation applied at link time will apply the
1725       // link-time value, so we flag the location with an
1726       // R_X86_64_RELATIVE relocation so the dynamic loader can
1727       // relocate it easily.
1728       if (parameters->options().output_is_position_independent())
1729         {
1730           unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1731           Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1732           rela_dyn->add_local_relative(object, r_sym,
1733                                        elfcpp::R_X86_64_RELATIVE,
1734                                        output_section, data_shndx,
1735                                        reloc.get_r_offset(),
1736                                        reloc.get_r_addend());
1737         }
1738       break;
1739
1740     case elfcpp::R_X86_64_32:
1741     case elfcpp::R_X86_64_32S:
1742     case elfcpp::R_X86_64_16:
1743     case elfcpp::R_X86_64_8:
1744       // If building a shared library (or a position-independent
1745       // executable), we need to create a dynamic relocation for this
1746       // location.  We can't use an R_X86_64_RELATIVE relocation
1747       // because that is always a 64-bit relocation.
1748       if (parameters->options().output_is_position_independent())
1749         {
1750           this->check_non_pic(object, r_type, NULL);
1751
1752           Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1753           unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1754           if (lsym.get_st_type() != elfcpp::STT_SECTION)
1755             rela_dyn->add_local(object, r_sym, r_type, output_section,
1756                                 data_shndx, reloc.get_r_offset(),
1757                                 reloc.get_r_addend());
1758           else
1759             {
1760               gold_assert(lsym.get_st_value() == 0);
1761               unsigned int shndx = lsym.get_st_shndx();
1762               bool is_ordinary;
1763               shndx = object->adjust_sym_shndx(r_sym, shndx,
1764                                                &is_ordinary);
1765               if (!is_ordinary)
1766                 object->error(_("section symbol %u has bad shndx %u"),
1767                               r_sym, shndx);
1768               else
1769                 rela_dyn->add_local_section(object, shndx,
1770                                             r_type, output_section,
1771                                             data_shndx, reloc.get_r_offset(),
1772                                             reloc.get_r_addend());
1773             }
1774         }
1775       break;
1776
1777     case elfcpp::R_X86_64_PC64:
1778     case elfcpp::R_X86_64_PC32:
1779     case elfcpp::R_X86_64_PC16:
1780     case elfcpp::R_X86_64_PC8:
1781       break;
1782
1783     case elfcpp::R_X86_64_PLT32:
1784       // Since we know this is a local symbol, we can handle this as a
1785       // PC32 reloc.
1786       break;
1787
1788     case elfcpp::R_X86_64_GOTPC32:
1789     case elfcpp::R_X86_64_GOTOFF64:
1790     case elfcpp::R_X86_64_GOTPC64:
1791     case elfcpp::R_X86_64_PLTOFF64:
1792       // We need a GOT section.
1793       target->got_section(symtab, layout);
1794       // For PLTOFF64, we'd normally want a PLT section, but since we
1795       // know this is a local symbol, no PLT is needed.
1796       break;
1797
1798     case elfcpp::R_X86_64_GOT64:
1799     case elfcpp::R_X86_64_GOT32:
1800     case elfcpp::R_X86_64_GOTPCREL64:
1801     case elfcpp::R_X86_64_GOTPCREL:
1802     case elfcpp::R_X86_64_GOTPLT64:
1803       {
1804         // The symbol requires a GOT entry.
1805         Output_data_got<64, false>* got = target->got_section(symtab, layout);
1806         unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1807
1808         // For a STT_GNU_IFUNC symbol we want the PLT offset.  That
1809         // lets function pointers compare correctly with shared
1810         // libraries.  Otherwise we would need an IRELATIVE reloc.
1811         bool is_new;
1812         if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1813           is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
1814         else
1815           is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1816         if (is_new)
1817           {
1818             // If we are generating a shared object, we need to add a
1819             // dynamic relocation for this symbol's GOT entry.
1820             if (parameters->options().output_is_position_independent())
1821               {
1822                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1823                 // R_X86_64_RELATIVE assumes a 64-bit relocation.
1824                 if (r_type != elfcpp::R_X86_64_GOT32)
1825                   {
1826                     unsigned int got_offset =
1827                       object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1828                     rela_dyn->add_local_relative(object, r_sym,
1829                                                  elfcpp::R_X86_64_RELATIVE,
1830                                                  got, got_offset, 0);
1831                   }
1832                 else
1833                   {
1834                     this->check_non_pic(object, r_type, NULL);
1835
1836                     gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
1837                     rela_dyn->add_local(
1838                         object, r_sym, r_type, got,
1839                         object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0);
1840                   }
1841               }
1842           }
1843         // For GOTPLT64, we'd normally want a PLT section, but since
1844         // we know this is a local symbol, no PLT is needed.
1845       }
1846       break;
1847
1848     case elfcpp::R_X86_64_COPY:
1849     case elfcpp::R_X86_64_GLOB_DAT:
1850     case elfcpp::R_X86_64_JUMP_SLOT:
1851     case elfcpp::R_X86_64_RELATIVE:
1852     case elfcpp::R_X86_64_IRELATIVE:
1853       // These are outstanding tls relocs, which are unexpected when linking
1854     case elfcpp::R_X86_64_TPOFF64:
1855     case elfcpp::R_X86_64_DTPMOD64:
1856     case elfcpp::R_X86_64_TLSDESC:
1857       gold_error(_("%s: unexpected reloc %u in object file"),
1858                  object->name().c_str(), r_type);
1859       break;
1860
1861       // These are initial tls relocs, which are expected when linking
1862     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
1863     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
1864     case elfcpp::R_X86_64_TLSDESC_CALL:
1865     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
1866     case elfcpp::R_X86_64_DTPOFF32:
1867     case elfcpp::R_X86_64_DTPOFF64:
1868     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
1869     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
1870       {
1871         bool output_is_shared = parameters->options().shared();
1872         const tls::Tls_optimization optimized_type
1873             = Target_x86_64::optimize_tls_reloc(!output_is_shared, r_type);
1874         switch (r_type)
1875           {
1876           case elfcpp::R_X86_64_TLSGD:       // General-dynamic
1877             if (optimized_type == tls::TLSOPT_NONE)
1878               {
1879                 // Create a pair of GOT entries for the module index and
1880                 // dtv-relative offset.
1881                 Output_data_got<64, false>* got
1882                     = target->got_section(symtab, layout);
1883                 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1884                 unsigned int shndx = lsym.get_st_shndx();
1885                 bool is_ordinary;
1886                 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1887                 if (!is_ordinary)
1888                   object->error(_("local symbol %u has bad shndx %u"),
1889                               r_sym, shndx);
1890                 else
1891                   got->add_local_pair_with_rela(object, r_sym,
1892                                                 shndx,
1893                                                 GOT_TYPE_TLS_PAIR,
1894                                                 target->rela_dyn_section(layout),
1895                                                 elfcpp::R_X86_64_DTPMOD64, 0);
1896               }
1897             else if (optimized_type != tls::TLSOPT_TO_LE)
1898               unsupported_reloc_local(object, r_type);
1899             break;
1900
1901           case elfcpp::R_X86_64_GOTPC32_TLSDESC:
1902             target->define_tls_base_symbol(symtab, layout);
1903             if (optimized_type == tls::TLSOPT_NONE)
1904               {
1905                 // Create reserved PLT and GOT entries for the resolver.
1906                 target->reserve_tlsdesc_entries(symtab, layout);
1907
1908                 // Generate a double GOT entry with an
1909                 // R_X86_64_TLSDESC reloc.  The R_X86_64_TLSDESC reloc
1910                 // is resolved lazily, so the GOT entry needs to be in
1911                 // an area in .got.plt, not .got.  Call got_section to
1912                 // make sure the section has been created.
1913                 target->got_section(symtab, layout);
1914                 Output_data_got<64, false>* got = target->got_tlsdesc_section();
1915                 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1916                 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
1917                   {
1918                     unsigned int got_offset = got->add_constant(0);
1919                     got->add_constant(0);
1920                     object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
1921                                                  got_offset);
1922                     Reloc_section* rt = target->rela_tlsdesc_section(layout);
1923                     // We store the arguments we need in a vector, and
1924                     // use the index into the vector as the parameter
1925                     // to pass to the target specific routines.
1926                     uintptr_t intarg = target->add_tlsdesc_info(object, r_sym);
1927                     void* arg = reinterpret_cast<void*>(intarg);
1928                     rt->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1929                                             got, got_offset, 0);
1930                   }
1931               }
1932             else if (optimized_type != tls::TLSOPT_TO_LE)
1933               unsupported_reloc_local(object, r_type);
1934             break;
1935
1936           case elfcpp::R_X86_64_TLSDESC_CALL:
1937             break;
1938
1939           case elfcpp::R_X86_64_TLSLD:       // Local-dynamic
1940             if (optimized_type == tls::TLSOPT_NONE)
1941               {
1942                 // Create a GOT entry for the module index.
1943                 target->got_mod_index_entry(symtab, layout, object);
1944               }
1945             else if (optimized_type != tls::TLSOPT_TO_LE)
1946               unsupported_reloc_local(object, r_type);
1947             break;
1948
1949           case elfcpp::R_X86_64_DTPOFF32:
1950           case elfcpp::R_X86_64_DTPOFF64:
1951             break;
1952
1953           case elfcpp::R_X86_64_GOTTPOFF:    // Initial-exec
1954             layout->set_has_static_tls();
1955             if (optimized_type == tls::TLSOPT_NONE)
1956               {
1957                 // Create a GOT entry for the tp-relative offset.
1958                 Output_data_got<64, false>* got
1959                     = target->got_section(symtab, layout);
1960                 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1961                 got->add_local_with_rela(object, r_sym, GOT_TYPE_TLS_OFFSET,
1962                                          target->rela_dyn_section(layout),
1963                                          elfcpp::R_X86_64_TPOFF64);
1964               }
1965             else if (optimized_type != tls::TLSOPT_TO_LE)
1966               unsupported_reloc_local(object, r_type);
1967             break;
1968
1969           case elfcpp::R_X86_64_TPOFF32:     // Local-exec
1970             layout->set_has_static_tls();
1971             if (output_is_shared)
1972               unsupported_reloc_local(object, r_type);
1973             break;
1974
1975           default:
1976             gold_unreachable();
1977           }
1978       }
1979       break;
1980
1981     case elfcpp::R_X86_64_SIZE32:
1982     case elfcpp::R_X86_64_SIZE64:
1983     default:
1984       gold_error(_("%s: unsupported reloc %u against local symbol"),
1985                  object->name().c_str(), r_type);
1986       break;
1987     }
1988 }
1989
1990
1991 // Report an unsupported relocation against a global symbol.
1992
1993 void
1994 Target_x86_64::Scan::unsupported_reloc_global(
1995     Sized_relobj_file<64, false>* object,
1996     unsigned int r_type,
1997     Symbol* gsym)
1998 {
1999   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
2000              object->name().c_str(), r_type, gsym->demangled_name().c_str());
2001 }
2002
2003 // Returns true if this relocation type could be that of a function pointer.
2004 inline bool
2005 Target_x86_64::Scan::possible_function_pointer_reloc(unsigned int r_type)
2006 {
2007   switch (r_type)
2008     {
2009     case elfcpp::R_X86_64_64:
2010     case elfcpp::R_X86_64_32:
2011     case elfcpp::R_X86_64_32S:
2012     case elfcpp::R_X86_64_16:
2013     case elfcpp::R_X86_64_8:
2014     case elfcpp::R_X86_64_GOT64:
2015     case elfcpp::R_X86_64_GOT32:
2016     case elfcpp::R_X86_64_GOTPCREL64:
2017     case elfcpp::R_X86_64_GOTPCREL:
2018     case elfcpp::R_X86_64_GOTPLT64:
2019       {
2020         return true;
2021       }
2022     }
2023   return false;
2024 }
2025
2026 // For safe ICF, scan a relocation for a local symbol to check if it
2027 // corresponds to a function pointer being taken.  In that case mark
2028 // the function whose pointer was taken as not foldable.
2029
2030 inline bool
2031 Target_x86_64::Scan::local_reloc_may_be_function_pointer(
2032   Symbol_table* ,
2033   Layout* ,
2034   Target_x86_64* ,
2035   Sized_relobj_file<64, false>* ,
2036   unsigned int ,
2037   Output_section* ,
2038   const elfcpp::Rela<64, false>& ,
2039   unsigned int r_type,
2040   const elfcpp::Sym<64, false>&)
2041 {
2042   // When building a shared library, do not fold any local symbols as it is
2043   // not possible to distinguish pointer taken versus a call by looking at
2044   // the relocation types.
2045   return (parameters->options().shared()
2046           || possible_function_pointer_reloc(r_type));
2047 }
2048
2049 // For safe ICF, scan a relocation for a global symbol to check if it
2050 // corresponds to a function pointer being taken.  In that case mark
2051 // the function whose pointer was taken as not foldable.
2052
2053 inline bool
2054 Target_x86_64::Scan::global_reloc_may_be_function_pointer(
2055   Symbol_table*,
2056   Layout* ,
2057   Target_x86_64* ,
2058   Sized_relobj_file<64, false>* ,
2059   unsigned int ,
2060   Output_section* ,
2061   const elfcpp::Rela<64, false>& ,
2062   unsigned int r_type,
2063   Symbol* gsym)
2064 {
2065   // When building a shared library, do not fold symbols whose visibility
2066   // is hidden, internal or protected.
2067   return ((parameters->options().shared()
2068            && (gsym->visibility() == elfcpp::STV_INTERNAL
2069                || gsym->visibility() == elfcpp::STV_PROTECTED
2070                || gsym->visibility() == elfcpp::STV_HIDDEN))
2071           || possible_function_pointer_reloc(r_type));
2072 }
2073
2074 // Scan a relocation for a global symbol.
2075
2076 inline void
2077 Target_x86_64::Scan::global(Symbol_table* symtab,
2078                             Layout* layout,
2079                             Target_x86_64* target,
2080                             Sized_relobj_file<64, false>* object,
2081                             unsigned int data_shndx,
2082                             Output_section* output_section,
2083                             const elfcpp::Rela<64, false>& reloc,
2084                             unsigned int r_type,
2085                             Symbol* gsym)
2086 {
2087   // A STT_GNU_IFUNC symbol may require a PLT entry.
2088   if (gsym->type() == elfcpp::STT_GNU_IFUNC
2089       && this->reloc_needs_plt_for_ifunc(object, r_type))
2090     target->make_plt_entry(symtab, layout, gsym);
2091
2092   switch (r_type)
2093     {
2094     case elfcpp::R_X86_64_NONE:
2095     case elfcpp::R_X86_64_GNU_VTINHERIT:
2096     case elfcpp::R_X86_64_GNU_VTENTRY:
2097       break;
2098
2099     case elfcpp::R_X86_64_64:
2100     case elfcpp::R_X86_64_32:
2101     case elfcpp::R_X86_64_32S:
2102     case elfcpp::R_X86_64_16:
2103     case elfcpp::R_X86_64_8:
2104       {
2105         // Make a PLT entry if necessary.
2106         if (gsym->needs_plt_entry())
2107           {
2108             target->make_plt_entry(symtab, layout, gsym);
2109             // Since this is not a PC-relative relocation, we may be
2110             // taking the address of a function. In that case we need to
2111             // set the entry in the dynamic symbol table to the address of
2112             // the PLT entry.
2113             if (gsym->is_from_dynobj() && !parameters->options().shared())
2114               gsym->set_needs_dynsym_value();
2115           }
2116         // Make a dynamic relocation if necessary.
2117         if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2118           {
2119             if (gsym->may_need_copy_reloc())
2120               {
2121                 target->copy_reloc(symtab, layout, object,
2122                                    data_shndx, output_section, gsym, reloc);
2123               }
2124             else if (r_type == elfcpp::R_X86_64_64
2125                      && gsym->type() == elfcpp::STT_GNU_IFUNC
2126                      && gsym->can_use_relative_reloc(false)
2127                      && !gsym->is_from_dynobj()
2128                      && !gsym->is_undefined()
2129                      && !gsym->is_preemptible())
2130               {
2131                 // Use an IRELATIVE reloc for a locally defined
2132                 // STT_GNU_IFUNC symbol.  This makes a function
2133                 // address in a PIE executable match the address in a
2134                 // shared library that it links against.
2135                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2136                 unsigned int r_type = elfcpp::R_X86_64_IRELATIVE;
2137                 rela_dyn->add_symbolless_global_addend(gsym, r_type,
2138                                                        output_section, object,
2139                                                        data_shndx,
2140                                                        reloc.get_r_offset(),
2141                                                        reloc.get_r_addend());
2142               }
2143             else if (r_type == elfcpp::R_X86_64_64
2144                      && gsym->can_use_relative_reloc(false))
2145               {
2146                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2147                 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
2148                                               output_section, object,
2149                                               data_shndx,
2150                                               reloc.get_r_offset(),
2151                                               reloc.get_r_addend());
2152               }
2153             else
2154               {
2155                 this->check_non_pic(object, r_type, gsym);
2156                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2157                 rela_dyn->add_global(gsym, r_type, output_section, object,
2158                                      data_shndx, reloc.get_r_offset(),
2159                                      reloc.get_r_addend());
2160               }
2161           }
2162       }
2163       break;
2164
2165     case elfcpp::R_X86_64_PC64:
2166     case elfcpp::R_X86_64_PC32:
2167     case elfcpp::R_X86_64_PC16:
2168     case elfcpp::R_X86_64_PC8:
2169       {
2170         // Make a PLT entry if necessary.
2171         if (gsym->needs_plt_entry())
2172           target->make_plt_entry(symtab, layout, gsym);
2173         // Make a dynamic relocation if necessary.
2174         if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2175           {
2176             if (gsym->may_need_copy_reloc())
2177               {
2178                 target->copy_reloc(symtab, layout, object,
2179                                    data_shndx, output_section, gsym, reloc);
2180               }
2181             else
2182               {
2183                 this->check_non_pic(object, r_type, gsym);
2184                 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2185                 rela_dyn->add_global(gsym, r_type, output_section, object,
2186                                      data_shndx, reloc.get_r_offset(),
2187                                      reloc.get_r_addend());
2188               }
2189           }
2190       }
2191       break;
2192
2193     case elfcpp::R_X86_64_GOT64:
2194     case elfcpp::R_X86_64_GOT32:
2195     case elfcpp::R_X86_64_GOTPCREL64:
2196     case elfcpp::R_X86_64_GOTPCREL:
2197     case elfcpp::R_X86_64_GOTPLT64:
2198       {
2199         // The symbol requires a GOT entry.
2200         Output_data_got<64, false>* got = target->got_section(symtab, layout);
2201         if (gsym->final_value_is_known())
2202           {
2203             // For a STT_GNU_IFUNC symbol we want the PLT address.
2204             if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2205               got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2206             else
2207               got->add_global(gsym, GOT_TYPE_STANDARD);
2208           }
2209         else
2210           {
2211             // If this symbol is not fully resolved, we need to add a
2212             // dynamic relocation for it.
2213             Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2214             if (gsym->is_from_dynobj()
2215                 || gsym->is_undefined()
2216                 || gsym->is_preemptible()
2217                 || (gsym->type() == elfcpp::STT_GNU_IFUNC
2218                     && parameters->options().output_is_position_independent()))
2219               got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
2220                                         elfcpp::R_X86_64_GLOB_DAT);
2221             else
2222               {
2223                 // For a STT_GNU_IFUNC symbol we want to write the PLT
2224                 // offset into the GOT, so that function pointer
2225                 // comparisons work correctly.
2226                 bool is_new;
2227                 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2228                   is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2229                 else
2230                   {
2231                     is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2232                     // Tell the dynamic linker to use the PLT address
2233                     // when resolving relocations.
2234                     if (gsym->is_from_dynobj()
2235                         && !parameters->options().shared())
2236                       gsym->set_needs_dynsym_value();
2237                   }
2238                 if (is_new)
2239                   {
2240                     unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2241                     rela_dyn->add_global_relative(gsym,
2242                                                   elfcpp::R_X86_64_RELATIVE,
2243                                                   got, got_off, 0);
2244                   }
2245               }
2246           }
2247         // For GOTPLT64, we also need a PLT entry (but only if the
2248         // symbol is not fully resolved).
2249         if (r_type == elfcpp::R_X86_64_GOTPLT64
2250             && !gsym->final_value_is_known())
2251           target->make_plt_entry(symtab, layout, gsym);
2252       }
2253       break;
2254
2255     case elfcpp::R_X86_64_PLT32:
2256       // If the symbol is fully resolved, this is just a PC32 reloc.
2257       // Otherwise we need a PLT entry.
2258       if (gsym->final_value_is_known())
2259         break;
2260       // If building a shared library, we can also skip the PLT entry
2261       // if the symbol is defined in the output file and is protected
2262       // or hidden.
2263       if (gsym->is_defined()
2264           && !gsym->is_from_dynobj()
2265           && !gsym->is_preemptible())
2266         break;
2267       target->make_plt_entry(symtab, layout, gsym);
2268       break;
2269
2270     case elfcpp::R_X86_64_GOTPC32:
2271     case elfcpp::R_X86_64_GOTOFF64:
2272     case elfcpp::R_X86_64_GOTPC64:
2273     case elfcpp::R_X86_64_PLTOFF64:
2274       // We need a GOT section.
2275       target->got_section(symtab, layout);
2276       // For PLTOFF64, we also need a PLT entry (but only if the
2277       // symbol is not fully resolved).
2278       if (r_type == elfcpp::R_X86_64_PLTOFF64
2279           && !gsym->final_value_is_known())
2280         target->make_plt_entry(symtab, layout, gsym);
2281       break;
2282
2283     case elfcpp::R_X86_64_COPY:
2284     case elfcpp::R_X86_64_GLOB_DAT:
2285     case elfcpp::R_X86_64_JUMP_SLOT:
2286     case elfcpp::R_X86_64_RELATIVE:
2287     case elfcpp::R_X86_64_IRELATIVE:
2288       // These are outstanding tls relocs, which are unexpected when linking
2289     case elfcpp::R_X86_64_TPOFF64:
2290     case elfcpp::R_X86_64_DTPMOD64:
2291     case elfcpp::R_X86_64_TLSDESC:
2292       gold_error(_("%s: unexpected reloc %u in object file"),
2293                  object->name().c_str(), r_type);
2294       break;
2295
2296       // These are initial tls relocs, which are expected for global()
2297     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
2298     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
2299     case elfcpp::R_X86_64_TLSDESC_CALL:
2300     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
2301     case elfcpp::R_X86_64_DTPOFF32:
2302     case elfcpp::R_X86_64_DTPOFF64:
2303     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
2304     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
2305       {
2306         const bool is_final = gsym->final_value_is_known();
2307         const tls::Tls_optimization optimized_type
2308             = Target_x86_64::optimize_tls_reloc(is_final, r_type);
2309         switch (r_type)
2310           {
2311           case elfcpp::R_X86_64_TLSGD:       // General-dynamic
2312             if (optimized_type == tls::TLSOPT_NONE)
2313               {
2314                 // Create a pair of GOT entries for the module index and
2315                 // dtv-relative offset.
2316                 Output_data_got<64, false>* got
2317                     = target->got_section(symtab, layout);
2318                 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_PAIR,
2319                                                target->rela_dyn_section(layout),
2320                                                elfcpp::R_X86_64_DTPMOD64,
2321                                                elfcpp::R_X86_64_DTPOFF64);
2322               }
2323             else if (optimized_type == tls::TLSOPT_TO_IE)
2324               {
2325                 // Create a GOT entry for the tp-relative offset.
2326                 Output_data_got<64, false>* got
2327                     = target->got_section(symtab, layout);
2328                 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2329                                           target->rela_dyn_section(layout),
2330                                           elfcpp::R_X86_64_TPOFF64);
2331               }
2332             else if (optimized_type != tls::TLSOPT_TO_LE)
2333               unsupported_reloc_global(object, r_type, gsym);
2334             break;
2335
2336           case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2337             target->define_tls_base_symbol(symtab, layout);
2338             if (optimized_type == tls::TLSOPT_NONE)
2339               {
2340                 // Create reserved PLT and GOT entries for the resolver.
2341                 target->reserve_tlsdesc_entries(symtab, layout);
2342
2343                 // Create a double GOT entry with an R_X86_64_TLSDESC
2344                 // reloc.  The R_X86_64_TLSDESC reloc is resolved
2345                 // lazily, so the GOT entry needs to be in an area in
2346                 // .got.plt, not .got.  Call got_section to make sure
2347                 // the section has been created.
2348                 target->got_section(symtab, layout);
2349                 Output_data_got<64, false>* got = target->got_tlsdesc_section();
2350                 Reloc_section* rt = target->rela_tlsdesc_section(layout);
2351                 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_DESC, rt,
2352                                                elfcpp::R_X86_64_TLSDESC, 0);
2353               }
2354             else if (optimized_type == tls::TLSOPT_TO_IE)
2355               {
2356                 // Create a GOT entry for the tp-relative offset.
2357                 Output_data_got<64, false>* got
2358                     = target->got_section(symtab, layout);
2359                 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2360                                           target->rela_dyn_section(layout),
2361                                           elfcpp::R_X86_64_TPOFF64);
2362               }
2363             else if (optimized_type != tls::TLSOPT_TO_LE)
2364               unsupported_reloc_global(object, r_type, gsym);
2365             break;
2366
2367           case elfcpp::R_X86_64_TLSDESC_CALL:
2368             break;
2369
2370           case elfcpp::R_X86_64_TLSLD:       // Local-dynamic
2371             if (optimized_type == tls::TLSOPT_NONE)
2372               {
2373                 // Create a GOT entry for the module index.
2374                 target->got_mod_index_entry(symtab, layout, object);
2375               }
2376             else if (optimized_type != tls::TLSOPT_TO_LE)
2377               unsupported_reloc_global(object, r_type, gsym);
2378             break;
2379
2380           case elfcpp::R_X86_64_DTPOFF32:
2381           case elfcpp::R_X86_64_DTPOFF64:
2382             break;
2383
2384           case elfcpp::R_X86_64_GOTTPOFF:    // Initial-exec
2385             layout->set_has_static_tls();
2386             if (optimized_type == tls::TLSOPT_NONE)
2387               {
2388                 // Create a GOT entry for the tp-relative offset.
2389                 Output_data_got<64, false>* got
2390                     = target->got_section(symtab, layout);
2391                 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2392                                           target->rela_dyn_section(layout),
2393                                           elfcpp::R_X86_64_TPOFF64);
2394               }
2395             else if (optimized_type != tls::TLSOPT_TO_LE)
2396               unsupported_reloc_global(object, r_type, gsym);
2397             break;
2398
2399           case elfcpp::R_X86_64_TPOFF32:     // Local-exec
2400             layout->set_has_static_tls();
2401             if (parameters->options().shared())
2402               unsupported_reloc_local(object, r_type);
2403             break;
2404
2405           default:
2406             gold_unreachable();
2407           }
2408       }
2409       break;
2410
2411     case elfcpp::R_X86_64_SIZE32:
2412     case elfcpp::R_X86_64_SIZE64:
2413     default:
2414       gold_error(_("%s: unsupported reloc %u against global symbol %s"),
2415                  object->name().c_str(), r_type,
2416                  gsym->demangled_name().c_str());
2417       break;
2418     }
2419 }
2420
2421 void
2422 Target_x86_64::gc_process_relocs(Symbol_table* symtab,
2423                                  Layout* layout,
2424                                  Sized_relobj_file<64, false>* object,
2425                                  unsigned int data_shndx,
2426                                  unsigned int sh_type,
2427                                  const unsigned char* prelocs,
2428                                  size_t reloc_count,
2429                                  Output_section* output_section,
2430                                  bool needs_special_offset_handling,
2431                                  size_t local_symbol_count,
2432                                  const unsigned char* plocal_symbols)
2433 {
2434
2435   if (sh_type == elfcpp::SHT_REL)
2436     {
2437       return;
2438     }
2439
2440    gold::gc_process_relocs<64, false, Target_x86_64, elfcpp::SHT_RELA,
2441                            Target_x86_64::Scan,
2442                            Target_x86_64::Relocatable_size_for_reloc>(
2443     symtab,
2444     layout,
2445     this,
2446     object,
2447     data_shndx,
2448     prelocs,
2449     reloc_count,
2450     output_section,
2451     needs_special_offset_handling,
2452     local_symbol_count,
2453     plocal_symbols);
2454
2455 }
2456 // Scan relocations for a section.
2457
2458 void
2459 Target_x86_64::scan_relocs(Symbol_table* symtab,
2460                            Layout* layout,
2461                            Sized_relobj_file<64, false>* object,
2462                            unsigned int data_shndx,
2463                            unsigned int sh_type,
2464                            const unsigned char* prelocs,
2465                            size_t reloc_count,
2466                            Output_section* output_section,
2467                            bool needs_special_offset_handling,
2468                            size_t local_symbol_count,
2469                            const unsigned char* plocal_symbols)
2470 {
2471   if (sh_type == elfcpp::SHT_REL)
2472     {
2473       gold_error(_("%s: unsupported REL reloc section"),
2474                  object->name().c_str());
2475       return;
2476     }
2477
2478   gold::scan_relocs<64, false, Target_x86_64, elfcpp::SHT_RELA,
2479       Target_x86_64::Scan>(
2480     symtab,
2481     layout,
2482     this,
2483     object,
2484     data_shndx,
2485     prelocs,
2486     reloc_count,
2487     output_section,
2488     needs_special_offset_handling,
2489     local_symbol_count,
2490     plocal_symbols);
2491 }
2492
2493 // Finalize the sections.
2494
2495 void
2496 Target_x86_64::do_finalize_sections(
2497     Layout* layout,
2498     const Input_objects*,
2499     Symbol_table* symtab)
2500 {
2501   const Reloc_section* rel_plt = (this->plt_ == NULL
2502                                   ? NULL
2503                                   : this->plt_->rela_plt());
2504   layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt,
2505                                   this->rela_dyn_, true, false);
2506
2507   // Fill in some more dynamic tags.
2508   Output_data_dynamic* const odyn = layout->dynamic_data();
2509   if (odyn != NULL)
2510     {
2511       if (this->plt_ != NULL
2512           && this->plt_->output_section() != NULL
2513           && this->plt_->has_tlsdesc_entry())
2514         {
2515           unsigned int plt_offset = this->plt_->get_tlsdesc_plt_offset();
2516           unsigned int got_offset = this->plt_->get_tlsdesc_got_offset();
2517           this->got_->finalize_data_size();
2518           odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT,
2519                                         this->plt_, plt_offset);
2520           odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT,
2521                                         this->got_, got_offset);
2522         }
2523     }
2524
2525   // Emit any relocs we saved in an attempt to avoid generating COPY
2526   // relocs.
2527   if (this->copy_relocs_.any_saved_relocs())
2528     this->copy_relocs_.emit(this->rela_dyn_section(layout));
2529
2530   // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
2531   // the .got.plt section.
2532   Symbol* sym = this->global_offset_table_;
2533   if (sym != NULL)
2534     {
2535       uint64_t data_size = this->got_plt_->current_data_size();
2536       symtab->get_sized_symbol<64>(sym)->set_symsize(data_size);
2537     }
2538 }
2539
2540 // Perform a relocation.
2541
2542 inline bool
2543 Target_x86_64::Relocate::relocate(const Relocate_info<64, false>* relinfo,
2544                                   Target_x86_64* target,
2545                                   Output_section*,
2546                                   size_t relnum,
2547                                   const elfcpp::Rela<64, false>& rela,
2548                                   unsigned int r_type,
2549                                   const Sized_symbol<64>* gsym,
2550                                   const Symbol_value<64>* psymval,
2551                                   unsigned char* view,
2552                                   elfcpp::Elf_types<64>::Elf_Addr address,
2553                                   section_size_type view_size)
2554 {
2555   if (this->skip_call_tls_get_addr_)
2556     {
2557       if ((r_type != elfcpp::R_X86_64_PLT32
2558            && r_type != elfcpp::R_X86_64_PC32)
2559           || gsym == NULL
2560           || strcmp(gsym->name(), "__tls_get_addr") != 0)
2561         {
2562           gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2563                                  _("missing expected TLS relocation"));
2564         }
2565       else
2566         {
2567           this->skip_call_tls_get_addr_ = false;
2568           return false;
2569         }
2570     }
2571
2572   const Sized_relobj_file<64, false>* object = relinfo->object;
2573
2574   // Pick the value to use for symbols defined in the PLT.
2575   Symbol_value<64> symval;
2576   if (gsym != NULL
2577       && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
2578     {
2579       symval.set_output_value(target->plt_section()->address()
2580                               + gsym->plt_offset());
2581       psymval = &symval;
2582     }
2583   else if (gsym == NULL && psymval->is_ifunc_symbol())
2584     {
2585       unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2586       if (object->local_has_plt_offset(r_sym))
2587         {
2588           symval.set_output_value(target->plt_section()->address()
2589                                   + object->local_plt_offset(r_sym));
2590           psymval = &symval;
2591         }
2592     }
2593
2594   const elfcpp::Elf_Xword addend = rela.get_r_addend();
2595
2596   // Get the GOT offset if needed.
2597   // The GOT pointer points to the end of the GOT section.
2598   // We need to subtract the size of the GOT section to get
2599   // the actual offset to use in the relocation.
2600   bool have_got_offset = false;
2601   unsigned int got_offset = 0;
2602   switch (r_type)
2603     {
2604     case elfcpp::R_X86_64_GOT32:
2605     case elfcpp::R_X86_64_GOT64:
2606     case elfcpp::R_X86_64_GOTPLT64:
2607     case elfcpp::R_X86_64_GOTPCREL:
2608     case elfcpp::R_X86_64_GOTPCREL64:
2609       if (gsym != NULL)
2610         {
2611           gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2612           got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size();
2613         }
2614       else
2615         {
2616           unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2617           gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2618           got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
2619                         - target->got_size());
2620         }
2621       have_got_offset = true;
2622       break;
2623
2624     default:
2625       break;
2626     }
2627
2628   switch (r_type)
2629     {
2630     case elfcpp::R_X86_64_NONE:
2631     case elfcpp::R_X86_64_GNU_VTINHERIT:
2632     case elfcpp::R_X86_64_GNU_VTENTRY:
2633       break;
2634
2635     case elfcpp::R_X86_64_64:
2636       Relocate_functions<64, false>::rela64(view, object, psymval, addend);
2637       break;
2638
2639     case elfcpp::R_X86_64_PC64:
2640       Relocate_functions<64, false>::pcrela64(view, object, psymval, addend,
2641                                               address);
2642       break;
2643
2644     case elfcpp::R_X86_64_32:
2645       // FIXME: we need to verify that value + addend fits into 32 bits:
2646       //    uint64_t x = value + addend;
2647       //    x == static_cast<uint64_t>(static_cast<uint32_t>(x))
2648       // Likewise for other <=32-bit relocations (but see R_X86_64_32S).
2649       Relocate_functions<64, false>::rela32(view, object, psymval, addend);
2650       break;
2651
2652     case elfcpp::R_X86_64_32S:
2653       // FIXME: we need to verify that value + addend fits into 32 bits:
2654       //    int64_t x = value + addend;   // note this quantity is signed!
2655       //    x == static_cast<int64_t>(static_cast<int32_t>(x))
2656       Relocate_functions<64, false>::rela32(view, object, psymval, addend);
2657       break;
2658
2659     case elfcpp::R_X86_64_PC32:
2660       Relocate_functions<64, false>::pcrela32(view, object, psymval, addend,
2661                                               address);
2662       break;
2663
2664     case elfcpp::R_X86_64_16:
2665       Relocate_functions<64, false>::rela16(view, object, psymval, addend);
2666       break;
2667
2668     case elfcpp::R_X86_64_PC16:
2669       Relocate_functions<64, false>::pcrela16(view, object, psymval, addend,
2670                                               address);
2671       break;
2672
2673     case elfcpp::R_X86_64_8:
2674       Relocate_functions<64, false>::rela8(view, object, psymval, addend);
2675       break;
2676
2677     case elfcpp::R_X86_64_PC8:
2678       Relocate_functions<64, false>::pcrela8(view, object, psymval, addend,
2679                                              address);
2680       break;
2681
2682     case elfcpp::R_X86_64_PLT32:
2683       gold_assert(gsym == NULL
2684                   || gsym->has_plt_offset()
2685                   || gsym->final_value_is_known()
2686                   || (gsym->is_defined()
2687                       && !gsym->is_from_dynobj()
2688                       && !gsym->is_preemptible()));
2689       // Note: while this code looks the same as for R_X86_64_PC32, it
2690       // behaves differently because psymval was set to point to
2691       // the PLT entry, rather than the symbol, in Scan::global().
2692       Relocate_functions<64, false>::pcrela32(view, object, psymval, addend,
2693                                               address);
2694       break;
2695
2696     case elfcpp::R_X86_64_PLTOFF64:
2697       {
2698         gold_assert(gsym);
2699         gold_assert(gsym->has_plt_offset()
2700                     || gsym->final_value_is_known());
2701         elfcpp::Elf_types<64>::Elf_Addr got_address;
2702         got_address = target->got_section(NULL, NULL)->address();
2703         Relocate_functions<64, false>::rela64(view, object, psymval,
2704                                               addend - got_address);
2705       }
2706
2707     case elfcpp::R_X86_64_GOT32:
2708       gold_assert(have_got_offset);
2709       Relocate_functions<64, false>::rela32(view, got_offset, addend);
2710       break;
2711
2712     case elfcpp::R_X86_64_GOTPC32:
2713       {
2714         gold_assert(gsym);
2715         elfcpp::Elf_types<64>::Elf_Addr value;
2716         value = target->got_plt_section()->address();
2717         Relocate_functions<64, false>::pcrela32(view, value, addend, address);
2718       }
2719       break;
2720
2721     case elfcpp::R_X86_64_GOT64:
2722       // The ABI doc says "Like GOT64, but indicates a PLT entry is needed."
2723       // Since we always add a PLT entry, this is equivalent.
2724     case elfcpp::R_X86_64_GOTPLT64:
2725       gold_assert(have_got_offset);
2726       Relocate_functions<64, false>::rela64(view, got_offset, addend);
2727       break;
2728
2729     case elfcpp::R_X86_64_GOTPC64:
2730       {
2731         gold_assert(gsym);
2732         elfcpp::Elf_types<64>::Elf_Addr value;
2733         value = target->got_plt_section()->address();
2734         Relocate_functions<64, false>::pcrela64(view, value, addend, address);
2735       }
2736       break;
2737
2738     case elfcpp::R_X86_64_GOTOFF64:
2739       {
2740         elfcpp::Elf_types<64>::Elf_Addr value;
2741         value = (psymval->value(object, 0)
2742                  - target->got_plt_section()->address());
2743         Relocate_functions<64, false>::rela64(view, value, addend);
2744       }
2745       break;
2746
2747     case elfcpp::R_X86_64_GOTPCREL:
2748       {
2749         gold_assert(have_got_offset);
2750         elfcpp::Elf_types<64>::Elf_Addr value;
2751         value = target->got_plt_section()->address() + got_offset;
2752         Relocate_functions<64, false>::pcrela32(view, value, addend, address);
2753       }
2754       break;
2755
2756     case elfcpp::R_X86_64_GOTPCREL64:
2757       {
2758         gold_assert(have_got_offset);
2759         elfcpp::Elf_types<64>::Elf_Addr value;
2760         value = target->got_plt_section()->address() + got_offset;
2761         Relocate_functions<64, false>::pcrela64(view, value, addend, address);
2762       }
2763       break;
2764
2765     case elfcpp::R_X86_64_COPY:
2766     case elfcpp::R_X86_64_GLOB_DAT:
2767     case elfcpp::R_X86_64_JUMP_SLOT:
2768     case elfcpp::R_X86_64_RELATIVE:
2769     case elfcpp::R_X86_64_IRELATIVE:
2770       // These are outstanding tls relocs, which are unexpected when linking
2771     case elfcpp::R_X86_64_TPOFF64:
2772     case elfcpp::R_X86_64_DTPMOD64:
2773     case elfcpp::R_X86_64_TLSDESC:
2774       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2775                              _("unexpected reloc %u in object file"),
2776                              r_type);
2777       break;
2778
2779       // These are initial tls relocs, which are expected when linking
2780     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
2781     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
2782     case elfcpp::R_X86_64_TLSDESC_CALL:
2783     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
2784     case elfcpp::R_X86_64_DTPOFF32:
2785     case elfcpp::R_X86_64_DTPOFF64:
2786     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
2787     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
2788       this->relocate_tls(relinfo, target, relnum, rela, r_type, gsym, psymval,
2789                          view, address, view_size);
2790       break;
2791
2792     case elfcpp::R_X86_64_SIZE32:
2793     case elfcpp::R_X86_64_SIZE64:
2794     default:
2795       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2796                              _("unsupported reloc %u"),
2797                              r_type);
2798       break;
2799     }
2800
2801   return true;
2802 }
2803
2804 // Perform a TLS relocation.
2805
2806 inline void
2807 Target_x86_64::Relocate::relocate_tls(const Relocate_info<64, false>* relinfo,
2808                                       Target_x86_64* target,
2809                                       size_t relnum,
2810                                       const elfcpp::Rela<64, false>& rela,
2811                                       unsigned int r_type,
2812                                       const Sized_symbol<64>* gsym,
2813                                       const Symbol_value<64>* psymval,
2814                                       unsigned char* view,
2815                                       elfcpp::Elf_types<64>::Elf_Addr address,
2816                                       section_size_type view_size)
2817 {
2818   Output_segment* tls_segment = relinfo->layout->tls_segment();
2819
2820   const Sized_relobj_file<64, false>* object = relinfo->object;
2821   const elfcpp::Elf_Xword addend = rela.get_r_addend();
2822   elfcpp::Shdr<64, false> data_shdr(relinfo->data_shdr);
2823   bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0;
2824
2825   elfcpp::Elf_types<64>::Elf_Addr value = psymval->value(relinfo->object, 0);
2826
2827   const bool is_final = (gsym == NULL
2828                          ? !parameters->options().shared()
2829                          : gsym->final_value_is_known());
2830   tls::Tls_optimization optimized_type
2831       = Target_x86_64::optimize_tls_reloc(is_final, r_type);
2832   switch (r_type)
2833     {
2834     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
2835       if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2836         {
2837           // If this code sequence is used in a non-executable section,
2838           // we will not optimize the R_X86_64_DTPOFF32/64 relocation,
2839           // on the assumption that it's being used by itself in a debug
2840           // section.  Therefore, in the unlikely event that the code
2841           // sequence appears in a non-executable section, we simply
2842           // leave it unoptimized.
2843           optimized_type = tls::TLSOPT_NONE;
2844         }
2845       if (optimized_type == tls::TLSOPT_TO_LE)
2846         {
2847           gold_assert(tls_segment != NULL);
2848           this->tls_gd_to_le(relinfo, relnum, tls_segment,
2849                              rela, r_type, value, view,
2850                              view_size);
2851           break;
2852         }
2853       else
2854         {
2855           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2856                                    ? GOT_TYPE_TLS_OFFSET
2857                                    : GOT_TYPE_TLS_PAIR);
2858           unsigned int got_offset;
2859           if (gsym != NULL)
2860             {
2861               gold_assert(gsym->has_got_offset(got_type));
2862               got_offset = gsym->got_offset(got_type) - target->got_size();
2863             }
2864           else
2865             {
2866               unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2867               gold_assert(object->local_has_got_offset(r_sym, got_type));
2868               got_offset = (object->local_got_offset(r_sym, got_type)
2869                             - target->got_size());
2870             }
2871           if (optimized_type == tls::TLSOPT_TO_IE)
2872             {
2873               gold_assert(tls_segment != NULL);
2874               value = target->got_plt_section()->address() + got_offset;
2875               this->tls_gd_to_ie(relinfo, relnum, tls_segment, rela, r_type,
2876                                  value, view, address, view_size);
2877               break;
2878             }
2879           else if (optimized_type == tls::TLSOPT_NONE)
2880             {
2881               // Relocate the field with the offset of the pair of GOT
2882               // entries.
2883               value = target->got_plt_section()->address() + got_offset;
2884               Relocate_functions<64, false>::pcrela32(view, value, addend,
2885                                                       address);
2886               break;
2887             }
2888         }
2889       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2890                              _("unsupported reloc %u"), r_type);
2891       break;
2892
2893     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
2894     case elfcpp::R_X86_64_TLSDESC_CALL:
2895       if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2896         {
2897           // See above comment for R_X86_64_TLSGD.
2898           optimized_type = tls::TLSOPT_NONE;
2899         }
2900       if (optimized_type == tls::TLSOPT_TO_LE)
2901         {
2902           gold_assert(tls_segment != NULL);
2903           this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
2904                                   rela, r_type, value, view,
2905                                   view_size);
2906           break;
2907         }
2908       else
2909         {
2910           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2911                                    ? GOT_TYPE_TLS_OFFSET
2912                                    : GOT_TYPE_TLS_DESC);
2913           unsigned int got_offset = 0;
2914           if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC
2915               && optimized_type == tls::TLSOPT_NONE)
2916             {
2917               // We created GOT entries in the .got.tlsdesc portion of
2918               // the .got.plt section, but the offset stored in the
2919               // symbol is the offset within .got.tlsdesc.
2920               got_offset = (target->got_size()
2921                             + target->got_plt_section()->data_size());
2922             }
2923           if (gsym != NULL)
2924             {
2925               gold_assert(gsym->has_got_offset(got_type));
2926               got_offset += gsym->got_offset(got_type) - target->got_size();
2927             }
2928           else
2929             {
2930               unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2931               gold_assert(object->local_has_got_offset(r_sym, got_type));
2932               got_offset += (object->local_got_offset(r_sym, got_type)
2933                              - target->got_size());
2934             }
2935           if (optimized_type == tls::TLSOPT_TO_IE)
2936             {
2937               gold_assert(tls_segment != NULL);
2938               value = target->got_plt_section()->address() + got_offset;
2939               this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment,
2940                                       rela, r_type, value, view, address,
2941                                       view_size);
2942               break;
2943             }
2944           else if (optimized_type == tls::TLSOPT_NONE)
2945             {
2946               if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
2947                 {
2948                   // Relocate the field with the offset of the pair of GOT
2949                   // entries.
2950                   value = target->got_plt_section()->address() + got_offset;
2951                   Relocate_functions<64, false>::pcrela32(view, value, addend,
2952                                                           address);
2953                 }
2954               break;
2955             }
2956         }
2957       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2958                              _("unsupported reloc %u"), r_type);
2959       break;
2960
2961     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
2962       if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2963         {
2964           // See above comment for R_X86_64_TLSGD.
2965           optimized_type = tls::TLSOPT_NONE;
2966         }
2967       if (optimized_type == tls::TLSOPT_TO_LE)
2968         {
2969           gold_assert(tls_segment != NULL);
2970           this->tls_ld_to_le(relinfo, relnum, tls_segment, rela, r_type,
2971                              value, view, view_size);
2972           break;
2973         }
2974       else if (optimized_type == tls::TLSOPT_NONE)
2975         {
2976           // Relocate the field with the offset of the GOT entry for
2977           // the module index.
2978           unsigned int got_offset;
2979           got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
2980                         - target->got_size());
2981           value = target->got_plt_section()->address() + got_offset;
2982           Relocate_functions<64, false>::pcrela32(view, value, addend,
2983                                                   address);
2984           break;
2985         }
2986       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2987                              _("unsupported reloc %u"), r_type);
2988       break;
2989
2990     case elfcpp::R_X86_64_DTPOFF32:
2991       // This relocation type is used in debugging information.
2992       // In that case we need to not optimize the value.  If the
2993       // section is not executable, then we assume we should not
2994       // optimize this reloc.  See comments above for R_X86_64_TLSGD,
2995       // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
2996       // R_X86_64_TLSLD.
2997       if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
2998         {
2999           gold_assert(tls_segment != NULL);
3000           value -= tls_segment->memsz();
3001         }
3002       Relocate_functions<64, false>::rela32(view, value, addend);
3003       break;
3004
3005     case elfcpp::R_X86_64_DTPOFF64:
3006       // See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
3007       if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3008         {
3009           gold_assert(tls_segment != NULL);
3010           value -= tls_segment->memsz();
3011         }
3012       Relocate_functions<64, false>::rela64(view, value, addend);
3013       break;
3014
3015     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
3016       if (optimized_type == tls::TLSOPT_TO_LE)
3017         {
3018           gold_assert(tls_segment != NULL);
3019           Target_x86_64::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3020                                                 rela, r_type, value, view,
3021                                                 view_size);
3022           break;
3023         }
3024       else if (optimized_type == tls::TLSOPT_NONE)
3025         {
3026           // Relocate the field with the offset of the GOT entry for
3027           // the tp-relative offset of the symbol.
3028           unsigned int got_offset;
3029           if (gsym != NULL)
3030             {
3031               gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3032               got_offset = (gsym->got_offset(GOT_TYPE_TLS_OFFSET)
3033                             - target->got_size());
3034             }
3035           else
3036             {
3037               unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
3038               gold_assert(object->local_has_got_offset(r_sym,
3039                                                        GOT_TYPE_TLS_OFFSET));
3040               got_offset = (object->local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)
3041                             - target->got_size());
3042             }
3043           value = target->got_plt_section()->address() + got_offset;
3044           Relocate_functions<64, false>::pcrela32(view, value, addend, address);
3045           break;
3046         }
3047       gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3048                              _("unsupported reloc type %u"),
3049                              r_type);
3050       break;
3051
3052     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
3053       value -= tls_segment->memsz();
3054       Relocate_functions<64, false>::rela32(view, value, addend);
3055       break;
3056     }
3057 }
3058
3059 // Do a relocation in which we convert a TLS General-Dynamic to an
3060 // Initial-Exec.
3061
3062 inline void
3063 Target_x86_64::Relocate::tls_gd_to_ie(const Relocate_info<64, false>* relinfo,
3064                                       size_t relnum,
3065                                       Output_segment*,
3066                                       const elfcpp::Rela<64, false>& rela,
3067                                       unsigned int,
3068                                       elfcpp::Elf_types<64>::Elf_Addr value,
3069                                       unsigned char* view,
3070                                       elfcpp::Elf_types<64>::Elf_Addr address,
3071                                       section_size_type view_size)
3072 {
3073   // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3074   // .word 0x6666; rex64; call __tls_get_addr
3075   // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax
3076
3077   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -4);
3078   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
3079
3080   tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3081                  (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3082   tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3083                  (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
3084
3085   memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0", 16);
3086
3087   const elfcpp::Elf_Xword addend = rela.get_r_addend();
3088   Relocate_functions<64, false>::pcrela32(view + 8, value, addend - 8, address);
3089
3090   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3091   // We can skip it.
3092   this->skip_call_tls_get_addr_ = true;
3093 }
3094
3095 // Do a relocation in which we convert a TLS General-Dynamic to a
3096 // Local-Exec.
3097
3098 inline void
3099 Target_x86_64::Relocate::tls_gd_to_le(const Relocate_info<64, false>* relinfo,
3100                                       size_t relnum,
3101                                       Output_segment* tls_segment,
3102                                       const elfcpp::Rela<64, false>& rela,
3103                                       unsigned int,
3104                                       elfcpp::Elf_types<64>::Elf_Addr value,
3105                                       unsigned char* view,
3106                                       section_size_type view_size)
3107 {
3108   // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3109   // .word 0x6666; rex64; call __tls_get_addr
3110   // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax
3111
3112   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -4);
3113   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
3114
3115   tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3116                  (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3117   tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3118                  (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
3119
3120   memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0", 16);
3121
3122   value -= tls_segment->memsz();
3123   Relocate_functions<64, false>::rela32(view + 8, value, 0);
3124
3125   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3126   // We can skip it.
3127   this->skip_call_tls_get_addr_ = true;
3128 }
3129
3130 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
3131
3132 inline void
3133 Target_x86_64::Relocate::tls_desc_gd_to_ie(
3134     const Relocate_info<64, false>* relinfo,
3135     size_t relnum,
3136     Output_segment*,
3137     const elfcpp::Rela<64, false>& rela,
3138     unsigned int r_type,
3139     elfcpp::Elf_types<64>::Elf_Addr value,
3140     unsigned char* view,
3141     elfcpp::Elf_types<64>::Elf_Addr address,
3142     section_size_type view_size)
3143 {
3144   if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3145     {
3146       // leaq foo@tlsdesc(%rip), %rax
3147       // ==> movq foo@gottpoff(%rip), %rax
3148       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3149       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3150       tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3151                      view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3152       view[-2] = 0x8b;
3153       const elfcpp::Elf_Xword addend = rela.get_r_addend();
3154       Relocate_functions<64, false>::pcrela32(view, value, addend, address);
3155     }
3156   else
3157     {
3158       // call *foo@tlscall(%rax)
3159       // ==> nop; nop
3160       gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3161       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3162       tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3163                      view[0] == 0xff && view[1] == 0x10);
3164       view[0] = 0x66;
3165       view[1] = 0x90;
3166     }
3167 }
3168
3169 // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
3170
3171 inline void
3172 Target_x86_64::Relocate::tls_desc_gd_to_le(
3173     const Relocate_info<64, false>* relinfo,
3174     size_t relnum,
3175     Output_segment* tls_segment,
3176     const elfcpp::Rela<64, false>& rela,
3177     unsigned int r_type,
3178     elfcpp::Elf_types<64>::Elf_Addr value,
3179     unsigned char* view,
3180     section_size_type view_size)
3181 {
3182   if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3183     {
3184       // leaq foo@tlsdesc(%rip), %rax
3185       // ==> movq foo@tpoff, %rax
3186       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3187       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3188       tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3189                      view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3190       view[-2] = 0xc7;
3191       view[-1] = 0xc0;
3192       value -= tls_segment->memsz();
3193       Relocate_functions<64, false>::rela32(view, value, 0);
3194     }
3195   else
3196     {
3197       // call *foo@tlscall(%rax)
3198       // ==> nop; nop
3199       gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3200       tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3201       tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3202                      view[0] == 0xff && view[1] == 0x10);
3203       view[0] = 0x66;
3204       view[1] = 0x90;
3205     }
3206 }
3207
3208 inline void
3209 Target_x86_64::Relocate::tls_ld_to_le(const Relocate_info<64, false>* relinfo,
3210                                       size_t relnum,
3211                                       Output_segment*,
3212                                       const elfcpp::Rela<64, false>& rela,
3213                                       unsigned int,
3214                                       elfcpp::Elf_types<64>::Elf_Addr,
3215                                       unsigned char* view,
3216                                       section_size_type view_size)
3217 {
3218   // leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt;
3219   // ... leq foo@dtpoff(%rax),%reg
3220   // ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx
3221
3222   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3223   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 9);
3224
3225   tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3226                  view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x3d);
3227
3228   tls::check_tls(relinfo, relnum, rela.get_r_offset(), view[4] == 0xe8);
3229
3230   memcpy(view - 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12);
3231
3232   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3233   // We can skip it.
3234   this->skip_call_tls_get_addr_ = true;
3235 }
3236
3237 // Do a relocation in which we convert a TLS Initial-Exec to a
3238 // Local-Exec.
3239
3240 inline void
3241 Target_x86_64::Relocate::tls_ie_to_le(const Relocate_info<64, false>* relinfo,
3242                                       size_t relnum,
3243                                       Output_segment* tls_segment,
3244                                       const elfcpp::Rela<64, false>& rela,
3245                                       unsigned int,
3246                                       elfcpp::Elf_types<64>::Elf_Addr value,
3247                                       unsigned char* view,
3248                                       section_size_type view_size)
3249 {
3250   // We need to examine the opcodes to figure out which instruction we
3251   // are looking at.
3252
3253   // movq foo@gottpoff(%rip),%reg  ==>  movq $YY,%reg
3254   // addq foo@gottpoff(%rip),%reg  ==>  addq $YY,%reg
3255
3256   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3257   tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3258
3259   unsigned char op1 = view[-3];
3260   unsigned char op2 = view[-2];
3261   unsigned char op3 = view[-1];
3262   unsigned char reg = op3 >> 3;
3263
3264   if (op2 == 0x8b)
3265     {
3266       // movq
3267       if (op1 == 0x4c)
3268         view[-3] = 0x49;
3269       view[-2] = 0xc7;
3270       view[-1] = 0xc0 | reg;
3271     }
3272   else if (reg == 4)
3273     {
3274       // Special handling for %rsp.
3275       if (op1 == 0x4c)
3276         view[-3] = 0x49;
3277       view[-2] = 0x81;
3278       view[-1] = 0xc0 | reg;
3279     }
3280   else
3281     {
3282       // addq
3283       if (op1 == 0x4c)
3284         view[-3] = 0x4d;
3285       view[-2] = 0x8d;
3286       view[-1] = 0x80 | reg | (reg << 3);
3287     }
3288
3289   value -= tls_segment->memsz();
3290   Relocate_functions<64, false>::rela32(view, value, 0);
3291 }
3292
3293 // Relocate section data.
3294
3295 void
3296 Target_x86_64::relocate_section(
3297     const Relocate_info<64, false>* relinfo,
3298     unsigned int sh_type,
3299     const unsigned char* prelocs,
3300     size_t reloc_count,
3301     Output_section* output_section,
3302     bool needs_special_offset_handling,
3303     unsigned char* view,
3304     elfcpp::Elf_types<64>::Elf_Addr address,
3305     section_size_type view_size,
3306     const Reloc_symbol_changes* reloc_symbol_changes)
3307 {
3308   gold_assert(sh_type == elfcpp::SHT_RELA);
3309
3310   gold::relocate_section<64, false, Target_x86_64, elfcpp::SHT_RELA,
3311                          Target_x86_64::Relocate>(
3312     relinfo,
3313     this,
3314     prelocs,
3315     reloc_count,
3316     output_section,
3317     needs_special_offset_handling,
3318     view,
3319     address,
3320     view_size,
3321     reloc_symbol_changes);
3322 }
3323
3324 // Apply an incremental relocation.  Incremental relocations always refer
3325 // to global symbols.
3326
3327 void
3328 Target_x86_64::apply_relocation(
3329     const Relocate_info<64, false>* relinfo,
3330     elfcpp::Elf_types<64>::Elf_Addr r_offset,
3331     unsigned int r_type,
3332     elfcpp::Elf_types<64>::Elf_Swxword r_addend,
3333     const Symbol* gsym,
3334     unsigned char* view,
3335     elfcpp::Elf_types<64>::Elf_Addr address,
3336     section_size_type view_size)
3337 {
3338   gold::apply_relocation<64, false, Target_x86_64, Target_x86_64::Relocate>(
3339     relinfo,
3340     this,
3341     r_offset,
3342     r_type,
3343     r_addend,
3344     gsym,
3345     view,
3346     address,
3347     view_size);
3348 }
3349
3350 // Return the size of a relocation while scanning during a relocatable
3351 // link.
3352
3353 unsigned int
3354 Target_x86_64::Relocatable_size_for_reloc::get_size_for_reloc(
3355     unsigned int r_type,
3356     Relobj* object)
3357 {
3358   switch (r_type)
3359     {
3360     case elfcpp::R_X86_64_NONE:
3361     case elfcpp::R_X86_64_GNU_VTINHERIT:
3362     case elfcpp::R_X86_64_GNU_VTENTRY:
3363     case elfcpp::R_X86_64_TLSGD:            // Global-dynamic
3364     case elfcpp::R_X86_64_GOTPC32_TLSDESC:  // Global-dynamic (from ~oliva url)
3365     case elfcpp::R_X86_64_TLSDESC_CALL:
3366     case elfcpp::R_X86_64_TLSLD:            // Local-dynamic
3367     case elfcpp::R_X86_64_DTPOFF32:
3368     case elfcpp::R_X86_64_DTPOFF64:
3369     case elfcpp::R_X86_64_GOTTPOFF:         // Initial-exec
3370     case elfcpp::R_X86_64_TPOFF32:          // Local-exec
3371       return 0;
3372
3373     case elfcpp::R_X86_64_64:
3374     case elfcpp::R_X86_64_PC64:
3375     case elfcpp::R_X86_64_GOTOFF64:
3376     case elfcpp::R_X86_64_GOTPC64:
3377     case elfcpp::R_X86_64_PLTOFF64:
3378     case elfcpp::R_X86_64_GOT64:
3379     case elfcpp::R_X86_64_GOTPCREL64:
3380     case elfcpp::R_X86_64_GOTPCREL:
3381     case elfcpp::R_X86_64_GOTPLT64:
3382       return 8;
3383
3384     case elfcpp::R_X86_64_32:
3385     case elfcpp::R_X86_64_32S:
3386     case elfcpp::R_X86_64_PC32:
3387     case elfcpp::R_X86_64_PLT32:
3388     case elfcpp::R_X86_64_GOTPC32:
3389     case elfcpp::R_X86_64_GOT32:
3390       return 4;
3391
3392     case elfcpp::R_X86_64_16:
3393     case elfcpp::R_X86_64_PC16:
3394       return 2;
3395
3396     case elfcpp::R_X86_64_8:
3397     case elfcpp::R_X86_64_PC8:
3398       return 1;
3399
3400     case elfcpp::R_X86_64_COPY:
3401     case elfcpp::R_X86_64_GLOB_DAT:
3402     case elfcpp::R_X86_64_JUMP_SLOT:
3403     case elfcpp::R_X86_64_RELATIVE:
3404     case elfcpp::R_X86_64_IRELATIVE:
3405       // These are outstanding tls relocs, which are unexpected when linking
3406     case elfcpp::R_X86_64_TPOFF64:
3407     case elfcpp::R_X86_64_DTPMOD64:
3408     case elfcpp::R_X86_64_TLSDESC:
3409       object->error(_("unexpected reloc %u in object file"), r_type);
3410       return 0;
3411
3412     case elfcpp::R_X86_64_SIZE32:
3413     case elfcpp::R_X86_64_SIZE64:
3414     default:
3415       object->error(_("unsupported reloc %u against local symbol"), r_type);
3416       return 0;
3417     }
3418 }
3419
3420 // Scan the relocs during a relocatable link.
3421
3422 void
3423 Target_x86_64::scan_relocatable_relocs(Symbol_table* symtab,
3424                                        Layout* layout,
3425                                        Sized_relobj_file<64, false>* object,
3426                                        unsigned int data_shndx,
3427                                        unsigned int sh_type,
3428                                        const unsigned char* prelocs,
3429                                        size_t reloc_count,
3430                                        Output_section* output_section,
3431                                        bool needs_special_offset_handling,
3432                                        size_t local_symbol_count,
3433                                        const unsigned char* plocal_symbols,
3434                                        Relocatable_relocs* rr)
3435 {
3436   gold_assert(sh_type == elfcpp::SHT_RELA);
3437
3438   typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
3439     Relocatable_size_for_reloc> Scan_relocatable_relocs;
3440
3441   gold::scan_relocatable_relocs<64, false, elfcpp::SHT_RELA,
3442       Scan_relocatable_relocs>(
3443     symtab,
3444     layout,
3445     object,
3446     data_shndx,
3447     prelocs,
3448     reloc_count,
3449     output_section,
3450     needs_special_offset_handling,
3451     local_symbol_count,
3452     plocal_symbols,
3453     rr);
3454 }
3455
3456 // Relocate a section during a relocatable link.
3457
3458 void
3459 Target_x86_64::relocate_for_relocatable(
3460     const Relocate_info<64, false>* relinfo,
3461     unsigned int sh_type,
3462     const unsigned char* prelocs,
3463     size_t reloc_count,
3464     Output_section* output_section,
3465     off_t offset_in_output_section,
3466     const Relocatable_relocs* rr,
3467     unsigned char* view,
3468     elfcpp::Elf_types<64>::Elf_Addr view_address,
3469     section_size_type view_size,
3470     unsigned char* reloc_view,
3471     section_size_type reloc_view_size)
3472 {
3473   gold_assert(sh_type == elfcpp::SHT_RELA);
3474
3475   gold::relocate_for_relocatable<64, false, elfcpp::SHT_RELA>(
3476     relinfo,
3477     prelocs,
3478     reloc_count,
3479     output_section,
3480     offset_in_output_section,
3481     rr,
3482     view,
3483     view_address,
3484     view_size,
3485     reloc_view,
3486     reloc_view_size);
3487 }
3488
3489 // Return the value to use for a dynamic which requires special
3490 // treatment.  This is how we support equality comparisons of function
3491 // pointers across shared library boundaries, as described in the
3492 // processor specific ABI supplement.
3493
3494 uint64_t
3495 Target_x86_64::do_dynsym_value(const Symbol* gsym) const
3496 {
3497   gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3498   return this->plt_section()->address() + gsym->plt_offset();
3499 }
3500
3501 // Return a string used to fill a code section with nops to take up
3502 // the specified length.
3503
3504 std::string
3505 Target_x86_64::do_code_fill(section_size_type length) const
3506 {
3507   if (length >= 16)
3508     {
3509       // Build a jmpq instruction to skip over the bytes.
3510       unsigned char jmp[5];
3511       jmp[0] = 0xe9;
3512       elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
3513       return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
3514               + std::string(length - 5, '\0'));
3515     }
3516
3517   // Nop sequences of various lengths.
3518   const char nop1[1] = { 0x90 };                   // nop
3519   const char nop2[2] = { 0x66, 0x90 };             // xchg %ax %ax
3520   const char nop3[3] = { 0x0f, 0x1f, 0x00 };       // nop (%rax)
3521   const char nop4[4] = { 0x0f, 0x1f, 0x40, 0x00};  // nop 0(%rax)
3522   const char nop5[5] = { 0x0f, 0x1f, 0x44, 0x00,   // nop 0(%rax,%rax,1)
3523                          0x00 };
3524   const char nop6[6] = { 0x66, 0x0f, 0x1f, 0x44,   // nopw 0(%rax,%rax,1)
3525                          0x00, 0x00 };
3526   const char nop7[7] = { 0x0f, 0x1f, 0x80, 0x00,   // nopl 0L(%rax)
3527                          0x00, 0x00, 0x00 };
3528   const char nop8[8] = { 0x0f, 0x1f, 0x84, 0x00,   // nopl 0L(%rax,%rax,1)
3529                          0x00, 0x00, 0x00, 0x00 };
3530   const char nop9[9] = { 0x66, 0x0f, 0x1f, 0x84,   // nopw 0L(%rax,%rax,1)
3531                          0x00, 0x00, 0x00, 0x00,
3532                          0x00 };
3533   const char nop10[10] = { 0x66, 0x2e, 0x0f, 0x1f, // nopw %cs:0L(%rax,%rax,1)
3534                            0x84, 0x00, 0x00, 0x00,
3535                            0x00, 0x00 };
3536   const char nop11[11] = { 0x66, 0x66, 0x2e, 0x0f, // data16
3537                            0x1f, 0x84, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
3538                            0x00, 0x00, 0x00 };
3539   const char nop12[12] = { 0x66, 0x66, 0x66, 0x2e, // data16; data16
3540                            0x0f, 0x1f, 0x84, 0x00, // nopw %cs:0L(%rax,%rax,1)
3541                            0x00, 0x00, 0x00, 0x00 };
3542   const char nop13[13] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3543                            0x2e, 0x0f, 0x1f, 0x84, // nopw %cs:0L(%rax,%rax,1)
3544                            0x00, 0x00, 0x00, 0x00,
3545                            0x00 };
3546   const char nop14[14] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3547                            0x66, 0x2e, 0x0f, 0x1f, // data16
3548                            0x84, 0x00, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
3549                            0x00, 0x00 };
3550   const char nop15[15] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3551                            0x66, 0x66, 0x2e, 0x0f, // data16; data16
3552                            0x1f, 0x84, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
3553                            0x00, 0x00, 0x00 };
3554
3555   const char* nops[16] = {
3556     NULL,
3557     nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3558     nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3559   };
3560
3561   return std::string(nops[length], length);
3562 }
3563
3564 // Return the addend to use for a target specific relocation.  The
3565 // only target specific relocation is R_X86_64_TLSDESC for a local
3566 // symbol.  We want to set the addend is the offset of the local
3567 // symbol in the TLS segment.
3568
3569 uint64_t
3570 Target_x86_64::do_reloc_addend(void* arg, unsigned int r_type,
3571                                uint64_t) const
3572 {
3573   gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
3574   uintptr_t intarg = reinterpret_cast<uintptr_t>(arg);
3575   gold_assert(intarg < this->tlsdesc_reloc_info_.size());
3576   const Tlsdesc_info& ti(this->tlsdesc_reloc_info_[intarg]);
3577   const Symbol_value<64>* psymval = ti.object->local_symbol(ti.r_sym);
3578   gold_assert(psymval->is_tls_symbol());
3579   // The value of a TLS symbol is the offset in the TLS segment.
3580   return psymval->value(ti.object, 0);
3581 }
3582
3583 // FNOFFSET in section SHNDX in OBJECT is the start of a function
3584 // compiled with -fsplit-stack.  The function calls non-split-stack
3585 // code.  We have to change the function so that it always ensures
3586 // that it has enough stack space to run some random function.
3587
3588 void
3589 Target_x86_64::do_calls_non_split(Relobj* object, unsigned int shndx,
3590                                   section_offset_type fnoffset,
3591                                   section_size_type fnsize,
3592                                   unsigned char* view,
3593                                   section_size_type view_size,
3594                                   std::string* from,
3595                                   std::string* to) const
3596 {
3597   // The function starts with a comparison of the stack pointer and a
3598   // field in the TCB.  This is followed by a jump.
3599
3600   // cmp %fs:NN,%rsp
3601   if (this->match_view(view, view_size, fnoffset, "\x64\x48\x3b\x24\x25", 5)
3602       && fnsize > 9)
3603     {
3604       // We will call __morestack if the carry flag is set after this
3605       // comparison.  We turn the comparison into an stc instruction
3606       // and some nops.
3607       view[fnoffset] = '\xf9';
3608       this->set_view_to_nop(view, view_size, fnoffset + 1, 8);
3609     }
3610   // lea NN(%rsp),%r10
3611   // lea NN(%rsp),%r11
3612   else if ((this->match_view(view, view_size, fnoffset,
3613                              "\x4c\x8d\x94\x24", 4)
3614             || this->match_view(view, view_size, fnoffset,
3615                                 "\x4c\x8d\x9c\x24", 4))
3616            && fnsize > 8)
3617     {
3618       // This is loading an offset from the stack pointer for a
3619       // comparison.  The offset is negative, so we decrease the
3620       // offset by the amount of space we need for the stack.  This
3621       // means we will avoid calling __morestack if there happens to
3622       // be plenty of space on the stack already.
3623       unsigned char* pval = view + fnoffset + 4;
3624       uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
3625       val -= parameters->options().split_stack_adjust_size();
3626       elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
3627     }
3628   else
3629     {
3630       if (!object->has_no_split_stack())
3631         object->error(_("failed to match split-stack sequence at "
3632                         "section %u offset %0zx"),
3633                       shndx, static_cast<size_t>(fnoffset));
3634       return;
3635     }
3636
3637   // We have to change the function so that it calls
3638   // __morestack_non_split instead of __morestack.  The former will
3639   // allocate additional stack space.
3640   *from = "__morestack";
3641   *to = "__morestack_non_split";
3642 }
3643
3644 // The selector for x86_64 object files.
3645
3646 class Target_selector_x86_64 : public Target_selector_freebsd
3647 {
3648 public:
3649   Target_selector_x86_64()
3650     : Target_selector_freebsd(elfcpp::EM_X86_64, 64, false, "elf64-x86-64",
3651                               "elf64-x86-64-freebsd", "elf_x86_64")
3652   { }
3653
3654   Target*
3655   do_instantiate_target()
3656   { return new Target_x86_64(); }
3657
3658 };
3659
3660 Target_selector_x86_64 target_selector_x86_64;
3661
3662 } // End anonymous namespace.