SymbolicSemantics.h

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

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>

#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics.h>
#include "Cxx_GrammarSerialization.h"
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <Rose/BinaryAnalysis/SymbolicExpr.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/set.hpp>

#include <map>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {              // documented elsewhere
namespace InstructionSemantics2 {       // documented elsewhere

namespace SymbolicSemantics {

typedef SymbolicExpr::Leaf LeafNode;
typedef SymbolicExpr::LeafPtr LeafPtr;
typedef SymbolicExpr::Interior InteriorNode;
typedef SymbolicExpr::InteriorPtr InteriorPtr;
typedef SymbolicExpr::Node ExprNode;
typedef SymbolicExpr::Ptr ExprPtr;
typedef std::set<SgAsmInstruction*> InsnSet;

// Boolean flags

namespace AllowSideEffects {
    enum Flag {NO, YES};
}


//                                      Merging symbolic values

typedef Sawyer::SharedPointer<class Merger> MergerPtr;

class Merger: public BaseSemantics::Merger {
    size_t setSizeLimit_;
protected:
    Merger(): BaseSemantics::Merger(), setSizeLimit_(1) {}

public:
    typedef MergerPtr Ptr;

    static Ptr instance() {
        return Ptr(new Merger);
    }

    static Ptr instance(size_t n) {
        Ptr retval = Ptr(new Merger);
        retval->setSizeLimit(n);
        return retval;
    }

    size_t setSizeLimit() const { return setSizeLimit_; }
    void setSizeLimit(size_t n) { setSizeLimit_ = n; }
};



//                                      Semantic values

typedef Sawyer::SharedPointer<class SValue> SValuePtr;

class Formatter: public BaseSemantics::Formatter {
public:
    SymbolicExpr::Formatter expr_formatter;
};

class SValue: public BaseSemantics::SValue {
public:
    using Super = BaseSemantics::SValue;

    using Ptr = SValuePtr;

protected:
    ExprPtr expr;

    InsnSet defs;

    // Serialization
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        roseAstSerializationRegistration(s);            // "defs" has SgAsmInstruction ASTs
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
        s & BOOST_SERIALIZATION_NVP(expr);
        s & BOOST_SERIALIZATION_NVP(defs);
    }
#endif

    // Real constructors
protected:
    SValue() {}                                         // needed for serialization
    explicit SValue(size_t nbits): BaseSemantics::SValue(nbits) {
        expr = SymbolicExpr::makeIntegerVariable(nbits);
    }
    SValue(size_t nbits, uint64_t number): BaseSemantics::SValue(nbits) {
        expr = SymbolicExpr::makeIntegerConstant(nbits, number);
    }
    SValue(ExprPtr expr): BaseSemantics::SValue(expr->nBits()) {
        this->expr = expr;
    }

    // Static allocating constructors
public:
    static SValuePtr instance() {
        return SValuePtr(new SValue(SymbolicExpr::makeIntegerVariable(1)));
    }

    static SValuePtr instance_bottom(size_t nbits) {
        return SValuePtr(new SValue(SymbolicExpr::makeIntegerVariable(nbits, "", ExprNode::BOTTOM)));
    }

    static SValuePtr instance_undefined(size_t nbits) {
        return SValuePtr(new SValue(SymbolicExpr::makeIntegerVariable(nbits)));
    }

    static SValuePtr instance_unspecified(size_t nbits) {
        return SValuePtr(new SValue(SymbolicExpr::makeIntegerVariable(nbits, "", ExprNode::UNSPECIFIED)));
    }

    static SValuePtr instance_integer(size_t nbits, uint64_t value) {
        return SValuePtr(new SValue(SymbolicExpr::makeIntegerConstant(nbits, value)));
    }

    static SValuePtr instance_symbolic(const SymbolicExpr::Ptr &value) {
        ASSERT_not_null(value);
        return SValuePtr(new SValue(value));
    }

