Subversion Repositories openrisc

// x86_64.cc -- x86_64 target support for gold.

// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.

// Written by Ian Lance Taylor <iant@google.com>.

// This file is part of gold.

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

// MA 02110-1301, USA.

#include "gold.h"

#include <cstring>

#include "elfcpp.h"

#include "parameters.h"

#include "reloc.h"

#include "x86_64.h"

#include "object.h"

#include "symtab.h"

#include "layout.h"

#include "output.h"

#include "copy-relocs.h"

#include "target.h"

#include "target-reloc.h"

#include "target-select.h"

#include "tls.h"

#include "freebsd.h"

#include "gc.h"

namespace

{

using namespace gold;

class Output_data_plt_x86_64;

// The x86_64 target class.

// See the ABI at

//   http://www.x86-64.org/documentation/abi.pdf

// TLS info comes from

//   http://people.redhat.com/drepper/tls.pdf

//   http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt

class Target_x86_64 : public Target_freebsd<64, false>

{

 public:

  // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures

  // uses only Elf64_Rela relocation entries with explicit addends."

  typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;

  Target_x86_64()

    : Target_freebsd<64, false>(&x86_64_info),

      got_(NULL), plt_(NULL), got_plt_(NULL), rela_dyn_(NULL),

      copy_relocs_(elfcpp::R_X86_64_COPY), dynbss_(NULL),

      got_mod_index_offset_(-1U), tls_base_symbol_defined_(false)

  { }

  // Hook for a new output section.

  void

  do_new_output_section(Output_section*) const;

  // Scan the relocations to look for symbol adjustments.

  void

  gc_process_relocs(const General_options& options,

                    Symbol_table* symtab,

                    Layout* layout,

                    Sized_relobj<64, false>* object,

                    unsigned int data_shndx,

                    unsigned int sh_type,

                    const unsigned char* prelocs,

                    size_t reloc_count,

                    Output_section* output_section,

                    bool needs_special_offset_handling,

                    size_t local_symbol_count,

                    const unsigned char* plocal_symbols);

  // Scan the relocations to look for symbol adjustments.

  void

  scan_relocs(const General_options& options,

              Symbol_table* symtab,

              Layout* layout,

              Sized_relobj<64, false>* object,

              unsigned int data_shndx,

              unsigned int sh_type,

              const unsigned char* prelocs,

              size_t reloc_count,

              Output_section* output_section,

              bool needs_special_offset_handling,

              size_t local_symbol_count,

              const unsigned char* plocal_symbols);

  // Finalize the sections.

  void

  do_finalize_sections(Layout*);

  // Return the value to use for a dynamic which requires special

  // treatment.

  uint64_t

  do_dynsym_value(const Symbol*) const;

  // Relocate a section.

  void

  relocate_section(const Relocate_info<64, false>*,

                   unsigned int sh_type,

                   const unsigned char* prelocs,

                   size_t reloc_count,

                   Output_section* output_section,

                   bool needs_special_offset_handling,

                   unsigned char* view,

                   elfcpp::Elf_types<64>::Elf_Addr view_address,

                   section_size_type view_size,

                   const Reloc_symbol_changes*);

  // Scan the relocs during a relocatable link.

  void

  scan_relocatable_relocs(const General_options& options,

                          Symbol_table* symtab,

                          Layout* layout,

                          Sized_relobj<64, false>* object,

                          unsigned int data_shndx,

                          unsigned int sh_type,

                          const unsigned char* prelocs,

                          size_t reloc_count,

                          Output_section* output_section,

                          bool needs_special_offset_handling,

                          size_t local_symbol_count,

                          const unsigned char* plocal_symbols,

                          Relocatable_relocs*);

  // Relocate a section during a relocatable link.

  void

  relocate_for_relocatable(const Relocate_info<64, false>*,

                           unsigned int sh_type,

                           const unsigned char* prelocs,

                           size_t reloc_count,

                           Output_section* output_section,

                           off_t offset_in_output_section,

                           const Relocatable_relocs*,

                           unsigned char* view,

                           elfcpp::Elf_types<64>::Elf_Addr view_address,

                           section_size_type view_size,

                           unsigned char* reloc_view,

                           section_size_type reloc_view_size);

  // Return a string used to fill a code section with nops.

  std::string

  do_code_fill(section_size_type length) const;

