InstructionProvider.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_InstructionProvider_H
#define ROSE_BinaryAnalysis_Partitioner2_InstructionProvider_H

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include "Disassembler.h"
#include "BaseSemantics2.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 *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();
            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()
        : disassembler_(NULL), useDisassembler_(false) {
        // Start off with a large map to reduce early rehashing. There will probably be a lot of instructions.
        insnMap_.rehash(1000000);
    }

    InstructionProvider(Disassembler *disassembler, const MemoryMap::Ptr &map)
        : disassembler_(disassembler), memMap_(map), useDisassembler_(true) {
        ASSERT_not_null(disassembler);
        // Start off with a large map to reduce early rehashing. There will probably be a lot of instructions.
        insnMap_.rehash(1000000);
    }

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

    bool isDisassemblerEnabled() const {
        return useDisassembler_;
    }
    void enableDisassembler(bool enable=true) {
        ASSERT_require(!enable || disassembler_);
        useDisassembler_ = enable;
    }
    void disableDisassembler() {
        useDisassembler_ = false;
    }
    SgAsmInstruction* operator[](rose_addr_t va) const;

    void insert(SgAsmInstruction*);

    Disassembler* disassembler() const { return disassembler_; }

    size_t nCached() const { return insnMap_.size(); }

    const RegisterDictionary* registerDictionary() const { return disassembler_->registerDictionary(); }

    const CallingConvention::Dictionary& callingConventions() const { return disassembler_->callingConventions(); }

    RegisterDescriptor instructionPointerRegister() const { return disassembler_->instructionPointerRegister(); }

    RegisterDescriptor stackPointerRegister() const { return disassembler_->stackPointerRegister(); }

    RegisterDescriptor stackFrameRegister() const { return disassembler_->stackFrameRegister(); }

    RegisterDescriptor callReturnRegister() const { return disassembler_->callReturnRegister(); }

    RegisterDescriptor stackSegmentRegister() const { return disassembler_->stackSegmentRegister(); }

    ByteOrder::Endianness defaultByteOrder() const { return disassembler_->byteOrder(); }

    size_t wordSize() const { return 8 * disassembler_->wordSizeBytes(); }

    size_t instructionAlignment() const { return disassembler_->instructionAlignment(); }

    InstructionSemantics2::BaseSemantics::DispatcherPtr dispatcher() const { return disassembler_->dispatcher(); }

    void showStatistics() const;
};

} // namespace
} // namespace

#endif
#endif