    // Virtual allocating constructors
public:
    virtual BaseSemantics::SValuePtr bottom_(size_t nbits) const override {
        return instance_bottom(nbits);
    }
    virtual BaseSemantics::SValuePtr undefined_(size_t nbits) const override {
        return instance_undefined(nbits);
    }
    virtual BaseSemantics::SValuePtr unspecified_(size_t nbits) const override {
        return instance_unspecified(nbits);
    }
    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) const override {
        return instance_integer(nbits, value);
    }
    virtual BaseSemantics::SValuePtr boolean_(bool value) const override {
        return instance_integer(1, value?1:0);
    }
    virtual BaseSemantics::SValuePtr copy(size_t new_width=0) const override {
        SValuePtr retval(new SValue(*this));
        if (new_width!=0 && new_width!=retval->nBits())
            retval->set_width(new_width);
        return retval;
    }
    virtual Sawyer::Optional<BaseSemantics::SValuePtr>
    createOptionalMerge(const BaseSemantics::SValuePtr &other, const BaseSemantics::MergerPtr&,
                        const SmtSolverPtr&) const override;

    // Dynamic pointer casts
public:
    static SValuePtr promote(const BaseSemantics::SValuePtr &v) { // hot
        SValuePtr retval = v.dynamicCast<SValue>();
        ASSERT_not_null(retval);
        return retval;
    }

    // Override virtual methods...
public:
    virtual bool isBottom() const override;

    virtual void print(std::ostream&, BaseSemantics::Formatter&) const override;

    virtual void hash(Combinatorics::Hasher&) const override;

protected: // when implementing use these names; but when calling, use the camelCase names
    virtual bool may_equal(const BaseSemantics::SValuePtr &other,
                           const SmtSolverPtr &solver = SmtSolverPtr()) const override;
    virtual bool must_equal(const BaseSemantics::SValuePtr &other,
                            const SmtSolverPtr &solver = SmtSolverPtr()) const override;

    // It's not possible to change the size of a symbolic expression in place. That would require that we recursively change
    // the size of the SymbolicExpr, which might be shared with many unrelated values whose size we don't want to affect.
    virtual void set_width(size_t nbits) override {
        ASSERT_require(nbits==nBits());
    }

    virtual bool is_number() const override {
        return expr->isIntegerConstant();
    }

    virtual uint64_t get_number() const override;

    virtual std::string get_comment() const override;
    virtual void set_comment(const std::string&) const override;

    // Additional methods first declared in this class...
public:
    virtual SValuePtr substitute(const SValuePtr &from, const SValuePtr &to, const SmtSolverPtr &solver) const;

    virtual void defined_by(SgAsmInstruction *insn, const InsnSet &set1, const InsnSet &set2, const InsnSet &set3) {
        add_defining_instructions(set3);
        defined_by(insn, set1, set2);
    }
    virtual void defined_by(SgAsmInstruction *insn, const InsnSet &set1, const InsnSet &set2) {
        add_defining_instructions(set2);
        defined_by(insn, set1);
    }
    virtual void defined_by(SgAsmInstruction *insn, const InsnSet &set1) {
        add_defining_instructions(set1);
        defined_by(insn);
    }
    virtual void defined_by(SgAsmInstruction *insn) {
        add_defining_instructions(insn);
    }
    virtual const ExprPtr& get_expression() const {
        return expr;
    }

    virtual void set_expression(const ExprPtr &new_expr) {
        ASSERT_not_null(new_expr);
        expr = new_expr;
        width = new_expr->nBits();
    }
    virtual void set_expression(const SValuePtr &source) {
        set_expression(source->get_expression());
    }
    virtual const InsnSet& get_defining_instructions() const {
        return defs;
    }

    virtual size_t add_defining_instructions(const InsnSet &to_add);
    virtual size_t add_defining_instructions(const SValuePtr &source) {
        return add_defining_instructions(source->get_defining_instructions());
    }
    virtual size_t add_defining_instructions(SgAsmInstruction *insn);
    virtual void set_defining_instructions(const InsnSet &new_defs) {
        defs = new_defs;
    }
    virtual void set_defining_instructions(const SValuePtr &source) {
        set_defining_instructions(source->get_defining_instructions());
    }
    virtual void set_defining_instructions(SgAsmInstruction *insn);
};


//                                      Register state

typedef BaseSemantics::RegisterStateGeneric RegisterState;
typedef BaseSemantics::RegisterStateGenericPtr RegisterStatePtr;


//                                      List-based Memory state

typedef boost::shared_ptr<class MemoryListState> MemoryListStatePtr;

class MemoryListState: public BaseSemantics::MemoryCellList {
public:
    using Super = BaseSemantics::MemoryCellList;

