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 extends Type.Class.Method.Body { private final static boolean EMIT_NOPS = false; private static final int NO_CODE = -1; public final Type.Class.Method method; private final ClassFile.AttrGen codeAttrs; private final Vector exnTable = new Vector(); private final Hashtable thrownExceptions = new Hashtable(); int maxStack = 16; int maxLocals; private int size; private int capacity; private byte[] op; private Object[] arg; private ConstantPool.Ent[] cparg; public void insertBlank(int idx) { for(int i=0;i= idx) si.setDefaultTarget(pos+1); for(int j=0;j= idx) si.setTarget(j, pos+1); } break; } default: if (OP_BRANCH(op[i])) { int pos = ((Integer)arg[i]).intValue(); if (pos >= idx) arg[i] = N(pos+1); } break; } } size++; for(int i=size; i>idx; i--) { op[i] = op[i-1]; arg[i] = arg[i-1]; cparg = null; } } // Constructors ////////////////////////////////////////////////////////////////////////////// MethodGen(Type.Class.Method method, int flags) { method.super(flags, new ClassFile.AttrGen()); this.method = method; codeAttrs = new ClassFile.AttrGen(); if (!isConcrete()) size = capacity = -1; maxLocals = Math.max(method.getNumArgs() + (flags&STATIC)==0 ? 1 : 0, 4); } MethodGen(Type.Class c, DataInput in, ConstantPool cp) throws IOException { this(in.readShort(), cp.getUtf8KeyByIndex(in.readShort()), c, in, cp); } private MethodGen(short flags, String name, Type.Class c, DataInput in, ConstantPool cp) throws IOException { this(flags, name, c.method(name,cp.getUtf8KeyByIndex(in.readShort())), c, in, cp); } private MethodGen(short flags, String name, Type.Class.Method m, Type.Class c, DataInput in, ConstantPool cp) throws IOException { m.super(flags, new ClassFile.AttrGen(in,cp)); this.method = m; if (isConcrete()) { byte[] codeAttr = (byte[]) attrs.get("Code"); if (codeAttr == null) throw new ClassFile.ClassReadExn("code attr expected"); DataInputStream ci = new DataInputStream(new ByteArrayInputStream(codeAttr)); maxStack = ci.readUnsignedShort(); maxLocals = ci.readUnsignedShort(); int codeLen = ci.readInt(); int[] bytecodeMap = parseCode(ci,codeLen,cp); int numExns = ci.readUnsignedShort(); while(numExns-- > 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); } } } // Parsing ////////////////////////////////////////////////////////////////////////////// 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.type = type; } 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(type == null ? 0 : cp.getIndex(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)); } /** 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 (newCap <= capacity) return; newCap = Math.max(newCap, capacity == 0 ? 256 : capacity*2); byte[] op2 = new byte[newCap]; 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); arg = arg2; capacity = newCap; } // Accessors ////////////////////////////////////////////////////////////////////////////// public int getFlags() { return flags; } public Hashtable getThrownExceptions() { return thrownExceptions; } /** 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(); 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; } /** 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 = 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) { 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 || 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; } break; } if ((OP_DATA[op&0xff]&OP_VALID_FLAG) == 0) throw new IllegalArgumentException("unknown bytecode"); this.op[pos] = op; this.arg[pos] = arg; } /** 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; } // Bytecode-Specific inner classes //////////////////////////////////////////////////////////////////////////////// public static abstract class Switch { public final Object[] targets; public Object defaultTarget; Switch(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 int getTarget(int pos) { return ((Integer)targets[pos]).intValue(); } public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } abstract int length(); public static class Table extends Switch { public final int lo; public final int hi; public Table(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); } int length() { return 12 + targets.length * 4; } // 4bytes/target, hi, lo, default } public static class Lookup extends Switch { public final int[] vals; public Lookup(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 } } /** 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.Array type; public int dims; public MultiANewArray(Type.Array 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; } } // Emitting Bits ////////////////////////////////////////////////////////////////////////////// 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 " + target + "/" + size); return arg; } /** 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.getTypeDescriptor()); 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 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 = 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 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(codeSize); // Pass 4 - Actually write the bytecodes for(i=0;i 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: { Switch si = (Switch) 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 = ((Switch.Lookup)si).vals; o.writeInt(si.size()); for(int j=0;j= 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 (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 = cp.getIndex(cparg[i]); 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 = (arg instanceof Type.Primitive) ? ((Type.Primitive)arg).toArraySpec() : ((Integer)arg).intValue(); if (argLength == 1) { 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 ((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"); } } break; } } //if (baos.size() - 8 != codeSize) throw new Error("we didn't output what we were supposed to"); o.writeShort(exnTable.size()); 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); o.writeShort(flags); o.writeShort(cp.getUtf8Index(method.name)); o.writeShort(cp.getUtf8Index(method.getTypeDescriptor())); attrs.dump(o,cp); } /** 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_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 = { 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 }; // Debugging ////////////////////////////////////////////////////////////////////////////// public void debugBodyToString(StringBuffer sb) { // 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", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" }; for(int i=0;iop (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; 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 IllegalArgumentException("Can't negate " + Integer.toHexString(op)); } } }