MemoryState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryState_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/AddressSpace.h>
 
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Memory State
 
class MemoryState: public AddressSpace {
public:
    typedef MemoryStatePtr Ptr;
 
private:
    SValuePtr addrProtoval_;                            
    SValuePtr valProtoval_;                             
    ByteOrder::Endianness byteOrder_;                   
    MergerPtr merger_;
    bool byteRestricted_;                               // are cell values all exactly one byte wide?
 
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(AddressSpace);
        s & BOOST_SERIALIZATION_NVP(addrProtoval_);
        s & BOOST_SERIALIZATION_NVP(valProtoval_);
        s & BOOST_SERIALIZATION_NVP(byteOrder_);
        //s & merger_ -- not saved
        s & BOOST_SERIALIZATION_NVP(byteRestricted_);
    }
#endif
 
 
    // Real constructors
protected:
    MemoryState();                                      // for serialization
 
    MemoryState(Purpose, const std::string &name, const SValuePtr &valProtoval); // for deriving classes
    MemoryState(const SValuePtr &addrProtoval, const SValuePtr &valProtoval);
    MemoryState(const MemoryStatePtr &other);
 
public:
    virtual ~MemoryState();
 
    // Static allocating constructors. None needed since this class is abstract
 
    // Virtual constructors
public:
    virtual MemoryStatePtr create(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) const = 0;
 
    // Dynamic pointer casts.  No-op since this is the base class.
public:
    static MemoryStatePtr promote(const AddressSpacePtr&);
 
    // Methods first declared at this level of the class hierarchy
public:
    MergerPtr merger() const;
    void merger(const MergerPtr&);
    SValuePtr get_addr_protoval() const;
 
    SValuePtr get_val_protoval() const;
 
    virtual void clear() = 0;
 
    bool byteRestricted() const;
    void byteRestricted(bool);
    ByteOrder::Endianness get_byteOrder() const;
    void set_byteOrder(ByteOrder::Endianness);
    virtual SValuePtr readMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) = 0;
 
    virtual SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) = 0;
 
    virtual void writeMemory(const SValuePtr &addr, const SValuePtr &value,
                             RiscOperators *addrOps, RiscOperators *valOps) = 0;
 
    virtual SValuePtr readLocal(uint8_t index);
    virtual void writeLocal(uint8_t index, const SValuePtr &value);
 
    virtual void pushOperand(const SValuePtr &value);
 
    virtual SValuePtr popOperand();
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState);
#endif
 
#endif
#endif