DispatcherJvm.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_DispatcherJvm_H
#define ROSE_BinaryAnalysis_InstructionSemantics_DispatcherJvm_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/DescriptorParser.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Dispatcher.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/FrameState.h>
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
 
using DispatcherJvmPtr = boost::shared_ptr<class DispatcherJvm>;
 
class DispatcherJvm: public BaseSemantics::Dispatcher {
public:
    using Super = BaseSemantics::Dispatcher;
 
    using Ptr = DispatcherJvmPtr;
 
public:
    const RegisterDescriptor REG_PC, REG_SP, REG_FP;
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void save(S &s, const unsigned /*version*/) const {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
    }
 
    template<class S>
    void load(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
        initializeDispatchTable();
        initializeMemoryState();
    }
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif
 
public:
    ~DispatcherJvm();
protected:
    DispatcherJvm() = delete;
    explicit DispatcherJvm(const Architecture::BaseConstPtr&);
    DispatcherJvm(const Architecture::BaseConstPtr&, const BaseSemantics::RiscOperatorsPtr&);
 
public:
    static Ptr instance(const Architecture::BaseConstPtr&);
 
    static Ptr instance(const Architecture::BaseConstPtr&, const BaseSemantics::RiscOperatorsPtr&);
 
    static Ptr promote(const BaseSemantics::DispatcherPtr&);
 
public:
    // documented in the base class
    virtual BaseSemantics::DispatcherPtr create(const BaseSemantics::RiscOperatorsPtr&) const override;
 
    virtual int iprocKey(SgAsmInstruction*) const override;
    virtual RegisterDescriptor instructionPointerRegister() const override;
 
    void recordSemanticError(const std::string &msg);
 
    static size_t nBitsForKind(BaseSemantics::ValueKind);
 
    static SgAsmJvmConstantPool* constantPool(BaseSemantics::RiscOperators *ops);
 
    static std::string methodDescriptor(SgAsmJvmConstantPool *pool, size_t index);
 
    static std::string fieldDescriptor(SgAsmJvmConstantPool *pool, size_t index);
 
    ByteCode::Method::Ptr resolveMethod(SgAsmJvmConstantPool *pool, size_t index);
 
    ByteCode::Method::Ptr resolveRuntimeMethod(SgAsmJvmConstantPool *pool, size_t index,
                                               const BaseSemantics::SValue::Ptr &receiver);
 
    static BaseSemantics::SValuePtr
    syntheticValue(const BaseSemantics::SValuePtr &protoval,
                   const DescriptorType &type,
                   const std::string &symbolName = "");
 
    static BaseSemantics::SValuePtr
    syntheticObjectReference(const BaseSemantics::SValuePtr &protoval,
                             const std::string &descriptor,
                             const std::string &symbolName = "");
 
    static BaseSemantics::SValuePtr
    syntheticArrayReference(const BaseSemantics::SValuePtr &protoval,
                            const std::string &descriptor,
                            const std::string &symbolName = "");
 
    static void initializeInvocationLocals(BaseSemantics::RiscOperators *ops,
                                           const BaseSemantics::FrameState::Ptr &frame,
                                           const std::string &descriptor, bool hasReceiver);
 
private:
    // Initializes the dispatch table that handles each kind of instruction
    void initializeDispatchTable();
 
    // Initializes memory state, such as the default byte order
    void initializeMemoryState();
};
 
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::DispatcherJvm);
#endif
 
#endif
#endif