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/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Disassembler/Exception.h>
#include <Rose/BinaryAnalysis/InstructionMap.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"
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/version.hpp>
#endif
 
// REG_SP possibly defined on __sun
// REG_LINK possibly defined on Windows
#undef REG_SP
#undef REG_LINK
 
namespace Rose {
namespace BinaryAnalysis {
namespace Disassembler {
 
class Base: public Sawyer::SharedObject {
    //                                  Types
public:
    using Ptr = BasePtr;
 
    //                                  Data members
private:
    Architecture::BaseConstPtr architecture_;
 
protected:
    RegisterDescriptor REG_IP, REG_SP, REG_SS, REG_SF, REG_LINK; 
    size_t instructionAlignment_ = 1;                            
public:
 
 
    //                                  Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned version) {
        s & BOOST_SERIALIZATION_NVP(REG_IP);
        s & BOOST_SERIALIZATION_NVP(REG_SS);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(REG_SF);
        if (version >= 2)
            s & BOOST_SERIALIZATION_NVP(instructionAlignment_);
    }
#endif
 
 
    //                                  Constructors
protected:
    explicit Base(const Architecture::BaseConstPtr&);
 
public:
    virtual ~Base();
 
    virtual Ptr clone() const = 0;
 
 
    /***************************************************************************************************************************
     *                                          Disassembler properties and settings
     ***************************************************************************************************************************/
public:
    Architecture::BaseConstPtr architecture() const;
 
    virtual const std::string& name() const;
 
    virtual size_t bytesPerWord() const;
 
    virtual ByteOrder::Endianness byteOrder() const;
 
    Unparser::BasePtr unparser() const;
 
    size_t instructionAlignment() const;
 
 
    /***************************************************************************************************************************
     *                                          Instruction disassembly functions
     ***************************************************************************************************************************/
public:
    virtual SgAsmInstruction *disassembleOne(const MemoryMap::Ptr &map, Address start_va, AddressSet *successors=NULL) = 0;
 
    SgAsmInstruction *disassembleOne(const unsigned char *buf, Address buf_va, size_t buf_size, Address 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, Address va);
 
    // Deprecated [Robb Matzke 2023-11-24]
public:
    size_t wordSizeBytes() const ROSE_DEPRECATED("use bytesPerWord()");
    RegisterDictionaryPtr registerDictionary() const ROSE_DEPRECATED("use architecture()");
    virtual RegisterDescriptor instructionPointerRegister() const ROSE_DEPRECATED("use architecture()");
    virtual RegisterDescriptor stackPointerRegister() const ROSE_DEPRECATED("use architecture()");
    virtual RegisterDescriptor stackFrameRegister() const ROSE_DEPRECATED("use architecture()");
    virtual RegisterDescriptor stackSegmentRegister() const ROSE_DEPRECATED("use architecture()");
    virtual RegisterDescriptor callReturnRegister() const ROSE_DEPRECATED("use architecture()");
};
 
} // namespace
} // namespace
} // namespace
 
// Class versions must be at global scope
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Disassembler::Base, 3);
#endif
 
#endif
#endif