    using Ptr = MemoryListStatePtr;

    class CellCompressor: public Sawyer::SharedObject {
    public:
        using Ptr = Sawyer::SharedPointer<CellCompressor>;
    protected:
        CellCompressor() {}
    public:
        virtual ~CellCompressor() {}

        virtual SValuePtr operator()(const SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                     BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps,
                                     const MemoryCellList::CellList &cells) = 0;
    };

    class CellCompressorMcCarthy: public CellCompressor {
    public:
        static Ptr instance();                          
        virtual SValuePtr operator()(const SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                     BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps,
                                     const CellList &cells) override;
    };

    class CellCompressorSimple: public CellCompressor {
    public:
        static Ptr instance();                          
        virtual SValuePtr operator()(const SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                     BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps,
                                     const CellList &cells) override;
    };

    class CellCompressorChoice: public CellCompressor {
        CellCompressor::Ptr mccarthy_;
        CellCompressor::Ptr simple_;
    protected:
        CellCompressorChoice();
    public:
        static Ptr instance();                          
        virtual SValuePtr operator()(const SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                     BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps,
                                     const CellList &cells) override;
    };

    class CellCompressorSet: public CellCompressor {
    public:
        static Ptr instance();                          
        virtual SValuePtr operator()(const SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                     BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps,
                                     const CellList &cells) override;
    };

private:
    CellCompressor::Ptr cellCompressor_;                // Callback when a memory read aliases multiple memory cells.

    // 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_BASE_OBJECT_NVP(Super);
    }
#endif


    // Real constructors
protected:
    MemoryListState()                                   // for serialization
        : cellCompressor_(CellCompressorChoice::instance()) {}

    explicit MemoryListState(const BaseSemantics::MemoryCellPtr &protocell)
        : BaseSemantics::MemoryCellList(protocell), cellCompressor_(CellCompressorChoice::instance()) {}

    MemoryListState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval)
        : BaseSemantics::MemoryCellList(addrProtoval, valProtoval), cellCompressor_(CellCompressorChoice::instance()) {}

    MemoryListState(const MemoryListState &other)
        : BaseSemantics::MemoryCellList(other), cellCompressor_(other.cellCompressor_) {}

    // Static allocating constructors
public:
    static MemoryListStatePtr instance(const BaseSemantics::MemoryCellPtr &protocell) {
        return MemoryListStatePtr(new MemoryListState(protocell));
    }

    static  MemoryListStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval,
                                        const BaseSemantics::SValuePtr &valProtoval) {
        return MemoryListStatePtr(new MemoryListState(addrProtoval, valProtoval));
    }

    static MemoryListStatePtr instance(const MemoryListStatePtr &other) {
        return MemoryListStatePtr(new MemoryListState(*other));
    }

    // Virtual constructors
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const override {
        return instance(addrProtoval, valProtoval);
    }

    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::MemoryCellPtr &protocell) const override {
        return instance(protocell);
    }

    virtual BaseSemantics::MemoryStatePtr clone() const override {
        return BaseSemantics::MemoryStatePtr(new MemoryListState(*this));
    }

    // Dynamic pointer casts
public:
    static MemoryListStatePtr promote(const BaseSemantics::MemoryStatePtr &x) {
        MemoryListStatePtr retval = boost::dynamic_pointer_cast<MemoryListState>(x);
        ASSERT_not_null(retval);
        return retval;
    }

    // Methods we inherited
public:
    virtual BaseSemantics::SValuePtr readMemory(const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt,
                                                BaseSemantics::RiscOperators *addrOps,
                                                BaseSemantics::RiscOperators *valOps) override;

    virtual BaseSemantics::SValuePtr peekMemory(const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt,
                                                BaseSemantics::RiscOperators *addrOps,
                                                BaseSemantics::RiscOperators *valOps) override;

    virtual void writeMemory(const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &value,
                             BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override;

protected:
    BaseSemantics::SValuePtr readOrPeekMemory(const BaseSemantics::SValuePtr &address,
                                              const BaseSemantics::SValuePtr &dflt,
                                              BaseSemantics::RiscOperators *addrOps,
                                              BaseSemantics::RiscOperators *valOps,
                                              AllowSideEffects::Flag allowSideEffects);

    // Methods first declared in this class
public:
    CellCompressor::Ptr cellCompressor() const;
    void cellCompressor(const CellCompressor::Ptr&);
    // Deprecated [Robb Matzke 2021-12-15]
    CellCompressor::Ptr get_cell_compressor() const ROSE_DEPRECATED("use cellCompressor");
    void set_cell_compressor(const CellCompressor::Ptr&) ROSE_DEPRECATED("use cellCompressor");
};


