MemoryMap.h

Go to the documentation of this file.

#ifndef ROSE_MemoryMap_H
#define ROSE_MemoryMap_H

#include "ByteOrder.h"
#include <boost/shared_ptr.hpp>

/* Increase ADDR if necessary to make it a multiple of ALMNT */
#define ALIGN_UP(ADDR,ALMNT)       ((((ADDR)+(ALMNT)-1)/(ALMNT))*(ALMNT))

/* Decrease ADDR if necessary to make it a multiple of ALMNT */
#define ALIGN_DN(ADDR,ALMNT)       (((ADDR)/(ALMNT))*(ALMNT))


class MemoryMap {
public:

    enum Protection {
        /* Protection bits */
        MM_PROT_BITS    = 0x00000007,     /*NO_STRINGIFY*/
        MM_PROT_READ    = 0x00000001,    
        MM_PROT_WRITE   = 0x00000002,    
        MM_PROT_EXEC    = 0x00000004,    
        /* Protection convenience stuff */
        MM_PROT_NONE    = 0x00000000,    
        MM_PROT_ANY     = 0x00000007,    
        MM_PROT_RW      = (MM_PROT_READ|MM_PROT_WRITE),                   /*NO_STRINGIFY*/
        MM_PROT_RX      = (MM_PROT_READ|MM_PROT_EXEC),                  /*NO_STRINGIFY*/
        MM_PROT_RWX     = (MM_PROT_ANY),                                                        /*NO_STRINGIFY*/

        /* Other flags. These generally aren't interpreted by MemoryMap, but can be used to pass info.  When merging memory
         * segments, MemoryMap::Segment::merge() will not treat two regions as being consistent if they have different
         * bits set. */
        MM_PROT_FLAGS   = 0xfffffff0,   
        MM_PROT_PRIVATE = 0x00000010,   
    };

    enum CopyLevel {
        COPY_SHALLOW,                   
        COPY_DEEP,                      
        COPY_ON_WRITE                   
    };

    /**************************************************************************************************************************
     *                                  Buffers
     **************************************************************************************************************************/
public:
    class Buffer;
    typedef boost::shared_ptr<Buffer> BufferPtr;

    class Buffer {
    public:
        virtual ~Buffer() {}

        virtual BufferPtr clone() const = 0;

        virtual bool is_read_only() const { return read_only; }
        virtual void set_read_only(bool b=true) { read_only = b; }
        void clear_read_only() { set_read_only(false); } // final
        virtual std::string get_name() const { return name; }
        virtual void set_name(const std::string &s) { name = s; }
        virtual size_t size() const { return p_size; }
        virtual void resize(size_t n) { p_size = n; }
        virtual size_t read(void *buf, size_t offset, size_t nbytes) const = 0;

        virtual size_t write(const void *buf, size_t offset, size_t nbytes) = 0;

        virtual void save(const std::string &filename) const;

        virtual const void* get_data_ptr() const = 0;

        virtual bool is_zero() const;

    protected:
        Buffer(size_t size): read_only(false), p_size(size) { name=new_name(); }
        std::string new_name() /*final*/;

        bool read_only;                         
        std::string name;                       
        size_t p_size;                          
    };

    class NullBuffer: public Buffer {
    public:
        static BufferPtr create(size_t size);

        virtual const void *get_data_ptr() const /*overrides*/ { return NULL; }

        virtual BufferPtr clone() const { return create(size()); }
        virtual size_t read(void*, size_t offset, size_t nbytes) const /*overrides*/ { return 0; }
        virtual size_t write(const void*, size_t offset, size_t nbytes) /*overrides*/ { return 0; }

    protected:
        NullBuffer(size_t size): Buffer(size) {}
    };

    class ExternBuffer: public Buffer {
    public:
        static BufferPtr create(void *data, size_t size);
        static BufferPtr create(const void *data, size_t size);
        virtual BufferPtr clone() const;
        virtual void resize(size_t n) /*overrides*/;
        virtual const void *get_data_ptr() const /*overrides*/ { return p_data; }
        virtual size_t read(void*, size_t offset, size_t nbytes) const /*overrides*/;
        virtual size_t write(const void*, size_t offset, size_t nbytes) /*overrides*/;

    protected:
        ExternBuffer(const uint8_t *data, size_t size)
            : Buffer(size), p_data(const_cast<uint8_t*>(data)) { set_read_only(); }
        ExternBuffer(uint8_t *data, size_t size)
            : Buffer(size), p_data(data) {}
        mutable uint8_t *p_data;
    };

    class ByteBuffer: public ExternBuffer {
    public:
        virtual ~ByteBuffer() { delete[] p_data; }

        static BufferPtr create(void *data, size_t size);

        static BufferPtr create_from_file(const std::string &filename, size_t start_offset=0);

    protected:
        ByteBuffer(uint8_t *data, size_t size): ExternBuffer(data, size) {}
    };

