RiscOperators.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RiscOperators_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RiscOperators_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/Utility.h>
#include <Rose/BinaryAnalysis/HotPatch.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <Combinatorics.h>
 
#include <boost/enable_shared_from_this.hpp>
 
#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 {
 
//                                      RISC Operators
 
class RiscOperators: public boost::enable_shared_from_this<RiscOperators> {
public:
    using Ptr = RiscOperatorsPtr;
 
private:
    SValuePtr protoval_;                                // Prototypical value used for its virtual constructors
    StatePtr currentState_;                             // State upon which RISC operators operate
    StatePtr initialState_;                             // Lazily updated initial state; see readMemory
    SmtSolverPtr solver_;                               // Optional SMT solver
    SgAsmInstruction *currentInsn_ = nullptr;           // Current instruction, as set by latest startInstruction call
    size_t nInsns_ = 0;                                 // Number of instructions processed
    std::string name_;                                  // Name to use for debugging
    HotPatch hotPatch_;                                 // Adjustments to the semantic state after each instruction.
    bool isNoopRead_ = false;                           // Read is part of a possible no-op read-then-write sequence
 
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned version) {
        s & BOOST_SERIALIZATION_NVP(protoval_);
        s & BOOST_SERIALIZATION_NVP(currentState_);
        s & BOOST_SERIALIZATION_NVP(initialState_);
        s & BOOST_SERIALIZATION_NVP(solver_);
        s & BOOST_SERIALIZATION_NVP(currentInsn_);
        s & BOOST_SERIALIZATION_NVP(nInsns_);
        s & BOOST_SERIALIZATION_NVP(name_);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(hotPatch_);
        if (version >= 2)
            s & BOOST_SERIALIZATION_NVP(isNoopRead_);
    }
#endif
 
    // Real constructors
protected:
    // for serialization
    RiscOperators();
 
    explicit RiscOperators(const SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr());
    explicit RiscOperators(const StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr());
 
public:
    virtual ~RiscOperators();
 
    // Static allocating constructors.  None needed since this class is abstract.
 
 
    // Virtual constructors.
