code.java

是一款用JAVA 编写的编译器 具有很强的编译功能

	    default:
		break;
	    }
	    if (stacksize+2 >= stack.length) {
		Type[] newstack = new Type[2*stack.length];
		System.arraycopy(stack, 0, newstack, 0, stack.length);
		stack = newstack;
	    }
	    stack[stacksize++] = t;
	    switch (width(t)) {
	    case 1:
		break;
	    case 2:
		stack[stacksize++] = null;
		break;
	    default:
		throw new AssertionError(t);
	    }
	    if (stacksize > max_stack)
		max_stack = stacksize;
	}

	Type pop1() {
	    if (debugCode) System.err.println("   popping " + 1);
	    stacksize--;
	    Type result = stack[stacksize];
	    stack[stacksize] = null;
	    assert result != null && width(result) == 1;
	    return result;
	}

	Type peek() {
	    return stack[stacksize-1];
	}

	Type pop2() {
	    if (debugCode) System.err.println("   popping " + 2);
	    stacksize -= 2;
	    Type result = stack[stacksize];
	    stack[stacksize] = null;
	    assert stack[stacksize+1] == null;
	    assert result != null && width(result) == 2;
	    return result;
	}

	void pop(int n) {
	    if (debugCode) System.err.println("   popping " + n);
	    while (n > 0) {
		stack[--stacksize] = null;
		n--;
	    }
	}

	void pop(Type t) {
	    pop(width(t));
	}

	/** Force the top of the stack to be treated as this supertype
	 *  of its current type. */
	void forceStackTop(Type t) {
            if (!alive) return;
	    switch (t.tag) {
	    case CLASS:
	    case ARRAY:
		int width = width(t);
		Type old = stack[stacksize-width];
		assert types.isSubtype(types.erasure(old),
				       types.erasure(t));
		stack[stacksize-width] = t;
		break;
	    default:
	    }
	}

	void markInitialized(UninitializedType old) {
	    Type newtype = old.initializedType();
	    for (int i=0; i<stacksize; i++)
		if (stack[i] == old) stack[i] = newtype;
	    for (int i=0; i<lvar.length; i++) {
		LocalVar lv = lvar[i];
		if (lv != null && lv.sym.type == old) {
		    VarSymbol sym = lv.sym;
		    sym = sym.clone(sym.owner);
		    sym.type = newtype;
		    LocalVar newlv = lvar[i] = new LocalVar(sym);
		    // should the following be initialized to cp?
		    newlv.start_pc = lv.start_pc;
		}
	    }
	}

	State join(State other) {
	    defined = defined.andSet(other.defined);
	    assert stacksize == other.stacksize;
	    assert nlocks == other.nlocks;
	    for (int i=0; i<stacksize; ) {
		Type t = stack[i];
		Type tother = other.stack[i];
		Type result =
		    t==tother ? t :
		    types.isSubtype(t, tother) ? tother :
		    types.isSubtype(tother, t) ? t :
		    error();
		int w = width(result);
		stack[i] = result;
		if (w == 2) assert stack[i+1] == null;
		i += w;
	    }
	    return this;
	}

	Type error() {
	    throw new AssertionError("inconsistent stack types at join point");
	}

	void dump() {
	    dump(-1);
	}

	void dump(int pc) {
	    System.err.print("stackMap for " + meth.owner + "." + meth);
	    if (pc == -1)
		System.out.println();
	    else
		System.out.println(" at " + pc);
	    System.err.println(" stack (from bottom):");
	    for (int i=0; i<stacksize; i++)
		System.err.println("  " + i + ": " + stack[i]);

	    int lastLocal = 0;
	    for (int i=max_locals-1; i>=0; i--) {
		if (defined.isMember(i)) {
		    lastLocal = i;
		    break;
		}
	    }
	    if (lastLocal >= 0)
		System.err.println(" locals:");
	    for (int i=0; i<=lastLocal; i++) {
		System.err.print("  " + i + ": ");
		if (defined.isMember(i)) {
		    LocalVar var = lvar[i];
		    if (var == null) {
			System.err.println("(none)");
		    } else if (var.sym == null)
			System.err.println("UNKNOWN!");
		    else
			System.err.println("" + var.sym + " of type " +
					   var.sym.erasure(types));
		} else {
		    System.err.println("undefined");
		}
	    }
	    if (nlocks != 0) {
		System.err.print(" locks:");
		for (int i=0; i<nlocks; i++) {
		    System.err.print(" " + locks[i]);
		}
		System.err.println();
	    }
	}
    }

    static Type jsrReturnValue = new Type(TypeTags.INT, null);


