Add KBOOT.

apps/elftosb/common/StExecutableImage.h

@@ -0,0 +1,257 @@
+/*
+ * File:	StExecutableImage.h
+ *
+ * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
+ * See included license file for license details.
+ */
+#if !defined(_StExecutableImage_h_)
+#define _StExecutableImage_h_
+
+#include "stdafx.h"
+#include <list>
+
+/*!
+ * \brief Used to build a representation of memory regions.
+ *
+ * An intermediate representation of the memory regions and segments loaded
+ * from an executable file. Also used to find contiguous segments that are
+ * specified separately in the source file.
+ *
+ * When regions are added, an attempt is made to coalesce contiguous regions.
+ * In order for this to succeed, the touching regions must be of the same
+ * type and have the same permissions. Regions are also kept sorted by their
+ * address range as they are added.
+ *
+ * \todo Implement alignment support.
+ */
+class StExecutableImage
+{
+public:
+    //! Possible types of memory regions.
+    typedef enum
+    {
+        TEXT_REGION, //!< A region containing data or instructions.
+        FILL_REGION  //!< Region to be initialized with zero bytes.
+    } MemoryRegionType;
+
+    //! Memory region flag constants.
+    enum
+    {
+        REGION_READ_FLAG = 1,  //!< Region is readable.
+        REGION_WRITE_FLAG = 2, //!< Region is writable.
+        REGION_EXEC_FLAG = 4,  //!< Region may contain executable code.
+
+        REGION_RW_FLAG = REGION_READ_FLAG | REGION_WRITE_FLAG, //!< Region is read-write.
+
+        //! Mask to access only permissions flags for a region.
+        REGION_PERM_FLAG_MASK = 0x7
+    };
+
+    /*!
+     * Representation of a contiguous region of memory.
+        *
+        * \todo Add comparison operators so we can use the STL sort algorithm.
+     */
+    struct MemoryRegion
+    {
+        MemoryRegionType m_type; //!< Memory region type.
+        uint32_t m_address;      //!< The 32-bit start address of this region.
+        uint32_t m_length;       //!< Number of bytes in this region.
+        uint8_t *m_data;         //!< Pointer to data. Will be NULL for FILL_REGION type.
+        unsigned m_flags;        //!< Flags for the region.
+
+        //! \brief Calculates the address of the last byte occupied by this region.
+        inline uint32_t endAddress() const { return m_address + m_length - 1; }
+        //! \brief Equality operator.
+        bool operator==(const MemoryRegion &other) const;
+    };
+
+    //! A list of #StExecutableImage::MemoryRegion objects.
+    typedef std::list<MemoryRegion> MemoryRegionList;
+
+    //! The iterator type used to access #StExecutableImage::MemoryRegion objects. This type
+    //! is used by the methods #getRegionBegin() and #getRegionEnd().
+    typedef MemoryRegionList::const_iterator const_iterator;
+
+    //! The possible actions for regions matching an address filter range.
+    typedef enum
+    {
+        ADDR_FILTER_NONE,    //!< Do nothing.
+        ADDR_FILTER_ERROR,   //!< Raise an error exception.
+        ADDR_FILTER_WARNING, //!< Raise a warning exception.
+        ADDR_FILTER_CROP     //!< Don't include the matching address range in the executable image.
+    } AddressFilterAction;
+
+    /*!
+     * An address filter consists of a single address range and an action. If a
+     * memory region overlaps the filter's range then the action will be performed.
+     * The possible filter actions are defined by the #AddressFilterAction enumeration.
+     */
+    struct AddressFilter
+    {
+        AddressFilterAction m_action; //!< Action to be performed when the filter is matched.
+        uint32_t m_fromAddress;       //!< Start address of the filter. Should be lower than or equal to #m_toAddress.
+        uint32_t m_toAddress;         //!< End address of the filter. Should be higher than or equal to #m_fromAddress.
+        unsigned m_priority;          //!< Priority for this filter. Zero is the lowest priority.
+
+        //! \brief Constructor.
+        AddressFilter(AddressFilterAction action, uint32_t from, uint32_t to, unsigned priority = 0)
+            : m_action(action)
+            , m_fromAddress(from)
+            , m_toAddress(to)
+            , m_priority(priority)
+        {
+        }
+
+        //! \brief Test routine.
+        bool matchesMemoryRegion(const MemoryRegion &region) const;
+
+        //! \brief Compares two address filter objects.
+        int compare(const AddressFilter &other) const;
+
+        //! \name Comparison operators
+        //@{
+        inline bool operator<(const AddressFilter &other) const { return compare(other) == -1; }
+        inline bool operator>(const AddressFilter &other) const { return compare(other) == 1; }
+        inline bool operator==(const AddressFilter &other) const { return compare(other) == 0; }
+        inline bool operator<=(const AddressFilter &other) const { return compare(other) != 1; }
+        inline bool operator>=(const AddressFilter &other) const { return compare(other) != -1; }
+        //@}
+    };
+
+    //! List of #StExecutableImage::AddressFilter objects.
+    typedef std::list<AddressFilter> AddressFilterList;
+
+    //! The exception class raised for the #ADDR_FILTER_ERROR and #ADDR_FILTER_WARNING
+    //! filter actions.
+    class address_filter_exception
+    {
+    public:
+        //! \brief Constructor.
+        //!
+        //! A local copy of \a matchingFilter is made, in case the image and/or filter
+        //! are on the stack and would be disposed of when the exception is raised.
+        address_filter_exception(bool isError, std::string &imageName, const AddressFilter &matchingFilter)
+            : m_isError(isError)
+            , m_imageName(imageName)
+            , m_filter(matchingFilter)
+        {
+        }
+
+        //! \brief Returns true if the exception is an error. Otherwise the exception
+        //!     is for a warning.
+        inline bool isError() const { return m_isError; }
+        //! \brief
+        inline std::string getImageName() const { return m_imageName; }
+        //! \brief
+        inline const AddressFilter &getMatchingFilter() const { return m_filter; }
+    protected:
+        bool m_isError;
+        std::string m_imageName;
+        AddressFilter m_filter;
+    };
+
+public:
+    //! \brief Constructor.
+    StExecutableImage(int inAlignment = 256);
+
+    //! \brief Copy constructor.
+    StExecutableImage(const StExecutableImage &inOther);
+
+    //! \brief Destructor.
+    virtual ~StExecutableImage();
+
+    //! \name Image name
+    //! Methods for getting and setting the image name.
+    //@{
+    //! \brief Sets the image's name to \a inName.
+    virtual void setName(const std::string &inName);
+
+    //! \brief Returns a copy of the image's name.
+    virtual std::string getName() const;
+    //@}
+
+    //! \name Regions
+    //! Methods to add and access memory regions.
+    //@{
+    //! \brief Add a region to be filled with zeroes.
+    virtual void addFillRegion(uint32_t inAddress, unsigned inLength);
+
+    //! \brief Add a region containing data to be loaded.
+    virtual void addTextRegion(uint32_t inAddress, const uint8_t *inData, unsigned inLength);
+
+    //! \brief Returns the total number of regions.
+    //!
+    //! Note that this count may not be the same as the number of calls to
+    //! addFillRegion() and addTextRegion() due to region coalescing.
+    inline unsigned getRegionCount() const { return static_cast<unsigned>(m_image.size()); }
+    //! \brief Returns a reference to the region specified by \a inIndex.
+    const MemoryRegion &getRegionAtIndex(unsigned inIndex) const;
+
+    //! \brief Return an iterator to the first region.
+    inline const_iterator getRegionBegin() const { return m_image.begin(); }
+    //! \brief Return an iterator to the next-after-last region.
+    inline const_iterator getRegionEnd() const { return m_image.end(); }
+    //@}
+
+    //! \name Entry point
+    //@{
+    //! \brief Sets the entry point address.
+    inline void setEntryPoint(uint32_t inEntryAddress)
+    {
+        m_entry = inEntryAddress;
+        m_hasEntry = true;
+    }
+
+    //! \brief Returns true if an entry point has been set.
+    inline bool hasEntryPoint() const { return m_hasEntry; }
+    //! \brief Returns the entry point address.
+    inline uint32_t getEntryPoint() const { return hasEntryPoint() ? m_entry : 0; }
+    //@}
+
+    //! \name Address filter
+    //@{
+    //! \brief Add a new address filter.
+    virtual void addAddressFilter(const AddressFilter &filter);
+
+    //! \brief Add multiple address filters at once.
+    //!
+    //! The template argument \a _T must be an iterator or const iterator that
+    //! dereferences to an StExecutableImage::AddressFilter reference. All filters
+    //! from \a from to \a to will be added to the address filter list.
+    template <typename _T>
+    void addAddressFilters(_T from, _T to)
+    {
+        _T it = from;
+        for (; it != to; ++it)
+        {
+            addAddressFilter(*it);
+        }
+    }
+
+    //! \brief Remove all active filters.
+    virtual void clearAddressFilters();
+
+    //! \brief Process all active filters and perform associated actions.
+    virtual void applyAddressFilters();
+    //@}
+
+protected:
+    std::string m_name;          //!< The name of the image (can be a file name, for instance).
+    int m_alignment;             //!< The required address alignment for each memory region.
+    bool m_hasEntry;             //!< True if an entry point has been set.
+    uint32_t m_entry;            //!< Entry point address.
+    MemoryRegionList m_image;    //!< The memory regions.
+    AddressFilterList m_filters; //!< List of active address filters.
+
+    //! \brief Deletes the portion \a region that overlaps \a filter.
+    void cropRegionToFilter(MemoryRegion &region, const AddressFilter &filter);
+
+    //! \brief Inserts the region in sorted order or merges with one already in the image.
+    void insertOrMergeRegion(MemoryRegion &inRegion);
+
+    //! \brief Merges two memory regions into one.
+    void mergeRegions(MemoryRegion &inOldRegion, MemoryRegion &inNewRegion);
+};
+
+#endif // _StExecutableImage_h_