Dispatcher.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_Dispatcher_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_Dispatcher_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Instruction Dispatcher
 
class InsnProcessor {
public:
    virtual ~InsnProcessor() {}
    virtual void process(const DispatcherPtr &dispatcher, SgAsmInstruction *insn) = 0;
};
    
class Dispatcher: public boost::enable_shared_from_this<Dispatcher> {
public:
    using Ptr = DispatcherPtr;
 
private:
    Architecture::BaseConstPtr architecture_;           // Required architecture
    RiscOperatorsPtr operators_;
 
protected:
    bool autoResetInstructionPointer_ = true;           
    // Dispatchers keep a table of all the kinds of instructions they can handle.  The lookup key is typically some sort of
    // instruction identifier, such as from SgAsmX86Instruction::get_kind(), and comes from the iprocKey() virtual method.
    typedef std::vector<InsnProcessor*> InsnProcessors;
    InsnProcessors iproc_table;
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serializeCommon(S &s, const unsigned version) {
        ASSERT_always_require(version >= 2);
        s & boost::serialization::make_nvp("operators", operators_); // for backward compatibility
        s & BOOST_SERIALIZATION_NVP(autoResetInstructionPointer_);
        //s & iproc_table; -- not saved
    }
 
    template<class S>
    void save(S &s, const unsigned version) const {
        const_cast<Dispatcher*>(this)->serializeCommon(s, version);
        ASSERT_not_null(architecture_);
        const std::string architecture = Architecture::name(architecture_);
        s & BOOST_SERIALIZATION_NVP(architecture);
    }
 
    template<class S>
    void load(S &s, const unsigned version) {
        serializeCommon(s, version);
        std::string architecture;
        s & BOOST_SERIALIZATION_NVP(architecture);
        architecture_ = Architecture::findByName(architecture).orThrow();
    }
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif
    
    // Real constructors
protected:
    Dispatcher();                                       // used only by boost::serialization
 
    // Prototypical constructor
    explicit Dispatcher(const Architecture::BaseConstPtr&);
 
    Dispatcher(const Architecture::BaseConstPtr&, const RiscOperatorsPtr&);
 
public:
    virtual ~Dispatcher();
 
    // Static allocating constructors. None since this is an abstract class
 
 
    // Virtual constructors
public:
    virtual DispatcherPtr create(const RiscOperatorsPtr &ops) const = 0;
 
    // Methods to process instructions
public:
    virtual void processInstruction(SgAsmInstruction *insn);
 
    virtual void processDelaySlot(SgAsmInstruction *delayInsn);
 
protected:
    // The part of processing instructions that's common to both `processInstruction` and `processDelaySlot`.
    virtual void processCommon();
 
    // Instruction processor table operations
public:
    virtual InsnProcessor *iprocLookup(SgAsmInstruction *insn);
 
    virtual void iprocReplace(SgAsmInstruction *insn, InsnProcessor *iproc);
 
    virtual int iprocKey(SgAsmInstruction*) const = 0;
 
    virtual void iprocSet(int key, InsnProcessor *iproc);
 
    virtual InsnProcessor *iprocGet(int key);
 
    // Convenience methods that defer the call to some member object
public:
    Architecture::BaseConstPtr architecture() const;
 
    virtual RiscOperatorsPtr operators() const;
    virtual void operators(const RiscOperatorsPtr&);
    virtual StatePtr currentState() const;
 
    virtual SValuePtr protoval() const;
 
    virtual SgAsmInstruction* currentInstruction() const;
 
    virtual SValuePtr undefined_(size_t nbits) const;
    virtual SValuePtr unspecified_(size_t nbits) const;
    virtual SValuePtr number_(size_t nbits, uint64_t number) const;
 
    // Methods related to registers
public:
    RegisterDictionaryPtr registerDictionary() const /*final*/;
 
    virtual RegisterDescriptor findRegister(const std::string &regname, size_t nbits=0, bool allowMissing=false) const;
 
    size_t addressWidth() const;
 
    virtual RegisterDescriptor instructionPointerRegister() const;
 
    virtual RegisterDescriptor stackPointerRegister() const;
 
    virtual RegisterDescriptor stackFrameRegister() const;
 
    virtual RegisterDescriptor callReturnRegister() const;
 
    bool autoResetInstructionPointer() const { return autoResetInstructionPointer_; }
    void autoResetInstructionPointer(bool b) { autoResetInstructionPointer_ = b; }
    // Miscellaneous methods that tend to be the same for most dispatchers
public:
    virtual void initializeState(const StatePtr&);
 
    virtual void advanceInstructionPointer(SgAsmInstruction*);
 
    virtual RegisterDescriptor segmentRegister(SgAsmMemoryReferenceExpression*);
 
    virtual void incrementRegisters(SgAsmExpression*);
 
    virtual void decrementRegisters(SgAsmExpression*);
 
    virtual void preUpdate(SgAsmExpression*, const BaseSemantics::SValuePtr &enabled);
 
    virtual void postUpdate(SgAsmExpression*, const BaseSemantics::SValuePtr &enabled);
 
    virtual SValuePtr effectiveAddress(SgAsmExpression*, size_t nbits=0);
 
    virtual SValuePtr read(SgAsmExpression*, size_t value_nbits=0, size_t addr_nbits=0);
 
    virtual void write(SgAsmExpression*, const SValuePtr &value, size_t addr_nbits=0);
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::Dispatcher);
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::Dispatcher, 2);
 
#endif
#endif