abstractx86stream.java

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

	/**
	 * Create a imul eax, srcReg
	 * @param srcReg
	 */
	public abstract void writeIMUL_EAX(Register srcReg);
	/**
	 * Create a inc reg32
	 * @param dstReg
	 */
	public abstract void writeINC(Register dstReg);
	/**
	 * Create a int vector
	 * @param vector
	 */
	public abstract void writeINT(int vector);
	/**
	 * Create a conditional jump to a label The opcode sequence is: 0x0f <jumpOpcode><rel32>
	 * @param label
	 * @param jumpOpcode
	 */
	public abstract void writeJCC(Label label, int jumpOpcode);
	/**
	 * Create a relative jump to a given label
	 * 
	 * @param label
	 */
	public abstract void writeJMP(Label label);

	/**
	 * Create a absolute jump to address in register
	 * @param reg32
	 */
	public abstract void writeJMP(Register reg32);
	
	/**
	 * Create a absolute jump to [reg32+disp]
	 * @param reg32
	 */
	public abstract void writeJMP(Register reg32, int disp);
	
	/**
	 * Create a absolute jump 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 abstract void writeJMP(Object tablePtr, int offset, boolean rawAddress);
	
	/**
	 * Create a absolute jump to address stored at the given offset (in register) 
	 * in the given table pointer.
	 * @param tablePtr
	 * @param offsetReg
	 */
	public abstract void writeJMP(Object tablePtr, Register offsetReg);
	
	/**
	 * Create a LOOP label instruction. The given label must have be resolved before!
	 * 
	 * @param label
	 * @throws UnresolvedObjectRefException
	 */
	public abstract void writeLOOP(Label label) throws UnresolvedObjectRefException;
	/**
	 * Create a lea dstReg,[srcReg+disp]
	 * @param dstReg
	 * @param srcReg
	 * @param disp
	 */
	public abstract void writeLEA(Register dstReg, Register srcReg, int disp);
	/**
	 * Create a lea dstReg,[srcReg+srcIdxReg*scale+disp]
	 * @param dstReg
	 * @param srcReg
	 * @param srcIdxReg
	 * @param scale
	 * @param disp
	 */
	public abstract void writeLEA(Register dstReg, Register srcReg, Register srcIdxReg, int scale, int disp);
	/**
	 * Create a LODSD
	 */
	public abstract void writeLODSD();
	/**
	 * Create a mov <reg>,<imm32>
	 * @param destReg
	 * @param imm32
	 */
	public abstract void writeMOV_Const(Register destReg, int imm32);

	/**
	 * Create a mov [destReg+destDisp],<imm32>
	 * @param destReg
	 * @param destDisp
	 * @param imm32
	 */
	public abstract void writeMOV_Const(Register destReg, int destDisp, int imm32);
		
	/**
	 * Create a mov <dstReg>,<srcReg>
	 * @param operandSize
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeMOV(int operandSize, Register dstReg, Register srcReg);

	/**
	 * Create a mov [dstReg+dstDisp], <srcReg>
	 * @param operandSize
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeMOV(int operandSize, Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a mov [dstReg+dstIdxReg*scale+dstDisp], <srcReg>
	 * @param operandSize
	 * @param dstReg
	 * @param dstIdxReg
	 * @param scale
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeMOV(int operandSize, Register dstReg, Register dstIdxReg, int scale, int dstDisp, Register srcReg);
	/**
	 * Create a mov dstReg, [srcReg+srcDisp]
	 * @param operandSize
	 * @param dstReg
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeMOV(int operandSize, Register dstReg, Register srcReg, int srcDisp);
	/**
	 * Create a mov dstReg, [srcReg+srcIdxReg*scale+srcDisp]
	 * @param operandSize
	 * @param dstReg
	 * @param srcReg
	 * @param srcIdxReg
	 * @param scale
	 * @param srcDisp
	 */
	public abstract void writeMOV(int operandSize, Register dstReg, Register srcReg, Register srcIdxReg, int scale, int srcDisp);
	/**
	 * Create a mov <reg>,<label>
	 * @param dstReg
	 * @param label
	 */
	public abstract void writeMOV_Const(Register dstReg, Object label);

	/**
	 * Create a movsx <dstReg>,<srcReg>
	 * @param dstReg
	 * @param srcReg
	 * @param srcSize
	 */
	public abstract void writeMOVSX(Register dstReg, Register srcReg, int srcSize);
	/**
	 * Create a movzx <dstReg>,<srcReg>
	 * @param dstReg
	 * @param srcReg
	 * @param srcSize
	 */
	public abstract void writeMOVZX(Register dstReg, Register srcReg, int srcSize);
	/**
	 * Create a mul eax, srcReg
	 * @param srcReg
	 */
	public abstract void writeMUL_EAX(Register srcReg);
	/**
	 * Create a neg dword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeNEG(Register dstReg, int dstDisp);
	/**
	 * Create a neg dstReg
	 * @param dstReg
	 */
	public abstract void writeNEG(Register dstReg);
	/**
	 * Create a nop
	 */
	public abstract void writeNOP();
	/**
	 * Create a OR dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeOR(Register dstReg, Register srcReg);
	/**
	 * Create a OR [dstReg+dstDisp], srcReg
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeOR(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a sahf
	 */
	public abstract void writeSAHF();
	/**
	 * Create a SAL dstReg,cl
	 * @param dstReg
	 */
	public abstract void writeSAL_CL(Register dstReg);
	/**
	 * Create a SAL dstReg,imm8
	 * @param dstReg
	 * @param imm8
	 */
	public abstract void writeSAL(Register dstReg, int imm8);
	/**
	 * Create a SAR dstReg,cl
	 * @param dstReg
	 */
	public abstract void writeSAR_CL(Register dstReg);
	/**
	 * Create a SAR dstReg,imm8
	 * @param dstReg
	 * @param imm8
	 */
	public abstract void writeSAR(Register dstReg, int imm8);
	/**
	 * Create a SHL dstReg,cl
	 * @param dstReg
	 */
	public abstract void writeSHL_CL(Register dstReg);
	/**
	 * Create a SHLD dstReg,srcReg,cl
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeSHLD_CL(Register dstReg, Register srcReg);
	/**
	 * Create a SHL dstReg,imm8
	 * @param dstReg
	 * @param imm8
	 */
	public abstract void writeSHL(Register dstReg, int imm8);
	/**
	 * Create a SHR dstReg,cl
	 * @param dstReg
	 */
	public abstract void writeSHR_CL(Register dstReg);
	/**
	 * Create a SHRD dstReg,srcReg,cl
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeSHRD_CL(Register dstReg, Register srcReg);
	/**
	 * Create a SHL dstReg,imm8
	 * @param dstReg
	 * @param imm8
	 */
	public abstract void writeSHR(Register dstReg, int imm8);
	/**
	 * Create a SBB dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeSBB(Register dstReg, Register srcReg);
	/**
	 * Create a SBB dstReg, imm32
	 * @param dstReg
	 * @param imm32
	 */
	public abstract void writeSBB(Register dstReg, int imm32);
	/**
	 * Create a SBB dword [dstReg+dstDisp], <imm32>
	 * @param dstReg
	 * @param dstDisp
	 * @param imm32
	 */
	public abstract void writeSBB(Register dstReg, int dstDisp, int imm32);
	/**
	 * Create a SBB [dstReg+dstDisp], <srcReg>
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeSBB(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a SUB dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeSUB(Register dstReg, Register srcReg);
	/**
	 * Create a SUB reg, imm32
	 * 
	 * @param reg
	 * @param imm32
	 */
	public abstract void writeSUB(Register reg, int imm32);
	/**
	 * Create a SUB [dstReg+dstDisp], <srcReg>
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeSUB(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a XOR dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeXOR(Register dstReg, Register srcReg);
	/**
	 * Create a XOR [dstReg+dstDisp], srcReg
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeXOR(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Start a new object and write its header. An ObjectInfo object is returned, on which the
	 * <code>markEnd</code> mehod must be called after all data has been written into the object.
	 * 
	 * @param cls
	 * @see ObjectInfo
	 * @return The info for the started object
	 */
	public abstract ObjectInfo startObject(VmType cls);
	
	/**
	 * Create a pop reg32
	 * @param dstReg
	 */
	public abstract void writePOP(Register dstReg);
	/**
	 * Create a pop dword [reg32+disp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writePOP(Register dstReg, int dstDisp);
	/**
	 * Create a push dword <imm32>
	 * @param imm32
	 * @return The ofset of the start of the instruction.
	 */
	public abstract int writePUSH(int imm32);
	/**
	 * Create a push reg32
	 * @param srcReg
	 * @return The ofset of the start of the instruction.
	 */
	public abstract int writePUSH(Register srcReg);
	/**
	 * Create a push dword [reg32+disp]
	 * @param srcReg
	 * @param srcDisp
	 * @return The ofset of the start of the instruction.
	 */
	public abstract int writePUSH(Register srcReg, int srcDisp);
	/**
	 * Create a push dword [baseReg+indexReg*scale+disp]
	 * @param srcBaseReg
	 * @param srcIndexReg
	 * @param srcScale
	 * @param srcDisp
	 * @return The ofset of the start of the instruction.
	 */
	public abstract int writePUSH(Register srcBaseReg, Register srcIndexReg, int srcScale, int srcDisp);

	/**
	 * Create a ret near to caller
	 */
	public abstract void writeRET();
	/**
	 * Create a ret imm16 near to caller
	 * @param imm16
	 */
	public abstract void writeRET(int imm16);
	/**
	 * Create a TEST al, imm8
	 * @param value
	 */
	public abstract void writeTEST_AL(int value);
	/**
	 * Create a TEST eax, imm32
	 * @param value
	 */
	public abstract void writeTEST_EAX(int value);
	/**
	 * Create a TEST reg, imm32
	 * 
	 * @param reg
	 * @param imm32
	 */
	public abstract void writeTEST(Register reg, int imm32);
	/**
	 * Create a TEST reg1, reg2
	 * 
	 * @param reg1
	 * @param reg2
	 */
	public abstract void writeTEST(Register reg1, Register reg2);
	
	/**
	 * Create 32-bit offset relative to the current (after this offset) offset.
	 * @param label
	 */
	public abstract void writeRelativeObjectRef(Label label);
	
	/**
	 * Write my contents to the given stream.
	 * 
	 * @param os
	 * @throws IOException
	 */
	public abstract void writeTo(OutputStream os) throws IOException;
	
	/**
	 * Is logging enabled.
	 * This method will only return true on on debug like implementations. 
	 * @return boolean
	 */
	public abstract boolean isLogEnabled();
	
	/**
	 * Write a log message.
	 * This method is only implemented on debug like implementations. 
	 * @param msg
	 */
	public abstract void log(Object msg);
}