//                                      Map-based Memory state

typedef boost::shared_ptr<class MemoryMapState> MemoryMapStatePtr;

class MemoryMapState: public BaseSemantics::MemoryCellMap {
public:
    using Super = BaseSemantics::MemoryCellMap;

    using Ptr = MemoryMapStatePtr;

    // 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_BASE_OBJECT_NVP(Super);
    }
#endif

    // Real constructors
protected:
    MemoryMapState() {}                                 // for serialization

    explicit MemoryMapState(const BaseSemantics::MemoryCellPtr &protocell)
        : BaseSemantics::MemoryCellMap(protocell) {}

    MemoryMapState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval)
        : BaseSemantics::MemoryCellMap(addrProtoval, valProtoval) {}

    // Static allocating constructors
public:
    static MemoryMapStatePtr instance(const BaseSemantics::MemoryCellPtr &protocell) {
        return MemoryMapStatePtr(new MemoryMapState(protocell));
    }

    static MemoryMapStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval,
                                      const BaseSemantics::SValuePtr &valProtoval) {
        return MemoryMapStatePtr(new MemoryMapState(addrProtoval, valProtoval));
    }

    static MemoryMapStatePtr instance(const MemoryMapStatePtr &other) {
        return MemoryMapStatePtr(new MemoryMapState(*other));
    }

    // Virtual constructors
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const override {
        return instance(addrProtoval, valProtoval);
    }

    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::MemoryCellPtr &protocell) const {
        return instance(protocell);
    }

    virtual BaseSemantics::MemoryStatePtr clone() const override {
        return BaseSemantics::MemoryStatePtr(new MemoryMapState(*this));
    }

    // Dynamic pointer casts
public:
    static MemoryMapStatePtr promote(const BaseSemantics::MemoryStatePtr &x) {
        MemoryMapStatePtr retval = boost::dynamic_pointer_cast<MemoryMapState>(x);
        ASSERT_not_null(retval);
        return retval;
    }

    // Methods we override from the super class (documented in the super class)
public:
    virtual CellKey generateCellKey(const BaseSemantics::SValuePtr &addr_) const override;
};



//                                      Default memory state

// List-base memory was the type originally used by this domain. We must keep it that way because some analysis, including 3rd
// party, assumes that the state is list-based.  New analysis can use the map-based state by instantiating it when the symbolic
// risc operators are constructed.
typedef MemoryListState MemoryState;
typedef MemoryListStatePtr MemoryStatePtr;

//                                      Complete state

typedef BaseSemantics::State State;
typedef BaseSemantics::StatePtr StatePtr;


//                                      RISC operators

enum WritersMode {
    TRACK_NO_WRITERS,                                   
    TRACK_LATEST_WRITER,                                
    TRACK_ALL_WRITERS                                   
};

enum DefinersMode {
    TRACK_NO_DEFINERS,                                  
    TRACK_LATEST_DEFINER,                               
    TRACK_ALL_DEFINERS                                  
};

typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;

class RiscOperators: public BaseSemantics::RiscOperators {
public:
    using Super = BaseSemantics::RiscOperators;

    using Ptr = RiscOperatorsPtr;

protected:
    bool omit_cur_insn;                                 // if true, do not include cur_insn as a definer
    DefinersMode computingDefiners_;                    // whether to track definers (instruction VAs) of SValues
    WritersMode computingMemoryWriters_;                // whether to track writers (instruction VAs) to memory.
    WritersMode computingRegisterWriters_;              // whether to track writers (instruction VAs) to registers.
    uint64_t trimThreshold_;                            // max size of expressions (zero means no maximimum)
    bool reinterpretMemoryReads_;                       // cast data to unsigned integer when reading from memory
    bool reinterpretRegisterReads_;                     // cast data to unsigned integer when reading from registers
    size_t nTrimmed_ = 0;                               // number of expressions trimmed down to a new variable