    class MmapBuffer: public ExternBuffer {
    public:
        virtual ~MmapBuffer();

        static BufferPtr create(size_t length, int prot, int flags, int fd, off_t offset);

        static BufferPtr create(const std::string &filename, int oflags, int mprot, int mflags);

        virtual void resize(size_t n) /*overrides*/;

    protected:
        MmapBuffer(uint8_t *data, size_t size, bool read_only): ExternBuffer(data, size) { set_read_only(read_only); }
    };

    class AnonymousBuffer: public ExternBuffer {
    public:
        virtual ~AnonymousBuffer() { delete[] p_data; }

        static BufferPtr create(size_t size);

        virtual BufferPtr clone() const /*overrides*/;
        virtual const void *get_data_ptr() const /*overrides*/;
        virtual size_t read(void*, size_t offset, size_t nbytes) const /*overrides*/;
        virtual size_t write(const void*, size_t offset, size_t nbytes) /*overrides*/;
        virtual bool is_zero() const /*overrides*/;

    protected:
        AnonymousBuffer(size_t size): ExternBuffer((uint8_t*)NULL, size) {}
    };

    /**************************************************************************************************************************
     *                                  Segments
     **************************************************************************************************************************/
public:

    class Segment {
    public:
        Segment(): buffer_offset(0), mapperms(0), copy_on_write(false) {}

        Segment(const BufferPtr &buffer, rose_addr_t offset, unsigned perms, std::string name="")
            : buffer(buffer), buffer_offset(offset), mapperms(perms), name(name), copy_on_write(false) {}

        BufferPtr get_buffer() const { return buffer; }
        void set_buffer(const BufferPtr &b) { buffer = b; }
        bool check(const Extent &range, rose_addr_t *first_bad_va=NULL) const;

        unsigned get_mapperms() const { return mapperms; }
        void set_mapperms(unsigned p) { mapperms = p; }
        rose_addr_t get_buffer_offset() const { return buffer_offset; }
        rose_addr_t get_buffer_offset(const Extent &my_range, rose_addr_t va) const;
        void set_buffer_offset(rose_addr_t n);
        bool is_cow() const { return copy_on_write; }
        void set_cow(bool b=true) { copy_on_write = b; }
        void clear_cow() { set_cow(false); }
        bool operator==(const Segment &other) const;

        const std::string &get_name() const { return name; }
        void set_name(const std::string &s) { name = s; }
        friend std::ostream& operator<<(std::ostream&, const Segment&);

    private:
        // Stuff for manipulating segment debug names
        typedef std::map<std::string, std::set<std::string> > NamePairings;
        void merge_names(const Segment &other);
        std::string get_name_pairings(NamePairings*) const;
        void set_name(const NamePairings&, const std::string &s1, const std::string &s2);

        // The following methods are part of the RangeMap interface.  See documentation in RangeMap::RangeMapVoid.
        friend class RangeMap<Extent, Segment>;
        void removing(const Extent &range);
        void truncate(const Extent &range, rose_addr_t new_end);
        bool merge(const Extent &range, const Extent &other_range, const Segment &other_segment);
        Segment split(const Extent &range, rose_addr_t new_end);
        void print(std::ostream&) const;

    private:
        BufferPtr buffer;               
        rose_addr_t buffer_offset;      
        unsigned mapperms;              
        std::string name;               
        bool copy_on_write;             
    };

    /**************************************************************************************************************************
     *                                  RangeMap-related things
     **************************************************************************************************************************/
public:
    typedef RangeMap<Extent, Segment> Segments;
    typedef Segments::iterator iterator;
    typedef Segments::const_iterator const_iterator;
    typedef Segments::reverse_iterator reverse_iterator;
    typedef Segments::const_reverse_iterator const_reverse_iterator;

    /**************************************************************************************************************************
     *                                  Visitors
     **************************************************************************************************************************/
public:
    class Visitor {
    public:
        virtual ~Visitor() {}
        virtual bool operator()(const MemoryMap*, const Extent&, const Segment&) = 0;
    };

    /**************************************************************************************************************************
     *                                  Exceptions
     **************************************************************************************************************************/
public:
    class Exception: public std::runtime_error {
    public:
        Exception(const std::string &mesg, const MemoryMap *map): std::runtime_error(mesg), map(map) {}
        virtual ~Exception() throw() {}
        virtual std::string leader(std::string dflt="memory map problem") const;   
        virtual std::string details(bool) const; 
        virtual void print(std::ostream&, bool verbose=true) const;
        friend std::ostream& operator<<(std::ostream&, const Exception&);
    public:
        const MemoryMap *map;           
    };

    struct Inconsistent : public Exception {
        Inconsistent(const std::string &mesg, const MemoryMap *map,
                     const Extent &new_range, const Segment &new_segment,
                     const Extent &old_range, const Segment &old_segment)
            : Exception(mesg, map),
              new_range(new_range), old_range(old_range),
              new_segment(new_segment), old_segment(old_segment) {}
        virtual ~Inconsistent() throw() {}
        virtual void print(std::ostream&, bool verbose=true) const;
        friend std::ostream& operator<<(std::ostream&, const Inconsistent&);
        Extent new_range, old_range;
        Segment new_segment, old_segment;
    };

