MemoryMap.h

#ifndef ROSE_BinaryAnalysis_MemoryMap_H
#define ROSE_BinaryAnalysis_MemoryMap_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/Exception.h>
 
#include <Combinatorics.h>
#include <rose_extent.h>
#include <sageContainer.h>
 
#include <Sawyer/Access.h>
#include <Sawyer/AddressMap.h>
#include <Sawyer/AllocatingBuffer.h>
#include <Sawyer/MappedBuffer.h>
#include <Sawyer/NullBuffer.h>
#include <Sawyer/Optional.h>
#include <Sawyer/StaticBuffer.h>
 
#include <boost/config.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/type_traits/is_integral.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
 
template<typename T, typename U>
typename boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type
alignUp(T address, U alignment) {
    ASSERT_require(alignment > 0);
    T almt = static_cast<T>(alignment);
    return ((address + almt - 1) / almt) * almt;
}
 
template<typename T, typename U>
typename boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type
alignDown(T address, U alignment) {
    ASSERT_require(alignment > 0);
    T almt = static_cast<T>(alignment);
    return (address / almt) * almt;
}
 
class MemoryMap: public Sawyer::Container::AddressMap<rose_addr_t, uint8_t>, public Sawyer::SharedObject {
public:
    using Ptr = MemoryMapPtr;
 
    typedef rose_addr_t Address;
    typedef uint8_t Value;
    typedef Sawyer::Container::AddressMap<Address, Value> Super;
    typedef Sawyer::Container::Buffer<Address, Value> Buffer;
    typedef Sawyer::Container::AllocatingBuffer<Address, Value> AllocatingBuffer;
    typedef Sawyer::Container::MappedBuffer<Address, Value> MappedBuffer;
    typedef Sawyer::Container::NullBuffer<Address, Value> NullBuffer;
    typedef Sawyer::Container::StaticBuffer<Address, Value> StaticBuffer;
    typedef Sawyer::Container::SegmentPredicate<Address, Value> SegmentPredicate;
    typedef Sawyer::Container::AddressMapConstraints<Sawyer::Container::AddressMap<rose_addr_t, uint8_t> > Constraints;
    typedef Sawyer::Container::AddressMapConstraints<const Sawyer::Container::AddressMap<rose_addr_t, uint8_t> > ConstConstraints;
 
    struct Attach {                                     // For consistency with other <Feature>::Boolean types
        enum Boolean {
            NO,                                         
            YES                                         
        };
    };
 
    enum class Clobber {NO, YES};
 
private:
    ByteOrder::Endianness endianness_;
    std::string name_;
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s.template register_type<AllocatingBuffer>();
        s.template register_type<MappedBuffer>();
        s.template register_type<NullBuffer>();
        s.template register_type<StaticBuffer>();
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
        s & BOOST_SERIALIZATION_NVP(endianness_);
    }
#endif
 
public:
 
    // Whoever pollutes all namespaces with these common word preprocessor symbols is a lunatic!
#   if defined(READABLE) || defined(WRITABLE) || defined(EXECUTABLE) || defined(IMMUTABLE) || defined(PRIVATE)
#    ifdef _MSC_VER
#     pragma message("Undefining common words from the global namespace: READABLE, WRITABLE, EXECUTABLE, IMMUTABLE, PRIVATE")
#    else
#     warning "Undefining common words from the global namespace: READABLE, WRITABLE, EXECUTABLE, IMMUTABLE, PRIVATE"
#    endif
#    undef READABLE
#    undef WRITABLE
#    undef EXECUTABLE
#    undef IMMUTABLE
#    undef PRIVATE
#   endif
 
    // Accessibility flags
    static const unsigned NO_ACCESS = 0;
    static const unsigned READABLE      = Sawyer::Access::READABLE;
    static const unsigned WRITABLE      = Sawyer::Access::WRITABLE;
    static const unsigned EXECUTABLE    = Sawyer::Access::EXECUTABLE;
    static const unsigned IMMUTABLE     = Sawyer::Access::IMMUTABLE;
    static const unsigned PRIVATE       = Sawyer::Access::PRIVATE;
    static const unsigned INITIALIZED   = 0x00000200;   // Partitioner2: initialized memory even if writable
 
    // Aggregate accessibility flags
    static const unsigned READ_WRITE = READABLE | WRITABLE;
    static const unsigned READ_EXECUTE = READABLE | EXECUTABLE;
    static const unsigned READ_WRITE_EXECUTE = READABLE | WRITABLE | EXECUTABLE;
 
    // These bits are reserved for use in ROSE
    static const unsigned RESERVED_ACCESS_BITS = 0x0000ffff;
 
 
