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/Merger.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/SValue.h>
#include <Rose/BinaryAnalysis/RegisterDictionary.h>
 
#include <boost/enable_shared_from_this.hpp>
#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>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Register States
 
class RegisterState: public boost::enable_shared_from_this<RegisterState> {
public:
    using Ptr = RegisterStatePtr;
 
private:
    MergerPtr merger_;
    SValuePtr protoval_;                                
protected:
    RegisterDictionaryPtr regdict;                      
    // Serialization
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned version) {
        //s & merger_; -- not saved
        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;
 
    virtual RegisterStatePtr clone() const = 0;
 
    // Dynamic pointer casts. No-op since this is the base class.
public:
    static RegisterStatePtr promote(const RegisterStatePtr&);
 
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 bool merge(const RegisterStatePtr &other, RiscOperators *ops) = 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;
 
    virtual void hash(Combinatorics::Hasher&, RiscOperators*) const = 0;
 
    void print(std::ostream &stream, const std::string prefix = "") const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    class WithFormatter {
        RegisterStatePtr obj;
        Formatter &fmt;
    public:
        WithFormatter(const RegisterStatePtr &obj, Formatter &fmt): obj(obj), fmt(fmt) {}
        void print(std::ostream &stream) const { obj->print(stream, fmt); }
    };
 
    WithFormatter with_format(Formatter &fmt) { return WithFormatter(shared_from_this(), fmt); }
    WithFormatter operator+(Formatter &fmt) { return with_format(fmt); }
    WithFormatter operator+(const std::string &linePrefix);
};
 
std::ostream& operator<<(std::ostream&, const RegisterState&);
std::ostream& operator<<(std::ostream&, const RegisterState::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RegisterState, 1);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RegisterState);
 
#endif
#endif