  // Return whether SYM is defined by the ABI.

  bool

  do_is_defined_by_abi(const Symbol* sym) const

  { return strcmp(sym->name(), "__tls_get_addr") == 0; }

  // Adjust -fstack-split code which calls non-stack-split code.

  void

  do_calls_non_split(Relobj* object, unsigned int shndx,

                     section_offset_type fnoffset, section_size_type fnsize,

                     unsigned char* view, section_size_type view_size,

                     std::string* from, std::string* to) const;

  // Return the size of the GOT section.

  section_size_type

  got_size()

  {

    gold_assert(this->got_ != NULL);

    return this->got_->data_size();

  }

 private:

  // The class which scans relocations.

  class Scan

  {

  public:

    Scan()

      : issued_non_pic_error_(false)

    { }

    inline void

    local(const General_options& options, Symbol_table* symtab,

          Layout* layout, Target_x86_64* target,

          Sized_relobj<64, false>* object,

          unsigned int data_shndx,

          Output_section* output_section,

          const elfcpp::Rela<64, false>& reloc, unsigned int r_type,

          const elfcpp::Sym<64, false>& lsym);

    inline void

    global(const General_options& options, Symbol_table* symtab,

           Layout* layout, Target_x86_64* target,

           Sized_relobj<64, false>* object,

           unsigned int data_shndx,

           Output_section* output_section,

           const elfcpp::Rela<64, false>& reloc, unsigned int r_type,

           Symbol* gsym);

  private:

    static void

    unsupported_reloc_local(Sized_relobj<64, false>*, unsigned int r_type);

    static void

    unsupported_reloc_global(Sized_relobj<64, false>*, unsigned int r_type,

                             Symbol*);

    void

    check_non_pic(Relobj*, unsigned int r_type);

    // Whether we have issued an error about a non-PIC compilation.

    bool issued_non_pic_error_;

  };

  // The class which implements relocation.

  class Relocate

  {

   public:

    Relocate()

      : skip_call_tls_get_addr_(false), saw_tls_block_reloc_(false)

    { }

    ~Relocate()

    {

      if (this->skip_call_tls_get_addr_)

        {

          // FIXME: This needs to specify the location somehow.

          gold_error(_("missing expected TLS relocation"));

        }

    }

    // Do a relocation.  Return false if the caller should not issue

    // any warnings about this relocation.

    inline bool

    relocate(const Relocate_info<64, false>*, Target_x86_64*, Output_section*,

             size_t relnum, const elfcpp::Rela<64, false>&,

             unsigned int r_type, const Sized_symbol<64>*,

             const Symbol_value<64>*,

             unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,

             section_size_type);

   private:

    // Do a TLS relocation.

    inline void

    relocate_tls(const Relocate_info<64, false>*, Target_x86_64*,

                 size_t relnum, const elfcpp::Rela<64, false>&,

                 unsigned int r_type, const Sized_symbol<64>*,

                 const Symbol_value<64>*,

                 unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,

                 section_size_type);

    // Do a TLS General-Dynamic to Initial-Exec transition.

    inline void

    tls_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,

                 Output_segment* tls_segment,

                 const elfcpp::Rela<64, false>&, unsigned int r_type,

                 elfcpp::Elf_types<64>::Elf_Addr value,

                 unsigned char* view,

                 elfcpp::Elf_types<64>::Elf_Addr,

                 section_size_type view_size);

    // Do a TLS General-Dynamic to Local-Exec transition.

    inline void

    tls_gd_to_le(const Relocate_info<64, false>*, size_t relnum,

                 Output_segment* tls_segment,

                 const elfcpp::Rela<64, false>&, unsigned int r_type,

                 elfcpp::Elf_types<64>::Elf_Addr value,

                 unsigned char* view,

                 section_size_type view_size);

    // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.

    inline void

    tls_desc_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,

                      Output_segment* tls_segment,

                      const elfcpp::Rela<64, false>&, unsigned int r_type,

                      elfcpp::Elf_types<64>::Elf_Addr value,

                      unsigned char* view,

                      elfcpp::Elf_types<64>::Elf_Addr,

                      section_size_type view_size);

    // Do a TLSDESC-style General-Dynamic to Local-Exec transition.

    inline void

    tls_desc_gd_to_le(const Relocate_info<64, false>*, size_t relnum,

                      Output_segment* tls_segment,

                      const elfcpp::Rela<64, false>&, unsigned int r_type,

                      elfcpp::Elf_types<64>::Elf_Addr value,

                      unsigned char* view,

                      section_size_type view_size);

    // Do a TLS Local-Dynamic to Local-Exec transition.

    inline void

    tls_ld_to_le(const Relocate_info<64, false>*, size_t relnum,

                 Output_segment* tls_segment,

                 const elfcpp::Rela<64, false>&, unsigned int r_type,

                 elfcpp::Elf_types<64>::Elf_Addr value,

                 unsigned char* view,

                 section_size_type view_size);

    // Do a TLS Initial-Exec to Local-Exec transition.

    static inline void

    tls_ie_to_le(const Relocate_info<64, false>*, size_t relnum,

                 Output_segment* tls_segment,

                 const elfcpp::Rela<64, false>&, unsigned int r_type,

                 elfcpp::Elf_types<64>::Elf_Addr value,

                 unsigned char* view,

                 section_size_type view_size);

    // This is set if we should skip the next reloc, which should be a

    // PLT32 reloc against ___tls_get_addr.

    bool skip_call_tls_get_addr_;

    // This is set if we see a relocation which could load the address

    // of the TLS block.  Whether we see such a relocation determines

    // how we handle the R_X86_64_DTPOFF32 relocation, which is used

    // in debugging sections.

    bool saw_tls_block_reloc_;

  };

  // A class which returns the size required for a relocation type,

  // used while scanning relocs during a relocatable link.

  class Relocatable_size_for_reloc

  {

   public:

    unsigned int

    get_size_for_reloc(unsigned int, Relobj*);

  };

  // Adjust TLS relocation type based on the options and whether this

  // is a local symbol.

  static tls::Tls_optimization

  optimize_tls_reloc(bool is_final, int r_type);

  // Get the GOT section, creating it if necessary.

  Output_data_got<64, false>*

  got_section(Symbol_table*, Layout*);

  // Get the GOT PLT section.

  Output_data_space*

  got_plt_section() const

  {

    gold_assert(this->got_plt_ != NULL);

    return this->got_plt_;

  }

  // Create the PLT section.

  void

  make_plt_section(Symbol_table* symtab, Layout* layout);

  // Create a PLT entry for a global symbol.

  void

  make_plt_entry(Symbol_table*, Layout*, Symbol*);

  // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.

  void

  define_tls_base_symbol(Symbol_table*, Layout*);

  // Create the reserved PLT and GOT entries for the TLS descriptor resolver.

  void

  reserve_tlsdesc_entries(Symbol_table* symtab, Layout* layout);

  // Create a GOT entry for the TLS module index.

  unsigned int

  got_mod_index_entry(Symbol_table* symtab, Layout* layout,

                      Sized_relobj<64, false>* object);

  // Get the PLT section.

  Output_data_plt_x86_64*

  plt_section() const

  {

    gold_assert(this->plt_ != NULL);

    return this->plt_;

  }

  // Get the dynamic reloc section, creating it if necessary.

  Reloc_section*

  rela_dyn_section(Layout*);

  // Add a potential copy relocation.

  void

  copy_reloc(Symbol_table* symtab, Layout* layout,

             Sized_relobj<64, false>* object,

             unsigned int shndx, Output_section* output_section,

             Symbol* sym, const elfcpp::Rela<64, false>& reloc)

  {

    this->copy_relocs_.copy_reloc(symtab, layout,

                                  symtab->get_sized_symbol<64>(sym),

                                  object, shndx, output_section,

                                  reloc, this->rela_dyn_section(layout));

  }

  // Information about this specific target which we pass to the

  // general Target structure.

  static const Target::Target_info x86_64_info;

  enum Got_type

  {

    GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol

    GOT_TYPE_TLS_OFFSET = 1,    // GOT entry for TLS offset

    GOT_TYPE_TLS_PAIR = 2,      // GOT entry for TLS module/offset pair

    GOT_TYPE_TLS_DESC = 3       // GOT entry for TLS_DESC pair

  };

  // The GOT section.

  Output_data_got<64, false>* got_;

  // The PLT section.

  Output_data_plt_x86_64* plt_;

  // The GOT PLT section.

  Output_data_space* got_plt_;

  // The dynamic reloc section.

  Reloc_section* rela_dyn_;

  // Relocs saved to avoid a COPY reloc.

  Copy_relocs<elfcpp::SHT_RELA, 64, false> copy_relocs_;

  // Space for variables copied with a COPY reloc.

  Output_data_space* dynbss_;

  // Offset of the GOT entry for the TLS module index.

  unsigned int got_mod_index_offset_;

  // True if the _TLS_MODULE_BASE_ symbol has been defined.

  bool tls_base_symbol_defined_;

};

