Subversion Repositories open8_urisc

// ehframe.h -- handle exception frame sections for gold  -*- C++ -*-

// Copyright 2006, 2007, 2008, 2010, 2011 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_EHFRAME_H

#define GOLD_EHFRAME_H

#include <map>

#include <set>

#include <vector>

#include "output.h"

#include "merge.h"

namespace gold

{

template<int size, bool big_endian>

class Track_relocs;

class Eh_frame;

// This class manages the .eh_frame_hdr section, which holds the data

// for the PT_GNU_EH_FRAME segment.  gcc's unwind support code uses

// the PT_GNU_EH_FRAME segment to find the list of FDEs.  This saves

// the time required to register the exception handlers at startup

// time and when a shared object is loaded, and the time required to

// deregister the exception handlers when a shared object is unloaded.

class Eh_frame_hdr : public Output_section_data

{

 public:

  Eh_frame_hdr(Output_section* eh_frame_section, const Eh_frame*);

  // Record that we found an unrecognized .eh_frame section.

  void

  found_unrecognized_eh_frame_section()

  { this->any_unrecognized_eh_frame_sections_ = true; }

  // Record an FDE.

  void

  record_fde(section_offset_type fde_offset, unsigned char fde_encoding)

  {

    if (!this->any_unrecognized_eh_frame_sections_)

      this->fde_offsets_.push_back(std::make_pair(fde_offset, fde_encoding));

  }

 protected:

  // Set the final data size.

  void

  set_final_data_size();

  // Write the data to the file.

  void

  do_write(Output_file*);

  // Write to a map file.

  void

  do_print_to_mapfile(Mapfile* mapfile) const

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

 private:

  // Write the data to the file with the right endianness.

  template<int size, bool big_endian>

  void

  do_sized_write(Output_file*);

  // The data we record for one FDE: the offset of the FDE within the

  // .eh_frame section, and the FDE encoding.

  typedef std::pair<section_offset_type, unsigned char> Fde_offset;

  // The list of information we record for an FDE.

  typedef std::vector<Fde_offset> Fde_offsets;

  // When writing out the header, we convert the FDE offsets into FDE

  // addresses.  This is a list of pairs of the offset from the header

  // to the FDE PC and to the FDE itself.

  template<int size>

  class Fde_addresses

  {

   public:

    typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;

    typedef typename std::pair<Address, Address> Fde_address;

    typedef typename std::vector<Fde_address> Fde_address_list;

    typedef typename Fde_address_list::iterator iterator;

    Fde_addresses(unsigned int reserve)

      : fde_addresses_()

    { this->fde_addresses_.reserve(reserve); }

    void

    push_back(Address pc_address, Address fde_address)

    {

      this->fde_addresses_.push_back(std::make_pair(pc_address, fde_address));

    }

    iterator

    begin()

    { return this->fde_addresses_.begin(); }

    iterator

    end()

    { return this->fde_addresses_.end(); }

   private:

    Fde_address_list fde_addresses_;

  };

  // Compare Fde_address objects.

  template<int size>

  struct Fde_address_compare

  {

    bool

    operator()(const typename Fde_addresses<size>::Fde_address& f1,

               const typename Fde_addresses<size>::Fde_address& f2) const

    { return f1.first < f2.first; }

  };

  // Return the PC to which an FDE refers.

  template<int size, bool big_endian>

  typename elfcpp::Elf_types<size>::Elf_Addr

  get_fde_pc(typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address,

             const unsigned char* eh_frame_contents,

             section_offset_type fde_offset, unsigned char fde_encoding);

  // Convert Fde_offsets to Fde_addresses.

  template<int size, bool big_endian>

  void

  get_fde_addresses(Output_file* of,

                    const Fde_offsets* fde_offsets,

                    Fde_addresses<size>* fde_addresses);

  // The .eh_frame section.

  Output_section* eh_frame_section_;

  // The .eh_frame section data.

  const Eh_frame* eh_frame_data_;

  // Data from the FDEs in the .eh_frame sections.

  Fde_offsets fde_offsets_;

  // Whether we found any .eh_frame sections which we could not

  // process.

  bool any_unrecognized_eh_frame_sections_;

};

// This class holds an FDE.

class Fde

{

 public:

  Fde(Relobj* object, unsigned int shndx, section_offset_type input_offset,

      const unsigned char* contents, size_t length)

    : object_(object),

      contents_(reinterpret_cast<const char*>(contents), length)

  {

    this->u_.from_object.shndx = shndx;

    this->u_.from_object.input_offset = input_offset;

  }

  // Create an FDE associated with a PLT.

  Fde(Output_data* plt, const unsigned char* contents, size_t length)

    : object_(NULL),

      contents_(reinterpret_cast<const char*>(contents), length)

  { this->u_.from_linker.plt = plt; }

  // Return the length of this FDE.  Add 4 for the length and 4 for

  // the offset to the CIE.

  size_t

  length() const

  { return this->contents_.length() + 8; }

