SymbolicSemantics.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_SymbolicSemantics_H
#define ROSE_BinaryAnalysis_InstructionSemantics_SymbolicSemantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Formatter.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryCellList.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryCellMap.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryState.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Merger.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RegisterStateGeneric.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RiscOperators.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/State.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/SValue.h>
#include <Rose/BinaryAnalysis/SymbolicExpression.h>
 
#include <Cxx_GrammarSerialization.h>
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/set.hpp>
 
#include <inttypes.h>
#include <map>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
 
namespace SymbolicSemantics {
 
using LeafNode = SymbolicExpression::Leaf;
using LeafPtr = SymbolicExpression::LeafPtr;
using InteriorNode = SymbolicExpression::Interior;
using InteriorPtr = SymbolicExpression::InteriorPtr;
using ExprNode = SymbolicExpression::Node;
using ExprPtr = SymbolicExpression::Ptr;
using InsnSet = std::set<SgAsmInstruction*>;
 
// Boolean flags
 
namespace AllowSideEffects {
    enum Flag {NO, YES};
}
 
 
//                                      Merging symbolic values
 
using MergerPtr = Sawyer::SharedPointer<class Merger>;
 
class Merger: public BaseSemantics::Merger {
    size_t setSizeLimit_ = 1;
protected:
    Merger();
 
public:
    typedef MergerPtr Ptr;
 
    static Ptr instance();
 
    static Ptr instance(size_t);
 
    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:
    SymbolicExpression::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);
    SValue(size_t nbits, uint64_t number);
    SValue(ExprPtr expr);
 
    // Static allocating constructors
public:
    static SValuePtr instance();
 
    static SValuePtr instance_bottom(size_t nbits);
 
    static SValuePtr instance_undefined(size_t nbits);
 
    static SValuePtr instance_unspecified(size_t nbits);
 
    static SValuePtr instance_integer(size_t nbits, uint64_t value);
 
    static SValuePtr instance_symbolic(const SymbolicExpression::Ptr &value);
 
    // Virtual allocating constructors
public:
    virtual BaseSemantics::SValuePtr bottom_(size_t nbits) const override;
    virtual BaseSemantics::SValuePtr undefined_(size_t nbits) const override;
    virtual BaseSemantics::SValuePtr unspecified_(size_t nbits) const override;
    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) const override;
    virtual BaseSemantics::SValuePtr boolean_(bool value) const override;
    virtual BaseSemantics::SValuePtr copy(size_t new_width=0) const override;
 
    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&);
 
    // 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 SymbolicExpression, which might be shared with many unrelated values whose size we don't want to affect.
    virtual void set_width(size_t nbits) override;
    virtual bool is_number() const override;
    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);
    virtual void defined_by(SgAsmInstruction *insn, const InsnSet &set1, const InsnSet &set2);
    virtual void defined_by(SgAsmInstruction *insn, const InsnSet &set1);
    virtual void defined_by(SgAsmInstruction *insn);
    virtual const ExprPtr& get_expression() const;
 
    virtual void set_expression(const ExprPtr &new_expr);
    virtual void set_expression(const SValuePtr &source);
    virtual const InsnSet& get_defining_instructions() const;
 
    virtual size_t add_defining_instructions(const InsnSet &to_add);
    virtual size_t add_defining_instructions(const SValuePtr &source);
    virtual size_t add_defining_instructions(SgAsmInstruction *insn);
    virtual void set_defining_instructions(const InsnSet &new_defs);
    virtual void set_defining_instructions(const SValuePtr &source);
    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 BaseSemantics::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 BaseSemantics::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 BaseSemantics::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 BaseSemantics::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 BaseSemantics::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
    explicit MemoryListState(const BaseSemantics::MemoryCellPtr &protocell);
    MemoryListState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval);
    MemoryListState(const MemoryListState &other);
 
    // Static allocating constructors
public:
    static MemoryListStatePtr instance(const BaseSemantics::MemoryCellPtr &protocell);
 
    static  MemoryListStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval);
 
    static MemoryListStatePtr instance(const MemoryListStatePtr &other);
 
    // Virtual constructors
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const override;
 
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::MemoryCellPtr &protocell) const override;
 
    virtual BaseSemantics::MemoryStatePtr clone() const override;
 
    // Dynamic pointer casts
public:
    static MemoryListStatePtr promote(const BaseSemantics::MemoryStatePtr&);
 
    // 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);
 
    MemoryMapState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval);
 
    // Static allocating constructors
public:
    static MemoryMapStatePtr instance(const BaseSemantics::MemoryCellPtr &protocell);
 
    static MemoryMapStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval);
 
    static MemoryMapStatePtr instance(const MemoryMapStatePtr &other);
 
    // Virtual constructors
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const override;
 
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::MemoryCellPtr &protocell) const;
 
    virtual BaseSemantics::MemoryStatePtr clone() const override;
 
    // Dynamic pointer casts
public:
    static MemoryMapStatePtr promote(const BaseSemantics::MemoryStatePtr&);
 
    // 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
 
    explicit RiscOperators(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver);
 
    explicit RiscOperators(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver);
 
    // Static allocating constructors
public:
    ~RiscOperators();
 
    static RiscOperatorsPtr instanceFromRegisters(const RegisterDictionaryPtr&, const SmtSolverPtr &solver = SmtSolverPtr());
 
    static RiscOperatorsPtr instanceFromProtoval(const BaseSemantics::SValuePtr &protoval,
                                                 const SmtSolverPtr &solver = SmtSolverPtr());
 
    static RiscOperatorsPtr instanceFromState(const BaseSemantics::StatePtr&, const SmtSolverPtr &solver = SmtSolverPtr());
 
    // Virtual constructors
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr&,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    // Dynamic pointer casts
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr&);
 
    // Inherited methods for constructing values.
public:
    virtual BaseSemantics::SValuePtr boolean_(bool b) override;
    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) override;
 
    // 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());
 
protected:
    SValuePtr svalueUndefined(size_t nbits);
    SValuePtr svalueBottom(size_t nbits);
    SValuePtr svalueUnspecified(size_t nbits);
    SValuePtr svalueNumber(size_t nbits, uint64_t value);
    SValuePtr svalueBoolean(bool b);
 
    // 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 SymbolicExpression::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 iteWithStatus(const BaseSemantics::SValuePtr &sel_,
                                                   const BaseSemantics::SValuePtr &a_,
                                                   const BaseSemantics::SValuePtr &b_,
                                                   IteStatus&) 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::InstructionSemantics::SymbolicSemantics::SValue);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::MemoryListState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::MemoryMapState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators);
#endif
 
#endif
#endif