/* **************************************************************************
 * Local variables
 ****************************************************************************/

    /** A live range of a local variable. */
    static class LocalVar {
	final VarSymbol sym;
	final char reg;
	char start_pc = Character.MAX_VALUE;
	char length = Character.MAX_VALUE;
	LocalVar(VarSymbol v) {
	    this.sym = v;
	    this.reg = (char)v.adr;
	}
	public LocalVar dup() {
	    return new LocalVar(sym);
	}
	public String toString() {
	    return "" + sym + " in register " + ((int)reg) + " starts at pc=" + ((int)start_pc) + " length=" + ((int)length);
	}
    };

    /** Local variables, indexed by register. */
    LocalVar[] lvar;

    /** Add a new local variable. */
    private void addLocalVar(VarSymbol v) {
	int adr = v.adr;
	if (adr+1 >= lvar.length) {
	    int newlength = lvar.length << 1;
	    if (newlength <= adr) newlength = adr + 10;
	    LocalVar[] new_lvar = new LocalVar[newlength];
	    System.arraycopy(lvar, 0, new_lvar, 0, lvar.length);
	    lvar = new_lvar;
	}
	assert lvar[adr] == null;
	if (pendingJumps != null) resolvePending();
	lvar[adr] = new LocalVar(v);
	state.defined.excl(adr);
    }

    /** Set the current variable defined state. */
    public void setDefined(Bits newDefined) {
	if (alive && newDefined != state.defined) {
	    Bits diff = state.defined.dup().xorSet(newDefined);
	    for (int adr = diff.nextBit(0);
		 adr >= 0;
		 adr = diff.nextBit(adr+1)) {
		if (adr >= nextreg)
		    state.defined.excl(adr);
		else if (state.defined.isMember(adr))
		    setUndefined(adr);
		else
		    setDefined(adr);
	    }
	}
    }

    /** Mark a register as being (possibly) defined. */
    public void setDefined(int adr) {
	LocalVar v = lvar[adr];
	if (v == null) {
	    state.defined.excl(adr);
	} else {
	    state.defined.incl(adr);
	    if (cp < Character.MAX_VALUE) {
		if (v.start_pc == Character.MAX_VALUE)
		    v.start_pc = (char)cp;
	    }
	}
    }

    /** Mark a register as being undefined. */
    public void setUndefined(int adr) {
	state.defined.excl(adr);
	if (adr < lvar.length &&
	    lvar[adr] != null &&
	    lvar[adr].start_pc != Character.MAX_VALUE) {
	    LocalVar v = lvar[adr];
	    char length = (char)(curPc() - v.start_pc);
	    if (length > 0 && length < Character.MAX_VALUE) {
		lvar[adr] = v.dup();
		v.length = length;
		putVar(v);
	    } else {
		v.start_pc = Character.MAX_VALUE;
	    }
	}
    }

    /** End the scope of a variable. */
    private void endScope(int adr) {
	LocalVar v = lvar[adr];
	if (v != null) {
	    lvar[adr] = null;
	    if (v.start_pc != Character.MAX_VALUE) {
		char length = (char)(curPc() - v.start_pc);
		if (length < Character.MAX_VALUE) {
		    v.length = length;
		    putVar(v);
		}
	    }
	}
	state.defined.excl(adr);
    }

    /** Put a live variable range into the buffer to be output to the
     *  class file.
     */
    void putVar(LocalVar var) {
	if (!varDebugInfo) return;
	if ((var.sym.flags() & Flags.SYNTHETIC) != 0) return;
	if (varBuffer == null)
	    varBuffer = new LocalVar[20];
	else if (varBufferSize >= varBuffer.length) {
	    LocalVar[] newVarBuffer = new LocalVar[varBufferSize*2];
	    System.arraycopy(varBuffer, 0, newVarBuffer, 0, varBuffer.length);
	    varBuffer = newVarBuffer;
	}
	varBuffer[varBufferSize++] = var;
    }

    /** Previously live local variables, to be put into the variable table. */
    LocalVar[] varBuffer;
    int varBufferSize;

    /** Create a new local variable address and return it.
     */
    private int newLocal(int typecode) {
	int reg = nextreg;
	int w = width(typecode);
	nextreg = reg + w;
	if (nextreg > max_locals) max_locals = nextreg;
	return reg;
    }

    private int newLocal(Type type) {
	return newLocal(typecode(type));
    }

    public int newLocal(VarSymbol v) {
	int reg = v.adr = newLocal(v.erasure(types));
	addLocalVar(v);
	return reg;
    }

    /** Start a set of fresh registers.
     */
    public void newRegSegment() {
	nextreg = max_locals;
    }

    /** End scopes of all variables with registers >= first.
     */
    public void endScopes(int first) {
	int prevNextReg = nextreg;
	nextreg = first;
	for (int i = nextreg; i < prevNextReg; i++) endScope(i);
    }

