NativeSemantics.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_NativeSemantics_H
#define ROSE_BinaryAnalysis_InstructionSemantics_NativeSemantics_H
#include <featureTests.h>
#if defined(ROSE_ENABLE_BINARY_ANALYSIS) && defined(ROSE_ENABLE_DEBUGGER_LINUX)

#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/Debugger/Linux.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/ConcreteSemantics.h>

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

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {

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::Linux::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    RegisterState();

    RegisterState(const BaseSemantics::SValuePtr &protoval, const Debugger::Linux::Ptr &process);

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    ~RegisterState();

    static RegisterStatePtr instance();

    static RegisterStatePtr instance(const BaseSemantics::SValuePtr &protoval, const Debugger::Linux::Ptr &process);

    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::RegisterStatePtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const RegisterDictionaryPtr&) const override;

    virtual BaseSemantics::RegisterStatePtr clone() const override;

    //----------------------------------------
    // Dynamic pointer casts
    //----------------------------------------
public:
    static RegisterStatePtr promote(const BaseSemantics::RegisterStatePtr&);

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Linux::Ptr process() const;

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

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

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

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

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

    virtual void updateReadProperties(RegisterDescriptor) override {}
    virtual void updateWriteProperties(RegisterDescriptor, BaseSemantics::InputOutputProperty) override {}

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

    virtual void print(std::ostream&, Formatter&) const 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::Linux::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    MemoryState();

    MemoryState(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval,
                const Debugger::Linux::Ptr &process);

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    ~MemoryState();

    static MemoryStatePtr instance();

    static MemoryStatePtr instance(const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval,
                                   const Debugger::Linux::Ptr &process);

    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::MemoryStatePtr create(const BaseSemantics::SValuePtr &addrProtoval,
                                                 const BaseSemantics::SValuePtr &valProtoval) const override;

    virtual BaseSemantics::MemoryStatePtr clone() const override;

    //----------------------------------------
    // Dynamic pointer casts
    //----------------------------------------
public:
    static MemoryStatePtr promote(const BaseSemantics::MemoryStatePtr&);

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Linux::Ptr process() const;

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

    virtual bool merge(const BaseSemantics::MemoryStatePtr &/*other*/, BaseSemantics::RiscOperators */*addrOps*/,
                       BaseSemantics::RiscOperators */*valOps*/) 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) 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) override;

    virtual void writeMemory(const BaseSemantics::SValuePtr &/*addr*/, const BaseSemantics::SValuePtr &/*value*/,
                             BaseSemantics::RiscOperators */*addrOps*/, BaseSemantics::RiscOperators */*valOps*/) 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 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&);

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    ~RiscOperators();

    static RiscOperatorsPtr instanceFromProtoval(const BaseSemantics::SValuePtr &protoval, const Debugger::Linux::Ptr &process);

    static RiscOperatorsPtr instanceFromState(const BaseSemantics::StatePtr &state);

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

    //----------------------------------------
    // Dynamic pointer casts
    //----------------------------------------
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr&);

    //----------------------------------------
    // Additional properties
    //----------------------------------------
public:
    Debugger::Linux::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::Linux::Ptr process_;

    //----------------------------------------
    // Real constructors
    //----------------------------------------
protected:
    Dispatcher(const Debugger::Linux::Ptr &process, const BaseSemantics::SValuePtr &protoval);

    Dispatcher(const BaseSemantics::RiscOperatorsPtr&);

    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    ~Dispatcher();

    static DispatcherPtr instance(const Debugger::Linux::Ptr &process, const BaseSemantics::SValuePtr &protoval = SValue::instance());

    static DispatcherPtr instance(const Debugger::Linux::Specimen&, const BaseSemantics::SValuePtr &protoval = SValue::instance());

    static DispatcherPtr instance(const BaseSemantics::RiscOperatorsPtr&);

    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::DispatcherPtr
    create(const BaseSemantics::RiscOperatorsPtr&, size_t addrWidth, const RegisterDictionaryPtr&) const override;

    //----------------------------------------
    // Operations
    //----------------------------------------
public:
    virtual void processInstruction(SgAsmInstruction *insn) override;
    void processInstruction(rose_addr_t va);
    virtual SgAsmInstruction* currentInstruction() const override;

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

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


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

#endif
#endif