/*
* File:        ELFSourceFile.h
*
* Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
* See included license file for license details.
*/
#if !defined(_ELFSourceFile_h_)
#define _ELFSourceFile_h_

#include "SourceFile.h"
#include "StELFFile.h"
#include "smart_ptr.h"
#include "DataSource.h"
#include "DataTarget.h"
#include "ELF.h"

namespace elftosb
{

//! Set of supported compiler toolsets.
enum elf_toolset_t
{
       kUnknownToolset,        //!< Unknown.
       kGHSToolset,            //!< Green Hills Software MULTI
       kGCCToolset,            //!< GNU GCC
       kADSToolset                     //!< ARM UK RealView
};

//! Options for handling the .secinfo section in GHS-produced ELF files.
enum secinfo_clear_t
{
       // Default value for the .secinfo action.
       kSecinfoDefault,

       //! Ignore the .secinfo section if present. The standard ELF loading
       //! rules are followed.
       kSecinfoIgnore,

       //! The boot ROM clears only those SHT_NOBITS sections present in .secinfo.
       kSecinfoROMClear,

       //! The C startup is responsible for clearing sections. No fill commands
       //! are generated for any SHT_NOBITS sections.
       kSecinfoCStartupClear
};

/*!
* \brief Executable and Loading Format (ELF) source file.
*/
class ELFSourceFile : public SourceFile
{
public:
       //! \brief Default constructor.
       ELFSourceFile(const std::string & path);

       //! \brief Destructor.
       virtual ~ELFSourceFile();

       //! \brief Identifies whether the stream contains an ELF file.
       static bool isELFFile(std::istream & stream);

       //! \name Opening and closing
       //@{
       //! \brief Opens the file.
       virtual void open();

       //! \brief Closes the file.
       virtual void close();
       //@}

       //! \name Format capabilities
       //@{
       virtual bool supportsNamedSections() const { return true; }
       virtual bool supportsNamedSymbols() const { return true; }
       //@}

       //! \name Data source
       //@{
       //! \brief Creates a data source from the entire file.
       virtual DataSource * createDataSource();

       //! \brief Creates a data source from one or more sections of the file.
       virtual DataSource * createDataSource(StringMatcher & matcher);
       //@}

       //! \name Entry point
       //@{
       //! \brief Returns true if an entry point was set in the file.
       virtual bool hasEntryPoint();

       //! \brief Returns the entry point address.
       virtual uint32_t getEntryPointAddress();
       //@}

       //! \name Data target
       //@{
       virtual DataTarget * createDataTargetForSection(const std::string & section);
       virtual DataTarget * createDataTargetForSymbol(const std::string & symbol);
       //@}

       //! \name Symbols
       //@{
       //! \brief Returns whether a symbol exists in the source file.
       virtual bool hasSymbol(const std::string & name);

       //! \brief Returns the value of a symbol.
       virtual uint32_t getSymbolValue(const std::string & name);

       //! \brief Returns the size of a symbol.
       virtual unsigned getSymbolSize(const std::string & name);
       //@}

       //! \name Direct ELF format access
       //@{
       //! \brief Returns the underlying StELFFile object.
       StELFFile * getELFFile() { return m_file; }

       //! \brief Gets information about a symbol in the ELF file.
       bool lookupSymbol(const std::string & name, Elf32_Sym & info);
       //@}

protected:
       smart_ptr<StELFFile> m_file;    //!< Parser for the ELF file.
       elf_toolset_t m_toolset;        //!< Toolset that produced the ELF file.
       secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.

protected:
       //! \brief Parses the toolset option value.
       elf_toolset_t readToolsetOption();

       //! \brief Reads the secinfoClear option.
       secinfo_clear_t readSecinfoClearOption();

protected:
       /*!
        * \brief A data source with ELF file sections as the contents.
        *
        * Each segment of this data source corresponds directly with a named section
        * of the ELF file it represents. When the data source is created, it contains
        * no segments. Segments are created with the addSection() method, which takes
        * the index of an ELF section and creates a corresponding segment.
        *
        * Two segment subclasses are used with this data source. The first, ProgBitsSegment,
        * is used to represent sections whose type is #SHT_PROGBITS. These sections have
        * binary data stored in the ELF file. The second segment type is NoBitsSegment.
        * It is used to represent sections whose type is #SHT_NOBITS. These sections have
        * no data, but simply allocate a region of memory to be filled with zeroes.
        * As such, the NoBitsSegment class is a subclass of DataSource::PatternSegment.
        */
       class ELFDataSource : public DataSource
       {
       public:
               /*!
                * \brief Represents one named #SHT_PROGBITS section within the ELF file.
                */
               class ProgBitsSegment : public DataSource::Segment
               {
               public:
                       ProgBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);

                       virtual unsigned getData(unsigned offset, unsigned maxBytes, uint8_t * buffer);
                       virtual unsigned getLength();

                       virtual bool hasNaturalLocation() { return true; }
                       virtual uint32_t getBaseAddress();

               protected:
                       StELFFile * m_elf;      //!< The format parser instance for this ELF file.
                       unsigned m_sectionIndex;        //!< The index of the section this segment represents.
               };

               /*!
                * \brief Represents one named #SHT_NOBITS section within the ELF file.
                *
                * This segment class is a subclass of DataSource::PatternSegment since it
                * represents a region of memory to be filled with zeroes.
                */
               class NoBitsSegment : public DataSource::PatternSegment
               {
               public:
                       NoBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);

                       virtual unsigned getLength();

                       virtual bool hasNaturalLocation() { return true; }
                       virtual uint32_t getBaseAddress();

               protected:
                       StELFFile * m_elf;      //!< The format parser instance for this ELF file.
                       unsigned m_sectionIndex;        //!< The index of the section this segment represents.
               };

       public:
               //! \brief Default constructor.
               ELFDataSource(StELFFile * elf) : DataSource(), m_elf(elf) {}

               //! \brief Destructor.
               virtual ~ELFDataSource();

               //! Set the option to control .secinfo usage.
               inline void setSecinfoOption(secinfo_clear_t option) { m_secinfoOption = option; }

               //! \brief Adds the ELF section at position \a sectionIndex to the data source.
               void addSection(unsigned sectionIndex);

               //! \brief Returns the number of segments in the source.
               virtual unsigned getSegmentCount() { return (unsigned)m_segments.size(); }

               //! \brief Returns the segment at position \a index.
               virtual DataSource::Segment * getSegmentAt(unsigned index) { return m_segments[index]; }

       protected:
               StELFFile * m_elf;      //!< The ELF file parser.
               secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.

               typedef std::vector<DataSource::Segment*> segment_vector_t;     //!< A list of segment instances.
               segment_vector_t m_segments;    //!< The segments of this data source.
       };

};

}; // namespace elftosb

#endif // _ELFSourceFile_h_

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.