  // Add a mapping for this FDE to MERGE_MAP, so that relocations

  // against the FDE are applied to right part of the output file.

  void

  add_mapping(section_offset_type output_offset, Merge_map* merge_map) const

  {

    if (this->object_ != NULL)

      merge_map->add_mapping(this->object_, this->u_.from_object.shndx,

                             this->u_.from_object.input_offset, this->length(),

                             output_offset);

  }

  // Write the FDE to OVIEW starting at OFFSET.  FDE_ENCODING is the

  // encoding, from the CIE.  Round up the bytes to ADDRALIGN if

  // necessary.  ADDRESS is the virtual address of OVIEW.  Record the

  // FDE in EH_FRAME_HDR.  Return the new offset.

  template<int size, bool big_endian>

  section_offset_type

  write(unsigned char* oview, section_offset_type offset,

        uint64_t address, unsigned int addralign,

        section_offset_type cie_offset, unsigned char fde_encoding,

        Eh_frame_hdr* eh_frame_hdr);

 private:

  // The object in which this FDE was seen.  This will be NULL for a

  // linker generated FDE.

  Relobj* object_;

  union

  {

    // These fields are used if the FDE is from an input object (the

    // object_ field is not NULL).

    struct

    {

      // Input section index for this FDE.

      unsigned int shndx;

      // Offset within the input section for this FDE.

      section_offset_type input_offset;

    } from_object;

    // This field is used if the FDE is generated by the linker (the

    // object_ field is NULL).

    struct

    {

      // The only linker generated FDEs are for PLT sections, and this

      // points to the PLT section.

      Output_data* plt;

    } from_linker;

  } u_;

  // FDE data.

  std::string contents_;

};

// This class holds a CIE.

class Cie

{

 public:

  Cie(Relobj* object, unsigned int shndx, section_offset_type input_offset,

      unsigned char fde_encoding, const char* personality_name,

      const unsigned char* contents, size_t length)

    : object_(object),

      shndx_(shndx),

      input_offset_(input_offset),

      fde_encoding_(fde_encoding),

      personality_name_(personality_name),

      fdes_(),

      contents_(reinterpret_cast<const char*>(contents), length)

  { }

  ~Cie();

  // We permit copying a CIE when there are no FDEs.  This is

  // convenient in the code which creates them.

  Cie(const Cie& cie)

    : object_(cie.object_),

      shndx_(cie.shndx_),

      input_offset_(cie.input_offset_),

      fde_encoding_(cie.fde_encoding_),

      personality_name_(cie.personality_name_),

      fdes_(),

      contents_(cie.contents_)

  { gold_assert(cie.fdes_.empty()); }

  // Add an FDE associated with this CIE.

  void

  add_fde(Fde* fde)

  { this->fdes_.push_back(fde); }

  // Return the number of FDEs.

  unsigned int

  fde_count() const

  { return this->fdes_.size(); }

  // Set the output offset of this CIE to OUTPUT_OFFSET.  It will be

  // followed by all its FDEs.  ADDRALIGN is the required address

  // alignment, typically 4 or 8.  This updates MERGE_MAP with the

  // mapping.  It returns the new output offset.

  section_offset_type

  set_output_offset(section_offset_type output_offset, unsigned int addralign,

                    Merge_map*);

  // Write the CIE to OVIEW starting at OFFSET.  EH_FRAME_HDR is the

  // exception frame header for FDE recording.  Round up the bytes to

  // ADDRALIGN.  ADDRESS is the virtual address of OVIEW.  Return the

  // new offset.

  template<int size, bool big_endian>

  section_offset_type

  write(unsigned char* oview, section_offset_type offset, uint64_t address,

        unsigned int addralign, Eh_frame_hdr* eh_frame_hdr);

  friend bool operator<(const Cie&, const Cie&);

  friend bool operator==(const Cie&, const Cie&);

 private:

  // The class is not assignable.

  Cie& operator=(const Cie&);

  // The object in which this CIE was first seen.  This will be NULL

  // for a linker generated CIE.

  Relobj* object_;

  // Input section index for this CIE.  This will be 0 for a linker

  // generated CIE.

  unsigned int shndx_;

  // Offset within the input section for this CIE.  This will be 0 for

  // a linker generated CIE.

  section_offset_type input_offset_;

  // The encoding of the FDE.  This is a DW_EH_PE code.

  unsigned char fde_encoding_;

  // The name of the personality routine.  This will be the name of a

  // global symbol, or will be the empty string.

  std::string personality_name_;

  // List of FDEs.

  std::vector<Fde*> fdes_;

  // CIE data.

  std::string contents_;

};

extern bool operator<(const Cie&, const Cie&);

extern bool operator==(const Cie&, const Cie&);

// This class manages .eh_frame sections.  It discards duplicate

// exception information.

class Eh_frame : public Output_section_data

{

 public:

  Eh_frame();

  // Record the associated Eh_frame_hdr, if any.

  void

