Disassembler/Base.h

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

#include <Rose/BinaryAnalysis/CallingConvention.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Disassembler/Exception.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/Unparser/Settings.h>
#include <Rose/Diagnostics.h>

#include "integerOps.h"
#include "Map.h"

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

// REG_SP possibly defined on __sun
// REG_LINK possibly defined on Windows
#undef REG_SP
#undef REG_LINK

namespace Rose {
namespace BinaryAnalysis {
namespace Disassembler {

typedef Map<rose_addr_t, SgAsmInstruction*> InstructionMap;

class Base: public Sawyer::SharedObject {
    //                                  Types
public:
    using Ptr = BasePtr;

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

protected:
    RegisterDictionaryPtr p_registers;                           
    RegisterDescriptor REG_IP, REG_SP, REG_SS, REG_SF, REG_LINK; 
    ByteOrder::Endianness p_byteOrder = ByteOrder::ORDER_LSB;    
    size_t p_wordSizeBytes = 4;                                  
    std::string p_name;                                          
    size_t instructionAlignment_ = 1;                            
    InstructionSemantics::BaseSemantics::DispatcherPtr p_proto_dispatcher;

public:


    //                                  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);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(REG_SF);
        s & BOOST_SERIALIZATION_NVP(p_byteOrder);
        s & BOOST_SERIALIZATION_NVP(p_wordSizeBytes);
        s & BOOST_SERIALIZATION_NVP(p_name);
        if (version >= 2)
            s & BOOST_SERIALIZATION_NVP(instructionAlignment_);
    }
#endif


    //                                  Constructors
protected:
    Base() {}

public:
    virtual ~Base() {}

    //                                  Registration and lookup methods

public:
    virtual bool canDisassemble(SgAsmGenericHeader*) const = 0;

    const std::string& name() const {
        return p_name;
    }
    void name(const std::string &s) {
        p_name = s;
    }
    virtual Ptr 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; }
    size_t instructionAlignment() const;
    
    void registerDictionary(const RegisterDictionaryPtr &rdict) {
        p_registers = rdict;
    }
    RegisterDictionaryPtr 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_forbid(REG_IP.isEmpty());
        return REG_IP;
    }

    virtual RegisterDescriptor stackPointerRegister() const {
        ASSERT_forbid(REG_SP.isEmpty());
        return REG_SP;
    }

    virtual RegisterDescriptor stackFrameRegister() const {
        return REG_SF;                                  // need not be valid
    }

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

    virtual RegisterDescriptor callReturnRegister() const {
        return REG_LINK;                                // need not be valid
    }

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

    /***************************************************************************************************************************
     *                                          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/*out*/);

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

} // namespace
} // namespace
} // namespace

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Disassembler::Base, 2);

#endif
#endif