Disassembler/Mips.h

/* Disassembly specific to the MIPS architecture */
#ifndef ROSE_BinaryAnalysis_Disassembler_Mips_H
#define ROSE_BinaryAnalysis_Disassembler_Mips_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Disassembler/Base.h>
 
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/InstructionEnumsMips.h>
 
#include <SageBuilderAsm.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Disassembler {
 
class Mips: public Base {
public:
    using Ptr = MipsPtr;
 
protected:
    explicit Mips(const Architecture::BaseConstPtr&);
 
public:
    static Ptr instance(const Architecture::BaseConstPtr&);
 
    virtual Base::Ptr clone() const override;
    virtual SgAsmInstruction *disassembleOne(const MemoryMap::Ptr&, Address start_va, AddressSet *successors=NULL) override;
    virtual size_t nDelaySlots(MipsInstructionKind);
    virtual SgAsmInstruction *makeUnknownInstruction(const Exception&) override;
    SgAsmMipsInstruction *makeUnknownInstruction(Address insn_va, unsigned opcode) const;
 
    class Decoder {
    public:
        enum Architecture { Release1, Release2, Release3, Micro };
        Decoder(Architecture arch, unsigned match, unsigned mask): arch(arch), match(match), mask(mask) {}
        virtual ~Decoder() {}
        Architecture arch;      // architecture where this instruction was introduced
        unsigned match;         // value of compared bits
        unsigned mask;          // bits of 'match' that will be compared
        typedef Mips D;
        virtual SgAsmMipsInstruction *operator()(Address insn_va, const D *d, unsigned insn_bits) = 0;
    };
    class Decoder {…};
 
    Decoder *find_idis(Address insn_va, unsigned insn_bits) const;
 
    void insert_idis(Decoder*, bool replace=false);
 
    SgAsmMipsInstruction *disassemble_insn(Address insn_va, unsigned insn_bits, const std::vector<uint8_t> &bytes) const;
 
 
    // The following functions are used by the various instruction-specific Mips32 subclasses.
 
    SgAsmMipsInstruction *makeInstruction(Address insn_va, MipsInstructionKind,
                                          SgAsmExpression *arg1=NULL, SgAsmExpression *arg2=NULL,
                                          SgAsmExpression *arg3=NULL, SgAsmExpression *arg4=NULL) const;
 
    SgAsmType* makeType(MipsDataFormat) const;
 
    SgAsmRegisterReferenceExpression *makeRegister(Address insn_va, unsigned regnum) const;
 
    SgAsmRegisterReferenceExpression *makeFpRegister(Address insn_va, unsigned regnum, MipsDataFormat) const;
 
    SgAsmRegisterReferenceExpression *makeCp0Register(Address insn_va, unsigned regnum, unsigned sel) const;
 
    SgAsmRegisterReferenceExpression *makeCp2Register(unsigned regnum) const;
 
    SgAsmRegisterReferenceExpression *makeFpccRegister(Address insn_va, unsigned cc) const;
 
    SgAsmRegisterReferenceExpression *makeCp2ccRegister(unsigned cc) const;
 
    SgAsmRegisterReferenceExpression *makeHwRegister(unsigned regnum) const;
 
    SgAsmRegisterReferenceExpression *makeShadowRegister(Address insn_va, unsigned regnum) const;
 
    SgAsmIntegerValueExpression *makeImmediate8(unsigned value, size_t bit_offset, size_t nbits) const;
 
    SgAsmIntegerValueExpression *makeImmediate16(unsigned value, size_t bit_offset, size_t nbits) const;
 
    SgAsmIntegerValueExpression *makeImmediate32(unsigned value, size_t bit_offset, size_t nbits) const;
 
    SgAsmIntegerValueExpression *makeBranchTargetRelative(Address insn_va, unsigned offset16, size_t bit_offset,
                                                          size_t nbits) const;
 
    SgAsmIntegerValueExpression *makeBranchTargetAbsolute(Address insn_va, unsigned insn_index, size_t bit_offset,
                                                          size_t nbits) const;
 
    SgAsmBinaryAdd *makeRegisterOffset(Address insn_va, unsigned gprnum, unsigned offset16) const;
 
    SgAsmBinaryAdd *makeRegisterIndexed(Address insn_va, unsigned base_gprnum, unsigned index_gprnum) const;
 
    SgAsmMemoryReferenceExpression *makeMemoryReference(SgAsmExpression *addr, SgAsmType *type) const;
 
 
protected:
    void init();
 
protected:
    std::vector<Decoder*> idis_table;
};
class Mips: public Base {…};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif