Subversion Repositories openrisc_me

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

// 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.

#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 Pluginobj;

class Dynobj;

class Object_merge_map;

class Relocatable_relocs;

class Symbols_data;

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), is_needed_(false), uses_split_stack_(false),

      has_no_split_stack_(false), no_export_(false), 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 whether this object is needed--true if it is a dynamic

  // object which defines some symbol referenced by a regular object.

  // We keep the flag here rather than in Dynobj for convenience when

  // setting it.

  bool

  is_needed() const

  { return this->is_needed_; }

  // Record that this object is needed.

  void

  set_is_needed()

  { this->is_needed_ = true; }

  // Return whether this object was compiled with -fsplit-stack.

  bool

  uses_split_stack() const

  { return this->uses_split_stack_; }

  // Return whether this object contains any functions compiled with

  // the no_split_stack attribute.

  bool

  has_no_split_stack() const

  { return this->has_no_split_stack_; }

  // Returns NULL for Objects that are not plugin objects.  This method

  // is overridden in the Pluginobj class.

  Pluginobj*

  pluginobj()

  { return this->do_pluginobj(); }

  // 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_; }

  // 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(); }

  // 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 entsize given a section index.

  uint64_t

  section_entsize(unsigned int shndx)

  { return this->do_section_entsize(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, Layout *layout)

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

  // 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); }

  // Return whether this object was found in a system directory.

  bool

  is_in_system_directory() const

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

  // Return whether we found this object by searching a directory.

  bool

  searched_for() const

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

  bool

  no_export() const

  { return this->no_export_; }

  void

  set_no_export(bool value)

  { this->no_export_ = value; }

 protected:

  // Returns NULL for Objects that are not plugin objects.  This method

  // is overridden in the Pluginobj class.

  virtual Pluginobj*

  do_pluginobj()

  { return NULL; }

  // 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*, Layout*) = 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 entsize--implemented by child class.

  virtual uint64_t

  do_section_entsize(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;

  // 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*);

  // If NAME is the name of the special section which indicates that

  // this object was compiled with -fstack-split, mark it accordingly,

  // and return true.  Otherwise return false.

  bool

  handle_split_stack_section(const char* name);

 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_ : 1;

  // Whether this object is needed.  This is only set for dynamic

  // objects, and means that the object defined a symbol which was

  // used by a reference from a regular object.

  bool is_needed_ : 1;

  // Whether this object was compiled with -fsplit-stack.

  bool uses_split_stack_ : 1;

  // Whether this object contains any functions compiled with the

  // no_split_stack attribute.

  bool has_no_split_stack_ : 1;

  // True if exclude this object from automatic symbol export.

  // This is used only for archive objects.

  bool no_export_ : 1;

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

  Xindex* xindex_;

};

// 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),

      sd_(NULL)

  { }

  // During garbage collection, the Read_symbols_data pass for 

  // each object is stored as layout needs to be done after 

  // reloc processing.

  Symbols_data*

  get_symbols_data()

  { return this->sd_; }

  // Decides which section names have to be included in the worklist

  // as roots.

  bool

  is_section_name_included(const char *name);

  void

  copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,

                    unsigned int section_header_size);

  void

  set_symbols_data(Symbols_data* sd)

  { this->sd_ = sd; }

  // During garbage collection, the Read_relocs pass for all objects 

  // is done before scanning the relocs.  In that case, this->rd_ is

  // used to store the information from Read_relocs for each object.

  // This data is also used to compute the list of relevant sections.

  Read_relocs_data*

  get_relocs_data()

  { return this->rd_; }

  void

  set_relocs_data(Read_relocs_data* rd)

  { this->rd_ = rd; }

  virtual bool

  is_output_section_offset_invalid(unsigned int shndx) const = 0;

  // Read the relocs.

  void

  read_relocs(Read_relocs_data* rd)

  { return this->do_read_relocs(rd); }

  // Process the relocs, during garbage collection only.

  void

  gc_process_relocs(const General_options& options, Symbol_table* symtab,

                    Layout* layout, Read_relocs_data* rd)

  { return this->do_gc_process_relocs(options, symtab, layout, 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, Symbol_table* symtab)

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

  // 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)