x86stream.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 2,052 行 · 第 1/4 页

     * Create a ADD dstReg, [srcReg+srcDisp]
     * 
     * @param dstReg
     * @param srcReg
     * @param srcDisp
     */
    public final void writeADD(Register dstReg, Register srcReg, int srcDisp) {
        writeModRM(0x03, srcReg.getNr(), srcDisp, dstReg.getNr());
    }

    /**
     * Create a ADD [dstReg+dstDisp], imm32
     * 
     * @param dstReg
     * @param dstDisp
     * @param imm32
     */
    public void writeADD(Register dstReg, int dstDisp, int imm32) {
        writeModRM(0x81, dstReg.getNr(), dstDisp, 0);
        write32(imm32);
    }

    /**
     * Create a ADC [dstReg+dstDisp], <srcReg>
     * 
     * @param dstReg
     * @param dstDisp
     * @param srcReg
     */
    public final void writeADC(Register dstReg, int dstDisp, Register srcReg) {
        writeModRM(0x11, dstReg.getNr(), dstDisp, srcReg.getNr());
    }

    /**
     * Create a ADC dstReg, srcReg
     * 
     * @param dstReg
     * @param srcReg
     */
    public void writeADC(Register dstReg, Register srcReg) {
        writeModRR(0x11, dstReg.getNr(), srcReg.getNr());
    }

    /**
     * Create a AND reg, imm32
     * 
     * @param reg
     * @param imm32
     */
    public final void writeAND(Register reg, int imm32) {
        if (X86Utils.isByte(imm32)) {
            writeModRR(0x83, reg.getNr(), 4);
            write8(imm32);
        } else {
            writeModRR(0x81, reg.getNr(), 4);
            write32(imm32);
        }
    }

    /**
     * Create a AND dstReg, srcReg
     * 
     * @param dstReg
     * @param srcReg
     */
    public final void writeAND(Register dstReg, Register srcReg) {
        writeModRR(0x21, dstReg.getNr(), srcReg.getNr());
    }

    /**
     * Create a AND [dstReg+dstDisp], srcReg
     * 
     * @param dstReg
     * @param dstDisp
     * @param srcReg
     */
    public final void writeAND(Register dstReg, int dstDisp, Register srcReg) {
        writeModRM(0x21, dstReg.getNr(), dstDisp, srcReg.getNr());
    }

    /**
     * Create a bound lReg, [rReg+rDisp]
     * 
     * @param lReg
     * @param rReg
     * @param rDisp
     */
    public final void writeBOUND(Register lReg, Register rReg, int rDisp) {
        writeModRM(0x62, rReg.getNr(), rDisp, lReg.getNr());
    }

    /**
     * Create a relative call to a given label
     * 
     * @param label
     */
    public final void writeCALL(Label label) {
        write8(0xe8); // call rel32
        writeRelativeObjectRef(label);
    }

    /**
     * Create a call to address stored at the given offset in the given table
     * pointer.
     * 
     * @param tablePtr
     * @param offset
     * @param rawAddress
     *            If true, tablePtr is a raw address
     */
    public final void writeCALL(Object tablePtr, int offset, boolean rawAddress) {
        write8(0xFF); // Opcode
        write8(0x15); // effective address == disp32
        writeObjectRef(tablePtr, offset, rawAddress);
    }

    /**
     * Create a call to address stored at the given [reg+offset].
     * 
     * @param reg
     * @param offset
     */
    public final void writeCALL(Register reg, int offset) {
        writeModRM(0xFF, reg.getNr(), offset, 2);
    }

    /**
     * Create a cdq
     */
    public final void writeCDQ() {
        write8(0x99);
    }

    /**
     * Create a CMOVcc dst,src
     * 
     * @param dst,src
     */
    public void writeCMOVcc(int ccOpcode, Register dst, Register src) {
        if (!haveCMOV) { throw new IllegalArgumentException(
                "CMOVcc not support on current cpu"); }
        write8(0x0F);
        writeModRR(ccOpcode - 0x40, src.getNr(), dst.getNr());
    }

    /**
     * Create a CMOVcc dst,[src+srcDisp]
     * 
     * @param dst
     * @param src
     * @param srcDisp
     */
    public void writeCMOVcc(int ccOpcode, Register dst, Register src,
            int srcDisp) {
        if (!haveCMOV) { throw new IllegalArgumentException(
                "CMOVcc not support on current cpu"); }
        write8(0x0F);
        writeModRM(ccOpcode - 0x40, src.getNr(), srcDisp, dst.getNr());
    }

    /**
     * Create a CMP EAX, imm32
     * 
     * @param imm32
     */
    public final void writeCMP_EAX(int imm32) {
        write8(0x3d);
        write32(imm32);
    }

    /**
     * Create a CMP reg, imm32
     * 
     * @param reg
     * @param imm32
     */
    public final void writeCMP(Register reg, int imm32) {
        if (X86Utils.isByte(imm32)) {
            writeModRR(0x83, reg.getNr(), 7);
            write8(imm32);
        } else {
            writeModRR(0x81, reg.getNr(), 7);
            write32(imm32);
        }
    }

    /**
     * Create a CMP [reg+regDisp], imm32
     * 
     * @param memPtr
     * @param imm32
     */
    public final void writeCMP_MEM(int memPtr, int imm32) {
        write8(0x81); // Opcode
        write8(0x3D); // effective address == disp32
        write32(memPtr);
        write32(imm32);
    }

    /**
     * Create a CMP reg,[memPtr]
     * 
     * @param reg
     * @param memPtr
     */
    public void writeCMP_MEM(Register reg, int memPtr) {
        write8(0x3b); // opcode
        write8((reg.getNr() << 3) | 5); // disp32
        write32(memPtr);
    }

    /**
     * Create a CMP reg1, reg2
     * 
     * @param reg1
     * @param reg2
     */
    public final void writeCMP(Register reg1, Register reg2) {
        writeModRR(0x39, reg1.getNr(), reg2.getNr());
    }

    /**
     * Create a CMP reg1, [reg2+disp]
     * 
     * @param reg1
     * @param reg2
     * @param disp
     */
    public void writeCMP(Register reg1, Register reg2, int disp) {
        writeModRM(0x3b, reg2.getNr(), disp, reg1.getNr());
    }

    /**
     * Create a CMP [reg1+disp], reg2
     * 
     * @param reg1
     * @param disp
     * @param reg2
     */
    public void writeCMP(Register reg1, int disp, Register reg2) {
        writeModRM(0x39, reg1.getNr(), disp, reg2.getNr());
    }

    /**
     * Create a CMPXCHG dword [dstReg], srcReg
     * 
     * @param dstReg
     * @param dstDisp
     * @param srcReg
     * @param lock
     */
    public final void writeCMPXCHG_EAX(Register dstReg, int dstDisp,
            Register srcReg, boolean lock) {
        if (lock) {
            write8(0xF0);
        }
        write8(0x0F);
        writeModRM(0xB1, dstReg.getNr(), dstDisp, srcReg.getNr());
    }

    /**
     * Create a dec reg32
     * 
     * @param dstReg
     */
    public final void writeDEC(Register dstReg) {
        write8(0x48 + dstReg.getNr());
    }

    /**
     * Create a dec dword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeDEC(Register dstReg, int dstDisp) {
        writeModRM(0xff, dstReg.getNr(), dstDisp, 1);
    }

    /**
     * Create a fadd dword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFADD32(Register srcReg, int srcDisp) {
        writeModRM(0xd8, srcReg.getNr(), srcDisp, 0);
    }

    /**
     * Create a fadd qword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFADD64(Register srcReg, int srcDisp) {
        writeModRM(0xdc, srcReg.getNr(), srcDisp, 0);
    }

    /**
     * Create a fchs
     */
    public final void writeFCHS() {
        write8(0xd9);
        write8(0xe0);
    }

    /**
     * Create a fdiv dword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFDIV32(Register srcReg, int srcDisp) {
        writeModRM(0xd8, srcReg.getNr(), srcDisp, 6);
    }

    /**
     * Create a fdiv qword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFDIV64(Register srcReg, int srcDisp) {
        writeModRM(0xdc, srcReg.getNr(), srcDisp, 6);
    }

    /**
     * Create a ffree
     * 
     * @param fReg
     */
    public final void writeFFREE(Register fReg) {
        write8(0xdd);
        write8(0xc0 | fReg.getNr());
    }

    /**
     * Create a fild dword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFILD32(Register dstReg, int dstDisp) {
        writeModRM(0xdb, dstReg.getNr(), dstDisp, 0);
    }

    /**
     * Create a fild qword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFILD64(Register dstReg, int dstDisp) {
        writeModRM(0xdf, dstReg.getNr(), dstDisp, 5);
    }

    /**
     * Create a fistp dword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFISTP32(Register dstReg, int dstDisp) {
        writeModRM(0xdb, dstReg.getNr(), dstDisp, 3);
    }

    /**
     * Create a fistp qword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFISTP64(Register dstReg, int dstDisp) {
        writeModRM(0xdf, dstReg.getNr(), dstDisp, 7);
    }

    /**
     * Create a fld dword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFLD32(Register srcReg, int srcDisp) {
        writeModRM(0xd9, srcReg.getNr(), srcDisp, 0);
    }

    /**
     * Create a fld qword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFLD64(Register srcReg, int srcDisp) {
        writeModRM(0xdd, srcReg.getNr(), srcDisp, 0);
    }

    /**
     * Create a fmul dword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFMUL32(Register srcReg, int srcDisp) {
        writeModRM(0xd8, srcReg.getNr(), srcDisp, 1);
    }

    /**
     * Create a fmul qword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFMUL64(Register srcReg, int srcDisp) {
        writeModRM(0xdc, srcReg.getNr(), srcDisp, 1);
    }

    /**
     * Create a fnstsw, Store fp status word in AX
     */
    public final void writeFNSTSW_AX() {
        write8(0xdf);
        write8(0xe0);
    }

    /**
     * Create a fprem
     */
    public final void writeFPREM() {
        write8(0xd9);
        write8(0xf8);
    }

    /**
     * Create a fstp dword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFSTP32(Register dstReg, int dstDisp) {
        writeModRM(0xd9, dstReg.getNr(), dstDisp, 3);
    }

    /**
     * Create a fstp qword [dstReg+dstDisp]
     * 
     * @param dstReg
     * @param dstDisp
     */
    public final void writeFSTP64(Register dstReg, int dstDisp) {
        writeModRM(0xdd, dstReg.getNr(), dstDisp, 3);
    }

    /**
     * Create a fsub dword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFSUB32(Register srcReg, int srcDisp) {
        writeModRM(0xd8, srcReg.getNr(), srcDisp, 4);
    }

    /**
     * Create a fsub qword [srcReg+srcDisp]
     * 
     * @param srcReg
     * @param srcDisp
     */
    public final void writeFSUB64(Register srcReg, int srcDisp) {
        writeModRM(0xdc, srcReg.getNr(), srcDisp, 4);
    }

    /**
     * Create a fucompp, Compare - Pop twice
     */
    public final void writeFUCOMPP() {
        write8(0xda);
        write8(0xe9);
    }

    /**
     * Create a idiv eax, srcReg
     * 
     * @param srcReg
     */
    public final void writeIDIV_EAX(Register srcReg) {
        writeModRR(0xF7, srcReg.getNr(), 7);
    }

    /**
     * Create a imul eax, srcReg
     * 
     * @param srcReg
     */
    public final void writeIMUL_EAX(Register srcReg) {
        writeModRR(0xF7, srcReg.getNr(), 5);
    }

    /**
     * Create a inc reg32
     * 
     * @param dstReg
     */
    public final void writeINC(Register dstReg) {
        write8(0x40 + dstReg.getNr());
    }

    /**
     * Create a int vector
     * 
     * @param vector
     */