Subversion Repositories scarts

// object.h -- support for an object file for linking in gold  -*- C++ -*-

// Copyright 2006, 2007, 2008 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.

#ifndef GOLD_OBJECT_H

#define GOLD_OBJECT_H

#include <string>

#include <vector>

#include "elfcpp.h"

#include "elfcpp_file.h"

#include "fileread.h"

#include "target.h"

namespace gold

{

class General_options;

class Task;

class Cref;

class Archive;

class Layout;

class Output_section;

class Output_file;

class Output_symtab_xindex;

class Dynobj;

class Object_merge_map;

class Relocatable_relocs;

template<typename Stringpool_char>

class Stringpool_template;

// Data to pass from read_symbols() to add_symbols().

struct Read_symbols_data

{

  // Section headers.

  File_view* section_headers;

  // Section names.

  File_view* section_names;

  // Size of section name data in bytes.

  section_size_type section_names_size;

  // Symbol data.

  File_view* symbols;

  // Size of symbol data in bytes.

  section_size_type symbols_size;

  // Offset of external symbols within symbol data.  This structure

  // sometimes contains only external symbols, in which case this will

  // be zero.  Sometimes it contains all symbols.

  section_offset_type external_symbols_offset;

  // Symbol names.

  File_view* symbol_names;

  // Size of symbol name data in bytes.

  section_size_type symbol_names_size;

  // Version information.  This is only used on dynamic objects.

  // Version symbol data (from SHT_GNU_versym section).

  File_view* versym;

  section_size_type versym_size;

  // Version definition data (from SHT_GNU_verdef section).

  File_view* verdef;

  section_size_type verdef_size;

  unsigned int verdef_info;

  // Needed version data  (from SHT_GNU_verneed section).

  File_view* verneed;

  section_size_type verneed_size;

  unsigned int verneed_info;

};

// Information used to print error messages.

struct Symbol_location_info

{

  std::string source_file;

  std::string enclosing_symbol_name;

  int line_number;

};

// Data about a single relocation section.  This is read in

// read_relocs and processed in scan_relocs.

struct Section_relocs

{

  // Index of reloc section.

  unsigned int reloc_shndx;

  // Index of section that relocs apply to.

  unsigned int data_shndx;

  // Contents of reloc section.

  File_view* contents;

  // Reloc section type.

  unsigned int sh_type;

  // Number of reloc entries.

  size_t reloc_count;

  // Output section.

  Output_section* output_section;

  // Whether this section has special handling for offsets.

  bool needs_special_offset_handling;

  // Whether the data section is allocated (has the SHF_ALLOC flag set).

  bool is_data_section_allocated;

};

// Relocations in an object file.  This is read in read_relocs and

// processed in scan_relocs.

struct Read_relocs_data

{

  typedef std::vector<Section_relocs> Relocs_list;

  // The relocations.

  Relocs_list relocs;

  // The local symbols.

  File_view* local_symbols;

};

// The Xindex class manages section indexes for objects with more than

// 0xff00 sections.

class Xindex

{

 public:

  Xindex(int large_shndx_offset)

    : large_shndx_offset_(large_shndx_offset), symtab_xindex_()

  { }

  // Initialize the symtab_xindex_ array, given the object and the

  // section index of the symbol table to use.

  template<int size, bool big_endian>

  void

  initialize_symtab_xindex(Object*, unsigned int symtab_shndx);

  // Read in the symtab_xindex_ array, given its section index.

  // PSHDRS may optionally point to the section headers.

  template<int size, bool big_endian>

  void

  read_symtab_xindex(Object*, unsigned int xindex_shndx,

                     const unsigned char* pshdrs);

  // Symbol SYMNDX in OBJECT has a section of SHN_XINDEX; return the

  // real section index.

  unsigned int

  sym_xindex_to_shndx(Object* object, unsigned int symndx);

 private:

  // The type of the array giving the real section index for symbols

  // whose st_shndx field holds SHN_XINDEX.

  typedef std::vector<unsigned int> Symtab_xindex;

  // Adjust a section index if necessary.  This should only be called

