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:
    RiscOperatorsPtr operators_;

protected:
    RegisterDictionaryPtr regdict;                      
    size_t addrWidth_;                                  
    bool autoResetInstructionPointer_;                  
    // 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 serialize(S &s, const unsigned /*version*/) {
        s & boost::serialization::make_nvp("operators", operators_); // for backward compatibility
        s & BOOST_SERIALIZATION_NVP(regdict);
        s & BOOST_SERIALIZATION_NVP(addrWidth_);
        s & BOOST_SERIALIZATION_NVP(autoResetInstructionPointer_);
        //s & iproc_table; -- not saved
    }
#endif
    
    // Real constructors
protected:
    // Prototypical constructor
    Dispatcher();

    // Prototypical constructor
    Dispatcher(size_t addrWidth, const RegisterDictionaryPtr&);

    Dispatcher(const RiscOperatorsPtr&, size_t addrWidth, const RegisterDictionaryPtr&);

public:
    virtual ~Dispatcher();

    // Static allocating constructors. None since this is an abstract class


    // Virtual constructors
public:
    virtual DispatcherPtr create(const RiscOperatorsPtr &ops, size_t addrWidth, const RegisterDictionaryPtr&) const = 0;

    // Methods to process instructions
public:
    virtual void processInstruction(SgAsmInstruction *insn);

    // 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:
    // Deprecated [Robb Matzke 2020-11-19]
    virtual RiscOperatorsPtr get_operators() const ROSE_DEPRECATED("use \"operators\" instead") { return operators_; }

    virtual RiscOperatorsPtr operators() const { return operators_; }
    virtual void operators(const RiscOperatorsPtr &ops);
    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*/;
    void registerDictionary(const RegisterDictionaryPtr &rd) /*final*/;
    // Old names, the ones which are overridden in subclasses if necessary. These are deprecated and might go away someday, so
    // it's in your best interrest to use C++11 "override" in your declarations.
    virtual RegisterDictionaryPtr get_register_dictionary() const;
    virtual void set_register_dictionary(const RegisterDictionaryPtr &regdict);

    virtual RegisterDescriptor findRegister(const std::string &regname, size_t nbits=0, bool allowMissing=false) const;

    size_t addressWidth() const { return addrWidth_; }
    void addressWidth(size_t nbits);
    virtual RegisterDescriptor instructionPointerRegister() const = 0;

    virtual RegisterDescriptor stackPointerRegister() const = 0;

    virtual RegisterDescriptor stackFrameRegister() const = 0;

    virtual RegisterDescriptor callReturnRegister() const = 0;

    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);

#endif
#endif