abstractx86stream.java

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

/*
 * $Id: AbstractX86Stream.java,v 1.12 2004/02/24 08:04:59 epr Exp $
 */
package org.jnode.assembler.x86;

import java.io.IOException;
import java.io.OutputStream;
import java.util.Collection;

import org.jnode.assembler.Label;
import org.jnode.assembler.NativeStream;
import org.jnode.assembler.ObjectResolver;
import org.jnode.assembler.UnresolvedObjectRefException;
import org.jnode.vm.CpuID;
import org.jnode.vm.classmgr.VmType;
import org.jnode.vm.x86.X86CpuID;

/**
 * @author Ewout Prangsma ([e-mail])
 */
public abstract class AbstractX86Stream extends NativeStream implements X86Constants {

	protected final X86CpuID cpuId;
	
	/**
	 * Initialize this instance
	 * @param cpuId
	 */
	public AbstractX86Stream(X86CpuID cpuId) {
		this.cpuId = cpuId;
	}
	
	/**
	 * Gets the identification of the CPU for which this stream will produce data.
	 */
	public final CpuID getCPUID() {
		return cpuId;
	}
	
	/**
	 * Align on a given value
	 * 
	 * @param value
	 * @return The number of bytes needed to align.
	 */
	public abstract int align(int value);
	public abstract int get32(int offset);
	public abstract int get8(int offset);
	/**
	 * Returns the base address.
	 * 
	 * @return long
	 */
	public abstract long getBaseAddr();
	/**
	 * Return the actual bytes. This array may be longer then getLength() *
	 * 
	 * @return The actual bytes
	 */
	public abstract byte[] getBytes();
	/**
	 * Get the length in bytes of valid data
	 * @return the length of valid data
	 */
	public abstract int getLength();
	
	/**
	 * Remove count bytes from the end of the generated stream.
	 * @param count
	 */
	public abstract void trim(int count);
	
	/**
	 * Gets an objectref for a given object.
	 * 
	 * @param keyObj
	 * @return ObjectRef
	 */
	public abstract ObjectRef getObjectRef(Object keyObj);
	/**
	 * Gets all references of objects as instanceof ObjectRef
	 * 
	 * @return Collection
	 */
	public abstract Collection getObjectRefs();
	/**
	 * @return ObjectResolver
	 */
	public abstract ObjectResolver getResolver();
	/**
	 * Gets all unresolved references of objects as instanceof ObjectRef
	 * 
	 * @return Collection
	 */
	public abstract Collection getUnresolvedObjectRefs();
	/**
	 * Are there unresolved references?
	 * @return True if there are unresolved references, false otherwise
	 */
	public abstract boolean hasUnresolvedObjectRefs();
	public abstract void set32(int offset, int v32);
	public abstract void set8(int offset, int v8);
	public abstract ObjectRef setObjectRef(Object label);
	/**
	 * Sets the resolver.
	 * 
	 * @param resolver
	 *            The resolver to set
	 */
	public abstract void setResolver(ObjectResolver resolver);
	public abstract void write(byte[] data, int ofs, int len);
	public abstract void write16(int v16);
	public abstract void write32(int v32);
	public abstract void write64(long v64);
	/**
	 * Write an 8-bit unsigned byte.
	 * 
	 * @param v8
	 */
	public abstract void write8(int v8);
	/**
	 * Write an prefix byte
	 * 
	 * @param prefix
	 */
	public abstract void writePrefix(int prefix);
	/**
	 * Create a ADD dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeADD(Register dstReg, Register srcReg);
	/**
	 * Create a ADD [dstReg+dstDisp], <srcReg>
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeADD(Register dstReg, int dstDisp, Register srcReg);

	/**
     * Create a ADD dstReg, [srcReg+srcDisp]
     * 
     * @param dstReg
     * @param srcReg
     * @param srcDisp
     */
    public abstract void writeADD(Register dstReg, Register srcReg, int srcDisp);

