X-Git-Url: http://git.megacz.com/?p=org.ibex.classgen.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FMethodGen.java;h=96193daf9f3006382fbd2769c970ab143ad1d5cb;hp=6603ebd3849d9baca49b6596e6efac5f54faacb1;hb=0f4dbf22cb4e40d2f9cdedfb40b6e31647781b75;hpb=5171de54bf4029c4a51ee759cdb3b1d045ebffe6 diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java index 6603ebd..96193da 100644 --- a/src/org/ibex/classgen/MethodGen.java +++ b/src/org/ibex/classgen/MethodGen.java @@ -3,20 +3,18 @@ package org.ibex.classgen; import java.io.*; import java.util.*; +/** A class representing a method in a generated classfile + @see ClassFile#addMethod */ public class MethodGen implements CGConst { private final static boolean EMIT_NOPS = false; private static final int NO_CODE = -1; - private static final int FINISHED = -2; - - private final CPGen cp; - private final String name; - private final Type ret; - private final Type[] args; + + private final Type.Class.Method method; private final int flags; - private final ClassGen.AttrGen attrs; - private final ClassGen.AttrGen codeAttrs; - private final Hashtable exnTable = new Hashtable(); + private final ClassFile.AttrGen attrs; + private final ClassFile.AttrGen codeAttrs; + private final Vector exnTable = new Vector(); private final Hashtable thrownExceptions = new Hashtable(); private int maxStack = 16; @@ -26,76 +24,364 @@ public class MethodGen implements CGConst { private int capacity; private byte[] op; private Object[] arg; + private ConstantPool.Ent[] cparg; - MethodGen(ClassGen owner, String name, Type ret, Type[] args, int flags) { - if((flags & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED|ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE|ACC_ABSTRACT|ACC_STRICT)) != 0) - throw new IllegalArgumentException("invalid flags"); - this.cp = owner.cp; - this.name = name; - this.ret = ret; - this.args = args; - this.flags = flags; + public void debugToString(StringBuffer sb, String constructorName) { + // This is intentionally a local variable so it can be removed by gcclass + final String[] OP_NAMES = new String[]{ + "nop", "aconst_null", "iconst_m1", "iconst_0", "iconst_1", "iconst_2", + "iconst_3", "iconst_4", "iconst_5", "lconst_0", "lconst_1", "fconst_0", + "fconst_1", "fconst_2", "dconst_0", "dconst_1", "bipush", "sipush", + "ldc", "ldc_w", "ldc2_w", "iload", "lload", "fload", + "dload", "aload", "iload_0", "iload_1", "iload_2", "iload_3", + "lload_0", "lload_1", "lload_2", "lload_3", "fload_0", "fload_1", + "fload_2", "fload_3", "dload_0", "dload_1", "dload_2", "dload_3", + "aload_0", "aload_1", "aload_2", "aload_3", "iaload", "laload", + "faload", "daload", "aaload", "baload", "caload", "saload", + "istore", "lstore", "fstore", "dstore", "astore", "istore_0", + "istore_1", "istore_2", "istore_3", "lstore_0", "lstore_1", "lstore_2", + "lstore_3", "fstore_0", "fstore_1", "fstore_2", "fstore_3", "dstore_0", + "dstore_1", "dstore_2", "dstore_3", "astore_0", "astore_1", "astore_2", + "astore_3", "iastore", "lastore", "fastore", "dastore", "aastore", + "bastore", "castore", "sastore", "pop", "pop2", "dup", + "dup_x1", "dup_x2", "dup2", "dup2_x1", "dup2_x2", "swap", + "iadd", "ladd", "fadd", "dadd", "isub", "lsub", + "fsub", "dsub", "imul", "lmul", "fmul", "dmul", + "idiv", "ldiv", "fdiv", "ddiv", "irem", "lrem", + "frem", "drem", "ineg", "lneg", "fneg", "dneg", + "ishl", "lshl", "ishr", "lshr", "iushr", "lushr", + "iand", "land", "ior", "lor", "ixor", "lxor", + "iinc", "i2l", "i2f", "i2d", "l2i", "l2f", + "l2d", "f2i", "f2l", "f2d", "d2i", "d2l", + "d2f", "i2b", "i2c", "i2s", "lcmp", "fcmpl", + "fcmpg", "dcmpl", "dcmpg", "ifeq", "ifne", "iflt", + "ifge", "ifgt", "ifle", "if_icmpeq", "if_icmpne", "if_icmplt", + "if_icmpge", "if_icmpgt", "if_icmple", "if_acmpeq", "if_acmpne", "goto", + "jsr", "ret", "tableswitch", "lookupswitch", "ireturn", "lreturn", + "freturn", "dreturn", "areturn", "return", "getstatic", "putstatic", + "getfield", "putfield", "invokevirtual", "invokespecial", "invokestatic", "invokeinterface", + "", "new", "newarray", "anewarray", "arraylength", "athrow", + "checkcast", "instanceof", "monitorenter", "monitorexit", "wide", "multianewarray", + "ifnull", "ifnonnull", "goto_w", "jsr_w", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "" + }; + + sb.append(" ").append(ClassFile.flagsToString(flags,false)); + sb.append(method.debugToString()); + if(thrownExceptions.size() > 0) { + sb.append("throws"); + for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();) + sb.append(" ").append(((Type.Class)e.nextElement()).debugToString()).append(","); + sb.setLength(sb.length()-1); + sb.append(" "); + } + if((flags & (NATIVE|ABSTRACT))==0) { + sb.append("{\n"); + for(int i=0;i 0) + exnTable.addElement(new ExnTableEnt(ci,cp,bytecodeMap)); + codeAttrs = new ClassFile.AttrGen(ci,cp); + // FEATURE: Support these + // NOTE: Until we can support them properly we HAVE to delete them, + // they'll be incorrect after we rewrite the constant pool, etc + codeAttrs.remove("LineNumberTable"); + codeAttrs.remove("LocalVariableTable"); + + } else { + codeAttrs = new ClassFile.AttrGen(); + } + + if(attrs.contains("Exceptions")) { + DataInputStream ei = new DataInputStream(new ByteArrayInputStream((byte[]) attrs.get("Exceptions"))); + int exnCount = ei.readUnsignedShort(); + while(exnCount-- > 0) { + Type.Class t = (Type.Class) cp.getKeyByIndex(ei.readUnsignedShort()); + thrownExceptions.put(t,t); + } + } + } - attrs = new ClassGen.AttrGen(cp); - codeAttrs = new ClassGen.AttrGen(cp); + final int[] parseCode(DataInputStream in, int codeLen, ConstantPool cp) throws IOException { + int[] map = new int[codeLen]; + int pc; + for(pc=0;pc= max || bytecodeMap[startPC] < 0) throw new ClassFile.ClassReadExn("invalid startPC"); + if(endPC >= max || bytecodeMap[endPC] < 0) throw new ClassFile.ClassReadExn("invalid startPC"); + if(handlerPC >= max || bytecodeMap[handlerPC] < 0) throw new ClassFile.ClassReadExn("invalid startPC"); + this.start = bytecodeMap[startPC]; + this.end = bytecodeMap[endPC]; + this.handler = bytecodeMap[handlerPC]; + } + ExnTableEnt(int start, int end, int handler, Type.Class type) { this.start = start; this.end = end; this.handler = handler; - this.typeEnt = typeEnt; + this.type = type; } - public void dump(DataOutput o, int[] pc, int endPC) throws IOException { + void finish(ConstantPool cp) { if(type != null) cp.add(type); } + void dump(DataOutput o, int[] pc, int endPC, ConstantPool cp) throws IOException { o.writeShort(pc[start]); o.writeShort(end==pc.length ? endPC : pc[end]); o.writeShort(pc[handler]); - o.writeShort(typeEnt.getIndex()); + o.writeShort(type == null ? 0 : cp.getIndex(type)); } } - public final void addExceptionHandler(int startPC, int endPC, int handlerPC, Type.Object type) { - exnTable.put(type, new ExnTableEnt(startPC,endPC,handlerPC,cp.add(type))); + /** Adds an exception handler for the range [start, end) pointing to handler + @param start The instruction to start at (inclusive) + @param end The instruction to end at (exclusive) + @param handler The instruction of the excepton handler + @param type The type of exception that is to be handled (MUST inherit from Throwable) + */ + public final void addExceptionHandler(int start, int end, int handler, Type.Class type) { + exnTable.addElement(new ExnTableEnt(start, end, handler, type)); } - public final void addThrow(Type.Object type) { - thrownExceptions.put(type,cp.add(type)); - } + /** Adds a exception type that can be thrown from this method + NOTE: This isn't enforced by the JVM. This is for reference only. A method can throw exceptions not declared to be thrown + @param type The type of exception that can be thrown + */ + public final void addThrow(Type.Class type) { thrownExceptions.put(type, type); } private final void grow() { if(size == capacity) grow(size+1); } private final void grow(int newCap) { if(capacity == NO_CODE) throw new IllegalStateException("method can't have code"); - if(capacity == FINISHED) throw new IllegalStateException("method has been finished"); if(newCap <= capacity) return; - newCap = Math.max(newCap,capacity == 0 ? 256 : capacity*2); + newCap = Math.max(newCap, capacity == 0 ? 256 : capacity*2); byte[] op2 = new byte[newCap]; - if(capacity != 0) System.arraycopy(op,0,op2,0,size); + if(capacity != 0) System.arraycopy(op, 0, op2, 0, size); op = op2; Object[] arg2 = new Object[newCap]; - if(capacity != 0) System.arraycopy(arg,0,arg2,0,size); + if(capacity != 0) System.arraycopy(arg, 0, arg2, 0, size); arg = arg2; capacity = newCap; } + + /** Returns the size (in instructions) of this method + @return The size of the method (in instructions) + */ public final int size() { return size; } // These two are optimized for speed, they don't call set() below + /** Add a bytecode (with no argument) to the method */ public final int add(byte op) { int s = size; if(s == capacity) grow(); @@ -103,22 +389,57 @@ public class MethodGen implements CGConst { size++; return s; } + /** Set the bytecode at position pos to op */ public final void set(int pos, byte op) { this.op[pos] = op; } - public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } - public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } - public final int add(byte op, int arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } + /** Adds a bytecode, op, with argument arg to the method + @return The position of the new bytecode + */ + public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size, op, arg); return size++; } + /** Adds a bytecode with a boolean argument - equivalent to add(op, arg?1:0); + @return The position of the new bytecode + @see #add(byte, int) + */ + public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size, op, arg); return size++; } + /** Adds a bytecode with an integer argument. This is equivalent to add(op, new Integer(arg)), but optimized to prevent the allocation when possible + @return The position of the new bytecode + @see #add(byte, Object) + */ + public final int add(byte op, int arg) { if(capacity == size) grow(); set(size, op, arg); return size++; } + /** Gets the bytecode at position pos + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final byte get(int pos) { return op[pos]; } - public final Object getArg(int pos) { return arg[pos]; } - public final void setArg(int pos, int arg) { set(pos,op[pos],N(arg)); } - public final void setArg(int pos, Object arg) { set(pos,op[pos],arg); } + /** Gets the bytecode at position pos. NOTE: This isn't necessarily the same object that was set with add or set. + Arguments for instructions which access the constant pool (LDC, INVOKEVIRTUAL, etc) are converted to a more efficient + interal form when they are added. The value returned from this method for these instruction can be reused, but there + is no way to retrieve the original object + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ + public final Object getArg(int pos) { return arg[pos]; } + /** Sets the argument for pos to arg. This is equivalent to set(pos, op, new Integer(arg)), but optimized to prevent the allocation when possible. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + @see #setArg(int, Object) */ + public final void setArg(int pos, int arg) { set(pos, op[pos], N(arg)); } + /** Sets the argument for pos to arg. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ + public final void setArg(int pos, Object arg) { set(pos, op[pos], arg); } - public final void set(int pos, byte op, boolean b) { set(pos,op,b?1:0); } + /** Sets the bytecode and argument at pos to op and arg respectivly. + This is equivalent to set(pos, op, arg?1:0) + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ + public final void set(int pos, byte op, boolean arg) { set(pos, op, arg?1:0); } - // This MUST handle x{LOAD,STORE} and LDC with an int arg WITHOUT falling back to set(int,byte,Object) + // This MUST handle x{LOAD, STORE} and LDC with an int arg WITHOUT falling back to set(int, byte, Object) + /** Sets the bytecode and argument at pos to op and n respectivly. + This is equivalent to set(pos, op, new Integer(n)), but optimized to prevent the allocation when possible. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final void set(int pos, byte op, int n) { Object arg = null; OUTER: switch(op) { @@ -134,10 +455,11 @@ public class MethodGen implements CGConst { } if(n >= -128 && n <= 127) { op = BIPUSH; arg = N(n); } else if(n >= -32768 && n <= 32767) { op = SIPUSH; arg = N(n); } - else { arg = cp.add(N(n)); } + else { arg = N(n); } break; case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD: case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE: + if(n >= maxLocals) maxLocals = n + 1; if(n >= 0 && n <= 3) { byte base = 0; switch(op) { @@ -154,52 +476,55 @@ public class MethodGen implements CGConst { } op = (byte)((base&0xff) + n); } else { - if(n >= maxLocals) maxLocals = n + 1; arg = N(n); } break; default: - set(pos,op,N(n)); + set(pos, op, N(n)); return; } this.op[pos] = op; this.arg[pos] = arg; } + /** Sets the bytecode and argument at pos to op and arg respectivly. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final void set(int pos, byte op, Object arg) { switch(op) { case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD: case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE: - // set(int,byte,int) always handles these ops itself - set(pos,op,((Integer)arg).intValue()); + // set(int, byte, int) always handles these ops itself + set(pos, op, ((Integer)arg).intValue()); return; case LDC: - // set(int,byte,int) always handles these opts itself - if(arg instanceof Integer) { set(pos,op,((Integer)arg).intValue()); return; } - if(arg instanceof Boolean) { set(pos,op,((Boolean)arg).booleanValue()); return; } + // set(int, byte, int) always handles these opts itself + if(arg instanceof Integer) { set(pos, op, ((Integer)arg).intValue()); return; } + if(arg instanceof Boolean) { set(pos, op, ((Boolean)arg).booleanValue()); return; } if(arg instanceof Long) { long l = ((Long)arg).longValue(); - if(l == 0L) { this.op[pos] = LCONST_0; return; } - if(l == 1L) { this.op[pos] = LCONST_1; return; } + if(l == 0L || l == 1L) { + this.op[pos] = l == 0L ? LCONST_0 : LCONST_1; + this.arg[pos] = null; + return; + } + op = LDC2_W; + } else if(arg instanceof Double) { + op = LDC2_W; } - - if(arg instanceof Long || arg instanceof Double) op = LDC2_W; - break; - case INVOKEINTERFACE: - if(arg instanceof MethodRef) arg = new MethodRef.I((MethodRef)arg); break; } - int opdata = OP_DATA[op&0xff]; - if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent)) - arg = cp.add(arg); - else if((opdata&OP_VALID_FLAG) == 0) - throw new IllegalArgumentException("unknown bytecode"); + if((OP_DATA[op&0xff]&OP_VALID_FLAG) == 0) throw new IllegalArgumentException("unknown bytecode"); this.op[pos] = op; this.arg[pos] = arg; } - public static class SI { + /** This class represents the arguments to the TABLESWITH and LOOKUPSWITCH bytecodes + @see MethodGen.TSI + @see MethodGen.LSI + */ + public static abstract class SI { public final Object[] targets; public Object defaultTarget; @@ -211,22 +536,27 @@ public class MethodGen implements CGConst { public int size() { return targets.length; } public int getTarget(int pos) { return ((Integer)targets[pos]).intValue(); } - public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } + public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } + + abstract int length(); } + /** This class represents the arguments to the TABLESWITCH bytecode */ public static class TSI extends SI { public final int lo; public final int hi; - public int defaultTarget = -1; public TSI(int lo, int hi) { super(hi-lo+1); this.lo = lo; this.hi = hi; } - public void setTargetForVal(int val, Object o) { setTarget(val-lo,o); } - public void setTargetForVal(int val, int n) { setTarget(val-lo,n); } + public void setTargetForVal(int val, Object o) { setTarget(val-lo, o); } + public void setTargetForVal(int val, int n) { setTarget(val-lo, n); } + + int length() { return 12 + targets.length * 4; } // 4bytes/target, hi, lo, default } + /** This class represents the arguments to the LOOKUPSWITCH bytecode */ public static class LSI extends SI { public final int[] vals; public LSI(int size) { @@ -234,22 +564,85 @@ public class MethodGen implements CGConst { this.vals = new int[size]; } public final void setVal(int pos, int val) { vals[pos] = val; } + + int length() { return 8 + targets.length * 8; } // key/val per target, default, count } + /** This class represents the arguments to byecodes that take two integer arguments. */ public static class Pair { public int i1; public int i2; public Pair(int i1, int i2) { this.i1 = i1; this.i2 = i2; } } + + public static class MultiANewArray { + public Type.Class type; + public int dims; + public MultiANewArray(Type.Class type, int dims) { this.type = type; this.dims = dims; } + } + + public static class Wide { + public final byte op; + public final int varNum; + public final int n; + Wide(byte op, int varNum) { this(op, varNum, 0); } + Wide(byte op, int varNum, int n) { this.op = op; this.varNum = varNum; this.n = n; } + } + /** Sets the maximum number of locals in the function to maxLocals. NOTE: This defaults to 0 and is automatically increased as + necessary when *LOAD/*STORE bytecodes are added. You do not need to call this function in most cases */ public void setMaxLocals(int maxLocals) { this.maxLocals = maxLocals; } + /** Sets the maxinum size of th stack for this function to maxStack. This defaults to 16< */ public void setMaxStack(int maxStack) { this.maxStack = maxStack; } - public void finish() { - try { - _finish(); - } catch(IOException e) { - throw new Error("should never happen"); + /** Computes the final bytecode for this method. + @exception IllegalStateException if the data for a method is in an inconsistent state (required arguments missing, etc) + @exception Exn if the byteocode could not be generated for any other reason (constant pool full, etc) + */ + void finish(ConstantPool cp) { + cp.addUtf8(method.name); + cp.addUtf8(method.getDescriptor()); + + for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();) + cp.add(e.nextElement()); + + if(size == NO_CODE) return; + for(int i=0;i 0) attrs.put("Exceptions",""); + attrs.finish(cp); + codeAttrs.finish(cp); + + cparg = new ConstantPool.Ent[size]; + + for(int i=0, p=0;i= size) - throw new IllegalStateException("invalid target address"); + throw new IllegalStateException("invalid target address " + target + "/" + size); return arg; } - private void _finish() throws IOException { - if(size == FINISHED) return; - + private void generateCode(ConstantPool cp) { + try { + _generateCode(cp); + } catch(IOException e) { + throw new Error("should never happen"); + } + } + + private void _generateCode(ConstantPool cp) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutput o = new DataOutputStream(baos); int[] pc = new int[size]; int[] maxpc = pc; - int p,i; + int p, i; // Pass1 - Calculate maximum pc of each bytecode, widen some insns, resolve any unresolved jumps, etc - for(i=0,p=0;i 255) { + this.op[i] = WIDE; + this.arg[i] = new Wide(op, arg); + p += 4; + continue; + } + break; + } + case IINC: { + Pair pair = (Pair) this.arg[i]; + if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) { + this.op[i] = WIDE; + this.arg[i] = new Wide(IINC, pair.i1, pair.i2); + p += 6; + continue; + } break; } case LDC: - j = ((CPGen.Ent)arg[i]).getIndex(); - if(j >= 256) this.op[i] = op = LDC_W; - // fall through - default: - if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here"); - p += 1 + j; + j = cp.getIndex(cparg[i]); + if(j >= 256) { + this.op[i] = op = LDC_W; + p += 3; + continue; + } break; + default: } + if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here " + Integer.toString(op&0xff,16)); + p += 1 + j; } // Pass2 - Widen instructions if they can possibly be too short @@ -344,7 +774,7 @@ public class MethodGen implements CGConst { } // Pass3 - Calculate actual pc - for(i=0,p=0;i= 65536) throw new ClassFile.Exn("method too large in size"); + o.writeShort(maxStack); o.writeShort(maxLocals); o.writeInt(codeSize); @@ -380,8 +814,7 @@ public class MethodGen implements CGConst { byte op = this.op[i]; int opdata = OP_DATA[op&0xff]; if(op == NOP && !EMIT_NOPS) continue; - - o.writeByte(op&0xff); + o.writeByte(op); int argLength = opdata & OP_ARG_LENGTH_MASK; if(argLength == 0) continue; // skip if no args @@ -392,9 +825,10 @@ public class MethodGen implements CGConst { switch(op) { case IINC: { Pair pair = (Pair) arg; - if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassGen.Exn("overflow of iinc arg"); + if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassFile.Exn("overflow of iinc arg"); o.writeByte(pair.i1); o.writeByte(pair.i2); + break; } case TABLESWITCH: case LOOKUPSWITCH: { @@ -417,16 +851,38 @@ public class MethodGen implements CGConst { } break; } - case WIDE: - throw new Error("WIDE instruction not yet supported"); - + case WIDE: { + Wide wide = (Wide) arg; + o.writeByte(wide.op); + o.writeShort(wide.varNum); + if(wide.op == IINC) o.writeShort(wide.n); + break; + } + case MULTIANEWARRAY: { + o.writeShort(cp.getIndex(cparg[i])); + int v = ((MultiANewArray) arg).dims; + if(v >= 256) throw new ClassFile.Exn("overflow of dimensions in multianewarray"); + o.writeByte(v); + break; + } + case INVOKEINTERFACE: + o.writeShort(cp.getIndex(cparg[i])); + o.writeByte(((Type.Class.Method)arg).argTypes.length + 1); + o.writeByte(0); + break; default: if((opdata & OP_BRANCH_FLAG) != 0) { int v = pc[((Integer)arg).intValue()] - pc[i]; - if(v < -32768 || v > 32767) throw new ClassGen.Exn("overflow of s2 offset"); - o.writeShort(v); + if(argLength == 2) { + if(v < -32768 || v > 32767) throw new ClassFile.Exn("overflow of s2 offset"); + o.writeShort(v); + } else if(argLength == 4) { + o.writeInt(v); + } else { + throw new Error("should never happen"); + } } else if((opdata & OP_CPENT_FLAG) != 0) { - int v = ((CPGen.Ent)arg).getIndex(); + int v = cp.getIndex(cparg[i]); if(argLength == 1) o.writeByte(v); else if(argLength == 2) o.writeShort(v); else throw new Error("should never happen"); @@ -435,10 +891,10 @@ public class MethodGen implements CGConst { } else { int iarg = ((Integer)arg).intValue(); if(argLength == 1) { - if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option"); + if((opdata & OP_UNSIGNED_FLAG) != 0 ? iarg >= 256 : (iarg < -128 || iarg >= 128)) throw new ClassFile.Exn("overflow of s/u1 option"); o.writeByte(iarg); } else if(argLength == 2) { - if(iarg < -32768 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option"); + if((opdata & OP_UNSIGNED_FLAG) != 0 ? iarg >= 65536 : (iarg < -32768 || iarg >= 32768)) throw new ClassFile.Exn("overflow of s/u2 option"); o.writeShort(iarg); } else { throw new Error("should never happen"); @@ -451,34 +907,40 @@ public class MethodGen implements CGConst { //if(baos.size() - 8 != codeSize) throw new Error("we didn't output what we were supposed to"); o.writeShort(exnTable.size()); - for(Enumeration e = exnTable.keys();e.hasMoreElements();) - ((ExnTableEnt)exnTable.get(e.nextElement())).dump(o,pc,codeSize); - - o.writeShort(codeAttrs.size()); - codeAttrs.dump(o); + for(i=0;i 0) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + DataOutputStream o = new DataOutputStream(baos); + o.writeShort(thrownExceptions.size()); + for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();) + o.writeShort(cp.getIndex(thrownExceptions.get(e.nextElement()))); + baos.close(); + attrs.put("Exceptions", baos.toByteArray()); + } } + + void dump(DataOutput o, ConstantPool cp) throws IOException { + if((flags & (NATIVE|ABSTRACT))==0) generateCode(cp); + generateExceptions(cp); - public void dump(DataOutput o) throws IOException { o.writeShort(flags); - o.writeShort(cp.getUtf8Index(name)); - o.writeShort(cp.getUtf8Index(getDescriptor())); - o.writeShort(attrs.size()); - attrs.dump(o); + o.writeShort(cp.getUtf8Index(method.name)); + o.writeShort(cp.getUtf8Index(method.getDescriptor())); + attrs.dump(o,cp); } + /** Negates the IF* instruction, op (IF_ICMPGT -> IF_ICMPLE, IFNE -> IFEQ, etc) + @exception IllegalArgumentException if op isn't an IF* instruction */ public static byte negate(byte op) { switch(op) { case IFEQ: return IFNE; @@ -501,6 +963,8 @@ public class MethodGen implements CGConst { } } + /** Class that represents a target that isn't currently know. The target MUST be set with setTarget() before the classfile is written. + This class is more or less a mutable integer */ public static class PhantomTarget { private int target = -1; public void setTarget(int target) { this.target = target; } @@ -515,30 +979,32 @@ public class MethodGen implements CGConst { private static final int OP_BRANCH_FLAG = 1<<3; private static final int OP_CPENT_FLAG = 1<<4; - private static final int OP_VALID_FLAG = 1<<5; + private static final int OP_UNSIGNED_FLAG = 1<<5; + private static final int OP_VALID_FLAG = 1<<6; private static final int OP_ARG_LENGTH_MASK = 7; private static final boolean OP_VALID(byte op) { return (OP_DATA[op&0xff] & OP_VALID_FLAG) != 0; } private static final int OP_ARG_LENGTH(byte op) { return (OP_DATA[op&0xff]&OP_ARG_LENGTH_MASK); } private static final boolean OP_CPENT(byte op) { return (OP_DATA[op&0xff]&OP_CPENT_FLAG) != 0; } private static final boolean OP_BRANCH(byte op) { return (OP_DATA[op&0xff]&OP_BRANCH_FLAG ) != 0; } + private static final boolean OP_UNSIGNED(byte op) { return (OP_DATA[op&0xff]&OP_UNSIGNED_FLAG ) != 0; } // Run perl -x src/org/ibex/classgen/CGConst.java to generate this private static final byte[] OP_DATA = { - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x21, 0x22, 0x31, 0x32, 0x32, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, - 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x21, 0x27, 0x27, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x01, 0x32, 0x21, 0x32, 0x20, 0x20, - 0x32, 0x32, 0x20, 0x20, 0x27, 0x23, 0x2a, 0x2a, 0x2c, 0x2c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x41, 0x42, 0x51, 0x52, 0x52, 0x61, 0x61, 0x61, 0x61, 0x61, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x61, 0x61, 0x61, 0x61, 0x61, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x42, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, + 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x41, 0x47, 0x47, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x54, 0x01, 0x52, 0x41, 0x52, 0x40, 0x40, + 0x52, 0x52, 0x40, 0x40, 0x47, 0x53, 0x4a, 0x4a, 0x4c, 0x4c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }; }