DisassemblerX86.h

Go to the documentation of this file.

/* Disassembly specific to the x86 architecture. */

#ifndef ROSE_DISASSEMBLER_X86_H
#define ROSE_DISASSEMBLER_X86_H

#include "InstructionEnumsX86.h"

class DisassemblerX86: public Disassembler {


    /*========================================================================================================================
     * Public methods
     *========================================================================================================================*/
public:
    DisassemblerX86(size_t wordsize)
        : insnSize(x86_insnsize_none), ip(0), insnbufat(0), segOverride(x86_segreg_none), 
          branchPrediction(x86_branch_prediction_none), branchPredictionEnabled(false), rexPresent(false), rexW(false), 
          rexR(false), rexX(false), rexB(false), sizeMustBe64Bit(false), operandSizeOverride(false), addressSizeOverride(false),
          lock(false), repeatPrefix(x86_repeat_none), modregrmByteSet(false), modregrmByte(0), modeField(0), rmField(0), 
          modrm(NULL), reg(NULL), isUnconditionalJump(false) {
        init(wordsize);
    }

    DisassemblerX86(const DisassemblerX86 &other)
        : Disassembler(other), insnSize(other.insnSize), ip(other.ip), insnbufat(other.insnbufat),
          segOverride(other.segOverride), branchPrediction(other.branchPrediction),
          branchPredictionEnabled(other.branchPredictionEnabled), rexPresent(other.rexPresent), rexW(other.rexW), 
          rexR(other.rexR), rexX(other.rexX), rexB(other.rexB), sizeMustBe64Bit(other.sizeMustBe64Bit),
          operandSizeOverride(other.operandSizeOverride), addressSizeOverride(other.addressSizeOverride),
          lock(other.lock), repeatPrefix(other.repeatPrefix), modregrmByteSet(other.modregrmByteSet),
          modregrmByte(other.modregrmByte), modeField(other.modeField), rmField(other.rmField), modrm(other.modrm),
          reg(other.reg), isUnconditionalJump(other.isUnconditionalJump) {
    }
    
    virtual ~DisassemblerX86() {}

    virtual DisassemblerX86 *clone() const { return new DisassemblerX86(*this); }

    virtual bool can_disassemble(SgAsmGenericHeader*) const;

    virtual SgAsmInstruction *disassembleOne(const MemoryMap *map, rose_addr_t start_va, AddressSet *successors=NULL);

    virtual SgAsmInstruction *make_unknown_instruction(const Exception&);


    /*========================================================================================================================
     * Data types
     *========================================================================================================================*/
private:

    class ExceptionX86: public Exception {
    public:
        ExceptionX86(const std::string &mesg, const DisassemblerX86 *d)
            : Exception(mesg, d->ip, d->insnbuf, 8*d->insnbufat)
            {}
        ExceptionX86(const std::string &mesg, const DisassemblerX86 *d, size_t bit)
            : Exception(mesg, d->ip, d->insnbuf, bit)
            {}
    };

    enum RegisterMode 
        {
        rmLegacyByte, rmRexByte, rmWord, rmDWord, rmQWord, rmSegment, rmST, rmMM, rmXMM, rmControl, rmDebug, rmReturnNull
    };

    /* MMX registers? See mmPrefix method */
    enum MMPrefix 
        {
                mmNone, mmF3, mm66, mmF2
        };




    /*========================================================================================================================
     * Methods for reading and writing bytes of the instruction.  These keep track of how much has been read or written.
     *========================================================================================================================*/
private:

    uint8_t getByte();

    uint16_t getWord();

    uint32_t getDWord();

    uint64_t getQWord();

    /*========================================================================================================================
     * Miscellaneous helper methods
     *========================================================================================================================*/
private:
    SgAsmExpression *currentDataSegment() const;

    X86InstructionSize effectiveAddressSize() const;

    RegisterMode effectiveOperandMode() const {
        return sizeToMode(effectiveOperandSize());
    }

    X86InstructionSize effectiveOperandSize() const;

