src/org/ibex/classgen/JSSA.java

   1 package org.ibex.classgen;
   2 import java.io.*;
   3 import java.util.*;
   4
   5 /**
   6  *  a highly streamlined SSA-form intermediate representation of a
   7  *  sequence of JVM instructions; all stack manipulation is factored
   8  *  out.
   9  */
  10 public class JSSA extends MethodGen implements CGConst {
  11
  12     // Constructor //////////////////////////////////////////////////////////////////////////////
  13
  14     public JSSA(Type.Class c, DataInput in, ConstantPool cp) throws IOException {
  15         super(c, in, cp);
  16         for(int i=0; i<this.method.getNumArgs(); i++)
  17             local[i] = new Argument("arg"+i, this.method.getArgType(i));
  18         for(int i=0; i<size(); i++) {
  19             int    op  = get(i);
  20             Object arg = getArg(i);
  21             Object o = addOp(op, arg);
  22             if (o != null) {
  23                 ops[numOps] = o;
  24                 ofs[numOps++] = i;
  25             }
  26         }
  27     }
  28
  29     public void debugBodyToString(StringBuffer sb) {
  30         StringBuffer sb0 = new StringBuffer();
  31         super.debugBodyToString(sb0);
  32         StringTokenizer st = new StringTokenizer(sb0.toString(), "\n");
  33         String[] lines = new String[st.countTokens()];
  34         for(int i=0; i<lines.length; i++) lines[i] = st.nextToken();
  35         for(int j=0; j<ofs[0]; j++) {
  36             String s = "    /* " + lines[j].trim();
  37             while(s.length() < 50) s += " ";
  38             s += " */";
  39             sb.append(s);
  40             sb.append("\n");
  41         }
  42         for(int i=0; i<numOps; i++) {
  43             String s = "    /* " + lines[ofs[i]].trim();
  44             while(s.length() < 50) s += " ";
  45             s += " */  ";
  46             s += ops[i].toString();
  47             sb.append(s);
  48             sb.append(";\n");
  49             for(int j=ofs[i]+1; j<(i==numOps-1?size():ofs[i+1]); j++) {
  50                 s = "    /* " + lines[j].trim();
  51                 while(s.length() < 50) s += " ";
  52                 s += " */";
  53                 sb.append(s);
  54                 sb.append("\n");
  55             }
  56         }
  57     }
  58
  59     private Object[] ops = new Object[65535];
  60     private int[] ofs = new int[65535];
  61     private int numOps = 0;
  62
  63     // Instance Data; used ONLY during constructor; then thrown away /////////////////////////////////////////////////
  64
  65     /** this models the JVM locals; it is only used for unwinding stack-ops into an SSA-tree, then thrown away */
  66     private Expr[] local = new Expr[6];
  67
  68     /** this models the JVM stack; it is only used for unwinding stack-ops into an SSA-tree, then thrown away */
  69     private Expr[] stack = new Expr[65535];
  70
  71     /** JVM stack pointer */
  72     private int sp = 0;
  73
  74     private Expr push(Expr e) { return stack[sp++] = e; }
  75     private Expr pop()        { return stack[--sp]; }
  76
  77
  78     // SSA-node classes /////////////////////////////////////////////////////////////////////////////////////////
  79
  80     /** an purely imperative operation which does not generate data */
  81     public abstract class Op {
  82         //public abstract Op[] predecessors();  // not implemented yet
  83         //public abstract Op[] successors();    // not implemented yet
  84         public String toString() { return name(); }
  85         String name() {
  86             String name = this.getClass().getName();
  87             if (name.indexOf('$') != -1) name = name.substring(name.lastIndexOf('$')+1);
  88             if (name.indexOf('.') != -1) name = name.substring(name.lastIndexOf('.')+1);
  89             return name;
  90         }
  91     }
  92
  93     /** an operation which generates data */
  94     public abstract class Expr extends Op {
  95         //public abstract Expr[] contributors();  // not implemented yet
  96         //public abstract Expr[] dependents();    // not implemented yet
  97
  98         /** every JSSA.Expr either remembers its type _OR_ knows how to figure it out (the latter is preferred to eliminate
  99          *  redundant information that could possibly "disagree" with itself -- this happened a LOT in Soot) */
 100         public abstract Type getType();
 101     }
 102
 103     /**
 104      *  A "nondeterministic merge" -- for example when the first instruction in a loop reads from a local which could have been
 105      *  written to either by some instruction at the end of the previous iteration of the loop or by some instruction before
 106      *  the loop (on the first iteration).
 107      */
 108     public class Phi extends Expr {
 109         private final Expr[] inputs;
 110         public Phi(Expr[] inputs) {
 111             this.inputs = new Expr[inputs.length];
 112             System.arraycopy(inputs, 0, this.inputs, 0, inputs.length);
 113         }
 114         public Type getType() {
 115             // sanity check
 116             Type t = inputs[0].getType();
 117
 118             // FIXME: actually this should check type-unifiability... fe, the "type of null" unifies with any Type.Ref
 119             for(int i=1; i<inputs.length; i++)
 120                 if (inputs[i].getType() != t)
 121                     throw new Error("Phi node with disagreeing types!  Crisis!");
 122             return t;
 123         }
 124     }
 125
 126     public class Argument extends Expr {
 127         public final String name;
 128         public final Type t;
 129         public Argument(String name, Type t) { this.name = name; this.t = t; }
 130         public String toString() { return name; }
 131         public Type getType() { return t; }
 132     }
 133
 134     // Binary Operations //////////////////////////////////////////////////////////////////////////////
 135
 136     public abstract class BinExpr extends Expr {
 137         public final Expr e1;
 138         public final Expr e2;
 139         public BinExpr(Expr e1, Expr e2) { this.e1 = e1; this.e2 = e2; }
 140         public String toString() {
 141             return name() + "("+e1+", "+e2+")";
 142         }
 143     }
 144
 145     public class Comparison extends BinExpr {
 146         public Comparison(Expr e1, Expr e2) { super(e1, e2); }
 147         public Type getType() { return Type.BOOLEAN; }
 148     }
 149     public class Gt extends Comparison { public Gt(Expr e1, Expr e2) { super(e1, e2); } }
 150     public class Lt extends Comparison { public Lt(Expr e1, Expr e2) { super(e1, e2); } }
 151     public class Eq extends Comparison { public Eq(Expr e1, Expr e2) { super(e1, e2); } }
 152     public class Not extends Expr {
 153         public final Expr e;
 154         public Not(Expr e) { this.e = e; }
 155         public Type getType() { return Type.BOOLEAN; }
 156     }
 157
 158     // Math Operations //////////////////////////////////////////////////////////////////////////////
 159
 160     public class Math extends BinExpr {
 161         private final String show;
 162         public Math(Expr e1, Expr e2, String show) { super(e2, e1); this.show = show; }
 163         public String toString() { return e1+" "+show+" "+e2; }
 164         public Type getType() {
 165             Type t = e1.getType();
 166             if (t != e2.getType()) throw new Error("types disagree");
 167             return t;
 168         }
 169     }
 170     public class Add  extends Math { public  Add(Expr e, Expr e2) { super(e, e2, "+"); } }
 171     public class Sub  extends Math { public  Sub(Expr e, Expr e2) { super(e, e2, "-"); } }
 172     public class Mul  extends Math { public  Mul(Expr e, Expr e2) { super(e, e2, "*"); } }
 173     public class Rem  extends Math { public  Rem(Expr e, Expr e2) { super(e, e2, "%"); } }
 174     //public class Neg  extends Math { public  Neg(Expr e) { super(e, "-"); } }
 175     public class Div  extends Math { public  Div(Expr e, Expr e2) { super(e, e2, "/"); } }
 176     public class Shl  extends Math { public  Shl(Expr e, Expr e2) { super(e, e2, "<<"); } }
 177     public class Shr  extends Math { public  Shr(Expr e, Expr e2) { super(e, e2, ">>"); } }
 178     public class Ushr extends Math { public Ushr(Expr e, Expr e2) { super(e, e2, ">>>"); } }
 179     public class And  extends Math { public  And(Expr e, Expr e2) { super(e, e2, "&"); } }
 180     public class Or   extends Math { public   Or(Expr e, Expr e2) { super(e, e2, "|"); } }
 181     public class Xor  extends Math { public  Xor(Expr e, Expr e2) { super(e, e2, "^"); } }
 182
 183     // Other operations //////////////////////////////////////////////////////////////////////////////
 184
 185     public class Cast extends Expr {
 186         final Expr e;
 187         final Type t;
 188         public Cast(Expr e, Type t) { this.e = e; this.t = t; }
 189         public Type getType() { return t; }
 190     }
 191
 192     public class InstanceOf extends Expr {
 193         final Expr e;
 194         final Type t;
 195         public InstanceOf(Expr e, Type t) { this.e = e; this.t = t; }
 196         public Type getType() { return Type.BOOLEAN; }
 197     }
 198
 199     public class Throw extends Op {
 200         public final Expr e;
 201         public Throw(Expr e) { this.e = e; }
 202     }
 203
 204     public class Branch extends Op {
 205         public Branch(Expr condition, Object destination) { }
 206         public Branch(Label destination) { }
 207         public Branch(MethodGen.Switch s) { }
 208         public Branch() { }
 209     }
 210     public class Goto extends Branch { }
 211     public class RET extends Branch { }
 212     public class JSR extends Branch { public JSR(Label l) { super(l); } }
 213     public class If extends Branch { }
 214
 215     /** represents a "returnaddr" pushed onto the stack */
 216     public class Label extends Expr {
 217         public final Op op;
 218         public Type getType() { throw new Error("attempted to call getType() on a Label"); }
 219         public Label(Op op) { this.op = op; }
 220         public Label(int i) { this.op = null; /* FIXME */ }
 221     }
 222
 223     public class New extends Expr {
 224         public final Type.Class t;
 225         public Type getType() { return t; }
 226         public New(Type.Class t) { this.t = t; }
 227     }
 228
 229     public class NewArray extends Expr {
 230         public final Type.Array t;
 231         public final Expr[] dims;
 232         public NewArray(Type.Array t, Expr[] dims) { this.t = t; this.dims = dims; }
 233         public NewArray(Type.Array t, Expr dim) { this(t,new Expr[]{dim}); }
 234         public Type getType() { return t; }
 235     }
 236
 237     // FEATURE: Array stuff
 238
 239     public class Return extends Op {
 240         final Expr e;
 241         public Return() { this(null); }
 242         public Return(Expr e) { this.e = e; }
 243         public String toString() { return e==null?"return":("return "+e.toString()); }
 244     }
 245
 246     /** GETFIELD and GETSTATIC */
 247     public class Get extends Expr {
 248         final Type.Class.Field f;
 249         final Expr e;
 250         public Type getType() { return f.getType(); }
 251         public Get(Type.Class.Field f) { this(f, null); }
 252         public Get(Type.Class.Field f, Expr e) { this.f = f; this.e = e; }
 253         public String toString() {
 254             return
 255                 (e!=null
 256                  ? e+"."+f.name
 257                  : f.getDeclaringClass() == JSSA.this.method.getDeclaringClass()
 258                  ? f.name
 259                  : f.toString());
 260         }
 261     }
 262
 263     /** PUTFIELD and PUTSTATIC */
 264     public class Put extends Op {
 265         final Type.Class.Field f;
 266         final Expr v;
 267         final Expr e;
 268         public Put(Type.Class.Field f, Expr v) { this(f, v, null); }
 269         public Put(Type.Class.Field f, Expr v, Expr e) { this.f = f; this.v = v; this.e = e; }
 270         public String toString() {
 271             return
 272                 (e!=null
 273                  ? e+"."+f.name
 274                  : f.getDeclaringClass() == JSSA.this.method.getDeclaringClass()
 275                  ? f.name
 276                  : f.toString()) + " = " + v;
 277         }
 278     }
 279
 280     public class ArrayPut extends Op {
 281         final Expr e, i, v;
 282         public ArrayPut(Expr e, Expr i, Expr v) { this.e = e; this.i = i; this.v = v; }
 283     }
 284
 285     public class ArrayGet extends Expr {
 286         final Expr e, i;
 287         public ArrayGet(Expr e, Expr i) { this.e = e; this.i = i; }
 288         public Type getType() { return e.getType().asArray().getElementType(); }
 289     }
 290
 291     public class ArrayLength extends Expr {
 292         final Expr e;
 293         public ArrayLength(Expr e) { this.e = e; }
 294         public Type getType() { return Type.INT; }
 295     }
 296
 297     public abstract class Invoke extends Expr {
 298         public final Expr[] arguments;
 299         public final Type.Class.Method method;
 300         protected Invoke(Type.Class.Method m, Expr[] a) { this.arguments = a; this.method = m; }
 301
 302         public Type getType() { return method.getReturnType(); }
 303         protected void args(StringBuffer sb) {
 304             sb.append("(");
 305             for(int i=0; i<arguments.length; i++) {
 306                 if (i>0) sb.append(", ");
 307                 sb.append(arguments[i]+"");
 308             }
 309             sb.append(")");
 310         }
 311
 312         public String toString() {
 313             StringBuffer sb = new StringBuffer();
 314             sb.append(method.getDeclaringClass() == JSSA.this.method.getDeclaringClass()
 315                       ? method.name
 316                       : (method.getDeclaringClass() + "." + method.name));
 317             args(sb);
 318             return sb.toString();
 319         }
 320     }
 321     public class InvokeStatic    extends Invoke  { public InvokeStatic(Type.Class.Method m, Expr[] a) { super(m,a); } }
 322     public class InvokeSpecial   extends InvokeVirtual {
 323         public InvokeSpecial(Type.Class.Method m, Expr[] a, Expr e) { super(m,a,e); }
 324         public String toString() {
 325             StringBuffer sb = new StringBuffer();
 326             sb.append(method.name.equals("<init>") ? "super" : method.name);
 327             args(sb);
 328             return sb.toString();
 329         }
 330     }
 331     public class InvokeInterface extends InvokeVirtual{public InvokeInterface(Type.Class.Method m, Expr[] a, Expr e){super(m,a,e);}}
 332     public class InvokeVirtual   extends Invoke  {
 333         public final Expr instance;
 334         public InvokeVirtual(Type.Class.Method m, Expr[] a, Expr e) { super(m, a); instance = e; }
 335         public String toString() {
 336             StringBuffer sb = new StringBuffer();
 337             sb.append(method.name);
 338             args(sb);
 339             return sb.toString();
 340         }
 341     }
 342
 343     public class Constant extends Expr {
 344         private final Object o;
 345         public Constant(int i) { this(new Integer(i)); }
 346         public Constant(Object o) { this.o = o; }
 347         public String toString() { return o.toString(); }
 348         public Type getType() {
 349             if (o instanceof Byte) return Type.BYTE;
 350             if (o instanceof Short) return Type.SHORT;
 351             if (o instanceof Character) return Type.CHAR;
 352             if (o instanceof Boolean) return Type.BOOLEAN;
 353             if (o instanceof Long) return Type.LONG;
 354             if (o instanceof Double) return Type.DOUBLE;
 355             if (o instanceof Float) return Type.FLOAT;
 356             if (o instanceof ConstantPool.Ent) throw new Error("unimplemented");
 357             throw new Error("this should not happen");
 358         }
 359     }
 360
 361
 362     // Implementation //////////////////////////////////////////////////////////////////////////////
 363
 364     private Object addOp(int op, Object arg) {
 365         int i1 = 0;
 366         int i2 = 0;
 367         if (op==WIDE) {
 368             MethodGen.Wide w = (MethodGen.Wide)arg;
 369             op = w.op;
 370             arg = null;
 371             i1 = w.varNum;
 372             i2 = w.n;
 373         }
 374         if (op==IINC) {
 375             MethodGen.Pair p = (MethodGen.Pair)arg;
 376             arg = null;
 377             i1 = p.i1;
 378             i2 = p.i2;
 379         }
 380         switch(op) {
 381
 382             case NOP: return null;
 383
 384                 // Stack manipulations //////////////////////////////////////////////////////////////////////////////
 385
 386             case ACONST_NULL:                                                      return stack[sp++] = new Constant(null);
 387             case ICONST_M1:                                                        return stack[sp++] = new Constant(-1);
 388             case ICONST_0: case LCONST_0: case FCONST_0: case DCONST_0:            push(new Constant(0)); return null;
 389             case ICONST_1: case LCONST_1: case FCONST_1: case DCONST_1:            push(new Constant(1)); return null;
 390             case ICONST_2: case FCONST_2:                                          push(new Constant(2)); return null;
 391             case ICONST_3:                                                         push(new Constant(3)); return null;
 392             case ICONST_4:                                                         push(new Constant(4)); return null;
 393             case ICONST_5:                                                         push(new Constant(5)); return null;
 394             case ILOAD:    case LLOAD:    case FLOAD:    case DLOAD:    case ALOAD:    return push(local[i1]);
 395             case ILOAD_0:  case LLOAD_0:  case FLOAD_0:  case DLOAD_0:  case ALOAD_0:  return push(local[0]);
 396             case ILOAD_1:  case LLOAD_1:  case FLOAD_1:  case DLOAD_1:  case ALOAD_1:  return push(local[1]);
 397             case ALOAD_2:  case DLOAD_2:  case FLOAD_2:  case LLOAD_2:  case ILOAD_2:  return push(local[2]);
 398             case ILOAD_3:  case LLOAD_3:  case FLOAD_3:  case DLOAD_3:  case ALOAD_3:  return push(local[3]);
 399             case ISTORE:   case LSTORE:   case FSTORE:   case DSTORE:   case ASTORE:   local[i1] = pop(); return null;
 400             case ISTORE_0: case LSTORE_0: case FSTORE_0: case DSTORE_0: case ASTORE_0: local[0]  = pop(); return null;
 401             case ISTORE_1: case LSTORE_1: case FSTORE_1: case DSTORE_1: case ASTORE_1: local[1]  = pop(); return null;
 402             case ASTORE_2: case DSTORE_2: case FSTORE_2: case LSTORE_2: case ISTORE_2: local[2]  = pop(); return null;
 403             case ISTORE_3: case LSTORE_3: case FSTORE_3: case DSTORE_3: case ASTORE_3: local[3]  = pop(); return null;
 404             case POP:      stack[--sp] = null;
 405             case POP2:     stack[--sp] = null; stack[--sp] = null;   /** fixme: pops a WORD, not an item */
 406             case DUP:      stack[sp] = stack[sp-1]; sp++;
 407             case DUP2:     stack[sp] = stack[sp-2]; stack[sp+1] = stack[sp-1]; sp+=2;
 408
 409                 // Conversions //////////////////////////////////////////////////////////////////////////////
 410
 411                 // coercions are added as-needed when converting from JSSA back to bytecode, so we can
 412                 // simply discard them here (assuming the bytecode we're reading in was valid in the first place)
 413
 414             case I2L: case F2L: case D2L:               push(new Cast(pop(), Type.LONG)); return null;
 415             case I2F: case L2F: case D2F:               push(new Cast(pop(), Type.FLOAT)); return null;
 416             case I2D: case L2D: case F2D:               push(new Cast(pop(), Type.DOUBLE)); return null;
 417             case L2I: case F2I: case D2I:               push(new Cast(pop(), Type.INT)); return null;
 418             case I2B:                                   push(new Cast(pop(), Type.BYTE)); return null;
 419             case I2C:                                   push(new Cast(pop(), Type.CHAR)); return null;
 420             case I2S:                                   push(new Cast(pop(), Type.SHORT)); return null;
 421             case SWAP:                                  { Expr e1 = pop(), e2 = pop(); push(e2);  push(e1); return null; }
 422
 423                 // Math //////////////////////////////////////////////////////////////////////////////
 424
 425             case IADD: case LADD: case FADD: case DADD: push(new Add(pop(), pop())); return null;
 426             case ISUB: case LSUB: case FSUB: case DSUB: push(new Sub(pop(), pop())); return null;
 427             case IMUL: case LMUL: case FMUL: case DMUL: push(new Mul(pop(), pop())); return null;
 428             case IREM: case LREM: case FREM: case DREM: push(new Rem(pop(), pop())); return null;
 429                 //case INEG: case LNEG: case FNEG: case DNEG: push(new Neg(pop())); return null;
 430             case IDIV: case LDIV: case FDIV: case DDIV: push(new Div(pop(), pop())); return null;
 431             case ISHL: case LSHL:                       push(new Shl(pop(), pop())); return null;
 432             case ISHR: case LSHR:                       push(new Shr(pop(), pop())); return null;
 433             case IUSHR: case LUSHR:                     push(new Ushr(pop(), pop())); return null;
 434             case IAND: case LAND:                       push(new And(pop(), pop())); return null;
 435             case IOR:  case LOR:                        push(new Or(pop(), pop())); return null;
 436             case IXOR: case LXOR:                       push(new Xor(pop(), pop())); return null;
 437             case IINC:                                  return local[i1] = new Add(local[i1], new Constant(i2));
 438
 439                 // Control and branching //////////////////////////////////////////////////////////////////////////////
 440
 441             case IFNULL:                                return new Branch(new Eq(pop(), new Constant(null)), new Label(i1));
 442             case IFNONNULL:                             return new Branch(new Not(new Eq(pop(),new Constant(null))),new Label(i1));
 443             case IFEQ:                                  return new Branch(    new Eq(new Constant(0), pop()),  arg);
 444             case IFNE:                                  return new Branch(new Not(new Eq(new Constant(0), pop())), arg);
 445             case IFLT:                                  return new Branch(    new Lt(new Constant(0), pop()),  arg);
 446             case IFGE:                                  return new Branch(new Not(new Lt(new Constant(0), pop())), arg);
 447             case IFGT:                                  return new Branch(    new Gt(new Constant(0), pop()),  arg);
 448             case IFLE:                                  return new Branch(new Not(new Gt(new Constant(0), pop())), arg);
 449             case IF_ICMPEQ:                             return new Branch(    new Eq(pop(), pop()),  arg);
 450             case IF_ICMPNE:                             return new Branch(new Not(new Eq(pop(), pop())), arg);
 451             case IF_ICMPLT:                             return new Branch(    new Lt(pop(), pop()),  arg);
 452             case IF_ICMPGE:                             return new Branch(new Not(new Lt(pop(), pop())), arg);
 453             case IF_ICMPGT:                             return new Branch(    new Gt(pop(), pop()),  arg);
 454             case IF_ICMPLE:                             return new Branch(new Not(new Gt(pop(), pop())), arg);
 455             case IF_ACMPEQ:                             return new Branch(    new Eq(pop(), pop()),  arg);
 456             case IF_ACMPNE:                             return new Branch(new Not(new Eq(pop(), pop())), arg);
 457             case ATHROW:                                return new Throw(pop());
 458             case GOTO:                                  return new Branch(new Label(i1));
 459             case JSR:                                   return new JSR(new Label(i1));
 460             case RET:                                   return new RET();
 461             case RETURN:                                return new Return();
 462             case IRETURN: case LRETURN: case FRETURN: case DRETURN: case ARETURN:
 463                 return new Return(pop());
 464
 465                 // Array manipulations //////////////////////////////////////////////////////////////////////////////
 466
 467             case IALOAD:  case LALOAD:  case FALOAD:  case DALOAD:  case AALOAD:
 468             case BALOAD:  case CALOAD:  case SALOAD:                                  push(new ArrayGet(pop(), pop())); return null;
 469             case IASTORE: case LASTORE: case FASTORE: case DASTORE: case AASTORE:
 470             case BASTORE: case CASTORE: case SASTORE:                                 return new ArrayPut(pop(), pop(), pop());
 471
 472                 // Invocation //////////////////////////////////////////////////////////////////////////////
 473
 474             case INVOKEVIRTUAL: case INVOKESPECIAL: case INVOKESTATIC: case INVOKEINTERFACE: {
 475                 Type.Class.Method method = (Type.Class.Method)arg;
 476                 Expr args[] = new Expr[method.getNumArgs()];
 477                 for(int i=0; i<args.length; i++) args[args.length-i-1] = pop();
 478                 switch(op) {
 479                     case INVOKEVIRTUAL:   return push(new InvokeVirtual(method, args, pop()));
 480                     case INVOKEINTERFACE: return push(new InvokeInterface(method, args, pop()));
 481                     case INVOKESPECIAL:   return push(new InvokeSpecial(method, args, pop()));
 482                     case INVOKESTATIC:    return push(new InvokeStatic(method, args));
 483                 }
 484             }
 485
 486                 // Field Access //////////////////////////////////////////////////////////////////////////////
 487
 488             case GETSTATIC:         push(new Get((Type.Class.Field)arg, null)); return null;
 489             case PUTSTATIC:         return new Put((Type.Class.Field)arg, pop(), null);
 490             case GETFIELD:          push(new Get((Type.Class.Field)arg, pop())); return null;
 491             case PUTFIELD:          return new Put((Type.Class.Field)arg, pop(), pop());
 492
 493                 // Allocation //////////////////////////////////////////////////////////////////////////////
 494
 495             case NEW:               push(new New((Type.Class)arg)); return null;
 496             case NEWARRAY: {
 497                 Type base;
 498                 switch(((Integer)arg).intValue()) {
 499                     case 4: base = Type.BOOLEAN; break;
 500                     case 5: base = Type.CHAR; break;
 501                     case 6: base = Type.FLOAT; break;
 502                     case 7: base = Type.DOUBLE; break;
 503                     case 8: base = Type.BYTE; break;
 504                     case 9: base = Type.SHORT; break;
 505                     case 10: base = Type.INT; break;
 506                     case 11: base = Type.LONG; break;
 507                     default: throw new IllegalStateException("invalid array type");
 508                 }
 509                 push(new NewArray(base.makeArray(),pop()));
 510                 return null;
 511             }
 512             case ANEWARRAY:         push(new NewArray(((Type.Ref)arg).makeArray(), pop())); return null;
 513             case MULTIANEWARRAY: {
 514                 MethodGen.MultiANewArray mana = (MethodGen.MultiANewArray) arg;
 515                 Expr[] dims = new Expr[mana.dims];
 516                 for(int i=0;i<dims.length;i++) dims[i] = pop();
 517                 push(new NewArray(mana.type, dims));
 518                 return null;
 519             }
 520             case ARRAYLENGTH:       push(new ArrayLength(pop())); return null;
 521
 522                 // Runtime Type information //////////////////////////////////////////////////////////////////////////////
 523
 524             case CHECKCAST:         push(new Cast(pop(), (Type)arg)); return null;
 525             case INSTANCEOF:        push(new InstanceOf(pop(), (Type)arg)); return null;
 526
 527             case LDC: case LDC_W: case LDC2_W: push(new Constant(arg)); return null;
 528
 529             case BIPUSH:    push(new Constant(i1));  // FIXME return null;
 530             case SIPUSH:    push(new Constant(i1));  // FIXME return null;
 531
 532             case TABLESWITCH:    new Branch((MethodGen.Switch)arg);
 533             case LOOKUPSWITCH:   new Branch((MethodGen.Switch)arg);
 534
 535                 /*
 536             case MONITORENTER:   Op.monitorEnter(pop());
 537             case MONITOREXIT:    Op.monitorExit(pop());
 538                 */
 539
 540             case DUP_X1:         throw new Error("unimplemented");
 541             case DUP_X2:         throw new Error("unimplemented");
 542             case DUP2_X1:         throw new Error("unimplemented");
 543             case DUP2_X2:         throw new Error("unimplemented");
 544             case LCMP:         throw new Error("unimplemented");
 545             case FCMPL:         throw new Error("unimplemented");
 546             case FCMPG:         throw new Error("unimplemented");
 547             case DCMPL:         throw new Error("unimplemented");
 548             case DCMPG:         throw new Error("unimplemented");
 549             case GOTO_W:         throw new Error("unimplemented");
 550             case JSR_W:         throw new Error("unimplemented");
 551             default:          throw new Error("unhandled");
 552         }
 553     }
 554
 555     public static void main(String[] args) throws Exception {
 556         InputStream is = Class.forName(args[0]).getClassLoader().getResourceAsStream(args[0].replace('.', '/')+".class");
 557         System.out.println(new ClassFile(new DataInputStream(is), true).toString());
 558     }
 559 }