public:
    class Exception: public Rose::Exception {
    public:
        Exception(const std::string &mesg, const MemoryMap::Ptr map): Rose::Exception(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:
        MemoryMap::Ptr map;                             
    };
 
    struct Inconsistent : public Exception {
        Inconsistent(const std::string &mesg, const MemoryMap::Ptr &map,
                     const AddressInterval &new_range, const Segment &new_segment,
                     const AddressInterval &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&);
        AddressInterval new_range, old_range;
        Segment new_segment, old_segment;
    };
 
    struct NotMapped : public Exception {
        NotMapped(const std::string &mesg, const MemoryMap::Ptr &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::Ptr &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::Ptr &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;                             
    };
 
protected:
    MemoryMap(): endianness_(ByteOrder::ORDER_UNSPECIFIED) {}
 
public:
    static Ptr instance() {
        return Ptr(new MemoryMap);
    }
 
    Ptr shallowCopy() {
        return Ptr(new MemoryMap(*this));
    }
 
    ByteOrder::Endianness byteOrder() const { return endianness_; }
    void byteOrder(ByteOrder::Endianness order) { endianness_ = order; }
    const std::string& name() const;
    void name(const std::string&);
    // Note that the order of the enum members is for backward compatibility with an older version of insertFile whose third
    // argument was "bool writable = false" (MAP_RDONLY, but now intended to be MAP_PRIVATE) and when it was true was the same
    // as MAP_READWRITE.
    // 
    enum InsertFileMapMode {
        MAP_PRIVATE = 0,                                
        MAP_READWRITE = 1,                              
        MAP_RDONLY = 2                                  
    };
    
    size_t insertFile(const std::string &fileName, rose_addr_t va, InsertFileMapMode mode = MAP_PRIVATE,
                      std::string segmentName = "");
 
    AddressInterval insertFile(const std::string &locatorString);
 
    static std::string insertFileDocumentation();
 
    AddressInterval insertData(const std::string &locatorString);
 
    static std::string insertDataDocumentation();
 
    void adjustMap(const std::string &locatorString);
 
    static std::string adjustMapDocumentation();
 
 
    struct ProcessMapRecord {
        AddressInterval interval;                       
        unsigned accessibility;                         
        rose_addr_t fileOffset;                         
        std::string deviceName;                         
        size_t inode;                                   
        std::string comment;                            
        ProcessMapRecord()
            : accessibility(0), fileOffset(0), inode(0) {}
    };
 
    static std::vector<ProcessMapRecord> readProcessMap(pid_t);
 
#ifdef BOOST_WINDOWS
    void insertProcess(int pid, Attach::Boolean attach);
#else
    void insertProcess(pid_t pid, Attach::Boolean attach);
#endif
 
    void insertProcess(const std::string &locatorString);
 
    bool insertProcessPid(pid_t, const AddressInterval &where, unsigned accessibility, const std::string &name);
    void insertProcessPid(pid_t, const std::vector<ProcessMapRecord>&);
    bool insertProcessMemory(int memFile, const AddressInterval &where, unsigned accessibility, std::string name);
    static std::string insertProcessDocumentation();
 
    AddressIntervalSet linkTo(const MemoryMap::Ptr &source, const AddressIntervalSet &where, Clobber = Clobber::YES);
    AddressIntervalSet linkTo(const MemoryMap::Ptr &source, const AddressInterval &where, Clobber = Clobber::YES);
    MemoryMap::Ptr align(rose_addr_t lowAlignment, rose_addr_t highAlignment) const;
 
    static std::pair<Buffer::Ptr, std::string> copyFromFile(int fd, const AddressInterval&);
 
    void eraseZeros(size_t minsize);
 
    bool shrinkUnshare();
 
    size_t readQuick(void *buf, rose_addr_t startVa, size_t desired) const {
        return at(startVa).limit(desired).require(READABLE).read((uint8_t*)buf).size();
    }
 
    std::string readString(rose_addr_t startVa, size_t desired, int(*validChar)(int)=NULL, int(*invalidChar)(int)=NULL,
                           unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0, char terminator='\0') const;
 
    template<typename U>
    Sawyer::Optional<U> readUnsigned(rose_addr_t startVa) const {
        U val = 0;
        if (at(startVa).limit(sizeof val).read((uint8_t*)&val).size() != sizeof val)
            return Sawyer::Nothing();
        ByteOrder::convert((void*)&val, sizeof val, endianness_, ByteOrder::hostOrder());
        return val;
    }
 
    Sawyer::Optional<uint64_t> readLongUnsinged(rose_addr_t startVa) const {
        uint64_t val = 0;
        if (at(startVa).limit(sizeof val).read((uint8_t*)&val).size() != sizeof val)
            return Sawyer::Nothing();
        ByteOrder::convert((void*)&val, sizeof val, endianness_, ByteOrder::hostOrder());
        return val;
    }
    
    size_t writeUnsigned(uint32_t value, rose_addr_t startVa) {
        return at(startVa).limit(sizeof(uint32_t)).write((const uint8_t*)(&value)).size(); 
    }
 
    size_t writeUnsigned(uint64_t value, rose_addr_t startVa) {
        return at(startVa).limit(sizeof(uint64_t)).write((const uint8_t*)(&value)).size(); 
    } 
 
    Sawyer::Optional<uint8_t> readByte(rose_addr_t) const;
 
    SgUnsignedCharList readVector(rose_addr_t startVa, size_t desired, unsigned requiredPerms=READABLE) const;
 
    size_t writeQuick(const void *buf, rose_addr_t startVa, size_t desired) {
        return at(startVa).limit(desired).require(WRITABLE).write((const uint8_t*)buf).size();
    }
 
    Sawyer::Optional<rose_addr_t> findAny(const Extent &limits, const std::vector<uint8_t> &bytesToFind,
                                          unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
    Sawyer::Optional<rose_addr_t> findAny(const AddressInterval &limits, const std::vector<uint8_t> &bytesToFind,
                                          unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
    Sawyer::Optional<rose_addr_t> findSequence(const AddressInterval &interval, const std::vector<uint8_t> &sequence) const;
 
    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;                                  // mostly for calling from within GDB or similar
    Combinatorics::Hasher& hash(Combinatorics::Hasher&) const;
 
    static std::string segmentTitle(const Segment&);
 
    friend std::ostream& operator<<(std::ostream&, const MemoryMap&);
};
 
} // namespace
} // namespace
 
// Register the types needed for serialization since some of them are derived from polymorphic class templates.
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::AllocatingBuffer);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::MappedBuffer);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::NullBuffer);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::StaticBuffer);
#endif
 
#endif
#endif