src/blfwk/StExecutableImage.h

/*
 * Copyright (c) 2013-14, Freescale Semiconductor, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o Redistributions in binary form must reproduce the above copyright notice, this
 *   list of conditions and the following disclaimer in the documentation and/or
 *   other materials provided with the distribution.
 *
 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#if !defined(_StExecutableImage_h_)
#define _StExecutableImage_h_

#include "blfwk/stdafx.h"
#include <list>

class StExecutableImage
{
public:
    typedef enum
    {
        TEXT_REGION, 
        FILL_REGION  
    } MemoryRegionType;

    enum
    {
        REGION_READ_FLAG = 1,  
        REGION_WRITE_FLAG = 2, 
        REGION_EXEC_FLAG = 4,  

        REGION_RW_FLAG = REGION_READ_FLAG | REGION_WRITE_FLAG, 

        REGION_PERM_FLAG_MASK = 0x7
    };

    struct MemoryRegion
    {
        MemoryRegionType m_type; 
        uint32_t m_address;      
        uint32_t m_length;       
        uint8_t *m_data;         
        unsigned m_flags;        

        inline uint32_t endAddress() const { return m_address + m_length - 1; }
        bool operator==(const MemoryRegion &other) const;
    };

    typedef std::list<MemoryRegion> MemoryRegionList;

    typedef MemoryRegionList::const_iterator const_iterator;

    typedef enum
    {
        ADDR_FILTER_NONE,    
        ADDR_FILTER_ERROR,   
        ADDR_FILTER_WARNING, 
        ADDR_FILTER_CROP     
    } AddressFilterAction;

    struct AddressFilter
    {
        AddressFilterAction m_action; 
        uint32_t m_fromAddress;       
        uint32_t m_toAddress;         
        unsigned m_priority;          

        AddressFilter(AddressFilterAction action, uint32_t from, uint32_t to, unsigned priority = 0)
            : m_action(action)
            , m_fromAddress(from)
            , m_toAddress(to)
            , m_priority(priority)
        {
        }

        bool matchesMemoryRegion(const MemoryRegion &region) const;

        int compare(const AddressFilter &other) const;


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

    typedef std::list<AddressFilter> AddressFilterList;

    class address_filter_exception
    {
    public:
        address_filter_exception(bool isError, std::string &imageName, const AddressFilter &matchingFilter)
            : m_isError(isError)
            , m_imageName(imageName)
            , m_filter(matchingFilter)
        {
        }

        inline bool isError() const { return m_isError; }
        inline std::string getImageName() const { return m_imageName; }
        inline const AddressFilter &getMatchingFilter() const { return m_filter; }
    protected:
        bool m_isError;
        std::string m_imageName;
        AddressFilter m_filter;
    };

public:
    StExecutableImage(int inAlignment = 256);

    StExecutableImage(const StExecutableImage &inOther);

    virtual ~StExecutableImage();


    virtual void setName(const std::string &inName);

    virtual std::string getName() const;


    virtual void addFillRegion(uint32_t inAddress, unsigned inLength);

    virtual void addTextRegion(uint32_t inAddress, const uint8_t *inData, unsigned inLength);

    inline unsigned getRegionCount() const { return static_cast<unsigned>(m_image.size()); }
    const MemoryRegion &getRegionAtIndex(unsigned inIndex) const;

    inline const_iterator getRegionBegin() const { return m_image.begin(); }
    inline const_iterator getRegionEnd() const { return m_image.end(); }


    inline void setEntryPoint(uint32_t inEntryAddress)
    {
        m_entry = inEntryAddress;
        m_hasEntry = true;
    }

    inline bool hasEntryPoint() const { return m_hasEntry; }
    inline uint32_t getEntryPoint() const { return hasEntryPoint() ? m_entry : 0; }


    virtual void addAddressFilter(const AddressFilter &filter);

    template <typename _T>
    void addAddressFilters(_T from, _T to)
    {
        _T it = from;
        for (; it != to; ++it)
        {
            addAddressFilter(*it);
        }
    }

    virtual void clearAddressFilters();

    virtual void applyAddressFilters();

protected:
    std::string m_name;          
    int m_alignment;             
    bool m_hasEntry;             
    uint32_t m_entry;            
    MemoryRegionList m_image;    
    AddressFilterList m_filters; 

    void cropRegionToFilter(MemoryRegion &region, const AddressFilter &filter);

    void insertOrMergeRegion(MemoryRegion &inRegion);

    void mergeRegions(MemoryRegion &inOldRegion, MemoryRegion &inNewRegion);
};

#endif // _StExecutableImage_h_