    /**
	 * Create a ADD [dstReg+dstDisp], imm32
	 * @param dstReg
	 * @param dstDisp
	 * @param imm32
	 */
	public abstract void writeADD(Register dstReg, int dstDisp, int imm32);
	/**
	 * Create a ADC dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeADC(Register dstReg, Register srcReg);
	/**
	 * Create a ADC [dstReg+dstDisp], <srcReg>
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeADC(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a AND reg, imm32
	 * 
	 * @param reg
	 * @param imm32
	 */
	public abstract void writeAND(Register reg, int imm32);
	/**
	 * Create a AND dstReg, srcReg
	 * @param dstReg
	 * @param srcReg
	 */
	public abstract void writeAND(Register dstReg, Register srcReg);
	/**
	 * Create a AND [dstReg+dstDisp], srcReg
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 */
	public abstract void writeAND(Register dstReg, int dstDisp, Register srcReg);
	/**
	 * Create a bound lReg, [rReg+rDisp]
	 * @param lReg
	 * @param rReg
	 * @param rDisp
	 */
	public abstract void writeBOUND(Register lReg, Register rReg, int rDisp);
	/**
	 * Create a relative call to a given label
	 * 
	 * @param label
	 */
	public abstract void writeCALL(Label 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 abstract void writeCALL(Object tablePtr, int offset, boolean rawAddress);
	
	/**
	 * Create a call to address stored at the given [reg+offset]. 
	 * @param reg
	 * @param offset
	 */
	public abstract void writeCALL(Register reg, int offset);
	
	/**
	 * Create a cdq
	 */
	public abstract void writeCDQ();

	/**
	 * Create a CMOVcc dst,src
	 * 
	 * @param dst,src
	 */
	public abstract void writeCMOVcc(int ccOpcode, Register dst, Register src);

	/**
	 * Create a CMOVcc dst,[src+srcDisp]
	 * 
	 * @param dst
	 * @param src
	 * @param srcDisp
	 */
	public abstract void writeCMOVcc(int ccOpcode, Register dst, Register src, int srcDisp);

	/**
	 * Create a CMP EAX, imm32
	 * 
	 * @param imm32
	 */
	public abstract void writeCMP_EAX(int imm32);
	/**
	 * Create a CMP reg, imm32
	 * 
	 * @param reg
	 * @param imm32
	 */
	public abstract void writeCMP(Register reg, int imm32);
	/**
	 * Create a CMP reg1, [reg2+disp]
	 * 
	 * @param reg1
	 * @param reg2
	 * @param disp
	 */
	public abstract void writeCMP(Register reg1, Register reg2, int disp);
	/**
	 * Create a CMP [reg1+disp], reg2
	 * 
	 * @param reg1
	 * @param disp
	 * @param reg2
	 */
	public abstract void writeCMP(Register reg1, int disp, Register reg2);

	/**
	 * Create a CMP [memPtr], imm32
	 * @param memPtr
	 * @param imm32
	 */
	public abstract void writeCMP_MEM(int memPtr, int imm32);
	/**
	 * Create a CMP reg,[memPtr]
	 * @param reg
	 * @param memPtr
	 */
	public abstract void writeCMP_MEM(Register reg, int memPtr);
	/**
	 * Create a CMP reg1, reg2
	 * @param reg1
	 * @param reg2
	 */
	public abstract void writeCMP(Register reg1, Register reg2);
	/**
	 * Create a CMPXCHG dword [dstReg], srcReg
	 * @param dstReg
	 * @param dstDisp
	 * @param srcReg
	 * @param lock
	 */
	public abstract void writeCMPXCHG_EAX(Register dstReg, int dstDisp, Register srcReg, boolean lock);
	/**
	 * Create a dec reg32
	 * @param dstReg
	 */
	public abstract void writeDEC(Register dstReg);
	/**
	 * Create a dec dword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeDEC(Register dstReg, int dstDisp);
	/**
	 * Create a fadd dword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFADD32(Register srcReg, int srcDisp);
	/**
	 * Create a fadd qword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFADD64(Register srcReg, int srcDisp);
	/**
	 * Create a fchs
	 */
	public abstract void writeFCHS();
	/**
	 * Create a fdiv dword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFDIV32(Register srcReg, int srcDisp);
	/**
	 * Create a fdiv qword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFDIV64(Register srcReg, int srcDisp);
	/**
	 * Create a ffree
	 * @param fReg
	 */
	public abstract void writeFFREE(Register fReg);
	/**
	 * Create a fild dword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFILD32(Register dstReg, int dstDisp);
	/**
	 * Create a fild qword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFILD64(Register dstReg, int dstDisp);
	/**
	 * Create a fistp dword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFISTP32(Register dstReg, int dstDisp);
	/**
	 * Create a fistp qword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFISTP64(Register dstReg, int dstDisp);
	/**
	 * Create a fld dword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFLD32(Register srcReg, int srcDisp);
	/**
	 * Create a fld qword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFLD64(Register srcReg, int srcDisp);
	/**
	 * Create a fmul dword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFMUL32(Register srcReg, int srcDisp);
	/**
	 * Create a fmul qword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFMUL64(Register srcReg, int srcDisp);
	/**
	 * Create a fnstsw, Store fp status word in AX
	 */
	public abstract void writeFNSTSW_AX();
	/**
	 * Create a fprem
	 */
	public abstract void writeFPREM();
	/**
	 * Create a fstp dword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFSTP32(Register dstReg, int dstDisp);
	/**
	 * Create a fstp qword [dstReg+dstDisp]
	 * @param dstReg
	 * @param dstDisp
	 */
	public abstract void writeFSTP64(Register dstReg, int dstDisp);
	/**
	 * Create a fsub dword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFSUB32(Register srcReg, int srcDisp);
	/**
	 * Create a fsub qword [srcReg+srcDisp]
	 * @param srcReg
	 * @param srcDisp
	 */
	public abstract void writeFSUB64(Register srcReg, int srcDisp);
	/**
	 * Create a fucompp, Compare - Pop twice
	 */
	public abstract void writeFUCOMPP();
	/**
	 * Create a idiv eax, srcReg
	 * @param srcReg
	 */
	public abstract void writeIDIV_EAX(Register srcReg);