    // 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_BASE_OBJECT_NVP(Super);
        s & BOOST_SERIALIZATION_NVP(omit_cur_insn);
        s & BOOST_SERIALIZATION_NVP(computingDefiners_);
        s & BOOST_SERIALIZATION_NVP(computingMemoryWriters_);
        s & BOOST_SERIALIZATION_NVP(computingRegisterWriters_);
        s & BOOST_SERIALIZATION_NVP(trimThreshold_);
    }
#endif

    // Real constructors
protected:
    RiscOperators()                                     // for serialization
        : omit_cur_insn(false), computingDefiners_(TRACK_NO_DEFINERS), computingMemoryWriters_(TRACK_LATEST_WRITER),
          computingRegisterWriters_(TRACK_LATEST_WRITER), trimThreshold_(0), reinterpretMemoryReads_(true),
          reinterpretRegisterReads_(true) {}

    explicit RiscOperators(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr())
        : BaseSemantics::RiscOperators(protoval, solver), omit_cur_insn(false), computingDefiners_(TRACK_NO_DEFINERS),
          computingMemoryWriters_(TRACK_LATEST_WRITER), computingRegisterWriters_(TRACK_LATEST_WRITER), trimThreshold_(0),
          reinterpretMemoryReads_(true), reinterpretRegisterReads_(true) {
        name("Symbolic");
        ASSERT_always_not_null(protoval);
        ASSERT_always_not_null2(protoval.dynamicCast<SValue>(),
                                "SymbolicSemantics supports only symbolic SValue types or derivatives thereof");
    }

    explicit RiscOperators(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr())
        : BaseSemantics::RiscOperators(state, solver), omit_cur_insn(false), computingDefiners_(TRACK_NO_DEFINERS),
          computingMemoryWriters_(TRACK_LATEST_WRITER), computingRegisterWriters_(TRACK_LATEST_WRITER), trimThreshold_(0),
          reinterpretMemoryReads_(true), reinterpretRegisterReads_(true) {
        name("Symbolic");
        ASSERT_always_not_null(state);
        ASSERT_always_not_null(state->registerState());
        ASSERT_always_not_null2(boost::dynamic_pointer_cast<RegisterState>(state->registerState()),
                                "SymbolicSemantics supports only RegisterStateGeneric or derivatives thereof");
        ASSERT_always_not_null(state->protoval());
        ASSERT_always_not_null2(state->protoval().dynamicCast<SValue>(),
                                "SymbolicSemantics supports only symbolic SValue types or derivatives thereof");
    }

    // Static allocating constructors
public:
    static RiscOperatorsPtr instance(const RegisterDictionary *regdict, const SmtSolverPtr &solver = SmtSolverPtr()) {
        BaseSemantics::SValuePtr protoval = SValue::instance();
        BaseSemantics::RegisterStatePtr registers = RegisterState::instance(protoval, regdict);
        BaseSemantics::MemoryStatePtr memory = MemoryListState::instance(protoval, protoval);
        BaseSemantics::StatePtr state = State::instance(registers, memory);
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    static RiscOperatorsPtr instance(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(protoval, solver));
    }

    static RiscOperatorsPtr instance(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    // Virtual constructors
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override {
        return instance(protoval, solver);
    }

    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override {
        return instance(state, solver);
    }

    // Dynamic pointer casts
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr &x) {
        RiscOperatorsPtr retval = boost::dynamic_pointer_cast<RiscOperators>(x);
        ASSERT_not_null(retval);
        return retval;
    }

    // Inherited methods for constructing values.
public:
    virtual BaseSemantics::SValuePtr boolean_(bool b) override {
        SValuePtr retval = SValue::promote(BaseSemantics::RiscOperators::boolean_(b));
        if (computingDefiners() != TRACK_NO_DEFINERS && !omit_cur_insn)
            retval->defined_by(currentInstruction());
        return retval;
    }

    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) override {
        SValuePtr retval = SValue::promote(BaseSemantics::RiscOperators::number_(nbits, value));
        if (computingDefiners() != TRACK_NO_DEFINERS && !omit_cur_insn)
            retval->defined_by(currentInstruction());
        return retval;
    }

    // New methods for constructing values, so we don't have to write so many SValue::promote calls in the RiscOperators
    // implementations.
    SValuePtr svalueExpr(const ExprPtr &expr, const InsnSet &defs=InsnSet()) {
        SValuePtr newval = SValue::promote(protoval()->undefined_(expr->nBits()));
        newval->set_expression(expr);
        newval->set_defining_instructions(defs);
        return newval;
    }