    SgAsmType *effectiveOperandType() const {
        return sizeToType(effectiveOperandSize());
    }

    bool longMode() const {
        return insnSize == x86_insnsize_64;
    }

    /* FIXME: documentation? */
    MMPrefix mmPrefix() const;

    void not64() const {
        if (longMode())
            throw ExceptionX86("not valid for 64-bit code", this);
    }

    void setRex(uint8_t prefix);

    static RegisterMode sizeToMode(X86InstructionSize);

    static SgAsmType *sizeToType(X86InstructionSize s);



    /*========================================================================================================================
     * Methods that construct something. (Their names all start with "make".)
     *========================================================================================================================*/
private:

    SgAsmExpression *makeAddrSizeValue(int64_t val, size_t bit_offset, size_t bit_size);

    SgAsmx86Instruction *makeInstruction(X86InstructionKind kind, const std::string &mnemonic,
                                         SgAsmExpression *op1=NULL, SgAsmExpression *op2=NULL,
                                         SgAsmExpression *op3=NULL, SgAsmExpression *op4=NULL);

    SgAsmx86RegisterReferenceExpression *makeIP();

    /* FIXME: documentation? */
    SgAsmx86RegisterReferenceExpression *makeOperandRegisterByte(bool rexExtension, uint8_t registerNumber);

    /* FIXME: documentation? */
    SgAsmx86RegisterReferenceExpression *makeOperandRegisterFull(bool rexExtension, uint8_t registerNumber);

    SgAsmx86RegisterReferenceExpression *makeRegister(uint8_t fullRegisterNumber, RegisterMode, SgAsmType *registerType=NULL) const;

    /* FIXME: documentation? */
    SgAsmx86RegisterReferenceExpression *makeRegisterEffective(uint8_t fullRegisterNumber) {
        return makeRegister(fullRegisterNumber, effectiveOperandMode());
    }

    /* FIXME: documentation? */
    SgAsmx86RegisterReferenceExpression *makeRegisterEffective(bool rexExtension, uint8_t registerNumber) {
        return makeRegister(registerNumber + (rexExtension ? 8 : 0), effectiveOperandMode());
    }

    SgAsmExpression *makeSegmentRegister(X86SegmentRegister so, bool insn64) const;



    /*========================================================================================================================
     * Methods for operating on the ModR/M byte.
     *========================================================================================================================*/
private:

    void getModRegRM(RegisterMode regMode, RegisterMode rmMode, SgAsmType *t, SgAsmType *tForReg = NULL);

    SgAsmMemoryReferenceExpression *decodeModrmMemory();

    void fillInModRM(RegisterMode rmMode, SgAsmType *t);

    SgAsmExpression *makeModrmNormal(RegisterMode, SgAsmType *mrType);

    SgAsmx86RegisterReferenceExpression *makeModrmRegister(RegisterMode, SgAsmType* mrType=NULL);

    void requireMemory() const {
        if (!modregrmByteSet)
            throw ExceptionX86("requires Mod/RM byte", this);
        if (modeField == 3)
            throw ExceptionX86("requires memory", this);
    }



    /*========================================================================================================================
     * Methods that construct an SgAsmExpression for an immediate operand.
     *========================================================================================================================*/
private:

    SgAsmExpression *getImmByte();
    SgAsmExpression *getImmWord();
    SgAsmExpression* getImmDWord();
    SgAsmExpression* getImmQWord();
    SgAsmExpression *getImmForAddr();
    SgAsmExpression *getImmIv();
    SgAsmExpression *getImmJz();
    SgAsmExpression *getImmByteAsIv();
    SgAsmExpression *getImmIzAsIv();
    SgAsmExpression *getImmJb();




    /*========================================================================================================================
     * Main disassembly functions, each generally containing a huge "switch" statement based on one of the opcode bytes.
     *========================================================================================================================*/
private:

    SgAsmx86Instruction *disassemble();

    SgAsmx86Instruction *decodeOpcode0F();

