NativeSemantics.h

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

#include <Rose/BinaryAnalysis/Debugger.h>
#include <Rose/BinaryAnalysis/InstructionSemantics2/ConcreteSemantics.h>

#include <boost/noncopyable.hpp>
#include <boost/filesystem.hpp>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {

namespace NativeSemantics {

//                                      Value type

typedef ConcreteSemantics::SValue SValue;

typedef ConcreteSemantics::SValuePtr SValuePtr;

typedef ConcreteSemantics::Formatter Formatter;

//                                      Register state

typedef boost::shared_ptr<class RegisterState> RegisterStatePtr;

class RegisterState: public BaseSemantics::RegisterState, boost::noncopyable {
public:
    using Super = BaseSemantics::RegisterState;

    using Ptr = RegisterStatePtr;

private:
    Debugger::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    RegisterState() {}

    RegisterState(const BaseSemantics::SValuePtr &protoval, const Debugger::Ptr &process)
        : BaseSemantics::RegisterState(protoval, process->registerDictionary()), process_(process) {
        ASSERT_not_null(process);
    }
    
    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    static RegisterStatePtr instance() {
        return RegisterStatePtr(new RegisterState);
    }

    static RegisterStatePtr instance(const BaseSemantics::SValuePtr &protoval, const Debugger::Ptr &process) {
        ASSERT_not_null(protoval);
        (void) SValue::promote(protoval);
        return RegisterStatePtr(new RegisterState(protoval, process));
    }
    
    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::RegisterStatePtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const RegisterDictionary *regdict) const ROSE_OVERRIDE {
        ASSERT_not_implemented("not applicable for this class");
    }

    virtual BaseSemantics::RegisterStatePtr clone() const ROSE_OVERRIDE {
        ASSERT_not_implemented("not applicable for this class");
    }
    
    //----------------------------------------
    // Dynamic pointer casts
    //----------------------------------------
public:
    static RegisterStatePtr promote(const BaseSemantics::RegisterStatePtr &x) {
        RegisterStatePtr retval = boost::dynamic_pointer_cast<RegisterState>(x);
        ASSERT_not_null(retval);
        return retval;
    }

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Ptr process() const {
        return process_;
    }

    //----------------------------------------
    // Virtual function implementations
    //----------------------------------------
public:
    virtual void clear() ROSE_OVERRIDE {}

    virtual void zero() ROSE_OVERRIDE {
        TODO("[Robb Matzke 2019-09-05]");               // set all registers to zero
    }

    virtual bool merge(const BaseSemantics::RegisterStatePtr &other, BaseSemantics::RiscOperators *ops) ROSE_OVERRIDE {
        ASSERT_not_implemented("[Robb Matzke 2019-09-05]");
    }

    virtual BaseSemantics::SValuePtr readRegister(RegisterDescriptor reg, const BaseSemantics::SValuePtr &dflt,
                                                  BaseSemantics::RiscOperators *ops) ROSE_OVERRIDE {
        return peekRegister(reg, dflt, ops);
    }
    
    virtual BaseSemantics::SValuePtr peekRegister(RegisterDescriptor, const BaseSemantics::SValuePtr &dflt,
                                                  BaseSemantics::RiscOperators*) ROSE_OVERRIDE;

    virtual void writeRegister(RegisterDescriptor, const BaseSemantics::SValuePtr &value,
                               BaseSemantics::RiscOperators*) ROSE_OVERRIDE;

    virtual void hash(Combinatorics::Hasher&, BaseSemantics::RiscOperators*) const override;

    virtual void print(std::ostream&, Formatter&) const ROSE_OVERRIDE;
};

//                                      Memory state

typedef boost::shared_ptr<class MemoryState> MemoryStatePtr;

class MemoryState: public BaseSemantics::MemoryState, boost::noncopyable {
public:
    using Super = BaseSemantics::MemoryState;

    using Ptr = MemoryStatePtr;

private:
    Debugger::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    MemoryState() {}

    MemoryState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval,
                const Debugger::Ptr &process)
        : BaseSemantics::MemoryState(addrProtoval, valProtoval), process_(process) {
        ASSERT_not_null(process);
    }

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    static MemoryStatePtr instance() {
        return MemoryStatePtr(new MemoryState);
    }

    static MemoryStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval,
                                   const Debugger::Ptr &process) {
        return MemoryStatePtr(new MemoryState(addrProtoval, valProtoval, process));
    }

    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const ROSE_OVERRIDE {
        ASSERT_not_implemented("not applicable for this class");
    }

    virtual BaseSemantics::MemoryStatePtr clone() const ROSE_OVERRIDE {
        ASSERT_not_implemented("not applicable for this class");
    }

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

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Ptr process() const {
        return process_;
    }

    //----------------------------------------
    // Virtual function implementations
    //----------------------------------------
public:
    virtual void clear() ROSE_OVERRIDE {}

    virtual bool merge(const BaseSemantics::MemoryStatePtr &other, BaseSemantics::RiscOperators *addrOps,
                       BaseSemantics::RiscOperators *valOps) ROSE_OVERRIDE {
        ASSERT_not_implemented("not applicable for this class");
    }

    virtual BaseSemantics::SValuePtr readMemory(const BaseSemantics::SValuePtr &address, const BaseSemantics::SValuePtr &dflt,
                                                BaseSemantics::RiscOperators *addrOps,
                                                BaseSemantics::RiscOperators *valOps) ROSE_OVERRIDE {
        return peekMemory(address, dflt, addrOps, valOps);
    }

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

    virtual void writeMemory(const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &value,
                             BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) ROSE_OVERRIDE {
        ASSERT_not_implemented("[Robb Matzke 2019-09-05]");
    }

    virtual void hash(Combinatorics::Hasher&, BaseSemantics::RiscOperators *addrOps,
                      BaseSemantics::RiscOperators *valOps) const override {
        ASSERT_not_implemented("[Robb Matzke 2021-03-26]");
    }

    virtual void print(std::ostream&, BaseSemantics::Formatter&) const ROSE_OVERRIDE {
        ASSERT_not_implemented("[Robb Matzke 2019-09-05]");
    }
};