/**************************************************************************
 * static tables
 *************************************************************************/

    public static String mnem(int opcode) {
	return Mneumonics.mnem[opcode];
    }

    private static class Mneumonics {
	private final static String[] mnem = new String[ByteCodeCount];
	static {
	    mnem[nop] = "nop";
	    mnem[aconst_null] = "aconst_null";
	    mnem[iconst_m1] = "iconst_m1";
	    mnem[iconst_0] = "iconst_0";
	    mnem[iconst_1] = "iconst_1";
	    mnem[iconst_2] = "iconst_2";
	    mnem[iconst_3] = "iconst_3";
	    mnem[iconst_4] = "iconst_4";
	    mnem[iconst_5] = "iconst_5";
	    mnem[lconst_0] = "lconst_0";
	    mnem[lconst_1] = "lconst_1";
	    mnem[fconst_0] = "fconst_0";
	    mnem[fconst_1] = "fconst_1";
	    mnem[fconst_2] = "fconst_2";
	    mnem[dconst_0] = "dconst_0";
	    mnem[dconst_1] = "dconst_1";
	    mnem[bipush] = "bipush";
	    mnem[sipush] = "sipush";
	    mnem[ldc1] = "ldc1";
	    mnem[ldc2] = "ldc2";
	    mnem[ldc2w] = "ldc2w";
	    mnem[iload] = "iload";
	    mnem[lload] = "lload";
	    mnem[fload] = "fload";
	    mnem[dload] = "dload";
	    mnem[aload] = "aload";
	    mnem[iload_0] = "iload_0";
	    mnem[lload_0] = "lload_0";
	    mnem[fload_0] = "fload_0";
	    mnem[dload_0] = "dload_0";
	    mnem[aload_0] = "aload_0";
	    mnem[iload_1] = "iload_1";
	    mnem[lload_1] = "lload_1";
	    mnem[fload_1] = "fload_1";
	    mnem[dload_1] = "dload_1";
	    mnem[aload_1] = "aload_1";
	    mnem[iload_2] = "iload_2";
	    mnem[lload_2] = "lload_2";
	    mnem[fload_2] = "fload_2";
	    mnem[dload_2] = "dload_2";
	    mnem[aload_2] = "aload_2";
	    mnem[iload_3] = "iload_3";
	    mnem[lload_3] = "lload_3";
	    mnem[fload_3] = "fload_3";
	    mnem[dload_3] = "dload_3";
	    mnem[aload_3] = "aload_3";
	    mnem[iaload] = "iaload";
	    mnem[laload] = "laload";
	    mnem[faload] = "faload";
	    mnem[daload] = "daload";
	    mnem[aaload] = "aaload";
	    mnem[baload] = "baload";
	    mnem[caload] = "caload";
	    mnem[saload] = "saload";
	    mnem[istore] = "istore";
	    mnem[lstore] = "lstore";
	    mnem[fstore] = "fstore";
	    mnem[dstore] = "dstore";
	    mnem[astore] = "astore";
	    mnem[istore_0] = "istore_0";
	    mnem[lstore_0] = "lstore_0";
	    mnem[fstore_0] = "fstore_0";
	    mnem[dstore_0] = "dstore_0";
	    mnem[astore_0] = "astore_0";
	    mnem[istore_1] = "istore_1";
	    mnem[lstore_1] = "lstore_1";
	    mnem[fstore_1] = "fstore_1";
	    mnem[dstore_1] = "dstore_1";
	    mnem[astore_1] = "astore_1";
	    mnem[istore_2] = "istore_2";
	    mnem[lstore_2] = "lstore_2";
	    mnem[fstore_2] = "fstore_2";
	    mnem[dstore_2] = "dstore_2";
	    mnem[astore_2] = "astore_2";
	    mnem[istore_3] = "istore_3";
	    mnem[lstore_3] = "lstore_3";
	    mnem[fstore_3] = "fstore_3";
	    mnem[dstore_3] = "dstore_3";
	    mnem[astore_3] = "astore_3";
	    mnem[iastore] = "iastore";
	    mnem[lastore] = "lastore";
	    mnem[fastore] = "fastore";
	    mnem[dastore] = "dastore";
	    mnem[aastore] = "aastore";
	    mnem[bastore] = "bastore";
	    mnem[castore] = "castore";
	    mnem[sastore] = "sastore";
	    mnem[pop] = "pop";
	    mnem[pop2] = "pop2";
	    mnem[dup] = "dup";
	    mnem[dup_x1] = "dup_x1";
	    mnem[dup_x2] = "dup_x2";
	    mnem[dup2] = "dup2";
	    mnem[dup2_x1] = "dup2_x1";
	    mnem[dup2_x2] = "dup2_x2";
	    mnem[swap] = "swap";
	    mnem[iadd] = "iadd";
	    mnem[ladd] = "ladd";
	    mnem[fadd] = "fadd";
	    mnem[dadd] = "dadd";
	    mnem[isub] = "isub";
	    mnem[lsub] = "lsub";
	    mnem[fsub] = "fsub";
	    mnem[dsub] = "dsub";
	    mnem[imul] = "imul";
	    mnem[lmul] = "lmul";
	    mnem[fmul] = "fmul";
	    mnem[dmul] = "dmul";
	    mnem[idiv] = "idiv";
	    mnem[ldiv] = "ldiv";
	    mnem[fdiv] = "fdiv";
	    mnem[ddiv] = "ddiv";
	    mnem[imod] = "imod";
	    mnem[lmod] = "lmod";
	    mnem[fmod] = "fmod";
	    mnem[dmod] = "dmod";
	    mnem[ineg] = "ineg";
	    mnem[lneg] = "lneg";
	    mnem[fneg] = "fneg";
	    mnem[dneg] = "dneg";
	    mnem[ishl] = "ishl";
	    mnem[lshl] = "lshl";
	    mnem[ishr] = "ishr";
	    mnem[lshr] = "lshr";
	    mnem[iushr] = "iushr";
	    mnem[lushr] = "lushr";
	    mnem[iand] = "iand";
	    mnem[land] = "land";
	    mnem[ior] = "ior";
	    mnem[lor] = "lor";
	    mnem[ixor] = "ixor";
	    mnem[lxor] = "lxor";
	    mnem[iinc] = "iinc";
	    mnem[i2l] = "i2l";
	    mnem[i2f] = "i2f";
	    mnem[i2d] = "i2d";
	    mnem[l2i] = "l2i";
	    mnem[l2f] = "l2f";
	    mnem[l2d] = "l2d";
	    mnem[f2i] = "f2i";
	    mnem[f2l] = "f2l";
	    mnem[f2d] = "f2d";
	    mnem[d2i] = "d2i";
	    mnem[d2l] = "d2l";
	    mnem[d2f] = "d2f";
	    mnem[int2byte] = "int2byte";
	    mnem[int2char] = "int2char";
	    mnem[int2short] = "int2short";
	    mnem[lcmp] = "lcmp";
	    mnem[fcmpl] = "fcmpl";
	    mnem[fcmpg] = "fcmpg";
	    mnem[dcmpl] = "dcmpl";
	    mnem[dcmpg] = "dcmpg";
	    mnem[ifeq] = "ifeq";
	    mnem[ifne] = "ifne";
	    mnem[iflt] = "iflt";
	    mnem[ifge] = "ifge";
	    mnem[ifgt] = "ifgt";
	    mnem[ifle] = "ifle";
	    mnem[if_icmpeq] = "if_icmpeq";
	    mnem[if_icmpne] = "if_icmpne";
	    mnem[if_icmplt] = "if_icmplt";
	    mnem[if_icmpge] = "if_icmpge";
	    mnem[if_icmpgt] = "if_icmpgt";
	    mnem[if_icmple] = "if_icmple";
	    mnem[if_acmpeq] = "if_acmpeq";
	    mnem[if_acmpne] = "if_acmpne";
	    mnem[goto_] = "goto_";
	    mnem[jsr] = "jsr";
	    mnem[ret] = "ret";
	    mnem[tableswitch] = "tableswitch";
	    mnem[lookupswitch] = "lookupswitch";
	    mnem[ireturn] = "ireturn";
	    mnem[lreturn] = "lreturn";
	    mnem[freturn] = "freturn";
	    mnem[dreturn] = "dreturn";
	    mnem[areturn] = "areturn";
	    mnem[return_] = "return_";
	    mnem[getstatic] = "getstatic";
	    mnem[putstatic] = "putstatic";
	    mnem[getfield] = "getfield";
	    mnem[putfield] = "putfield";
	    mnem[invokevirtual] = "invokevirtual";
	    mnem[invokespecial] = "invokespecial";
	    mnem[invokestatic] = "invokestatic";
	    mnem[invokeinterface] = "invokeinterface";
	    // mnem[___unused___] = "___unused___";
	    mnem[new_] = "new_";
	    mnem[newarray] = "newarray";
	    mnem[anewarray] = "anewarray";
	    mnem[arraylength] = "arraylength";
	    mnem[athrow] = "athrow";
	    mnem[checkcast] = "checkcast";
	    mnem[instanceof_] = "instanceof_";
	    mnem[monitorenter] = "monitorenter";
	    mnem[monitorexit] = "monitorexit";
	    mnem[wide] = "wide";
	    mnem[multianewarray] = "multianewarray";
	    mnem[if_acmp_null] = "if_acmp_null";
	    mnem[if_acmp_nonnull] = "if_acmp_nonnull";
	    mnem[goto_w] = "goto_w";
	    mnem[jsr_w] = "jsr_w";
	    mnem[breakpoint] = "breakpoint";
	}
    }
}