    SgAsmx86Instruction *decodeOpcode0F38();

    SgAsmx86Instruction *decodeX87InstructionD8();

    SgAsmx86Instruction *decodeX87InstructionD9();

    SgAsmx86Instruction *decodeX87InstructionDA();

    SgAsmx86Instruction *decodeX87InstructionDB();

    SgAsmx86Instruction *decodeX87InstructionDC();

    SgAsmx86Instruction *decodeX87InstructionDD();

    SgAsmx86Instruction *decodeX87InstructionDE();

    SgAsmx86Instruction *decodeX87InstructionDF();

    SgAsmx86Instruction *decodeGroup1(SgAsmExpression *imm);

    SgAsmx86Instruction *decodeGroup1a();

    SgAsmx86Instruction *decodeGroup2(SgAsmExpression *count);

    SgAsmx86Instruction *decodeGroup3(SgAsmExpression *immMaybe);

    SgAsmx86Instruction *decodeGroup4();

    SgAsmx86Instruction *decodeGroup5();

    SgAsmx86Instruction *decodeGroup6();

    SgAsmx86Instruction *decodeGroup7();

    SgAsmx86Instruction *decodeGroup8(SgAsmExpression *imm);

    SgAsmx86Instruction *decodeGroup11(SgAsmExpression *imm);

    SgAsmx86Instruction *decodeGroup15();

    SgAsmx86Instruction *decodeGroup16();

    SgAsmx86Instruction *decodeGroupP();



    /*========================================================================================================================
     * Data members and their initialization.
     *========================================================================================================================*/
private:

    void init(size_t wordsize);

    void startInstruction(SgAsmx86Instruction *insn) {
        startInstruction(insn->get_address(), NULL, 0);
        insnSize = insn->get_baseSize();
        lock = insn->get_lockPrefix();
        branchPrediction = insn->get_branchPrediction();
        branchPredictionEnabled = branchPrediction != x86_branch_prediction_none;
        segOverride = insn->get_segmentOverride();
    }
    
    void startInstruction(rose_addr_t start_va, const uint8_t *buf, size_t bufsz) {
        ip = start_va;
        insnbuf = SgUnsignedCharList(buf, buf+bufsz);
        insnbufat = 0;

        /* Prefix flags */
        segOverride = x86_segreg_none;
        branchPrediction = x86_branch_prediction_none;
        branchPredictionEnabled = false;
        rexPresent = rexW = rexR = rexX = rexB = false;
        sizeMustBe64Bit = false;
        operandSizeOverride = false;
        addressSizeOverride = false;
        lock = false;
        repeatPrefix = x86_repeat_none;
        modregrmByteSet = false;
        modregrmByte = modeField = regField = rmField = 0; /*arbitrary since modregrmByteSet is false*/
        modrm = reg = NULL;
        isUnconditionalJump = false;
    }

    /* Per-disassembler settings; see init() */
    X86InstructionSize insnSize;                
    /* Per-instruction settings; see startInstruction() */
    uint64_t ip;                                
    SgUnsignedCharList insnbuf;                 
    size_t insnbufat;                           
    /* Temporary flags set by the instruction; initialized by startInstruction() */
    X86SegmentRegister segOverride;             
    X86BranchPrediction branchPrediction;       /*FIXME: this seems to set only to x86_branch_prediction_true [RPM 2009-06-16] */
    bool branchPredictionEnabled;
    bool rexPresent, rexW, rexR, rexX, rexB;    
    bool sizeMustBe64Bit;                       
    bool operandSizeOverride;                   
    bool addressSizeOverride;                   
    bool lock;                                  
    X86RepeatPrefix repeatPrefix;               
    bool modregrmByteSet;                       
    uint8_t modregrmByte;                       
    uint8_t modeField;                          
    uint8_t regField;                           
    uint8_t rmField;                            
    SgAsmExpression *modrm;                     
    SgAsmExpression *reg;                       
    bool isUnconditionalJump;                   
};

#endif

---