//                                      Complete semantic state

typedef boost::shared_ptr<class State> StatePtr;

class State: public ConcreteSemantics::State, boost::noncopyable {
public:
    using Super = ConcreteSemantics::State;

    using Ptr = StatePtr;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    State(const BaseSemantics::RegisterStatePtr &registers, const BaseSemantics::MemoryStatePtr &memory)
        : ConcreteSemantics::State(registers, memory) {
        (void) RegisterState::promote(registers);
        (void) MemoryState::promote(memory);
    }

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    static StatePtr instance(const BaseSemantics::RegisterStatePtr &registers, const BaseSemantics::MemoryStatePtr &memory) {
        return StatePtr(new State(registers, memory));
    }
};

//                                      RISC operators

typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;

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

    using Ptr = RiscOperatorsPtr;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    explicit RiscOperators(const BaseSemantics::StatePtr &state)
        : ConcreteSemantics::RiscOperators(state, SmtSolverPtr()) {
        name("Native");
    }

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    static RiscOperatorsPtr instance(const BaseSemantics::SValuePtr &protoval, const Debugger::Ptr &process) {
        RegisterStatePtr registers = RegisterState::instance(protoval, process);
        MemoryStatePtr memory = MemoryState::instance(protoval, protoval, process);
        StatePtr state = State::instance(registers, memory);
        return RiscOperatorsPtr(new RiscOperators(state));
    }

    static RiscOperatorsPtr instance(const BaseSemantics::StatePtr &state) {
        (void) State::promote(state);                   // check that it's the correct type
        return RiscOperatorsPtr(new RiscOperators(state));
    }
    
    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        TODO("[Robb Matzke 2019-09-05]");
    }

    //----------------------------------------
    // 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;
    }

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Ptr process() const {
        return RegisterState::promote(currentState()->registerState())->process();
    }
};

//                                      Dispatcher

typedef boost::shared_ptr<class Dispatcher> DispatcherPtr;

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

    using Ptr = DispatcherPtr;

private:
    Debugger::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    Dispatcher(const Debugger::Ptr &process, const BaseSemantics::SValuePtr &protoval)
        : process_(process) {
        registerDictionary(process_->registerDictionary());
        addressWidth(process_->kernelWordSize());
        operators(RiscOperators::instance(protoval, process_));
    }

    Dispatcher(const BaseSemantics::RiscOperatorsPtr &ops)
        : process_(RiscOperators::promote(ops)->process()) {
        registerDictionary(process_->registerDictionary());
        addressWidth(process_->kernelWordSize());
        operators(ops);
    }
    
    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    static DispatcherPtr instance(const Debugger::Ptr &process,
                                  const BaseSemantics::SValuePtr &protoval = SValue::instance()) {
        return DispatcherPtr(new Dispatcher(process, protoval));
    }
    
    static DispatcherPtr instance(const Debugger::Specimen &specimen,
                                  const BaseSemantics::SValuePtr &protoval = SValue::instance()) {
        Debugger::Ptr process = Debugger::instance(specimen);
        return DispatcherPtr(new Dispatcher(process, protoval));
    }

    static DispatcherPtr instance(const BaseSemantics::RiscOperatorsPtr &ops) {
        (void) RiscOperators::promote(ops);             // check type
        return DispatcherPtr(new Dispatcher(ops));
    }
    
    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::DispatcherPtr
    create(const BaseSemantics::RiscOperatorsPtr &ops, size_t addrWidth=0,
           const RegisterDictionary *regs=NULL) const ROSE_OVERRIDE {
        notApplicable("create");
    }
    
    //----------------------------------------
    // Operations
    //----------------------------------------
public:
    virtual void processInstruction(SgAsmInstruction *insn) ROSE_OVERRIDE;
    void processInstruction(rose_addr_t va);
    virtual SgAsmInstruction* currentInstruction() const ROSE_OVERRIDE;

    virtual RegisterDescriptor instructionPointerRegister() const ROSE_OVERRIDE;
    virtual RegisterDescriptor stackPointerRegister() const ROSE_OVERRIDE;
    virtual RegisterDescriptor stackFrameRegister() const ROSE_OVERRIDE;
    virtual RegisterDescriptor callReturnRegister() const ROSE_OVERRIDE;

    virtual void iprocReplace(SgAsmInstruction*, BaseSemantics::InsnProcessor*) ROSE_OVERRIDE {
        notApplicable("iprocReplace");
    }
    virtual void iprocSet(int key, BaseSemantics::InsnProcessor*) ROSE_OVERRIDE {
        notApplicable("iprocSet");
    }
    virtual int iprocKey(SgAsmInstruction*) const ROSE_OVERRIDE {
        notApplicable("iprocKey");
    }
private:
    void notApplicable(const std::string &what) const SAWYER_ATTR_NORETURN {
        ASSERT_not_implemented(what + " is not applicable for this class");
    }
};


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

#endif
#endif