X-Git-Url: http://git.megacz.com/?p=org.ibex.classgen.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FMethodGen.java;h=383ed57e865b1b1b53a8580b6fe1ebd74b4ecca5;hp=04b6d5545c8c6288e523395f70c9e2f0d2a9ba8e;hb=94cebd4c12247ae7fd0a4b0cc66609fead0efece;hpb=424a26b0bce440b239eb4977304dd7ed89e37ec8
diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java
index 04b6d55..383ed57 100644
--- a/src/org/ibex/classgen/MethodGen.java
+++ b/src/org/ibex/classgen/MethodGen.java
@@ -3,16 +3,23 @@ package org.ibex.classgen;
import java.io.*;
import java.util.*;
+// FEATURE: Support WIDE bytecodes
+
+/** A class representing a method in a generated classfile
+ @see ClassGen#addMethod */
public class MethodGen implements CGConst {
- private final static boolean EMIT_NOPS = true;
+ 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 int flags;
- private final AttrGen attrs;
- private final AttrGen codeAttrs;
+ private final ClassGen.AttrGen attrs;
+ private final ClassGen.AttrGen codeAttrs;
private final Hashtable exnTable = new Hashtable();
private final Hashtable thrownExceptions = new Hashtable();
@@ -33,8 +40,8 @@ public class MethodGen implements CGConst {
this.args = args;
this.flags = flags;
- attrs = new AttrGen(cp);
- codeAttrs = new AttrGen(cp);
+ attrs = new ClassGen.AttrGen(cp);
+ codeAttrs = new ClassGen.AttrGen(cp);
cp.addUtf8(name);
cp.addUtf8(getDescriptor());
@@ -44,6 +51,7 @@ public class MethodGen implements CGConst {
maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0,4);
}
+ /** Returns the descriptor string for this method */
public String getDescriptor() { return MethodRef.getDescriptor(ret,args); }
private class ExnTableEnt {
@@ -65,17 +73,28 @@ public class MethodGen implements CGConst {
}
}
- 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.Object type) {
+ exnTable.put(type, new ExnTableEnt(start,end,handler,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.Object type) {
thrownExceptions.put(type,cp.add(type));
}
private final void grow() { if(size == capacity) grow(size+1); }
private final void grow(int newCap) {
- if(capacity == -1) throw new IllegalStateException("method can't have code");
+ 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);
@@ -89,12 +108,14 @@ public class MethodGen implements CGConst {
capacity = newCap;
}
+
+ /** Returns the size (in instructions) of this method
+ @return The size of the method (in instructions)
+ */
public final int size() { return size; }
- // FEATURE: Deprecate this
- public final int addPushConst(int n) { return add(LDC,n); }
-
// 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();
@@ -102,92 +123,144 @@ 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; }
+ /** 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]; }
+
+ /** 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); }
+ /** 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); }
- public final void set(int pos, byte op, boolean b) { set(pos,op,b?1:0); }
+ // 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) {
- if(op == LDC) {
- switch(n) {
- case -1: set(pos,ICONST_M1); return;
- case 0: set(pos,ICONST_0); return;
- case 1: set(pos,ICONST_1); return;
- case 2: set(pos,ICONST_2); return;
- case 3: set(pos,ICONST_3); return;
- case 4: set(pos,ICONST_4); return;
- case 5: set(pos,ICONST_5); return;
- }
- Object arg;
- if(n >= -128 && n <= 127) { op = BIPUSH; arg = N(n); }
- else if(n >= -32767 && n <= 32767) { op = SIPUSH; arg = N(n); }
- else { arg = cp.add(N(n)); }
- this.op[pos] = op;
- this.arg[pos] = arg;
- } else {
- set(pos,op,N(n));
- }
- }
-
- public void set(int pos, byte op, Object arg) {
- switch(op) {
+ Object arg = null;
+ OUTER: switch(op) {
+ case LDC:
+ switch(n) {
+ case -1: op = ICONST_M1; break OUTER;
+ case 0: op = ICONST_0; break OUTER;
+ case 1: op = ICONST_1; break OUTER;
+ case 2: op = ICONST_2; break OUTER;
+ case 3: op = ICONST_3; break OUTER;
+ case 4: op = ICONST_4; break OUTER;
+ case 5: op = ICONST_5; break OUTER;
+ }
+ 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)); }
+ break;
case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD:
case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE:
- {
- int iarg = ((Integer)arg).intValue();
- if(iarg >= 0 && iarg <= 3) {
+ if(n >= 0 && n <= 3) {
byte base = 0;
switch(op) {
- case ILOAD: base = ILOAD_0; break;
+ case ILOAD: base = ILOAD_0; break;
case ISTORE: base = ISTORE_0; break;
- case LLOAD: base = LLOAD_0; break;
+ case LLOAD: base = LLOAD_0; break;
case LSTORE: base = LSTORE_0; break;
- case FLOAD: base = FLOAD_0; break;
+ case FLOAD: base = FLOAD_0; break;
case FSTORE: base = FSTORE_0; break;
- case DLOAD: base = DLOAD_0; break;
+ case DLOAD: base = DLOAD_0; break;
case DSTORE: base = DSTORE_0; break;
- case ALOAD: base = ALOAD_0; break;
+ case ALOAD: base = ALOAD_0; break;
case ASTORE: base = ASTORE_0; break;
}
- op = (byte)((base&0xff) + iarg);
+ op = (byte)((base&0xff) + n);
} else {
- if(iarg >= maxLocals) maxLocals = iarg + 1;
+ if(n >= maxLocals) maxLocals = n + 1;
+ arg = N(n);
}
break;
- }
+ default:
+ 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());
+ 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; }
+
if(arg instanceof Long) {
long l = ((Long)arg).longValue();
- if(l == 0L) { set(pos,LCONST_0); return; }
- if(l == 1L) { set(pos,LCONST_1); return; }
+ if(l == 0L) { this.op[pos] = LCONST_0; return; }
+ if(l == 1L) { this.op[pos] = LCONST_1; return; }
}
if(arg instanceof Long || arg instanceof Double) op = LDC2_W;
- // fall through
- default: {
- 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");
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");
this.op[pos] = op;
this.arg[pos] = arg;
}
+ /** This class represents the arguments to the TABLESWITH and LOOKUPSWITCH bytecodes
+ @see MethodGen.TSI
+ @see MethodGen.LSI
+ */
public static class SI {
public final Object[] targets;
public Object defaultTarget;
@@ -200,13 +273,13 @@ 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(); }
}
+ /** 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;
@@ -216,6 +289,7 @@ public class MethodGen implements CGConst {
public void setTargetForVal(int val, int n) { setTarget(val-lo,n); }
}
+ /** This class represents the arguments to the LOOKUPSWITCH bytecode */
public static class LSI extends SI {
public final int[] vals;
public LSI(int size) {
@@ -225,15 +299,23 @@ public class MethodGen implements CGConst {
public final void setVal(int pos, int val) { vals[pos] = val; }
}
+ /** 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; }
}
+ /** 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; }
+ /** 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)
+ */
public void finish() {
try {
_finish();
@@ -257,7 +339,7 @@ public class MethodGen implements CGConst {
}
private void _finish() throws IOException {
- if(size == -1) return;
+ if(size == FINISHED) return;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutput o = new DataOutputStream(baos);
@@ -299,6 +381,12 @@ public class MethodGen implements CGConst {
p += 1 + 3 + 4; // opcode itself, padding, default
if(op == TABLESWITCH) p += 4 + 4 + targets.length * 4; // lo, hi, targets
else p += 4 + targets.length * 4 * 2; // count, key,val * targets
+ if(op == LOOKUPSWITCH) {
+ int[] vals = ((LSI)si).vals;
+ for(j=1;j= 65536) throw new ClassGen.Exn("method too large in size");
+
o.writeShort(maxStack);
o.writeShort(maxLocals);
o.writeInt(codeSize);
@@ -378,6 +468,7 @@ public class MethodGen implements CGConst {
if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassGen.Exn("overflow of iinc arg");
o.writeByte(pair.i1);
o.writeByte(pair.i2);
+ break;
}
case TABLESWITCH:
case LOOKUPSWITCH: {
@@ -400,18 +491,26 @@ public class MethodGen implements CGConst {
}
break;
}
+ case WIDE:
+ throw new Error("WIDE instruction not yet supported");
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 ClassGen.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();
if(argLength == 1) o.writeByte(v);
else if(argLength == 2) o.writeShort(v);
else throw new Error("should never happen");
- } else if(argLength == -1) {
+ } else if(argLength == 7) {
throw new Error("should never happen - variable length instruction not explicitly handled");
} else {
int iarg = ((Integer)arg).intValue();
@@ -419,7 +518,7 @@ public class MethodGen implements CGConst {
if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option");
o.writeByte(iarg);
} else if(argLength == 2) {
- if(iarg < -32767 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option");
+ if(iarg < -32768 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option");
o.writeShort(iarg);
} else {
throw new Error("should never happen");
@@ -449,10 +548,10 @@ public class MethodGen implements CGConst {
o.writeShort(((CPGen.Ent)thrownExceptions.get(e.nextElement())).getIndex());
attrs.add("Exceptions",baos.toByteArray());
- size = -1;
+ size = capacity = FINISHED;
}
- public void dump(DataOutput o) throws IOException {
+ void dump(DataOutput o) throws IOException {
o.writeShort(flags);
o.writeShort(cp.getUtf8Index(name));
o.writeShort(cp.getUtf8Index(getDescriptor()));
@@ -460,6 +559,8 @@ public class MethodGen implements CGConst {
attrs.dump(o);
}
+ /** 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;
@@ -482,6 +583,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; }