tools/elftosb/common/ELFSourceFile.h

   1 /*
   2  * File:        ELFSourceFile.h
   3  *
   4  * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
   5  * See included license file for license details.
   6  */
   7 #if !defined(_ELFSourceFile_h_)
   8 #define _ELFSourceFile_h_
   9
  10 #include "SourceFile.h"
  11 #include "StELFFile.h"
  12 #include "smart_ptr.h"
  13 #include "DataSource.h"
  14 #include "DataTarget.h"
  15 #include "ELF.h"
  16
  17 namespace elftosb
  18 {
  19
  20 //! Set of supported compiler toolsets.
  21 enum elf_toolset_t
  22 {
  23         kUnknownToolset,        //!< Unknown.
  24         kGHSToolset,            //!< Green Hills Software MULTI
  25         kGCCToolset,            //!< GNU GCC
  26         kADSToolset                     //!< ARM UK RealView
  27 };
  28
  29 //! Options for handling the .secinfo section in GHS-produced ELF files.
  30 enum secinfo_clear_t
  31 {
  32         // Default value for the .secinfo action.
  33         kSecinfoDefault,
  34
  35         //! Ignore the .secinfo section if present. The standard ELF loading
  36         //! rules are followed.
  37         kSecinfoIgnore,
  38
  39         //! The boot ROM clears only those SHT_NOBITS sections present in .secinfo.
  40         kSecinfoROMClear,
  41
  42         //! The C startup is responsible for clearing sections. No fill commands
  43         //! are generated for any SHT_NOBITS sections.
  44         kSecinfoCStartupClear
  45 };
  46
  47 /*!
  48  * \brief Executable and Loading Format (ELF) source file.
  49  */
  50 class ELFSourceFile : public SourceFile
  51 {
  52 public:
  53         //! \brief Default constructor.
  54         ELFSourceFile(const std::string & path);
  55
  56         //! \brief Destructor.
  57         virtual ~ELFSourceFile();
  58
  59         //! \brief Identifies whether the stream contains an ELF file.
  60         static bool isELFFile(std::istream & stream);
  61
  62         //! \name Opening and closing
  63         //@{
  64         //! \brief Opens the file.
  65         virtual void open();
  66
  67         //! \brief Closes the file.
  68         virtual void close();
  69         //@}
  70
  71         //! \name Format capabilities
  72         //@{
  73         virtual bool supportsNamedSections() const { return true; }
  74         virtual bool supportsNamedSymbols() const { return true; }
  75         //@}
  76
  77         //! \name Data source
  78         //@{
  79         //! \brief Creates a data source from the entire file.
  80         virtual DataSource * createDataSource();
  81
  82         //! \brief Creates a data source from one or more sections of the file.
  83         virtual DataSource * createDataSource(StringMatcher & matcher);
  84         //@}
  85
  86         //! \name Entry point
  87         //@{
  88         //! \brief Returns true if an entry point was set in the file.
  89         virtual bool hasEntryPoint();
  90
  91         //! \brief Returns the entry point address.
  92         virtual uint32_t getEntryPointAddress();
  93         //@}
  94
  95         //! \name Data target
  96         //@{
  97         virtual DataTarget * createDataTargetForSection(const std::string & section);
  98         virtual DataTarget * createDataTargetForSymbol(const std::string & symbol);
  99         //@}
 100
 101         //! \name Symbols
 102         //@{
 103         //! \brief Returns whether a symbol exists in the source file.
 104         virtual bool hasSymbol(const std::string & name);
 105
 106         //! \brief Returns the value of a symbol.
 107         virtual uint32_t getSymbolValue(const std::string & name);
 108
 109         //! \brief Returns the size of a symbol.
 110         virtual unsigned getSymbolSize(const std::string & name);
 111         //@}
 112
 113         //! \name Direct ELF format access
 114         //@{
 115         //! \brief Returns the underlying StELFFile object.
 116         StELFFile * getELFFile() { return m_file; }
 117
 118         //! \brief Gets information about a symbol in the ELF file.
 119         bool lookupSymbol(const std::string & name, Elf32_Sym & info);
 120         //@}
 121
 122 protected:
 123         smart_ptr<StELFFile> m_file;    //!< Parser for the ELF file.
 124         elf_toolset_t m_toolset;        //!< Toolset that produced the ELF file.
 125         secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.
 126
 127 protected:
 128         //! \brief Parses the toolset option value.
 129         elf_toolset_t readToolsetOption();
 130
 131         //! \brief Reads the secinfoClear option.
 132         secinfo_clear_t readSecinfoClearOption();
 133
 134 protected:
 135         /*!
 136          * \brief A data source with ELF file sections as the contents.
 137          *
 138          * Each segment of this data source corresponds directly with a named section
 139          * of the ELF file it represents. When the data source is created, it contains
 140          * no segments. Segments are created with the addSection() method, which takes
 141          * the index of an ELF section and creates a corresponding segment.
 142          *
 143          * Two segment subclasses are used with this data source. The first, ProgBitsSegment,
 144          * is used to represent sections whose type is #SHT_PROGBITS. These sections have
 145          * binary data stored in the ELF file. The second segment type is NoBitsSegment.
 146          * It is used to represent sections whose type is #SHT_NOBITS. These sections have
 147          * no data, but simply allocate a region of memory to be filled with zeroes.
 148          * As such, the NoBitsSegment class is a subclass of DataSource::PatternSegment.
 149          */
 150         class ELFDataSource : public DataSource
 151         {
 152         public:
 153                 /*!
 154                  * \brief Represents one named #SHT_PROGBITS section within the ELF file.
 155                  */
 156                 class ProgBitsSegment : public DataSource::Segment
 157                 {
 158                 public:
 159                         ProgBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);
 160
 161                         virtual unsigned getData(unsigned offset, unsigned maxBytes, uint8_t * buffer);
 162                         virtual unsigned getLength();
 163
 164                         virtual bool hasNaturalLocation() { return true; }
 165                         virtual uint32_t getBaseAddress();
 166
 167                 protected:
 168                         StELFFile * m_elf;      //!< The format parser instance for this ELF file.
 169                         unsigned m_sectionIndex;        //!< The index of the section this segment represents.
 170                 };
 171
 172                 /*!
 173                  * \brief Represents one named #SHT_NOBITS section within the ELF file.
 174                  *
 175                  * This segment class is a subclass of DataSource::PatternSegment since it
 176                  * represents a region of memory to be filled with zeroes.
 177                  */
 178                 class NoBitsSegment : public DataSource::PatternSegment
 179                 {
 180                 public:
 181                         NoBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);
 182
 183                         virtual unsigned getLength();
 184
 185                         virtual bool hasNaturalLocation() { return true; }
 186                         virtual uint32_t getBaseAddress();
 187
 188                 protected:
 189                         StELFFile * m_elf;      //!< The format parser instance for this ELF file.
 190                         unsigned m_sectionIndex;        //!< The index of the section this segment represents.
 191                 };
 192
 193         public:
 194                 //! \brief Default constructor.
 195                 ELFDataSource(StELFFile * elf) : DataSource(), m_elf(elf) {}
 196
 197                 //! \brief Destructor.
 198                 virtual ~ELFDataSource();
 199
 200                 //! Set the option to control .secinfo usage.
 201                 inline void setSecinfoOption(secinfo_clear_t option) { m_secinfoOption = option; }
 202
 203                 //! \brief Adds the ELF section at position \a sectionIndex to the data source.
 204                 void addSection(unsigned sectionIndex);
 205
 206                 //! \brief Returns the number of segments in the source.
 207                 virtual unsigned getSegmentCount() { return (unsigned)m_segments.size(); }
 208
 209                 //! \brief Returns the segment at position \a index.
 210                 virtual DataSource::Segment * getSegmentAt(unsigned index) { return m_segments[index]; }
 211
 212         protected:
 213                 StELFFile * m_elf;      //!< The ELF file parser.
 214                 secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.
 215
 216                 typedef std::vector<DataSource::Segment*> segment_vector_t;     //!< A list of segment instances.
 217                 segment_vector_t m_segments;    //!< The segments of this data source.
 218         };
 219
 220 };
 221
 222 }; // namespace elftosb
 223
 224 #endif // _ELFSourceFile_h_