textx86stream.java

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

/*
 * $Id: TextX86Stream.java,v 1.18 2004/02/26 10:33:49 epr Exp $
 */
package org.jnode.assembler.x86;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
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.util.NumberUtils;
import org.jnode.vm.classmgr.VmType;
import org.jnode.vm.x86.X86CpuID;

/**
 * Debug version of AbstractX86Stream.
 * 
 * @author Ewout Prangsma ([e-mail])
 */
public class TextX86Stream extends AbstractX86Stream {

	final PrintWriter out;
	private final StringBuffer buf = new StringBuffer();
	private final byte[] dummy = new byte[0];
	private int idx = 0;

	/**
	 * Initialize this instance
	 * 
	 * @param out
	 */
	public TextX86Stream(Writer out, X86CpuID cpuId) {
		super(cpuId);
		this.out = new PrintWriter(out);
	}

    /**
     * Remove all data and references.
     */
    public void clear() {
        buf.setLength(0);
        idx = 0;
    }
    
	/**
	 * Flush the contents of the used stream.
	 *  
	 */
	public void flush() throws IOException {
		out.print(buf.toString());
		idx += buf.length();
		buf.setLength(0);
		out.flush();
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#align(int)
	 */
	public int align(int value) {
		return 0;
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#get32(int)
	 */
	public int get32(int offset) {
		return 0;
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#get8(int)
	 */
	public int get8(int offset) {
		return 0;
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getBaseAddr()
	 */
	public long getBaseAddr() {
		return 0;
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getBytes()
	 */
	public byte[] getBytes() {
		return dummy;
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getLength()
	 */
	public int getLength() {
		return idx + buf.length();
	}

	/**
	 * Remove count bytes from the end of the generated stream.
	 * 
	 * @param count
	 */
	public void trim(int count) {
		buf.setLength(buf.length() - count);
		//println("\t; TRIM " + count + " bytes");
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getObjectRef(java.lang.Object)
	 */
	public ObjectRef getObjectRef(Object keyObj) {
		return new ObjectRefImpl(keyObj);
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getObjectRefs()
	 */
	public Collection getObjectRefs() {
		return null;
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#getResolver()
	 */
	public ObjectResolver getResolver() {
		return null;
	}

	/**
	 * @see org.jnode.assembler.NativeStream#getUnresolvedObjectRefs()
	 */
	public Collection getUnresolvedObjectRefs() {
		return null;
	}

	/**
	 * @see org.jnode.assembler.NativeStream#hasUnresolvedObjectRefs()
	 */
	public boolean hasUnresolvedObjectRefs() {
		return false;
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#set32(int, int)
	 */
	public void set32(int offset, int v32) {
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#set8(int, int)
	 */
	public void set8(int offset, int v8) {
		// TODO Auto-generated method stub

	}

	/**
	 * @see org.jnode.assembler.NativeStream#setObjectRef(java.lang.Object)
	 */
	public ObjectRef setObjectRef(Object label) {
		println(label + ":");
		return new ObjectRefImpl(label);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#setResolver(org.jnode.assembler.ObjectResolver)
	 */
	public void setResolver(ObjectResolver resolver) {
		// TODO Auto-generated method stub

	}

	/**
	 * @see org.jnode.assembler.NativeStream#startObject(org.jnode.vm.classmgr.VmType)
	 */
	public ObjectInfo startObject(VmType cls) {
		println(";\n; -- Start of object --\n;");
		return new ObjectInfoImpl();
	}

	/**
	 * @see org.jnode.assembler.NativeStream#write(byte[], int, int)
	 */
	public void write(byte[] data, int ofs, int len) {
		buf.append("\tdb ");
		for (int i = 0; i < len; i++) {
			if (i > 0) {
				buf.append(',');
			}
			buf.append(data[i]);
		}
		buf.append('\n');
	}

	/**
	 * @see org.jnode.assembler.NativeStream#write16(int)
	 */
	public void write16(int v16) {
		println("\tdw " + v16);
	}

	/**
	 * @see org.jnode.assembler.NativeStream#write32(int)
	 */
	public void write32(int v32) {
		println("\tdd " + v32);
	}

	/**
	 * @see org.jnode.assembler.NativeStream#write64(long)
	 */
	public void write64(long v64) {
		println("\tdq " + v64);
	}

	/**
	 * @see org.jnode.assembler.NativeStream#write8(int)
	 */
	public void write8(int v8) {
		println("\tdb " + v8);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writePrefix(int)
	 */
	public void writePrefix(int prefix) {

		final String str;
		switch (prefix) {
			case FS_PREFIX :
				str = "fs";
				break;
			default :
				throw new IllegalArgumentException("Unknown prefix " + prefix);
		}
		println("\tprefix " + str);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeADC(Register, int, Register)
	 */
	public void writeADC(Register dstReg, int dstDisp, Register srcReg) {

		println("\tadc [" + dstReg + disp(dstDisp) + "]," + srcReg);
	}

	/**
	 * Create a ADC dstReg, srcReg
	 * 
	 * @param dstReg
	 * @param srcReg
	 */
	public void writeADC(Register dstReg, Register srcReg) {

		println("\tadc " + dstReg + "," + srcReg);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeADD(Register, int, Register)
	 */
	public void writeADD(Register dstReg, int dstDisp, Register srcReg) {

		println("\tadd [" + dstReg + disp(dstDisp) + "]," + srcReg);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeADD(Register, Register)
	 */
	public void writeADD(Register dstReg, Register srcReg) {

		println("\tadd " + dstReg + "," + srcReg);
	}

	/**
     * Create a ADD dstReg, [srcReg+srcDisp]
     * 
     * @param dstReg
     * @param srcReg
     * @param srcDisp
     */
    public void writeADD(Register dstReg, Register srcReg, int srcDisp) {
		println("\tadd " + dstReg + ",[" + srcReg + disp(srcDisp) + "]");        
    }
    
	/**
	 * Create a ADD [dstReg+dstDisp], imm32
	 * 
	 * @param dstReg
	 * @param dstDisp
	 * @param imm32
	 */
	public void writeADD(Register dstReg, int dstDisp, int imm32) {

		println("\tadd dword[" + dstReg + disp(dstDisp) + "]," + imm32);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeAND(Register, int, Register)
	 */
	public void writeAND(Register dstReg, int dstDisp, Register srcReg) {

		println("\tand [" + dstReg + disp(dstDisp) + "]," + srcReg);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeAND(Register, int)
	 */
	public void writeAND(Register reg, int imm32) {

		println("\tand " + reg + ",0x" + NumberUtils.hex(imm32));
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeAND(Register, Register)
	 */
	public void writeAND(Register dstReg, Register srcReg) {

		println("\tand " + dstReg + "," + srcReg);
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeBOUND(Register, Register, int)
	 */
	public void writeBOUND(Register lReg, Register rReg, int rDisp) {

		println("\tbound " + lReg + ",[" + rReg + disp(rDisp) + "]");
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCALL(Label)
	 */
	public void writeCALL(Label label) {

		println("\tcall " + 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 void writeCALL(Object tablePtr, int offset, boolean rawAddress) {

		println("\tcall dword [" + tablePtr + disp(offset) + "]");
	}

	/**
	 * Create a call to address stored at the given [reg+offset].
	 * 
	 * @param reg
	 * @param offset
	 */
	public void writeCALL(Register reg, int offset) {

		println("\tcall dword [" + reg + disp(offset) + "]");
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCDQ()
	 */
	public void writeCDQ() {

		println("\tcdq");
	}

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

		println("\tCMOV" + ccName(ccOpcode) + " " + dst + "," + src);
	}

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

		println("\tCMOV" + ccName(ccOpcode) + " " + dst + ",[" + src + disp(srcDisp) + "]");
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCMP_EAX(int)
	 */
	public void writeCMP_EAX(int imm32) {

		println("\tcmp eax,0x" + NumberUtils.hex(imm32));
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCMP_MEM(int, int)
	 */
	public void writeCMP_MEM(int memPtr, int imm32) {

		println("\tcmp dword [" + memPtr + "],0x" + NumberUtils.hex(imm32));
	}

	/**
	 * Create a CMP reg,[memPtr]
	 * 
	 * @param reg
	 * @param memPtr
	 */
	public void writeCMP_MEM(Register reg, int memPtr) {

		println("\tcmp " + reg + ",dword [" + memPtr + "]");
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCMP(Register, int)
	 */
	public void writeCMP(Register reg, int imm32) {

		println("\tcmp " + reg + ",0x" + NumberUtils.hex(imm32));
	}

	/**
	 * @see org.jnode.assembler.x86.AbstractX86Stream#writeCMP(Register, Register)
	 */
	public void writeCMP(Register reg1, Register reg2) {

		println("\tcmp " + reg1 + "," + reg2);