protected:
    SValuePtr svalueUndefined(size_t nbits) {
        return SValue::promote(undefined_(nbits));
    }

    SValuePtr svalueBottom(size_t nbits) {
        return SValue::promote(bottom_(nbits));
    }

    SValuePtr svalueUnspecified(size_t nbits) {
        return SValue::promote(unspecified_(nbits));
    }

    SValuePtr svalueNumber(size_t nbits, uint64_t value) {
        return SValue::promote(number_(nbits, value));
    }

    SValuePtr svalueBoolean(bool b) {
        return SValue::promote(boolean_(b));
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_number(size_t nbits, uint64_t value) ROSE_DEPRECATED("use svalueNumber instead") {
        return svalueNumber(nbits, value);
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_boolean(bool b) ROSE_DEPRECATED("use svalueBoolean instead") {
        return svalueBoolean(b);
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_unspecified(size_t nbits) ROSE_DEPRECATED("use svalueUnspecified instead") {
        return svalueUnspecified(nbits);
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_bottom(size_t nbits) ROSE_DEPRECATED("use svalueBottom instead") {
        return svalueBottom(nbits);
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_undefined(size_t nbits) ROSE_DEPRECATED("use svalueUndefined instead") {
        return svalueUndefined(nbits);
    }

    // [Robb Matzke 2021-03-18]: deprecated
    SValuePtr svalue_expr(const ExprPtr &expr, const InsnSet &defs=InsnSet()) ROSE_DEPRECATED("use svalueExpr instead") {
        return svalueExpr(expr, defs);
    }

    // Configuration properties
public:

    void computingDefiners(DefinersMode m) { computingDefiners_ = m; }
    DefinersMode computingDefiners() const { return computingDefiners_; }
    void computingMemoryWriters(WritersMode m) { computingMemoryWriters_ = m; }
    WritersMode computingMemoryWriters() const { return computingMemoryWriters_; }
    void computingRegisterWriters(WritersMode m) { computingRegisterWriters_ = m; }
    WritersMode computingRegisterWriters() const { return computingRegisterWriters_; }
    // Used internally to control whether cur_insn should be omitted from the list of definers.
    bool getset_omit_cur_insn(bool b) { bool retval = omit_cur_insn; omit_cur_insn=b; return retval; }

    void trimThreshold(uint64_t n) { trimThreshold_ = n; }
    uint64_t trimThreshold() const { return trimThreshold_; }
    size_t nTrimmed() const { return nTrimmed_; }
    void nTrimmed(size_t n) { nTrimmed_ = n; }
    bool reinterpretMemoryReads() const { return reinterpretMemoryReads_; }
    void reinterpretMemoryReads(bool b) { reinterpretMemoryReads_ = b; }
    bool reinterpretRegisterReads() const { return reinterpretRegisterReads_; }
    void reinterpretRegisterReads(bool b) { reinterpretRegisterReads_ = b; }
    // Methods first defined at this level of the class hierarchy
public:
    virtual void substitute(const SValuePtr &from, const SValuePtr &to);

    virtual BaseSemantics::SValuePtr filterResult(const BaseSemantics::SValuePtr&);

    static SgAsmFloatType* sgIsIeee754(SgAsmType*);

    virtual SymbolicExpr::Type sgTypeToSymbolicType(SgAsmType*);

    // Override methods from base class.  These are the RISC operators that are invoked by a Dispatcher.
public:
    virtual void interrupt(int majr, int minr) override;
    virtual BaseSemantics::SValuePtr and_(const BaseSemantics::SValuePtr &a_,
                                          const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr or_(const BaseSemantics::SValuePtr &a_,
                                         const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr xor_(const BaseSemantics::SValuePtr &a_,
                                          const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr invert(const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr extract(const BaseSemantics::SValuePtr &a_,
                                             size_t begin_bit, size_t end_bit) override;
    virtual BaseSemantics::SValuePtr concat(const BaseSemantics::SValuePtr &a_,
                                            const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr leastSignificantSetBit(const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr mostSignificantSetBit(const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr rotateLeft(const BaseSemantics::SValuePtr &a_,
                                                const BaseSemantics::SValuePtr &sa_) override;
    virtual BaseSemantics::SValuePtr rotateRight(const BaseSemantics::SValuePtr &a_,
                                                 const BaseSemantics::SValuePtr &sa_) override;
    virtual BaseSemantics::SValuePtr shiftLeft(const BaseSemantics::SValuePtr &a_,
                                               const BaseSemantics::SValuePtr &sa_) override;
    virtual BaseSemantics::SValuePtr shiftRight(const BaseSemantics::SValuePtr &a_,
                                                const BaseSemantics::SValuePtr &sa_) override;
    virtual BaseSemantics::SValuePtr shiftRightArithmetic(const BaseSemantics::SValuePtr &a_,
                                                          const BaseSemantics::SValuePtr &sa_) override;
    virtual BaseSemantics::SValuePtr equalToZero(const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr ite(const BaseSemantics::SValuePtr &sel_,
                                         const BaseSemantics::SValuePtr &a_,
                                         const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr unsignedExtend(const BaseSemantics::SValuePtr &a_, size_t new_width) override;
    virtual BaseSemantics::SValuePtr signExtend(const BaseSemantics::SValuePtr &a_, size_t new_width) override;
    virtual BaseSemantics::SValuePtr add(const BaseSemantics::SValuePtr &a_,
                                         const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr addWithCarries(const BaseSemantics::SValuePtr &a_,
                                                    const BaseSemantics::SValuePtr &b_,
                                                    const BaseSemantics::SValuePtr &c_,
                                                    BaseSemantics::SValuePtr &carry_out/*out*/) override;
    virtual BaseSemantics::SValuePtr negate(const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr signedDivide(const BaseSemantics::SValuePtr &a_,
                                                  const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr signedModulo(const BaseSemantics::SValuePtr &a_,
                                                  const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr signedMultiply(const BaseSemantics::SValuePtr &a_,
                                                    const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr unsignedDivide(const BaseSemantics::SValuePtr &a_,
                                                    const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr unsignedModulo(const BaseSemantics::SValuePtr &a_,
                                                    const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr unsignedMultiply(const BaseSemantics::SValuePtr &a_,
                                                      const BaseSemantics::SValuePtr &b_) override;
    virtual BaseSemantics::SValuePtr fpConvert(const BaseSemantics::SValuePtr &a, SgAsmFloatType *aType,
                                               SgAsmFloatType *retType) override;
    virtual BaseSemantics::SValuePtr reinterpret(const BaseSemantics::SValuePtr&, SgAsmType*) override;
    virtual BaseSemantics::SValuePtr readRegister(RegisterDescriptor reg,
                                                  const BaseSemantics::SValuePtr &dflt) override;
    virtual BaseSemantics::SValuePtr peekRegister(RegisterDescriptor reg,
                                                  const BaseSemantics::SValuePtr &dflt) override;
    virtual void writeRegister(RegisterDescriptor reg, const BaseSemantics::SValuePtr &a_) override;
    virtual BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg,
                                                const BaseSemantics::SValuePtr &addr,
                                                const BaseSemantics::SValuePtr &dflt,
                                                const BaseSemantics::SValuePtr &cond) override;
    virtual BaseSemantics::SValuePtr peekMemory(RegisterDescriptor segreg,
                                                const BaseSemantics::SValuePtr &addr,
                                                const BaseSemantics::SValuePtr &dflt) override;
    virtual void writeMemory(RegisterDescriptor segreg,
                             const BaseSemantics::SValuePtr &addr,
                             const BaseSemantics::SValuePtr &data,
                             const BaseSemantics::SValuePtr &cond) override;

public:
    BaseSemantics::SValuePtr readOrPeekMemory(RegisterDescriptor segreg,
                                              const BaseSemantics::SValuePtr &addr,
                                              const BaseSemantics::SValuePtr &dflt,
                                              AllowSideEffects::Flag);
};

} // namespace
} // namespace
} // namespace
} // namespace

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::SValue);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::MemoryListState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::MemoryMapState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::RiscOperators);
#endif

#endif
#endif