X-Git-Url: http://git.megacz.com/?p=org.ibex.classgen.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FMethodGen.java;h=ba055bf78a666d700613bee7257d78adbff18e39;hp=b7cf78a9f8e093a418e3ea8f36e7cff780d7d70a;hb=69b2d27ebab56f1b0e4df2a3a301f4d852439e8e;hpb=cb0bae954e7dd0067e77c436c78ee19ace52d9e3 diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java index b7cf78a..ba055bf 100644 --- a/src/org/ibex/classgen/MethodGen.java +++ b/src/org/ibex/classgen/MethodGen.java @@ -1,30 +1,70 @@ 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 = true; + private final static boolean EMIT_NOPS = false; + private static final int NO_CODE = -1; + private static final int FINISHED = -2; + + private final ClassFile owner; 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 int nameIndex; - private final int descriptorIndex; + private final ClassFile.AttrGen attrs; + private final ClassFile.AttrGen codeAttrs; + private final Hashtable exnTable = new Hashtable(); + private final Hashtable thrownExceptions = new Hashtable(); private int maxStack = 16; - private int maxLocals=1; + private int maxLocals; private int size; private int capacity; private byte[] op; private Object[] arg; - MethodGen(ClassGen owner, String name, Type ret, Type[] args, int flags) { + public String toString() { StringBuffer sb = new StringBuffer(); toString(sb, ""); return sb.toString(); } + public void toString(StringBuffer sb, String constructorName) { + sb.append(ClassFile.flagsToString(flags)); + sb.append(ret); + sb.append(" "); + + if (name.equals("")) sb.append("static "); + else { + if (name.equals("")) sb.append(constructorName); + else sb.append(name); + sb.append("("); + for(int i=0; istart, 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.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.Class 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 == 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; } - public final int addPushConst(int n) { grow(); setPushConst(size,n); return size++; } - public final int addPushConst(long n) { grow(); setPushConst(size,n); return size++; } - public final int addPushConst(float n) { grow(); setPushConst(size,n); return size++; } - public final int addPushConst(double n) { grow(); setPushConst(size,n); return size++; } - public final int addPushConst(Object o) { grow(); setPushConst(size,o); return size++; } - public final int add(byte op, int arg) { return add(op,N(arg)); } - public final int add(byte op, Object arg) { grow(); set(size,op,arg); return size++; } - public final int add(byte op) { return add(op,null); } + // 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(); + this.op[s] = op; + 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 void set(int pos, byte op) { set(pos,op,null); } - public final void set(int pos, byte op, int n) { set(pos,op,N(n)); } + /** 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); } + + // 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) { + 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: + if(n >= maxLocals) maxLocals = n + 1; + if(n >= 0 && n <= 3) { + byte base = 0; + switch(op) { + case ILOAD: base = ILOAD_0; break; + case ISTORE: base = ISTORE_0; break; + case LLOAD: base = LLOAD_0; break; + case LSTORE: base = LSTORE_0; break; + case FLOAD: base = FLOAD_0; break; + case FSTORE: base = FSTORE_0; break; + case DLOAD: base = DLOAD_0; break; + case DSTORE: base = DSTORE_0; break; + case ALOAD: base = ALOAD_0; break; + case ASTORE: base = ASTORE_0; break; + } + op = (byte)((base&0xff) + n); + } else { + 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) { - if(capacity == -1) throw new IllegalStateException("method can't have code"); - if(size == -1) throw new IllegalStateException("method is finalized"); - int iarg = arg instanceof Integer ? ((Integer)arg).intValue() : -1; - switch(op) { - case LDC: if(iarg >= 256) op = LDC_W; break; + 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) { 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; + break; + case INVOKEINTERFACE: { + break; + } + } + int opdata = OP_DATA[op&0xff]; + if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent)) { + if (op==INVOKEINTERFACE) arg = cp.add(arg, true); + else 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 abstract class SI { + public final Object[] targets; + public Object defaultTarget; + + SI(int size) { targets = new Object[size]; } + public void setTarget(int pos, Object val) { targets[pos] = val; } + public void setTarget(int pos, int val) { targets[pos] = N(val); } + public void setDefaultTarget(int val) { setDefaultTarget(N(val)); } + public void setDefaultTarget(Object o) { defaultTarget = o; } + public int size() { return targets.length; } - public final void setPushConst(int pos, int n) { - switch(n) { - case -1: set(pos,ICONST_M1); break; - case 0: set(pos,ICONST_0); break; - case 1: set(pos,ICONST_1); break; - case 2: set(pos,ICONST_2); break; - case 3: set(pos,ICONST_3); break; - case 4: set(pos,ICONST_4); break; - case 5: set(pos,ICONST_5); break; - default: - if(n >= -128 && n <= 127) set(pos,BIPUSH,n); - if(n >= -32767 && n <= 32767) set(pos,SIPUSH,n); - setLDC(pos,N(n)); - break; - } - } - public final void setPushConst(int pos, long l) { - if(l==0) set(pos,LCONST_0); - else if(l==1) set(pos,LCONST_1); - else setLDC(pos,N(l)); + public int getTarget(int pos) { return ((Integer)targets[pos]).intValue(); } + public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } + + abstract int length(); } - public final void setPushConst(int pos, float f) { - if(f == 1.0f) set(pos,FCONST_0); - else if(f == 1.0f) set(pos,FCONST_1); - else if(f == 2.0f) set(pos,FCONST_2); - else setLDC(pos,N(f)); - } - public final void setPushConst(int pos, double d) { - if(d == 1.0) set(pos,DCONST_0); - else if(d == 2.0) set(pos,DCONST_1); - else setLDC(pos,N(d)); - } - public final void setPushConst(int pos, Object o) { - if(o instanceof Integer) setPushConst(pos,((Integer)o).intValue()); - else if(o instanceof Long) setPushConst(pos,((Long)o).longValue()); - else if(o instanceof Float) setPushConst(pos,((Float)o).floatValue()); - else if(o instanceof Double) setPushConst(pos,((Double)o).doubleValue()); - else setLDC(pos,o); - } + /** This class represents the arguments to the TABLESWITCH bytecode */ + public static class TSI extends SI { + public final int lo; + public final int hi; + 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); } - private void setLDC(int pos, Object o) { set(pos,LDC,cp.add(o)); } - - public final CPGen.Ent methodRef(Type.Object c, String name, Type ret, Type[] args) { - return methodRef(c,name,MethodGen.descriptor(ret,args)); + int length() { return 12 + targets.length * 4; } // 4bytes/target, hi, lo, default } - public final CPGen.Ent methodRef(Type.Object c, String name, String descriptor) { - return cp.add(new CPGen.MethodRef(c,new CPGen.NameAndType(name,descriptor))); + + /** This class represents the arguments to the LOOKUPSWITCH bytecode */ + public static class LSI extends SI { + public final int[] vals; + public LSI(int size) { + super(size); + 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 } - public final CPGen.Ent fieldRef(Type.Object c, String name, Type type) { - return fieldRef(c,name,type.getDescriptor()); + + /** 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 final CPGen.Ent fieldRef(Type.Object c, String name, String descriptor) { - return cp.add(new CPGen.FieldRef(c,new CPGen.NameAndType(name,descriptor))); - } + 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(); @@ -159,27 +371,104 @@ public class MethodGen implements CGConst { } } + private Object resolveTarget(Object arg) { + int target; + if(arg instanceof PhantomTarget) { + target = ((PhantomTarget)arg).getTarget(); + if(target == -1) throw new IllegalStateException("unresolved phantom target"); + arg = N(target); + } else { + target = ((Integer)arg).intValue(); + } + if(target < 0 || target >= size) + throw new IllegalStateException("invalid target address"); + return arg; + } + private void _finish() throws IOException { - if(size == -1) return; + if(size == FINISHED) return; + + cp.stable(); 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 - for(i=0,p=0;i 255) { + this.op[i] = WIDE; + this.arg[i] = new Wide(op, arg); + } + 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); + } + break; + } + case LDC: + j = cp.getIndex((CPGen.Ent)arg[i]); + if(j >= 256) this.op[i] = op = LDC_W; + break; + default: } + if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here"); + p += 1 + j; } + // Pass2 - Widen instructions if they can possibly be too short for(i=0;i 32767) op[i] = op[i] == GOTO ? GOTO_W : JSR_W; + break; } } } + // 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(p); + o.writeInt(codeSize); // Pass 4 - Actually write the bytecodes for(i=0;i 255 || pair[1] < -128 || pair[1] > 127) throw new ClassGen.Exn("overflow of iinc arg"); - o.writeByte(pair[0]); - o.writeByte(pair[1]); - continue; + Pair pair = (Pair) 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 IF_ICMPLT: - case GOTO: - case GOTO_W: - case JSR: - case JSR_W: - outArg = pc[iarg] - pc[i]; - if(outArg < -32768 || outArg > 32767) throw new ClassGen.Exn("overflow of s2 offset"); + case TABLESWITCH: + case LOOKUPSWITCH: { + SI si = (SI) arg; + int mypc = pc[i]; + for(p = pc[i]+1;(p&3)!=0;p++) o.writeByte(0); + o.writeInt(pc[si.getDefaultTarget()] - mypc); + if(op == LOOKUPSWITCH) { + int[] vals = ((LSI)si).vals; + o.writeInt(si.size()); + for(int j=0;j 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 = cp.getIndex((CPGen.Ent)arg); + if(argLength == 1) o.writeByte(v); + else if(argLength == 2) o.writeShort(v); + else throw new Error("should never happen"); + } else if(argLength == 7) { + throw new Error("should never happen - variable length instruction not explicitly handled"); + } else { + int iarg = ((Integer)arg).intValue(); + if(argLength == 1) { + if(iarg < -128 || iarg >= 256) throw new ClassFile.Exn("overflow of s/u1 option"); + o.writeByte(iarg); + } else if(argLength == 2) { + if(iarg < -32768 || iarg >= 65536) throw new ClassFile.Exn("overflow of s/u2 option"); + o.writeShort(iarg); + } else { + throw new Error("should never happen"); + } + } break; } - - if(argLength == 1) o.writeByte(outArg); - else if(argLength == 2) o.writeShort(outArg); - else throw new Error("should never happen"); } - o.writeShort(0); // FIXME: Exception table + //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); baos.close(); byte[] codeAttribute = baos.toByteArray(); - attrs.add("Code",codeAttribute); - size = -1; + attrs.add("Code", codeAttribute); + + baos.reset(); + o.writeShort(thrownExceptions.size()); + for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();) + o.writeShort(cp.getIndex((CPGen.Ent)thrownExceptions.get(e.nextElement()))); + attrs.add("Exceptions", baos.toByteArray()); + + size = capacity = FINISHED; } - public void dump(DataOutput o) throws IOException { + void dump(DataOutput o) throws IOException { o.writeShort(flags); - o.writeShort(nameIndex); - o.writeShort(descriptorIndex); + o.writeShort(cp.getUtf8Index(name)); + o.writeShort(cp.getUtf8Index(owner.getType().method(name, ret, args).getDescriptor())); o.writeShort(attrs.size()); attrs.dump(o); } - private static int opArgLength(byte op) { + /** 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 NOP: - case ICONST_M1: - case ICONST_0: - case ICONST_1: - case ICONST_2: - case ICONST_3: - case ICONST_4: - case ICONST_5: - case LCONST_0: - case LCONST_1: - case FCONST_0: - case FCONST_1: - case FCONST_2: - case DCONST_0: - case DCONST_1: - case ILOAD_0: - case ILOAD_1: - case ILOAD_2: - case ILOAD_3: - case ISTORE_0: - case ISTORE_1: - case ISTORE_2: - case ISTORE_3: - case RETURN: - return 0; - case LDC: - case BIPUSH: - case ILOAD: - case ISTORE: - return 1; - case LDC_W: - case SIPUSH: - case GETSTATIC: - case PUTSTATIC: - case GETFIELD: - case PUTFIELD: - case INVOKESTATIC: - case INVOKEVIRTUAL: - case INVOKESPECIAL: - case IINC: - case GOTO: - case JSR: - case IF_ICMPLT: - return 2; + case IFEQ: return IFNE; + case IFNE: return IFEQ; + case IFLT: return IFGE; + case IFGE: return IFLT; + case IFGT: return IFLE; + case IFLE: return IFGT; + case IF_ICMPEQ: return IF_ICMPNE; + case IF_ICMPNE: return IF_ICMPEQ; + case IF_ICMPLT: return IF_ICMPGE; + case IF_ICMPGE: return IF_ICMPLT; + case IF_ICMPGT: return IF_ICMPLE; + case IF_ICMPLE: return IF_ICMPGT; + case IF_ACMPEQ: return IF_ACMPNE; + case IF_ACMPNE: return IF_ACMPEQ; + default: - throw new ClassGen.Exn("unknown bytecode " + Integer.toHexString(op&0xff)); + throw new IllegalArgumentException("Can't negate " + Integer.toHexString(op)); } } - + + /** 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; } + public int getTarget() { return target; } + } + private static Integer N(int n) { return new Integer(n); } private static Long N(long n) { return new Long(n); } private static Float N(float f) { return new Float(f); } private static Double N(double d) { return new Double(d); } private static int max(int a, int b) { return a > b ? a : b; } + + 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_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; } + + // 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 + }; }