RegisterState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RegisterState_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RegisterState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/AddressSpace.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Merger.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/SValue.h>
#include <Rose/BinaryAnalysis/RegisterDictionary.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/version.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Register States
 
class RegisterState: public AddressSpace {
public:
    using Ptr = RegisterStatePtr;
 
private:
    MergerPtr merger_;
    SValuePtr protoval_;                                
protected:
    RegisterDictionaryPtr regdict;                      
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned version) {
        //s & merger_; -- not saved
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(AddressSpace);
        s & BOOST_SERIALIZATION_NVP(protoval_);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(regdict);
    }
#endif
 
    
    // Real constructors
protected:
    RegisterState();                                    // for serialization
 
    RegisterState(const SValuePtr &protoval, const RegisterDictionaryPtr &regdict);
 
public:
    virtual ~RegisterState();
 
    // Static allocating constructors.  None are needed--this class is abstract.
 
 
    // Virtual constructors.
public:
    virtual RegisterStatePtr create(const SValuePtr &protoval, const RegisterDictionaryPtr &regdict) const = 0;
 
    // Dynamic pointer casts. No-op since this is the base class.
public:
    static RegisterStatePtr promote(const AddressSpacePtr&);
 
public:
    // The rest of the API...
 
    MergerPtr merger() const { return merger_; }
    void merger(const MergerPtr &m) { merger_ = m; }
    SValuePtr protoval() const { return protoval_; }
 
    RegisterDictionaryPtr registerDictionary() const /*final*/;
    void registerDictionary(const RegisterDictionaryPtr&) /*final*/;
    virtual void clear() = 0;
 
    virtual void zero() = 0;
 
    virtual SValuePtr readRegister(RegisterDescriptor reg, const SValuePtr &dflt, RiscOperators *ops) = 0;
 
    virtual SValuePtr peekRegister(RegisterDescriptor reg, const SValuePtr &dflt, RiscOperators *ops) = 0;
 
    virtual void updateReadProperties(RegisterDescriptor) = 0;
 
    virtual void writeRegister(RegisterDescriptor reg, const SValuePtr &value, RiscOperators *ops) = 0;
 
    virtual void updateWriteProperties(RegisterDescriptor, InputOutputProperty) = 0;
};
class RegisterState: public AddressSpace {…};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RegisterState, 1);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RegisterState);
#endif
 
#endif
#endif