  set_eh_frame_hdr(Eh_frame_hdr* hdr)

  { this->eh_frame_hdr_ = hdr; }

  // Add the input section SHNDX in OBJECT.  SYMBOLS is the contents

  // of the symbol table section (size SYMBOLS_SIZE), SYMBOL_NAMES is

  // the symbol names section (size SYMBOL_NAMES_SIZE).  RELOC_SHNDX

  // is the relocation section if any (0 for none, -1U for multiple).

  // RELOC_TYPE is the type of the relocation section if any.  This

  // returns whether the section was incorporated into the .eh_frame

  // data.

  template<int size, bool big_endian>

  bool

  add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,

                            const unsigned char* symbols,

                            section_size_type symbols_size,

                            const unsigned char* symbol_names,

                            section_size_type symbol_names_size,

                            unsigned int shndx, unsigned int reloc_shndx,

                            unsigned int reloc_type);

  // Add a CIE and an FDE for a PLT section, to permit unwinding

  // through a PLT.  The FDE data should start with 8 bytes of zero,

  // which will be replaced by a 4 byte PC relative reference to the

  // address of PLT and a 4 byte size of PLT.

  void

  add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,

                      size_t cie_length, const unsigned char* fde_data,

                      size_t fde_length);

  // Return the number of FDEs.

  unsigned int

  fde_count() const;

 protected:

  // Set the final data size.

  void

  set_final_data_size();

  // Return the output address for an input address.

  bool

  do_output_offset(const Relobj*, unsigned int shndx,

                   section_offset_type offset,

                   section_offset_type* poutput) const;

  // Return whether this is the merge section for an input section.

  bool

  do_is_merge_section_for(const Relobj*, unsigned int shndx) const;

  // Write the data to the file.

  void

  do_write(Output_file*);

  // Write to a map file.

  void

  do_print_to_mapfile(Mapfile* mapfile) const

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

 private:

  // The comparison routine for the CIE map.

  struct Cie_less

  {

    bool

    operator()(const Cie* cie1, const Cie* cie2) const

    { return *cie1 < *cie2; }

  };

  // A set of unique CIEs.

  typedef std::set<Cie*, Cie_less> Cie_offsets;

  // A list of unmergeable CIEs.

  typedef std::vector<Cie*> Unmergeable_cie_offsets;

  // A mapping from offsets to CIEs.  This is used while reading an

  // input section.

  typedef std::map<uint64_t, Cie*> Offsets_to_cie;

  // A list of CIEs, and a bool indicating whether the CIE is

  // mergeable.

  typedef std::vector<std::pair<Cie*, bool> > New_cies;

  // Skip an LEB128.

  static bool

  skip_leb128(const unsigned char**, const unsigned char*);

  // The implementation of add_ehframe_input_section.

  template<int size, bool big_endian>

  bool

  do_add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,

                               const unsigned char* symbols,

                               section_size_type symbols_size,

                               const unsigned char* symbol_names,

                               section_size_type symbol_names_size,

                               unsigned int shndx,

                               unsigned int reloc_shndx,

                               unsigned int reloc_type,

                               const unsigned char* pcontents,

                               section_size_type contents_len,

                               New_cies*);

  // Read a CIE.

  template<int size, bool big_endian>

  bool

  read_cie(Sized_relobj_file<size, big_endian>* object,

           unsigned int shndx,

           const unsigned char* symbols,

           section_size_type symbols_size,

           const unsigned char* symbol_names,

           section_size_type symbol_names_size,

           const unsigned char* pcontents,

           const unsigned char* pcie,

           const unsigned char* pcieend,

           Track_relocs<size, big_endian>* relocs,

           Offsets_to_cie* cies,

           New_cies* new_cies);

  // Read an FDE.

  template<int size, bool big_endian>

  bool

  read_fde(Sized_relobj_file<size, big_endian>* object,

           unsigned int shndx,

           const unsigned char* symbols,

           section_size_type symbols_size,

           const unsigned char* pcontents,

           unsigned int offset,

           const unsigned char* pfde,

           const unsigned char* pfdeend,

           Track_relocs<size, big_endian>* relocs,

           Offsets_to_cie* cies);

  // Template version of write function.

  template<int size, bool big_endian>

  void

  do_sized_write(unsigned char* oview);

  // The exception frame header, if any.

  Eh_frame_hdr* eh_frame_hdr_;

  // A mapping from all unique CIEs to their offset in the output

  // file.

  Cie_offsets cie_offsets_;

  // A mapping from unmergeable CIEs to their offset in the output

  // file.

  Unmergeable_cie_offsets unmergeable_cie_offsets_;

  // A mapping from input sections to the output section.

  Merge_map merge_map_;

  // Whether we have created the mappings to the output section.

  bool mappings_are_done_;

  // The final data size.  This is only set if mappings_are_done_ is

  // true.

  section_size_type final_data_size_;

};

} // End namespace gold.

#endif // !defined(GOLD_EHFRAME_H)