X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FMethodGen.java;h=7816f8af8071fb39a0746c3d1ab033a7e045f7de;hb=b0c281117174062552c6470cc78b565163748a4d;hp=0fc86066298e47146232b5920db5e474e9f2309f;hpb=cb973f6697bbb6245407311e6092b16410679ed7;p=org.ibex.classgen.git
diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java
index 0fc8606..7816f8a 100644
--- a/src/org/ibex/classgen/MethodGen.java
+++ b/src/org/ibex/classgen/MethodGen.java
@@ -3,6 +3,10 @@ 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 = false;
@@ -47,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 {
@@ -68,10 +73,20 @@ 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));
}
@@ -93,9 +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; }
// 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 +123,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; }
+ /** 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); }
-
- 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)
+ /** 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) {
@@ -138,6 +193,7 @@ public class MethodGen implements CGConst {
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) {
@@ -153,8 +209,10 @@ public class MethodGen implements CGConst {
case ASTORE: base = ASTORE_0; break;
}
op = (byte)((base&0xff) + n);
+ } else if(n >= 256) {
+ arg = new Wide(op,n);
+ op = WIDE;
} else {
- if(n >= maxLocals) maxLocals = n + 1;
arg = N(n);
}
break;
@@ -166,6 +224,9 @@ public class MethodGen implements CGConst {
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:
@@ -173,6 +234,20 @@ public class MethodGen implements CGConst {
// set(int,byte,int) always handles these ops itself
set(pos,op,((Integer)arg).intValue());
return;
+ case RET:
+ if(((Integer)arg).intValue() > 255) {
+ op = WIDE;
+ arg = new Wide(RET,((Integer)arg).intValue());
+ }
+ break;
+ case IINC: {
+ Pair pair = (Pair) arg;
+ if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) {
+ op = WIDE;
+ arg = new Wide(IINC,pair.i1,pair.i2);
+ }
+ break;
+ }
case LDC:
// set(int,byte,int) always handles these opts itself
if(arg instanceof Integer) { set(pos,op,((Integer)arg).intValue()); return; }
@@ -199,6 +274,10 @@ public class MethodGen implements CGConst {
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;
@@ -214,6 +293,7 @@ public class MethodGen implements CGConst {
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;
@@ -226,6 +306,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) {
@@ -235,15 +316,31 @@ 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; }
}
+
+ 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; }
+ /** 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();
@@ -294,9 +391,12 @@ public class MethodGen implements CGConst {
switch(op) {
case GOTO:
- case JSR:
- p += 3;
+ case JSR: {
+ int arg = ((Integer)this.arg[i]).intValue();
+ if(arg < i && p - maxpc[arg] <= 32768) p += 3;
+ else p += 5;
break;
+ }
case NOP:
if(EMIT_NOPS) p++;
break;
@@ -317,6 +417,9 @@ public class MethodGen implements CGConst {
}
break;
}
+ case WIDE:
+ p += 2 + (((Wide)arg[i]).op == IINC ? 4 : 2);
+ break;
case LDC:
j = ((CPGen.Ent)arg[i]).getIndex();
if(j >= 256) this.op[i] = op = LDC_W;
@@ -360,6 +463,9 @@ public class MethodGen implements CGConst {
else p += 4 + si.size() * 4 * 2; // count, key,val * targets
break;
}
+ case WIDE:
+ p += 2 + (((Wide)arg[i]).op == IINC ? 4 : 2);
+ break;
default: {
int l = OP_DATA[op&0xff] & OP_ARG_LENGTH_MASK;
if(l == 7) throw new Error("shouldn't be here");
@@ -367,7 +473,6 @@ public class MethodGen implements CGConst {
}
}
}
-
int codeSize = p;
if(codeSize >= 65536) throw new ClassGen.Exn("method too large in size");
@@ -381,8 +486,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
@@ -419,8 +523,13 @@ 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;
+ }
default:
if((opdata & OP_BRANCH_FLAG) != 0) {
@@ -479,7 +588,7 @@ public class MethodGen implements CGConst {
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()));
@@ -487,6 +596,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;
@@ -509,6 +620,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; }