const Target::Target_info Target_x86_64::x86_64_info =

{

  64,                   // size

  false,                // is_big_endian

  elfcpp::EM_X86_64,    // machine_code

  false,                // has_make_symbol

  false,                // has_resolve

  true,                 // has_code_fill

  true,                 // is_default_stack_executable

  '\0',                 // wrap_char

  "/lib/ld64.so.1",     // program interpreter

  0x400000,             // default_text_segment_address

  0x1000,               // abi_pagesize (overridable by -z max-page-size)

  0x1000,               // common_pagesize (overridable by -z common-page-size)

  elfcpp::SHN_UNDEF,    // small_common_shndx

  elfcpp::SHN_X86_64_LCOMMON,   // large_common_shndx

  0,                     // small_common_section_flags

  elfcpp::SHF_X86_64_LARGE      // large_common_section_flags

};

// This is called when a new output section is created.  This is where

// we handle the SHF_X86_64_LARGE.

void

Target_x86_64::do_new_output_section(Output_section *os) const

{

  if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)

    os->set_is_large_section();

}

// Get the GOT section, creating it if necessary.

Output_data_got<64, false>*

Target_x86_64::got_section(Symbol_table* symtab, Layout* layout)

{

  if (this->got_ == NULL)

    {

      gold_assert(symtab != NULL && layout != NULL);

      this->got_ = new Output_data_got<64, false>();

      Output_section* os;

      os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,

                                           (elfcpp::SHF_ALLOC

                                            | elfcpp::SHF_WRITE),

                                           this->got_, false);

      os->set_is_relro();

      // The old GNU linker creates a .got.plt section.  We just

      // create another set of data in the .got section.  Note that we

      // always create a PLT if we create a GOT, although the PLT

      // might be empty.

      this->got_plt_ = new Output_data_space(8, "** GOT PLT");

      os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,

                                           (elfcpp::SHF_ALLOC

                                            | elfcpp::SHF_WRITE),

                                           this->got_plt_, false);

      os->set_is_relro();

      // The first three entries are reserved.

      this->got_plt_->set_current_data_size(3 * 8);

      // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.

      symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,

                                    this->got_plt_,

                                    0, 0, elfcpp::STT_OBJECT,

                                    elfcpp::STB_LOCAL,

                                    elfcpp::STV_HIDDEN, 0,

                                    false, false);

    }

  return this->got_;

}

// Get the dynamic reloc section, creating it if necessary.

Target_x86_64::Reloc_section*

Target_x86_64::rela_dyn_section(Layout* layout)

{

  if (this->rela_dyn_ == NULL)

    {

      gold_assert(layout != NULL);

      this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());

      layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,

                                      elfcpp::SHF_ALLOC, this->rela_dyn_, true);

    }

  return this->rela_dyn_;

}

// A class to handle the PLT data.

class Output_data_plt_x86_64 : public Output_section_data

{

 public:

  typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;

  Output_data_plt_x86_64(Layout*, Output_data_got<64, false>*,

                         Output_data_space*);

  // Add an entry to the PLT.

  void

  add_entry(Symbol* gsym);

  // Add the reserved TLSDESC_PLT entry to the PLT.

  void

  reserve_tlsdesc_entry(unsigned int got_offset)

  { this->tlsdesc_got_offset_ = got_offset; }

  // Return true if a TLSDESC_PLT entry has been reserved.

  bool

  has_tlsdesc_entry() const

  { return this->tlsdesc_got_offset_ != -1U; }

  // Return the GOT offset for the reserved TLSDESC_PLT entry.

  unsigned int

  get_tlsdesc_got_offset() const

  { return this->tlsdesc_got_offset_; }

  // Return the offset of the reserved TLSDESC_PLT entry.

  unsigned int

  get_tlsdesc_plt_offset() const

