RegisterState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_RegisterState_H
#define ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_RegisterState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/Merger.h>
#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/SValue.h>
#include <Rose/BinaryAnalysis/Registers.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 InstructionSemantics2 {
namespace BaseSemantics {

//                                      Register States

class RegisterState: public boost::enable_shared_from_this<RegisterState> {
public:
    using Ptr = RegisterStatePtr;

private:
    MergerPtr merger_;
    SValuePtr protoval_;                                
protected:
    const RegisterDictionary *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()
        : regdict(NULL) {}                                // for serialization

    RegisterState(const SValuePtr &protoval, const RegisterDictionary *regdict)
        : protoval_(protoval), regdict(regdict) {
        ASSERT_not_null(protoval_);
    }

public:
    virtual ~RegisterState() {}

    // Static allocating constructors.  None are needed--this class is abstract.


    // Virtual constructors.
public:
    virtual RegisterStatePtr create(const SValuePtr &protoval, const RegisterDictionary *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 &x) {
        ASSERT_not_null(x);
        return x;
    }

public:
    // The rest of the API...

    MergerPtr merger() const { return merger_; }
    void merger(const MergerPtr &m) { merger_ = m; }
    SValuePtr protoval() const { return protoval_; }

    const RegisterDictionary *registerDictionary() const /*final*/ {
        return regdict;
    }
    void registerDictionary(const RegisterDictionary *rd) /*final*/ {
        regdict = rd;
    }
    // [Robb Matzke 2021-03-18]: deprecated
    const RegisterDictionary *get_register_dictionary() const ROSE_DEPRECATED("use registerDictionary property") {
        return registerDictionary();
    }

    // [Robb Matzke 2021-03-18]: deprecated
    void set_register_dictionary(const RegisterDictionary *rd) ROSE_DEPRECATED("use registerDictionary property") {
        registerDictionary(rd);
    }

    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 writeRegister(RegisterDescriptor reg, const SValuePtr &value, RiscOperators *ops) = 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::InstructionSemantics2::BaseSemantics::RegisterState, 1);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterState);

#endif
#endif