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/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Combinatorics.h>                              // rose
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Memory State
 
class MemoryState: public boost::enable_shared_from_this<MemoryState> {
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_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        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(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;
 
    virtual MemoryStatePtr clone() const = 0;
 
    // Dynamic pointer casts.  No-op since this is the base class.
public:
    static MemoryStatePtr promote(const MemoryStatePtr&);
 
    // 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 bool merge(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps) = 0;
 
    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 void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const = 0;
 
    void print(std::ostream&, const std::string prefix = "") const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    class WithFormatter {
        MemoryStatePtr obj;
        Formatter &fmt;
    public:
        ~WithFormatter();
        WithFormatter() = delete;
        WithFormatter(const MemoryStatePtr&, Formatter&);
        void print(std::ostream&) const;
    };
 
    WithFormatter with_format(Formatter&);
    WithFormatter operator+(Formatter&);
    WithFormatter operator+(const std::string &linePrefix);
};
 
std::ostream& operator<<(std::ostream&, const MemoryState&);
std::ostream& operator<<(std::ostream&, const MemoryState::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState);
 
#endif
#endif