public:
    virtual RiscOperatorsPtr create(const SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;
 
    virtual RiscOperatorsPtr create(const StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;
 
    // Dynamic pointer casts.  No-op since this is the base class.
public:
    static RiscOperatorsPtr promote(const RiscOperatorsPtr &x) {
        ASSERT_not_null(x);
        return x;
    }
    
    // Other methods part of our API
public:
    virtual SValuePtr protoval() const { return protoval_; }
 
    virtual SmtSolverPtr solver() const { return solver_; }
    virtual void solver(const SmtSolverPtr &s) { solver_ = s; }
    const HotPatch& hotPatch() const { return hotPatch_; }
    HotPatch& hotPatch() { return hotPatch_; }
    void hotPatch(const HotPatch &hp) { hotPatch_ = hp; }
    virtual StatePtr currentState() const { return currentState_; }
    virtual void currentState(const StatePtr &s) { currentState_ = s; }
    virtual StatePtr initialState() const { return initialState_; }
    virtual void initialState(const StatePtr &s) { initialState_ = s; }
    virtual const std::string& name() const { return name_; }
    virtual void name(const std::string &s) { name_ = s; }
    virtual void hash(Combinatorics::Hasher&);
 
    void print(std::ostream &stream, const std::string prefix="") const;
    virtual void print(std::ostream &stream, Formatter &fmt) const;
    class WithFormatter {
        RiscOperatorsPtr obj;
        Formatter &fmt;
    public:
        WithFormatter(const RiscOperatorsPtr &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);
    virtual size_t nInsns() const { return nInsns_; }
    virtual void nInsns(size_t n) { nInsns_ = n; }
    virtual SgAsmInstruction* currentInstruction() const {
        return currentInsn_;
    }
    virtual void currentInstruction(SgAsmInstruction *insn) {
        currentInsn_ = insn;
    }
    virtual bool isNoopRead() const { return isNoopRead_; }
    virtual void isNoopRead(bool b) { isNoopRead_ = b; }
    virtual void startInstruction(SgAsmInstruction *insn);
 
    virtual void finishInstruction(SgAsmInstruction *insn);
 
    virtual void comment(const std::string&);
 
 
    //                                  Value Construction Operations
    // The trailing underscores are necessary for for undefined_() on some machines, so we just add one to the end of all the
    // virtual constructors for consistency.
 
    virtual SValuePtr undefined_(size_t nbits);
    virtual SValuePtr unspecified_(size_t nbits);
    virtual SValuePtr number_(size_t nbits, uint64_t value);
 
    virtual SValuePtr boolean_(bool value);
 
    virtual SValuePtr bottom_(size_t nbits);
 
    
    //                                  x86-specific Operations (FIXME)
 
    virtual SValuePtr filterCallTarget(const SValuePtr &a);
 
    virtual SValuePtr filterReturnTarget(const SValuePtr &a);
 
    virtual SValuePtr filterIndirectJumpTarget(const SValuePtr &a);
 
    virtual void hlt() {}
 
    virtual void cpuid() {}
 
    virtual SValuePtr rdtsc() { return unspecified_(64); }
 
 
    //                                  Boolean Operations
 
    virtual SValuePtr and_(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr or_(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr xor_(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr invert(const SValuePtr &a) = 0;
 
    virtual SValuePtr extract(const SValuePtr &a, size_t begin_bit, size_t end_bit) = 0;
 
    virtual SValuePtr concat(const SValuePtr &lowBits, const SValuePtr &highBits) = 0;
 
    virtual SValuePtr concatLoHi(const SValuePtr &lowBits, const SValuePtr &highBits) {
        return concat(lowBits, highBits);
    }
    virtual SValuePtr concatHiLo(const SValuePtr &highBits, const SValuePtr &lowBits) {
        return concat(lowBits, highBits);
    }
    virtual std::pair<SValuePtr /*low*/, SValuePtr /*high*/> split(const SValuePtr &a, size_t splitPoint);
 
    virtual SValuePtr leastSignificantSetBit(const SValuePtr &a) = 0;
 
    virtual SValuePtr mostSignificantSetBit(const SValuePtr &a) = 0;
 
    virtual SValuePtr countLeadingZeros(const SValuePtr &a);
 
    virtual SValuePtr countLeadingOnes(const SValuePtr &a);
 
    virtual SValuePtr rotateLeft(const SValuePtr &a, const SValuePtr &nbits) = 0;
 
    virtual SValuePtr rotateRight(const SValuePtr &a, const SValuePtr &nbits) = 0;
 
    virtual SValuePtr shiftLeft(const SValuePtr &a, const SValuePtr &nbits) = 0;
 
    virtual SValuePtr shiftRight(const SValuePtr &a, const SValuePtr &nbits) = 0;
 
    virtual SValuePtr shiftRightArithmetic(const SValuePtr &a, const SValuePtr &nbits) = 0;
 
    virtual SValuePtr reverseElmts(const SValuePtr &a, size_t elmtNBits);
 
 
    //                                  Comparison Operations
    
    virtual SValuePtr equalToZero(const SValuePtr &a) = 0;
 
    enum class IteStatus {
        NEITHER,                                        
        A,                                              
        B,                                              
        BOTH                                            
    };
 
    virtual SValuePtr iteWithStatus(const SValuePtr &cond, const SValuePtr &a, const SValuePtr &b, IteStatus &status /*out*/) = 0;
 
    virtual SValuePtr ite(const SValuePtr &cond, const SValuePtr &a, const SValuePtr &b) final {
        IteStatus status = IteStatus::NEITHER;
        return iteWithStatus(cond, a, b, status);
    }
 
    virtual SValuePtr isEqual(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isNotEqual(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isUnsignedLessThan(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isUnsignedLessThanOrEqual(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isUnsignedGreaterThan(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isUnsignedGreaterThanOrEqual(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isSignedLessThan(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isSignedLessThanOrEqual(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isSignedGreaterThan(const SValuePtr &a, const SValuePtr &b);
    virtual SValuePtr isSignedGreaterThanOrEqual(const SValuePtr &a, const SValuePtr &b);
    //                                  Integer Arithmetic Operations
 
    virtual SValuePtr unsignedExtend(const SValuePtr &a, size_t new_width);
 
    virtual SValuePtr signExtend(const SValuePtr &a, size_t new_width) = 0;
 
    virtual SValuePtr add(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr addCarry(const SValuePtr &a, const SValuePtr &b,
                               SValuePtr &carryOut /*out*/, SValuePtr &overflowed /*out*/);
 
    virtual SValuePtr subtract(const SValuePtr &minuend, const SValuePtr &subtrahend);
 
    virtual SValuePtr subtractCarry(const SValuePtr &minuend, const SValuePtr &subtrahend,
                                    SValuePtr &carryOut /*out*/, SValuePtr &overflowed /*out*/);
 
    virtual SValuePtr addWithCarries(const SValuePtr &a, const SValuePtr &b, const SValuePtr &c,
                                        SValuePtr &carry_out/*output*/) = 0;
 
    virtual SValuePtr negate(const SValuePtr &a) = 0;
 
    virtual SValuePtr signedDivide(const SValuePtr &dividend, const SValuePtr &divisor) = 0;
 
    virtual SValuePtr signedModulo(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr signedMultiply(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr unsignedDivide(const SValuePtr &dividend, const SValuePtr &divisor) = 0;
 
    virtual SValuePtr unsignedModulo(const SValuePtr &a, const SValuePtr &b) = 0;
 
    virtual SValuePtr unsignedMultiply(const SValuePtr &a, const SValuePtr &b) = 0;
 
 
    //                                  Interrupt and system calls
 
    virtual void interrupt(int majorNumber, int minorNumber);
 
    virtual void interrupt(const SValuePtr &majr, const SValuePtr &minr, const SValuePtr &raise);
 
    virtual void raiseInterrupt(unsigned majorNumber, unsigned minorNumber, const SValuePtr &raise);
 
 
    //                                  Floating-point operations
    //
    // For now these all have default implementations that throw NotImplemented, but we might change them to pure virtual
    // sometime in the future so they're consistent with most other RISC operators. [Robb P. Matzke 2015-08-03]
 
    virtual SValuePtr fpFromInteger(const SValuePtr &intValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpToInteger(const SValuePtr &fpValue, SgAsmFloatType *fpType, const SValuePtr &dflt);
 
    virtual SValuePtr fpConvert(const SValuePtr &a, SgAsmFloatType *aType, SgAsmFloatType *retType);
 
    virtual SValuePtr fpIsNan(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpIsDenormalized(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpIsZero(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpIsInfinity(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpSign(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpEffectiveExponent(const SValuePtr &fpValue, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpAdd(const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpSubtract(const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpMultiply(const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpDivide(const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpSquareRoot(const SValuePtr &a, SgAsmFloatType *fpType);
 
    virtual SValuePtr fpRoundTowardZero(const SValuePtr &a, SgAsmFloatType *fpType);
 
    //                                  Conversion operations
 
    virtual SValuePtr reinterpret(const SValuePtr &a, SgAsmType *retType);
 
    virtual SValuePtr convert(const SValuePtr &a, SgAsmType *srcType, SgAsmType *dstType);
 
    
    //                                  State Accessing Operations
    
    virtual SValuePtr readRegister(RegisterDescriptor reg) {   // old subclasses can still override this if they want,
        return readRegister(reg, undefined_(reg.nBits())); // but new subclasses should not override this method.
    }
    virtual SValuePtr readRegister(RegisterDescriptor reg, const SValuePtr &dflt); // new subclasses override this
    virtual void writeRegister(RegisterDescriptor reg, const SValuePtr &a);
 
    virtual SValuePtr peekRegister(RegisterDescriptor, const SValuePtr &dflt);
    SValuePtr peekRegister(RegisterDescriptor reg) {
        return peekRegister(reg, undefined_(reg.nBits()));
    }
    virtual SValuePtr readMemory(RegisterDescriptor segreg, const SValuePtr &addr, const SValuePtr &dflt,
                                 const SValuePtr &cond) = 0;
 
    virtual void writeMemory(RegisterDescriptor segreg, const SValuePtr &addr, const SValuePtr &data,
                             const SValuePtr &cond) = 0;
 
    virtual SValuePtr peekMemory(RegisterDescriptor segreg, const SValuePtr &addr, const SValuePtr &dflt) = 0;
};
 
std::ostream& operator<<(std::ostream&, const RiscOperators&);
std::ostream& operator<<(std::ostream&, const RiscOperators::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators, 2);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators);
#endif
 
#endif
#endif