Disassembler.h

#ifndef ROSE_DISASSEMBLER_H
#define ROSE_DISASSEMBLER_H

#include "BinaryCallingConvention.h"
#include "BinaryUnparser.h"
#include "Diagnostics.h"                                // Rose::Diagnostics
#include "Registers.h"
#include "MemoryMap.h"
#include "integerOps.h"
#include "Map.h"
#include "BaseSemantics2.h"

#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp>

namespace Rose {
namespace BinaryAnalysis {

class Disassembler {
public:
    class Exception: public std::runtime_error {
    public:
        Exception(const std::string &reason)
            : std::runtime_error(reason), ip(0), bit(0), insn(NULL)
            {}

        Exception(const std::string &reason, rose_addr_t ip)
            : std::runtime_error(reason), ip(ip), bit(0), insn(NULL)
            {}

        Exception(const std::string &reason, rose_addr_t ip, const SgUnsignedCharList &raw_data, size_t bit)
            : std::runtime_error(reason), ip(ip), bytes(raw_data), bit(bit), insn(NULL)
            {}

        Exception(const std::string &reason, SgAsmInstruction *insn)
            : std::runtime_error(reason), ip(insn->get_address()), bit(0), insn(insn)
            {}

        ~Exception() throw() {}

        void print(std::ostream&) const;
        friend std::ostream& operator<<(std::ostream &o, const Exception &e);

        rose_addr_t ip;                 
        SgUnsignedCharList bytes;       
        size_t bit;                     
        SgAsmInstruction *insn;         
    };

    typedef std::set<rose_addr_t> AddressSet;

    typedef Map<rose_addr_t, SgAsmInstruction*> InstructionMap;


    //                                  Data members
private:
    CallingConvention::Dictionary callingConventions_;

protected:
    const RegisterDictionary *p_registers;              
    RegisterDescriptor REG_IP, REG_SP, REG_SS;          
    static std::vector<Disassembler*> disassemblers;    
    ByteOrder::Endianness p_byteOrder;                  
    size_t p_wordSizeBytes;                             
    std::string p_name;                                 
    InstructionSemantics2::BaseSemantics::DispatcherPtr p_proto_dispatcher;

public:
    static Sawyer::Message::Facility mlog;              
    //                                  Serialization
#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_NVP(p_registers);
        s & BOOST_SERIALIZATION_NVP(REG_IP);
        s & BOOST_SERIALIZATION_NVP(REG_SS);
        s & BOOST_SERIALIZATION_NVP(p_byteOrder);
        s & BOOST_SERIALIZATION_NVP(p_wordSizeBytes);
        s & BOOST_SERIALIZATION_NVP(p_name);
    }
#endif


    //                                  Constructors
public:
    Disassembler(): p_registers(NULL), p_byteOrder(ByteOrder::ORDER_LSB), p_wordSizeBytes(4) {}
    virtual ~Disassembler() {}


    //                                  Registration and lookup methods

public:
    static void registerSubclass(Disassembler*);

    virtual bool canDisassemble(SgAsmGenericHeader*) const = 0;

    static Disassembler *lookup(SgAsmGenericHeader*);

    const std::string& name() const {
        return p_name;
    }
    void name(const std::string &s) {
        p_name = s;
    }
    static std::vector<std::string> isaNames();
    
    static Disassembler *lookup(SgAsmInterpretation*);

    static Disassembler *lookup(const std::string&);

    virtual Disassembler *clone() const = 0;


    /***************************************************************************************************************************
     *                                          Disassembler properties and settings
     ***************************************************************************************************************************/
public:
    virtual Unparser::BasePtr unparser() const = 0;

    ByteOrder::Endianness byteOrder() const { return p_byteOrder; }
    void byteOrder(ByteOrder::Endianness sex) { p_byteOrder = sex; }
    size_t wordSizeBytes() const { return p_wordSizeBytes; }
    void wordSizeBytes(size_t nbytes) { p_wordSizeBytes = nbytes; }
    void registerDictionary(const RegisterDictionary *rdict) {
        p_registers = rdict;
    }
    const RegisterDictionary *registerDictionary() const {
        return p_registers;
    }

    const CallingConvention::Dictionary& callingConventions() const { return callingConventions_; }
    CallingConvention::Dictionary& callingConventions() { return callingConventions_; }
    void callingConventions(const CallingConvention::Dictionary &d) { callingConventions_ = d; }
    virtual RegisterDescriptor instructionPointerRegister() const {
        ASSERT_require(REG_IP.is_valid());
        return REG_IP;
    }

    virtual RegisterDescriptor stackPointerRegister() const {
        ASSERT_require(REG_SP.is_valid());
        return REG_SP;
    }

    virtual RegisterDescriptor stackSegmentRegister() const {
        return REG_SS;                                  // need not be valid
    }

    const Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::DispatcherPtr& dispatcher() const {
        return p_proto_dispatcher;
    }

    static void initDiagnostics();

    /***************************************************************************************************************************
     *                                          Instruction disassembly functions
     ***************************************************************************************************************************/
public:
    virtual SgAsmInstruction *disassembleOne(const MemoryMap::Ptr &map, rose_addr_t start_va, AddressSet *successors=NULL) = 0;

    SgAsmInstruction *disassembleOne(const unsigned char *buf, rose_addr_t buf_va, size_t buf_size, rose_addr_t start_va,
                                     AddressSet *successors=NULL);


    /***************************************************************************************************************************
     *                                          Miscellaneous methods
     ***************************************************************************************************************************/
public:
    virtual SgAsmInstruction* makeUnknownInstruction(const Exception&) = 0;

    void mark_referenced_instructions(SgAsmInterpretation*, const MemoryMap::Ptr&, const InstructionMap&);

    AddressSet get_block_successors(const InstructionMap&, bool *complete);

private:
    static void initclass();
    static void initclassHelper();

    static SgAsmInstruction *find_instruction_containing(const InstructionMap &insns, rose_addr_t va);
};

} // namespace
} // namespace

#endif