  // for ordinary section indexes.

  unsigned int

  adjust_shndx(unsigned int shndx)

  {

    if (shndx >= elfcpp::SHN_LORESERVE)

      shndx += this->large_shndx_offset_;

    return shndx;

  }

  // Adjust to apply to large section indexes.

  int large_shndx_offset_;

  // The data from the SHT_SYMTAB_SHNDX section.

  Symtab_xindex symtab_xindex_;

};

// Object is an abstract base class which represents either a 32-bit

// or a 64-bit input object.  This can be a regular object file

// (ET_REL) or a shared object (ET_DYN).

class Object

{

 public:

  // NAME is the name of the object as we would report it to the user

  // (e.g., libfoo.a(bar.o) if this is in an archive.  INPUT_FILE is

  // used to read the file.  OFFSET is the offset within the input

  // file--0 for a .o or .so file, something else for a .a file.

  Object(const std::string& name, Input_file* input_file, bool is_dynamic,

         off_t offset = 0)

    : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),

      is_dynamic_(is_dynamic), target_(NULL), xindex_(NULL)

  { input_file->file().add_object(); }

  virtual ~Object()

  { this->input_file_->file().remove_object(); }

  // Return the name of the object as we would report it to the tuser.

  const std::string&

  name() const

  { return this->name_; }

  // Get the offset into the file.

  off_t

  offset() const

  { return this->offset_; }

  // Return whether this is a dynamic object.

  bool

  is_dynamic() const

  { return this->is_dynamic_; }

  // Return the target structure associated with this object.

  Target*

  target() const

  { return this->target_; }

  // Lock the underlying file.

  void

  lock(const Task* t)

  { this->input_file()->file().lock(t); }

  // Unlock the underlying file.

  void

  unlock(const Task* t)

  { this->input_file()->file().unlock(t); }

  // Return whether the underlying file is locked.

  bool

  is_locked() const

  { return this->input_file()->file().is_locked(); }

  // Return the token, so that the task can be queued.

  Task_token*

  token()

  { return this->input_file()->file().token(); }

  // Release the underlying file.

  void

  release()

  { this->input_file_->file().release(); }

  // Return whether we should just read symbols from this file.

  bool

  just_symbols() const

  { return this->input_file()->just_symbols(); }

  // Return the sized target structure associated with this object.

  // This is like the target method but it returns a pointer of

  // appropriate checked type.

  template<int size, bool big_endian>

  Sized_target<size, big_endian>*

  sized_target() const;

  // Get the number of sections.

  unsigned int

  shnum() const

  { return this->shnum_; }

  // Return a view of the contents of a section.  Set *PLEN to the

  // size.  CACHE is a hint as in File_read::get_view.

  const unsigned char*

  section_contents(unsigned int shndx, section_size_type* plen, bool cache);

  // Adjust a symbol's section index as needed.  SYMNDX is the index

  // of the symbol and SHNDX is the symbol's section from

  // get_st_shndx.  This returns the section index.  It sets

  // *IS_ORDINARY to indicate whether this is a normal section index,

  // rather than a special code between SHN_LORESERVE and

  // SHN_HIRESERVE.

  unsigned int

  adjust_sym_shndx(unsigned int symndx, unsigned int shndx, bool* is_ordinary)

  {

    if (shndx < elfcpp::SHN_LORESERVE)

      *is_ordinary = true;

    else if (shndx == elfcpp::SHN_XINDEX)

      {

        if (this->xindex_ == NULL)

          this->xindex_ = this->do_initialize_xindex();

        shndx = this->xindex_->sym_xindex_to_shndx(this, symndx);

        *is_ordinary = true;

      }

    else

      *is_ordinary = false;

    return shndx;

  }

  // Return the size of a section given a section index.

  uint64_t

  section_size(unsigned int shndx)

  { return this->do_section_size(shndx); }

  // Return the name of a section given a section index.

  std::string

  section_name(unsigned int shndx)

  { return this->do_section_name(shndx); }

  // Return the section flags given a section index.

  uint64_t

  section_flags(unsigned int shndx)

