projects / org.ibex.classgen.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cp cleanup, setsourcefile
[org.ibex.classgen.git] / src / org / ibex / classgen / MethodGen.java
diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java
index b193e59..b82567e 100644 (file)
--- a/src/org/ibex/classgen/MethodGen.java
+++ b/src/org/ibex/classgen/MethodGen.java
@@ -11,8 +11,8 @@ public class MethodGen implements CGConst {
     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 +33,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());
@@ -75,6 +75,7 @@ public class MethodGen implements CGConst {
     
     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(newCap <= capacity) return;
         newCap = Math.max(newCap,capacity == 0 ? 256 : capacity*2);
         
@@ -90,21 +91,26 @@ public class MethodGen implements CGConst {
     }
     public final int size() { return size; }
     
-    // FEATURE: Deprecate this
-    public final int addPushConst(int n) { return add(LDC,n); }
-
-    public final int add(byte op, Object arg) { grow(); set(size,op,arg); return size++; }
-    public final int add(byte op, boolean arg) { grow(); set(size,op,arg); return size++; }
-    public final int add(byte op, int arg) { grow(); set(size,op,arg); return size++; }
-    public final int add(byte op) { grow(); set(size,op); return size++; }
+    // These two are optimized for speed, they don't call set() below
+    public final int add(byte op) {
+        int s = size;
+        if(s == capacity) grow();
+        this.op[s] = op;
+        size++;
+        return s;
+    }
+    public final void set(int pos, byte op) { this.op[pos] = op; }
         
+    public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
+    public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
+    public final int add(byte op, int arg) { if(capacity == size) grow(); set(size,op,arg); return size++; }
+    
     public final byte get(int pos) { return op[pos]; }
     public final Object getArg(int pos) { return arg[pos]; }
     
     public final void setArg(int pos, int arg) { set(pos,op[pos],N(arg)); }
     public final void setArg(int pos, Object arg) { set(pos,op[pos],arg); }
     
-    public final void set(int pos, byte op) { set(pos,op,null); }
     
     public final void set(int pos, byte op, boolean b) { set(pos,op,b?1:0); }
     public final void set(int pos, byte op, int n) {
@@ -118,23 +124,25 @@ public class MethodGen implements CGConst {
                 case 4:  set(pos,ICONST_4);  return;
                 case 5:  set(pos,ICONST_5);  return;
             }
-            if(n >= -128 && n <= 127) set(pos,BIPUSH,N(n)); 
-            else if(n >= -32767 && n <= 32767) set(pos,SIPUSH,N(n));
-            else set(pos,LDC,cp.add(N(n)));
+            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));
         }
     }
     
-    private void set(int pos, byte op, Object arg) {
-        int iarg = arg instanceof Integer ? ((Integer)arg).intValue() : -1;
-        
+    public 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:
             {
+                int iarg = ((Integer)arg).intValue();
                 if(iarg >= 0 && iarg <= 3) {
-                    int base = -1;
+                    byte base = 0;
                     switch(op) {
                         case ILOAD:  base = ILOAD_0; break;
                         case ISTORE: base = ISTORE_0; break;
@@ -147,13 +155,14 @@ public class MethodGen implements CGConst {
                         case ALOAD:  base = ALOAD_0; break;
                         case ASTORE: base = ASTORE_0; break;
                     }
-                    op = (byte)(base + iarg);
+                    op = (byte)((base&0xff) + iarg);
                 } else {
-                    if(iarg > maxLocals) maxLocals = iarg;
+                    if(iarg >= maxLocals) maxLocals = iarg + 1;
                 }
+                break;
             }
             case LDC:
-                if(arg instanceof Integer) { set(pos,op,iarg); return; }
+                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();
@@ -163,18 +172,15 @@ public class MethodGen implements CGConst {
                 
                 if(arg instanceof Long || arg instanceof Double) op = LDC2_W;
                 // fall through
-            default:
-                if(OP_CPENT(op) && !(arg instanceof CPGen.Ent)) arg = cp.add(arg);
+            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;
+            }
         }
-        _set(pos,op,arg);
-    }
-    
-    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");
-        if(!OP_VALID(op)) throw new IllegalArgumentException("unknown bytecode");
-        
         this.op[pos] = op;
         this.arg[pos] = arg;
     }
