InstructionProvider.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_InstructionProvider_H
#define ROSE_BinaryAnalysis_Partitioner2_InstructionProvider_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/CallingConvention.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include "AstSerialization.h"

#include <boost/serialization/access.hpp>
#include <Sawyer/Assert.h>
#include <Sawyer/HashMap.h>
#include <Sawyer/SharedPointer.h>

namespace Rose {
namespace BinaryAnalysis {

class InstructionProvider: public Sawyer::SharedObject {
public:
    typedef Sawyer::SharedPointer<InstructionProvider> Ptr;

    typedef Sawyer::Container::HashMap<rose_addr_t, SgAsmInstruction*> InsnMap;

private:
    Disassembler::BasePtr disassembler_;
    MemoryMap::Ptr memMap_;
    mutable InsnMap insnMap_;                           // this is a cache
    bool useDisassembler_;

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void save(S &s, const unsigned /*version*/) const {
        roseAstSerializationRegistration(s);            // so we can save instructions through SgAsmInstruction base ptrs
        bool hasDisassembler = disassembler_ != NULL;
        s <<BOOST_SERIALIZATION_NVP(hasDisassembler);
        s <<BOOST_SERIALIZATION_NVP(useDisassembler_);
        s <<BOOST_SERIALIZATION_NVP(memMap_);
        s <<BOOST_SERIALIZATION_NVP(insnMap_);
        if (hasDisassembler) {
            std::string disName = Disassembler::name(disassembler_);
            s <<BOOST_SERIALIZATION_NVP(disName);
        }
    }

    template<class S>
    void load(S &s, const unsigned /*version*/) {
        roseAstSerializationRegistration(s);
        bool hasDisassembler = false;
        s >>BOOST_SERIALIZATION_NVP(hasDisassembler);
        s >>BOOST_SERIALIZATION_NVP(useDisassembler_);
        s >>BOOST_SERIALIZATION_NVP(memMap_);
        s >>BOOST_SERIALIZATION_NVP(insnMap_);
        if (hasDisassembler) {
            std::string disName;
            s >>BOOST_SERIALIZATION_NVP(disName);
            disassembler_ = Disassembler::lookup(disName);
            ASSERT_not_null2(disassembler_, "disassembler name=" + disName);
        }
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif

protected:
    InstructionProvider();

    InstructionProvider(const Disassembler::BasePtr &disassembler, const MemoryMap::Ptr &map);

public:
    ~InstructionProvider();

    static Ptr instance(const Disassembler::BasePtr &disassembler, const MemoryMap::Ptr &map) {
        return Ptr(new InstructionProvider(disassembler, map));
    }

    bool isDisassemblerEnabled() const {
        return useDisassembler_;
    }
    void enableDisassembler(bool enable=true);
    void disableDisassembler() {
        useDisassembler_ = false;
    }
    SgAsmInstruction* operator[](rose_addr_t va) 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;

    void showStatistics() const;
};

} // namespace
} // namespace

#endif
#endif