  { return this->do_section_flags(shndx); }

  // Return the section address given a section index.

  uint64_t

  section_address(unsigned int shndx)

  { return this->do_section_address(shndx); }

  // Return the section type given a section index.

  unsigned int

  section_type(unsigned int shndx)

  { return this->do_section_type(shndx); }

  // Return the section link field given a section index.

  unsigned int

  section_link(unsigned int shndx)

  { return this->do_section_link(shndx); }

  // Return the section info field given a section index.

  unsigned int

  section_info(unsigned int shndx)

  { return this->do_section_info(shndx); }

  // Return the required section alignment given a section index.

  uint64_t

  section_addralign(unsigned int shndx)

  { return this->do_section_addralign(shndx); }

  // Read the symbol information.

  void

  read_symbols(Read_symbols_data* sd)

  { return this->do_read_symbols(sd); }

  // Pass sections which should be included in the link to the Layout

  // object, and record where the sections go in the output file.

  void

  layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd)

  { this->do_layout(symtab, layout, sd); }

  // Add symbol information to the global symbol table.

  void

  add_symbols(Symbol_table* symtab, Read_symbols_data* sd)

  { this->do_add_symbols(symtab, sd); }

  // Functions and types for the elfcpp::Elf_file interface.  This

  // permit us to use Object as the File template parameter for

  // elfcpp::Elf_file.

  // The View class is returned by view.  It must support a single

  // method, data().  This is trivial, because get_view does what we

  // need.

  class View

  {

   public:

    View(const unsigned char* p)

      : p_(p)

    { }

    const unsigned char*

    data() const

    { return this->p_; }

   private:

    const unsigned char* p_;

  };

  // Return a View.

  View

  view(off_t file_offset, section_size_type data_size)

  { return View(this->get_view(file_offset, data_size, true, true)); }

  // Report an error.

  void

  error(const char* format, ...) const ATTRIBUTE_PRINTF_2;

  // A location in the file.

  struct Location

  {

    off_t file_offset;

    off_t data_size;

    Location(off_t fo, section_size_type ds)

      : file_offset(fo), data_size(ds)

    { }

  };

  // Get a View given a Location.

  View view(Location loc)

  { return View(this->get_view(loc.file_offset, loc.data_size, true, true)); }

  // Get a view into the underlying file.

  const unsigned char*

  get_view(off_t start, section_size_type size, bool aligned, bool cache)

  {

    return this->input_file()->file().get_view(this->offset_, start, size,

                                               aligned, cache);

  }

  // Get a lasting view into the underlying file.

  File_view*

  get_lasting_view(off_t start, section_size_type size, bool aligned,

                   bool cache)

  {

    return this->input_file()->file().get_lasting_view(this->offset_, start,

                                                       size, aligned, cache);

  }

  // Read data from the underlying file.

  void

  read(off_t start, section_size_type size, void* p)

  { this->input_file()->file().read(start + this->offset_, size, p); }

  // Read multiple data from the underlying file.

  void

  read_multiple(const File_read::Read_multiple& rm)

  { this->input_file()->file().read_multiple(this->offset_, rm); }

  // Stop caching views in the underlying file.

  void

  clear_view_cache_marks()

  { this->input_file()->file().clear_view_cache_marks(); }

  // Get the number of global symbols defined by this object, and the

  // number of the symbols whose final definition came from this

  // object.

  void

  get_global_symbol_counts(const Symbol_table* symtab, size_t* defined,

                           size_t* used) const

  { this->do_get_global_symbol_counts(symtab, defined, used); }

 protected:

  // Read the symbols--implemented by child class.

  virtual void

  do_read_symbols(Read_symbols_data*) = 0;

  // Lay out sections--implemented by child class.

  virtual void

  do_layout(Symbol_table*, Layout*, Read_symbols_data*) = 0;

  // Add symbol information to the global symbol table--implemented by

  // child class.

  virtual void

  do_add_symbols(Symbol_table*, Read_symbols_data*) = 0;

  // Return the location of the contents of a section.  Implemented by

  // child class.

  virtual Location

  do_section_contents(unsigned int shndx) = 0;

  // Get the size of a section--implemented by child class.

  virtual uint64_t

  do_section_size(unsigned int shndx) = 0;

  // Get the name of a section--implemented by child class.

  virtual std::string

  do_section_name(unsigned int shndx) = 0;

  // Get section flags--implemented by child class.

  virtual uint64_t

  do_section_flags(unsigned int shndx) = 0;

  // Get section address--implemented by child class.

  virtual uint64_t

  do_section_address(unsigned int shndx) = 0;

  // Get section type--implemented by child class.

  virtual unsigned int

  do_section_type(unsigned int shndx) = 0;

  // Get section link field--implemented by child class.

  virtual unsigned int

  do_section_link(unsigned int shndx) = 0;

  // Get section info field--implemented by child class.

  virtual unsigned int

  do_section_info(unsigned int shndx) = 0;

  // Get section alignment--implemented by child class.

  virtual uint64_t

  do_section_addralign(unsigned int shndx) = 0;

  // Return the Xindex structure to use.

  virtual Xindex*

  do_initialize_xindex() = 0;

  // Implement get_global_symbol_counts--implemented by child class.

  virtual void

  do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0;

  // Get the file.  We pass on const-ness.

  Input_file*

  input_file()

  { return this->input_file_; }

  const Input_file*

  input_file() const

  { return this->input_file_; }

  // Set the target.

  void

  set_target(int machine, int size, bool big_endian, int osabi,

             int abiversion);

  // Set the number of sections.

  void

  set_shnum(int shnum)

  { this->shnum_ = shnum; }

  // Functions used by both Sized_relobj and Sized_dynobj.

  // Read the section data into a Read_symbols_data object.

  template<int size, bool big_endian>

  void

  read_section_data(elfcpp::Elf_file<size, big_endian, Object>*,

                    Read_symbols_data*);

  // Let the child class initialize the xindex object directly.

  void

  set_xindex(Xindex* xindex)

  {

    gold_assert(this->xindex_ == NULL);

    this->xindex_ = xindex;

  }

  // If NAME is the name of a special .gnu.warning section, arrange

  // for the warning to be issued.  SHNDX is the section index.

  // Return whether it is a warning section.

  bool

  handle_gnu_warning_section(const char* name, unsigned int shndx,

                             Symbol_table*);

 private:

  // This class may not be copied.

  Object(const Object&);

  Object& operator=(const Object&);

  // Name of object as printed to user.

  std::string name_;

  // For reading the file.

  Input_file* input_file_;

  // Offset within the file--0 for an object file, non-0 for an

  // archive.

  off_t offset_;

  // Number of input sections.

  unsigned int shnum_;

  // Whether this is a dynamic object.

  bool is_dynamic_;

  // Target functions--may be NULL if the target is not known.

  Target* target_;

  // Many sections for objects with more than SHN_LORESERVE sections.

  Xindex* xindex_;

};

