InstructionProvider.h

#ifndef ROSE_BinaryAnalysis_InstructionProvider_H
#define ROSE_BinaryAnalysis_InstructionProvider_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
 
#include <Sawyer/HashMap.h>
#include <Sawyer/SharedPointer.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
 
class InstructionProvider: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<InstructionProvider> Ptr;
 
    typedef Sawyer::Container::HashMap<Address, SgAsmInstruction*> InsnMap;
 
private:
    Architecture::BaseConstPtr architecture_;           // required architecture
    Disassembler::BasePtr disassembler_;                // disassembler_ is non-null iff memMap_ is non-null
    MemoryMapPtr memMap_;                               // optional map from which instructions are decoded if disassembler_
    mutable InsnMap insnMap_;                           // this is a cache
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class Archive>
    void save(Archive&, const unsigned version) const;
 
    template<class Archive>
    void load(Archive&, const unsigned version);
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif
 
private:
    InstructionProvider();                              // used only by boost::serialization
protected:
    InstructionProvider(const Architecture::BaseConstPtr&, const MemoryMapPtr &map);
 
public:
    ~InstructionProvider();
 
    static Ptr instance(const Architecture::BaseConstPtr&, const MemoryMapPtr&);
 
    Architecture::BaseConstPtr architecture() const;
 
    bool isDisassemblerEnabled() const;
 
    SgAsmInstruction* operator[](Address) const;
    SgAsmInstruction* at(Address) const;
    void insert(SgAsmInstruction*);
 
    Disassembler::BasePtr disassembler() const;
 
    size_t nCached() const { return insnMap_.size(); }
 
    RegisterDictionaryPtr registerDictionary() const;
 
    const CallingConvention::Dictionary& callingConventions() const;
 
    RegisterDescriptor instructionPointerRegister() const;
 
    RegisterDescriptor stackPointerRegister() const;
 
    RegisterDescriptor stackFrameRegister() const;
 
    RegisterDescriptor callReturnRegister() const;
 
    RegisterDescriptor stackSegmentRegister() const;
 
    ByteOrder::Endianness defaultByteOrder() const;
 
    size_t wordSize() const;
 
    size_t instructionAlignment() const;
 
    InstructionSemantics::BaseSemantics::DispatcherPtr
    dispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) const;
 
    void showStatistics() const;
};
 
} // namespace
} // namespace
 
// Class versions must be at global scope
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionProvider, 2);
#endif
 
#endif
#endif