SourceAstSemantics2.h

// Turn instruction semantics into a C source AST
#ifndef Rose_SourceAstSemantics2_H
#define Rose_SourceAstSemantics2_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include "Disassembler.h"
#include "RegisterStateGeneric.h"
#include "NullSemantics2.h"

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

namespace SourceAstSemantics {

//                                      Value type

typedef Sawyer::SharedPointer<class SValue> SValuePtr;

class SValue: public BaseSemantics::SValue {
protected:
    static size_t nVariables_;
    std::string ctext_;

protected:
    // An undefined or unspecified value is a C variable that's not initialized.
    explicit SValue(size_t nbits);

    // An integer value, various types depending on width
    SValue(size_t nbits, uint64_t number);

    // Copy constructor deep-copies the AST.
    SValue(const SValue &other);
    
public:
    static SValuePtr instance() {
        return SValuePtr(new SValue(1));
    }

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

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

public:
    virtual BaseSemantics::SValuePtr bottom_(size_t nbits) const ROSE_OVERRIDE {
        return instance_undefined(nbits);
    }
    virtual BaseSemantics::SValuePtr undefined_(size_t nbits) const ROSE_OVERRIDE {
        return instance_undefined(nbits);
    }
    virtual BaseSemantics::SValuePtr unspecified_(size_t nbits) const ROSE_OVERRIDE {
        return instance_undefined(nbits);
    }
    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) const ROSE_OVERRIDE {
        return instance_integer(nbits, value);
    }
    virtual BaseSemantics::SValuePtr boolean_(bool value) const ROSE_OVERRIDE {
        return instance_integer(1, value ? 1 : 0);
    }
    virtual BaseSemantics::SValuePtr copy(size_t new_width=0) const ROSE_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&, const BaseSemantics::MergerPtr&,
                        const SmtSolverPtr&) const ROSE_OVERRIDE {
        throw BaseSemantics::NotImplemented("SourceAstSemantics is not suitable for dataflow analysis", NULL);
    }

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

public:
    virtual bool isBottom() const ROSE_OVERRIDE {
        return false;
    }

    virtual void hash(Combinatorics::Hasher&) const override;
    virtual void print(std::ostream&, BaseSemantics::Formatter&) const ROSE_OVERRIDE;

public:
    // These are not needed since this domain never tries to compare semantic values.
    virtual bool may_equal(const BaseSemantics::SValuePtr &other,
                           const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        ASSERT_not_reachable("no implementation necessary");
    }

    virtual bool must_equal(const BaseSemantics::SValuePtr &other,
                            const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        ASSERT_not_reachable("no implementation necessary");
    }
    
    virtual void set_width(size_t nbits) ROSE_OVERRIDE {
        ASSERT_not_reachable("no implementation necessary");
    }

    virtual bool is_number() const ROSE_OVERRIDE {
        return false;
    }

    virtual uint64_t get_number() const ROSE_OVERRIDE {
        ASSERT_not_reachable("no implementation necessary");
    }

public:
    static std::string unsignedTypeNameForSize(size_t nbits);
    static std::string signedTypeNameForSize(size_t nbits);
public:
    virtual const std::string& ctext() const {
        return ctext_;
    }
    virtual void ctext(const std::string &s) {
        ctext_ = s;
    }
};

//                                      State

// No state is necessary for this domain because all instruction side effects are immediately attached to the AST that's
//  being generated rather than being stored in some state.

typedef BaseSemantics::RegisterStateGeneric RegisterState;      
typedef BaseSemantics::RegisterStateGenericPtr RegisterStatePtr; 
typedef NullSemantics::MemoryState MemoryState;         
typedef NullSemantics::MemoryStatePtr MemoryStatePtr;   
typedef BaseSemantics::State State;                     
typedef BaseSemantics::StatePtr StatePtr;               
//                                      RiscOperators

typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;

class RiscOperators: public BaseSemantics::RiscOperators {
    typedef BaseSemantics::RiscOperators Super;

public:
    struct SideEffect {
        BaseSemantics::SValuePtr location;              
        BaseSemantics::SValuePtr temporary;             
        BaseSemantics::SValuePtr expression;            
        // Default constructor. Not normally used, but needed by <code>std::vector</code>. (DON'T DOCUMENT)
        SideEffect() {}

        // Used internally, not neede by users since data members are public.
        SideEffect(const BaseSemantics::SValuePtr &location, const BaseSemantics::SValuePtr &temporary,
                   const BaseSemantics::SValuePtr &expression)
            : location(location), temporary(temporary), expression(expression) {}

        bool isValid() const { return expression != NULL; }

        bool isSubstitution() const {
            return isValid() && location==NULL && temporary!=NULL;
        }
    };

    typedef std::vector<SideEffect> SideEffects;

private:
    SideEffects sideEffects_;                           // Side effects, including substitutions
    bool executionHalted_;                              // Stop adding inputs and outputs?

protected:
    RiscOperators(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver)
        : BaseSemantics::RiscOperators(protoval, solver), executionHalted_(false) {
        name("SourceAstSemantics");
        (void) SValue::promote(protoval); // make sure its dynamic type is a SourceAstSemantics::SValue
    }

    RiscOperators(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver)
        : BaseSemantics::RiscOperators(state, solver), executionHalted_(false) {
        name("SourceAstSemantics");
        (void) SValue::promote(state->protoval());      // values must have SourceAstSemantics::SValue dynamic type
    }

public:
    static RiscOperatorsPtr instance(const RegisterDictionary *regdict, const SmtSolverPtr &solver = SmtSolverPtr()) {
        BaseSemantics::SValuePtr protoval = SValue::instance();
        RegisterStatePtr registers = RegisterState::instance(protoval, regdict);
        BaseSemantics::MemoryStatePtr memory = MemoryState::instance(protoval, protoval);
        BaseSemantics::StatePtr state = State::instance(registers, memory);
        RiscOperatorsPtr ops = RiscOperatorsPtr(new RiscOperators(state, solver));
        ops->resetState();
        return ops;
    }

    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 ROSE_OVERRIDE {
        return instance(protoval, solver);
    }

    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_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;
    }

    // Supporting functions
public:
    BaseSemantics::SValuePtr makeSValue(size_t nbits, SgNode*, const std::string &ctext = "");

    BaseSemantics::SValuePtr saveSideEffect(const BaseSemantics::SValuePtr &expression,
                                            const BaseSemantics::SValuePtr &location = BaseSemantics::SValuePtr());

    BaseSemantics::SValuePtr substitute(const BaseSemantics::SValuePtr &expression);

    const SideEffects& sideEffects() const {
        return sideEffects_;
    }
    
    void resetState();

    std::string registerVariableName(RegisterDescriptor);

    void reset() {
        sideEffects_.clear();
        executionHalted_ = false;
        resetState();
    }

    void haltExecution() { executionHalted_ = true; }

    BaseSemantics::SValuePtr makeMask(size_t nBits, size_t nSet, size_t sa=0);

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

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

#endif
#endif