// Implement sized_target inline for efficiency.  This approach breaks

// static type checking, but is made safe using asserts.

template<int size, bool big_endian>

inline Sized_target<size, big_endian>*

Object::sized_target() const

{

  gold_assert(this->target_->get_size() == size);

  gold_assert(this->target_->is_big_endian() ? big_endian : !big_endian);

  return static_cast<Sized_target<size, big_endian>*>(this->target_);

}

// A regular object (ET_REL).  This is an abstract base class itself.

// The implementation is the template class Sized_relobj.

class Relobj : public Object

{

 public:

  Relobj(const std::string& name, Input_file* input_file, off_t offset = 0)

    : Object(name, input_file, false, offset),

      output_sections_(),

      map_to_relocatable_relocs_(NULL),

      object_merge_map_(NULL),

      relocs_must_follow_section_writes_(false)

  { }

  // Read the relocs.

  void

  read_relocs(Read_relocs_data* rd)

  { return this->do_read_relocs(rd); }

  // Scan the relocs and adjust the symbol table.

  void

  scan_relocs(const General_options& options, Symbol_table* symtab,

              Layout* layout, Read_relocs_data* rd)

  { return this->do_scan_relocs(options, symtab, layout, rd); }

  // The number of local symbols in the input symbol table.

  virtual unsigned int

