MemoryMap.h

Go to the documentation of this file.

#ifndef ROSE_MEMORY_MAP_H
#define ROSE_MEMORY_MAP_H

/* 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
         * regions, MemoryMap::MapElement::consistent() will not treat two regions as being consistent if they have different
         * bits set. */
        MM_PROT_FLAGS   = 0xfffffff0,   
        MM_PROT_PRIVATE = 0x00000010,   
    };

    typedef std::map<std::string, std::set<std::string> > NamePairings;
    
    class MapElement {
    public:
        MapElement()
            : va(0), size(0), base(NULL), offset(0), read_only(false), mapperms(MM_PROT_READ), anonymous(NULL) {}
        
        MapElement(const MapElement &other) {
            init(other);
        }

        MapElement &operator=(const MapElement &other) {
            nullify();
            init(other);
            return *this;
        }

        ~MapElement() {
            nullify();
        }

        MapElement(rose_addr_t va, size_t size, void *base, rose_addr_t offset, unsigned perms=MM_PROT_READ)
            : va(va), size(size), base(base), offset(offset), read_only(false), mapperms(perms), anonymous(NULL) {}

        MapElement(rose_addr_t va, size_t size, const void *base, rose_addr_t offset, unsigned perms=MM_PROT_READ)
            : va(va), size(size), base(const_cast<void*>(base)), offset(offset), read_only(true), mapperms(perms), anonymous(NULL)
            {}

        MapElement(rose_addr_t va, size_t size, unsigned perms=MM_PROT_READ)
            : va(va), size(size), base(NULL), offset(0), read_only(false), mapperms(perms), anonymous(new Anonymous)
            {}

        rose_addr_t get_va() const {
            return va;
        }

        size_t get_size() const {
            return size;
        }

        bool is_anonymous() const {
            return anonymous!=NULL;
        }

        bool is_read_only() const {
            return read_only;
        }

        unsigned get_mapperms() const {
            return mapperms;
        }

        void set_mapperms(unsigned new_perms) {
            mapperms = new_perms;
        }

        void *get_base(bool allocate_anonymous=true) const;

        rose_addr_t get_offset() const {
            return offset;
        }

        rose_addr_t get_va_offset(rose_addr_t va, size_t nbytes=1) const;

        bool consistent(const MapElement &other) const;

        bool merge(const MapElement &other);
                
        MapElement& set_name(const std::string &name);
        
        const std::string &get_name() const {
            return name;
        }

        std::string get_name_pairings(NamePairings*) const;
        
        MapElement& set_name(const NamePairings&, const std::string &s1="", const std::string &s2="");

#ifdef _MSC_VER
        /* CH (4/15/2010): Make < operator be its member function instead of non-member function outside to avoid template
         * parameter deduction failure in MSVC */
// tps : commented out because of operatror < is ambigious.
// there is a function at the end of the file that is ambigious
//inline bool operator<(const MemoryMap::MapElement &a, const MemoryMap::MapElement &b) {
//        bool operator<(const MapElement &a) const {
 //           return this->get_va() < a.get_va();
  //      }
#endif

    private:
        friend class MemoryMap;

        void init(const MapElement &other) {
            va = other.va;
            size = other.size;
            base = other.base;
            offset = other.offset;
            read_only = other.read_only;
            mapperms = other.mapperms;
            name = other.name;

            anonymous = other.anonymous;
            if (anonymous)
                anonymous->refcount++;
        }

        void nullify() {
            if (anonymous) {
                if (0==--(anonymous->refcount)) {
                    delete[] anonymous->base;
                    delete anonymous;
                }
            }

            anonymous = NULL;
            va = 0;
            size = 0;
            base = NULL;
            offset = 0;
            read_only = 0;
            mapperms = MM_PROT_NONE;
            name = "";
        }

        void merge_names(const MapElement &other);

        void set_va(rose_addr_t new_va) {
            va = new_va;
        }

        void set_offset(rose_addr_t new_offset) {
            offset = new_offset;
        }

        void set_size(size_t sz) {
            ROSE_ASSERT(sz>0);
            size = sz;
        }

        rose_addr_t va;                 
        size_t size;                    
        mutable void *base;             
        rose_addr_t offset;             
        bool read_only;                 
        unsigned mapperms;              
        std::string name;               
        class Anonymous {
        private:
            Anonymous(const Anonymous &other) { abort(); }
            Anonymous &operator=(const Anonymous &other) { abort(); return *this; } // return is to silence Klockwork
        public:
            Anonymous(): refcount(1), base(NULL) {}
            size_t refcount;
            uint8_t *base;
        } *anonymous;
    };

    struct Exception {
        Exception(const MemoryMap *map)
            : map(map) {}
        virtual ~Exception() {}
        friend std::ostream& operator<<(std::ostream&, const Exception&);
        virtual void print(std::ostream&) const;
        const MemoryMap *map;           
    };

    struct Inconsistent : public Exception {
        Inconsistent(const MemoryMap *map, const MapElement &a, const MapElement &b)
            : Exception(map), a(a), b(b) {}
        virtual ~Inconsistent() {}
        friend std::ostream& operator<<(std::ostream&, const Inconsistent&);
        virtual void print(std::ostream&) const;
        MapElement a, b;
    };

    struct NotMapped : public Exception {
        NotMapped(const MemoryMap *map, rose_addr_t va)
            : Exception(map), va(va) {}
        virtual ~NotMapped() {}
        friend std::ostream& operator<<(std::ostream&, const NotMapped&);
        virtual void print(std::ostream&) const;
        rose_addr_t va;
    };

    struct NoFreeSpace : public Exception {
        NoFreeSpace(const MemoryMap *map, size_t size)
            : Exception(map), size(size) {}
        virtual ~NoFreeSpace() {}
        friend std::ostream& operator<<(std::ostream&, const NoFreeSpace&);
        virtual void print(std::ostream&) const;
        size_t size;
    };

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

    MemoryMap() {}

    void clear();

    void insert(MapElement elmt);

    void erase(MapElement elmt);

    const MapElement* find(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;

    const std::vector<MapElement> &get_elements() const;

    void prune(bool(*predicate)(const MapElement&));

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

    size_t read(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;

    size_t read1(void *dst_buf, rose_addr_t va, size_t desired, unsigned req_perms=MM_PROT_READ,
                 const MemoryMap::MapElement **mep=NULL) const;

    size_t write(const void *src_buf, rose_addr_t start_va, size_t size, unsigned req_perms=MM_PROT_WRITE) const;

    size_t write1(const void *src_buf, rose_addr_t va, size_t size, unsigned req_perms=MM_PROT_WRITE,
                  const MemoryMap::MapElement **mep=NULL) const;

    ExtentMap va_extents() const;

    void mprotect(const MapElement &elmt, bool relax=false);

    void dump(FILE*, const char *prefix="") const;

    void dump(const std::string &basename) const;

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

private:
    mutable std::vector<MapElement> elements;   
};

inline bool operator<(const MemoryMap::MapElement &a, const MemoryMap::MapElement &b) {
    return a.get_va() < b.get_va();
}

#endif

---