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/type_traits/is_integral.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#endif
 
 
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;
}
alignUp(T address, U alignment) {…}
 
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;
}
alignDown(T address, U alignment) {…}
 
class MemoryMap: public Sawyer::Container::AddressMap<Address, uint8_t>, public Sawyer::SharedObject {
public:
    using Ptr = MemoryMapPtr;
 
    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<Address, uint8_t> > Constraints;
    typedef Sawyer::Container::AddressMapConstraints<const Sawyer::Container::AddressMap<Address, uint8_t> > ConstConstraints;
 
    struct Attach {                                     // For consistency with other <Feature>::Boolean types
        enum Boolean {
            NO,                                         
            YES                                         
        };
        enum Boolean {…};
    };
    struct Attach {                                     // For consistency with other <Feature>::Boolean types {…};
 
    enum class Clobber {NO, YES};
 
private:
    ByteOrder::Endianness endianness_;
    std::string name_;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
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;                             
    };
    class Exception: public Rose::Exception {…};
 
    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 Inconsistent : public Exception {…};
 
    struct NotMapped : public Exception {
        NotMapped(const std::string &mesg, const MemoryMap::Ptr &map, Address 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&);
        Address va;
    };
    struct NotMapped : public Exception {…};
 
    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 NoFreeSpace : public Exception {…};
    
    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;                             
    };
    struct SyntaxError: public Exception {…};
 
    class LocatorError: public Exception {
    public:
        LocatorError(const std::string &mesg, const std::string &locatorString, const size_t index)
            : Exception(mesg + "\n" +
                        "  locator string: \"" + locatorString + "\"\n"
                        "  error at " + std::string(7 + index, '-') + "^",
                        MemoryMap::Ptr()) {}
        virtual ~LocatorError() throw() {}
    };
    class LocatorError: public Exception {…};
 
private:
    // Address, size, and permissions parsed from "[ADDR][+SIZE][=PERM]".
    struct AddrSizePerm {
        Sawyer::Optional<Address> addr;                 // address if one was parsed at the beginning of the string
        size_t sizeAt = 0;                              // string index where we tried to parse the size "+" character
        Sawyer::Optional<uint64_t> size;                // size if one was parsed
        size_t permAt = 0;                              // string index where we tried to parse the permission "=" character.
        Sawyer::Optional<unsigned> perm;                // union of permissions if the leading "=" was present.
    };
 
protected:
    MemoryMap(): endianness_(ByteOrder::ORDER_UNSPECIFIED) {}
 
public:
    static Ptr instance() {
        return Ptr(new MemoryMap);
    }
    static Ptr instance() {…}
 
    Ptr shallowCopy() {
        return Ptr(new MemoryMap(*this));
    }
    Ptr shallowCopy() {…}
 
    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                                  
    };
    enum InsertFileMapMode {…};
    
    size_t insertFile(const std::string &fileName, Address 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;                         
        Address fileOffset;                             
        std::string deviceName;                         
        size_t inode;                                   
        std::string comment;                            
        ProcessMapRecord()
            : accessibility(0), fileOffset(0), inode(0) {}
        ProcessMapRecord() {…}
    };
    struct ProcessMapRecord {…};
 
    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(Address lowAlignment, Address highAlignment) const;
 
    static std::pair<Buffer::Ptr, std::string> copyFromFile(int fd, const AddressInterval&);
 
    void eraseZeros(size_t minsize);
 
    bool shrinkUnshare();
 
    bool combineAdjacentSegments();
 
    size_t readQuick(void *buf, Address startVa, size_t desired) const {
        return at(startVa).limit(desired).require(READABLE).read((uint8_t*)buf).size();
    }
    size_t readQuick(void *buf, Address startVa, size_t desired) const  {…}
 
    std::string readString(Address 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(Address 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<U> readUnsigned(Address startVa) const  {…}
 
    Sawyer::Optional<uint64_t> readLongUnsinged(Address 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;
    }
    Sawyer::Optional<uint64_t> readLongUnsinged(Address startVa) const  {…}
    
    size_t writeUnsigned(uint32_t value, Address startVa) {
        return at(startVa).limit(sizeof(uint32_t)).write((const uint8_t*)(&value)).size(); 
    }
    size_t writeUnsigned(uint32_t value, Address startVa) {…}
 
    size_t writeUnsigned(uint64_t value, Address startVa) {
        return at(startVa).limit(sizeof(uint64_t)).write((const uint8_t*)(&value)).size(); 
    } 
    size_t writeUnsigned(uint64_t value, Address startVa) {…}
 
    Sawyer::Optional<uint8_t> readByte(Address) const;
 
    SgUnsignedCharList readVector(Address startVa, size_t desired, unsigned requiredPerms=READABLE) const;
 
    size_t writeQuick(const void *buf, Address startVa, size_t desired) {
        return at(startVa).limit(desired).require(WRITABLE).write((const uint8_t*)buf).size();
    }
    size_t writeQuick(const void *buf, Address startVa, size_t desired) {…}
 
    Sawyer::Optional<Address> findAny(const Extent &limits, const std::vector<uint8_t> &bytesToFind,
                                      unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
    Sawyer::Optional<Address> findAny(const AddressInterval &limits, const std::vector<uint8_t> &bytesToFind,
                                      unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
    Sawyer::Optional<Address> 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&);
 
    static Sawyer::Result<AddrSizePerm, std::pair<std::string, size_t>> parseAddrSizePerm(const std::string&);
 
    static std::tuple<std::vector<std::tuple<std::string /*name*/, std::string /*value*/, size_t /*input_idx*/>>,
                      std::string /*following*/, size_t /*following_idx*/>
    parseNameValuePairs(const std::string &input);
};
class MemoryMap: public Sawyer::Container::AddressMap<Address, uint8_t>, public Sawyer::SharedObject {…};
 
} // namespace
} // namespace
 
// Register the types needed for serialization since some of them are derived from polymorphic class templates.
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
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