@@ -260,10 +266,11 @@ public class MethodGen implements CGConst {
         // Pass1 - Calculate maximum pc of each bytecode, widen some insns, resolve any unresolved jumps, etc
         for(i=0,p=0;i<size;i++) {
             byte op = this.op[i];
+            int opdata = OP_DATA[op&0xff];
             int j;
             maxpc[i] = p;
             
-            if(OP_BRANCH(op)) { 
+            if((opdata & OP_BRANCH_FLAG)!= 0) { 
                 try { 
                     arg[i] = resolveTarget(arg[i]);
                 } catch(RuntimeException e) {
@@ -296,7 +303,7 @@ public class MethodGen implements CGConst {
                     if(j >= 256) this.op[i] = op = LDC_W;
                     // fall through
                 default:
-                    if((j = OP_ARG_SIZE(op)) == -1) throw new Error("shouldn't be here");
+                    if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here");
                     p += 1 + j;
                     break;
             }
@@ -335,8 +342,8 @@ public class MethodGen implements CGConst {
                     break;
                 }
                 default: {
-                    int l = OP_ARG_SIZE(op);
-                    if(l == -1) throw new Error("shouldn't be here");
+                    int l = OP_DATA[op&0xff] & OP_ARG_LENGTH_MASK;
+                    if(l == 7) throw new Error("shouldn't be here");
                     p += 1 + l;                    
                 }
             }
@@ -351,17 +358,16 @@ public class MethodGen implements CGConst {
         // Pass 4 - Actually write the bytecodes
         for(i=0;i<size;i++) {
             byte op = this.op[i];
+            int opdata = OP_DATA[op&0xff];
             if(op == NOP && !EMIT_NOPS) continue;
             
             o.writeByte(op&0xff);
-            int argLength = OP_ARG_SIZE(op);
+            int argLength = opdata & OP_ARG_LENGTH_MASK;
             
             if(argLength == 0) continue; // skip if no args
             
             // Write args
             Object arg = this.arg[i];  
-            boolean wasInt = arg instanceof Integer;
-            int iarg = wasInt ? ((Integer)arg).intValue() : -1;
             
             switch(op) {
                 case IINC: {
@@ -393,11 +399,11 @@ public class MethodGen implements CGConst {
                 }
                     
                 default:
-                    if(OP_BRANCH(op)) {
-                        int v = pc[iarg] - pc[i];
+                    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);
-                    } else if(OP_CPENT(op)) {
+                    } 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);
@@ -405,7 +411,7 @@ public class MethodGen implements CGConst {
                     } else if(argLength == -1) {
                         throw new Error("should never happen - variable length instruction not explicitly handled");
                     } else {
-                        if(!wasInt) throw new IllegalStateException("Invalid argument given for " + Integer.toHexString(op&0xff));
+                        int iarg  = ((Integer)arg).intValue();
                         if(argLength == 1) {
                             if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option");
                             o.writeByte(iarg);
@@ -420,7 +426,7 @@ public class MethodGen implements CGConst {
             }
         }
 
-        if(baos.size() - 8 != codeSize) throw new Error("we didn't output what we were supposed to");
+        //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();)
@@ -485,28 +491,32 @@ public class MethodGen implements CGConst {
     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 boolean OP_VALID(byte op) { return (OP_DATA[op&0xff] & 1) != 0; }
-    private static final int OP_ARG_SIZE(byte op) { int n = ((OP_DATA[op&0xff]>>1)&3); return n == 7 ? -1 : n; }
-    private static final boolean OP_CPENT(byte op) { return (OP_DATA[op&0xff]&(1<<4)) != 0; }
-    private static final boolean OP_BRANCH(byte op) { return (OP_DATA[op&0xff]&(1<<5)) != 0; }
+    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 = {
-            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-            0x03, 0x05, 0x13, 0x15, 0x15, 0x03, 0x03, 0x03, 0x03, 0x03, 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, 0x13, 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,
+            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, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
-            0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x03, 0x0f, 0x0f, 0x01, 0x01, 0x01, 0x01,
-            0x01, 0x01, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x02, 0x15, 0x03, 0x15, 0x01, 0x01,
-            0x15, 0x15, 0x01, 0x01, 0x0f, 0x07, 0x25, 0x25, 0x29, 0x29, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-            0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-            0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-            0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
     };
 }
Unnamed repository; edit this file to name it for gitweb.