  { return (this->count_ + 1) * plt_entry_size; }

  // Return the .rel.plt section data.

  const Reloc_section*

  rel_plt() const

  { return this->rel_; }

 protected:

  void

  do_adjust_output_section(Output_section* os);

  // Write to a map file.

  void

  do_print_to_mapfile(Mapfile* mapfile) const

  { mapfile->print_output_data(this, _("** PLT")); }

 private:

  // The size of an entry in the PLT.

  static const int plt_entry_size = 16;

  // The first entry in the PLT.

  // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same

  // procedure linkage table for both programs and shared objects."

  static unsigned char first_plt_entry[plt_entry_size];

  // Other entries in the PLT for an executable.

  static unsigned char plt_entry[plt_entry_size];

  // The reserved TLSDESC entry in the PLT for an executable.

  static unsigned char tlsdesc_plt_entry[plt_entry_size];

  // Set the final size.

  void

  set_final_data_size();

  // Write out the PLT data.

  void

  do_write(Output_file*);

  // The reloc section.

  Reloc_section* rel_;

  // The .got section.

  Output_data_got<64, false>* got_;

  // The .got.plt section.

  Output_data_space* got_plt_;

  // The number of PLT entries.

  unsigned int count_;

  // Offset of the reserved TLSDESC_GOT entry when needed.

  unsigned int tlsdesc_got_offset_;

};

// Create the PLT section.  The ordinary .got section is an argument,

// since we need to refer to the start.  We also create our own .got

// section just for PLT entries.

Output_data_plt_x86_64::Output_data_plt_x86_64(Layout* layout,

                                               Output_data_got<64, false>* got,

                                               Output_data_space* got_plt)

  : Output_section_data(8), got_(got), got_plt_(got_plt), count_(0),

    tlsdesc_got_offset_(-1U)

{

  this->rel_ = new Reloc_section(false);

  layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,

                                  elfcpp::SHF_ALLOC, this->rel_, true);

}

void

Output_data_plt_x86_64::do_adjust_output_section(Output_section* os)

{

  os->set_entsize(plt_entry_size);

}

// Add an entry to the PLT.

void

Output_data_plt_x86_64::add_entry(Symbol* gsym)

{

  gold_assert(!gsym->has_plt_offset());

  // Note that when setting the PLT offset we skip the initial

  // reserved PLT entry.

  gsym->set_plt_offset((this->count_ + 1) * plt_entry_size);

  ++this->count_;

  section_offset_type got_offset = this->got_plt_->current_data_size();

  // Every PLT entry needs a GOT entry which points back to the PLT

  // entry (this will be changed by the dynamic linker, normally

  // lazily when the function is called).

  this->got_plt_->set_current_data_size(got_offset + 8);

  // Every PLT entry needs a reloc.

  gsym->set_needs_dynsym_entry();

  this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,

                         got_offset, 0);

  // Note that we don't need to save the symbol.  The contents of the

  // PLT are independent of which symbols are used.  The symbols only

  // appear in the relocations.

}

// Set the final size.

void

Output_data_plt_x86_64::set_final_data_size()

{

  unsigned int count = this->count_;

  if (this->has_tlsdesc_entry())

    ++count;

  this->set_data_size((count + 1) * plt_entry_size);

}

// The first entry in the PLT for an executable.

unsigned char Output_data_plt_x86_64::first_plt_entry[plt_entry_size] =

{

  // From AMD64 ABI Draft 0.98, page 76

  0xff, 0x35,   // pushq contents of memory address

  0, 0, 0, 0,       // replaced with address of .got + 8

  0xff, 0x25,   // jmp indirect

  0, 0, 0, 0,       // replaced with address of .got + 16

  0x90, 0x90, 0x90, 0x90   // noop (x4)

};

// Subsequent entries in the PLT for an executable.

unsigned char Output_data_plt_x86_64::plt_entry[plt_entry_size] =

{

  // From AMD64 ABI Draft 0.98, page 76

  0xff, 0x25,   // jmpq indirect

  0, 0, 0, 0,       // replaced with address of symbol in .got

  0x68,         // pushq immediate

  0, 0, 0, 0,       // replaced with offset into relocation table

  0xe9,         // jmpq relative

  0, 0, 0, 0        // replaced with offset to start of .plt

};

// The reserved TLSDESC entry in the PLT for an executable.