  local_symbol_count() const

  { return this->do_local_symbol_count(); }

  // Initial local symbol processing: count the number of local symbols

  // in the output symbol table and dynamic symbol table; add local symbol

  // names to *POOL and *DYNPOOL.

  void

  count_local_symbols(Stringpool_template<char>* pool,

                      Stringpool_template<char>* dynpool)

  { return this->do_count_local_symbols(pool, dynpool); }

  // Set the values of the local symbols, set the output symbol table

  // indexes for the local variables, and set the offset where local

  // symbol information will be stored. Returns the new local symbol index.

  unsigned int

  finalize_local_symbols(unsigned int index, off_t off)

  { return this->do_finalize_local_symbols(index, off); }

  // Set the output dynamic symbol table indexes for the local variables.

  unsigned int

  set_local_dynsym_indexes(unsigned int index)

  { return this->do_set_local_dynsym_indexes(index); }

  // Set the offset where local dynamic symbol information will be stored.

  unsigned int

  set_local_dynsym_offset(off_t off)

  { return this->do_set_local_dynsym_offset(off); }

  // Relocate the input sections and write out the local symbols.

  void

  relocate(const General_options& options, const Symbol_table* symtab,

           const Layout* layout, Output_file* of)

  { return this->do_relocate(options, symtab, layout, of); }

  // Return whether an input section is being included in the link.

  bool

  is_section_included(unsigned int shndx) const

  {

    gold_assert(shndx < this->output_sections_.size());

    return this->output_sections_[shndx] != NULL;

  }

  // Given a section index, return the corresponding Output_section.

  // The return value will be NULL if the section is not included in

  // the link.

  Output_section*

  output_section(unsigned int shndx) const

  {

    gold_assert(shndx < this->output_sections_.size());

    return this->output_sections_[shndx];

  }

  // Given a section index, return the offset in the Output_section.

  // The return value will be -1U if the section is specially mapped,

  // such as a merge section.

  uint64_t

  output_section_offset(unsigned int shndx) const

  { return this->do_output_section_offset(shndx); }

  // Set the offset of an input section within its output section.

  virtual void

  set_section_offset(unsigned int shndx, uint64_t off)

  { this->do_set_section_offset(shndx, off); }

  // Return true if we need to wait for output sections to be written

  // before we can apply relocations.  This is true if the object has

  // any relocations for sections which require special handling, such

  // as the exception frame section.

  bool

  relocs_must_follow_section_writes() const

  { return this->relocs_must_follow_section_writes_; }

  // Return the object merge map.

  Object_merge_map*

  merge_map() const

  { return this->object_merge_map_; }

  // Set the object merge map.

  void

  set_merge_map(Object_merge_map* object_merge_map)

  {

    gold_assert(this->object_merge_map_ == NULL);

    this->object_merge_map_ = object_merge_map;

  }

  // Record the relocatable reloc info for an input reloc section.

  void

  set_relocatable_relocs(unsigned int reloc_shndx, Relocatable_relocs* rr)

  {

    gold_assert(reloc_shndx < this->shnum());

    (*this->map_to_relocatable_relocs_)[reloc_shndx] = rr;

  }

  // Get the relocatable reloc info for an input reloc section.

  Relocatable_relocs*

  relocatable_relocs(unsigned int reloc_shndx)

  {

    gold_assert(reloc_shndx < this->shnum());

    return (*this->map_to_relocatable_relocs_)[reloc_shndx];

  }

 protected:

  // The output section to be used for each input section, indexed by

  // the input section number.  The output section is NULL if the

  // input section is to be discarded.

  typedef std::vector<Output_section*> Output_sections;

  // Read the relocs--implemented by child class.

  virtual void

  do_read_relocs(Read_relocs_data*) = 0;

  // Scan the relocs--implemented by child class.

  virtual void

  do_scan_relocs(const General_options&, Symbol_table*, Layout*,

                 Read_relocs_data*) = 0;