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 Architecture::BaseConstPtr&, const Debugger::Linux::Ptr &process, const BaseSemantics::SValuePtr &protoval);
 
    Dispatcher(const Architecture::BaseConstPtr&, const BaseSemantics::RiscOperatorsPtr&);
 
    //----------------------------------------
    // Static allocating constructors
    //----------------------------------------
public:
    ~Dispatcher();
 
    static DispatcherPtr instance(const Architecture::BaseConstPtr&, const Debugger::Linux::Ptr &process,
                                  const BaseSemantics::SValuePtr &protoval = SValue::instance());
 
    static DispatcherPtr instance(const Architecture::BaseConstPtr&, const Debugger::Linux::Specimen&,
                                  const BaseSemantics::SValuePtr &protoval = SValue::instance());
 
    static DispatcherPtr instance(const Architecture::BaseConstPtr&, const BaseSemantics::RiscOperatorsPtr&);
 
    //----------------------------------------
    // Virtual constructors
    //----------------------------------------
public:
    virtual BaseSemantics::DispatcherPtr
    create(const BaseSemantics::RiscOperatorsPtr&) 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