    struct NotMapped : public Exception {
        NotMapped(const std::string &mesg, const MemoryMap *map, rose_addr_t va)
            : Exception(mesg, map), va(va) {}
        virtual ~NotMapped() throw() {}
        virtual void print(std::ostream&, bool verbose=true) const;
        friend std::ostream& operator<<(std::ostream&, const NotMapped&);
        rose_addr_t va;
    };

    struct NoFreeSpace : public Exception {
        NoFreeSpace(const std::string &mesg, const MemoryMap *map, size_t size)
            : Exception(mesg, map), size(size) {}
        virtual ~NoFreeSpace() throw() {}
        virtual void print(std::ostream&, bool verbose=true) const;
        friend std::ostream& operator<<(std::ostream&, const NoFreeSpace&);
        size_t size;
    };

    struct SyntaxError: public Exception {
        SyntaxError(const std::string &mesg, const MemoryMap *map, const std::string &filename, unsigned linenum, int colnum=-1)
            : Exception(mesg, map), filename(filename), linenum(linenum), colnum(colnum) {}
        virtual ~SyntaxError() throw() {}
        virtual void print(std::ostream&, bool verbose=true) const;
        friend std::ostream& operator<<(std::ostream&, const SyntaxError&);
        std::string filename;                   
        unsigned linenum;                       
        int colnum;                             
    };

    /**************************************************************************************************************************
     *                                  Public Methods for MemoryMap
     **************************************************************************************************************************/

    MemoryMap(): sex(ByteOrder::ORDER_UNSPECIFIED) {}

    MemoryMap(const MemoryMap &other, CopyLevel copy_level=COPY_SHALLOW)
        : sex(ByteOrder::ORDER_UNSPECIFIED) {
        init(other, copy_level);
    }

    MemoryMap& init(const MemoryMap &source, CopyLevel copy_level=COPY_SHALLOW);

    bool empty() const { return p_segments.empty(); }

    void clear();

    size_t size() const;

    ByteOrder::Endianness get_byte_order() const { return sex; }
    void set_byte_order(ByteOrder::Endianness order) { sex = order; }
    void insert(const Extent &range, const Segment &segment, bool erase_prior=true);

    size_t insert_file(const std::string &filename, rose_addr_t va, bool writable=false, bool erase_prior=true,
                       const std::string &sgmtname="");

    bool exists(rose_addr_t va, unsigned required_perms=0) const { return exists(Extent(va), required_perms); }
    bool exists(Extent range, unsigned required_perms=0) const;
    void erase(const Extent &range);

    void erase(const Segment&);

    std::pair<Extent, Segment> at(rose_addr_t va) const;

    rose_addr_t find_free(rose_addr_t start_va, size_t size, rose_addr_t mem_alignment=1) const;

    rose_addr_t find_last_free(rose_addr_t max=(rose_addr_t)(-1)) const;

    void traverse(Visitor &visitor) const;

    void prune(Visitor &predicate);

    void prune(unsigned required, unsigned prohibited=MM_PROT_NONE);

    void erase_zeros(size_t minsize);

    const Segments &segments() const { return p_segments; }

    size_t read(void *dst_buf, rose_addr_t start_va, size_t desired, unsigned req_perms=MM_PROT_READ) const;
    size_t read1(void *dst_buf, rose_addr_t start_va, size_t desired, unsigned req_perms=MM_PROT_READ) const;
    SgUnsignedCharList read(rose_addr_t start_va, size_t desired, unsigned req_perms=MM_PROT_READ) const;

    std::string read_string(rose_addr_t start_va, size_t desired, int(*valid_char)(int)=NULL, int(*invalid_char)(int)=NULL,
                            unsigned req_perms=MM_PROT_READ) const;

    size_t write(const void *src_buf, rose_addr_t start_va, size_t desired, unsigned req_perms=MM_PROT_WRITE);
    size_t write1(const void *src_buf, rose_addr_t start_va, size_t desired, unsigned req_perms=MM_PROT_WRITE);
    ExtentMap va_extents() const;

    void mprotect(Extent range, unsigned perms, bool relax=false);

    void dump(FILE*, const char *prefix="") const;
    void dump(std::ostream&, std::string prefix="") const;
    void print(std::ostream &o, std::string prefix="") const { dump(o, prefix); }
    void dump(const std::string &basename) const;

    bool load(const std::string &basename);

    friend std::ostream& operator<<(std::ostream&, const MemoryMap&);

    /**************************************************************************************************************************
     *                                  Data members
     **************************************************************************************************************************/
protected:
    Segments p_segments;
    ByteOrder::Endianness sex;
};

#endif