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=383ed57e865b1b1b53a8580b6fe1ebd74b4ecca5;hb=69b2d27ebab56f1b0e4df2a3a301f4d852439e8e;hpb=94cebd4c12247ae7fd0a4b0cc66609fead0efece

diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java
index 383ed57..ba055bf 100644
--- a/src/org/ibex/classgen/MethodGen.java
+++ b/src/org/ibex/classgen/MethodGen.java
@@ -3,23 +3,22 @@ package org.ibex.classgen;
 import java.io.*;
 import java.util.*;
 
-// FEATURE: Support WIDE bytecodes
-
 /** A class representing a method in a generated classfile
-    @see ClassGen#addMethod */
+    @see ClassFile#addMethod */
 public class MethodGen implements CGConst {
     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 ClassGen.AttrGen attrs;
-    private final ClassGen.AttrGen codeAttrs;
+    private final ClassFile.AttrGen attrs;
+    private final ClassFile.AttrGen codeAttrs;
     private final Hashtable exnTable = new Hashtable();
     private final Hashtable thrownExceptions = new Hashtable();
     
@@ -31,7 +30,41 @@ public class MethodGen implements CGConst {
     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, "<init>"); return sb.toString(); }
+    public void   toString(StringBuffer sb, String constructorName) {
+        sb.append(ClassFile.flagsToString(flags));
+        sb.append(ret);
+        sb.append(" ");
+
+        if (name.equals("<clinit>")) sb.append("static ");
+        else {
+            if (name.equals("<init>")) sb.append(constructorName);
+            else sb.append(name);
+            sb.append("(");
+            for(int i=0; i<args.length; i++)
+                sb.append((i==0?"":", ")+args[i]);
+            sb.append(") ");
+        }
+        sb.append("{");
+        sb.append("}");
+        // FIXME: attrs, body
+    }
+
+    MethodGen(CPGen cp, DataInput in, ClassFile owner) throws IOException {
+        this.cp = cp;
+        this.owner = owner;
+        flags = in.readShort();
+        name = cp.getUtf8ByIndex(in.readShort());
+        String descriptor = cp.getUtf8ByIndex(in.readShort());
+        String ret = descriptor.substring(descriptor.indexOf(')')+1);
+        this.ret = Type.instance(ret);
+        //String args = descriptor.substring(1, descriptor.indexOf(')'));
+        args = new Type[0]; // FIXME
+        codeAttrs = null;
+        attrs = new ClassFile.AttrGen(cp, in);
+    }
+
+    MethodGen(ClassFile owner, String name, Type ret, Type[] args, int flags) {
         if((flags & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED|ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE|ACC_ABSTRACT|ACC_STRICT)) != 0)
             throw new IllegalArgumentException("invalid flags");
         this.cp = owner.cp;
@@ -39,21 +72,19 @@ public class MethodGen implements CGConst {
         this.ret = ret;
         this.args = args;
         this.flags = flags;
+        this.owner = owner;
         
-        attrs = new ClassGen.AttrGen(cp);
-        codeAttrs = new ClassGen.AttrGen(cp);
+        attrs = new ClassFile.AttrGen(cp);
+        codeAttrs = new ClassFile.AttrGen(cp);
         
         cp.addUtf8(name);
-        cp.addUtf8(getDescriptor());
+        cp.addUtf8(owner.getType().method(name, ret, args).getDescriptor());
         
         if((owner.flags & ACC_INTERFACE) != 0 || (flags & (ACC_ABSTRACT|ACC_NATIVE)) != 0) size = capacity = -1;
         
-        maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0,4);
+        maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0, 4);
     }
     
-    /** Returns the descriptor string for this method */
-    public String getDescriptor() { return MethodRef.getDescriptor(ret,args); }
-    
     private class ExnTableEnt {
         public int start;
         public int end;
@@ -69,26 +100,26 @@ public class MethodGen implements CGConst {
             o.writeShort(pc[start]);
             o.writeShort(end==pc.length ? endPC : pc[end]);
             o.writeShort(pc[handler]);
-            o.writeShort(typeEnt.getIndex());
+            o.writeShort(cp.getIndex(typeEnt));
         }
     }
     
-    /** Adds an exception handler for the range [<i>start</i>,<i>end</i>) pointing to <i>handler</i>
+    /** Adds an exception handler for the range [<i>start</i>, <i>end</i>) pointing to <i>handler</i>
         @param start The instruction to start at (inclusive)
         @param end The instruction to end at (exclusive)
         @param handler The instruction of the excepton handler
         @param type The type of exception that is to be handled (MUST inherit from Throwable)
     */
-    public final void addExceptionHandler(int start, int end, int handler, Type.Object type) {
-        exnTable.put(type, new ExnTableEnt(start,end,handler,cp.add(type)));
+    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.Object type) {
-        thrownExceptions.put(type,cp.add(type));
+    public final void addThrow(Type.Class type) {
+        thrownExceptions.put(type, cp.add(type));
     }
     
     private final void grow() { if(size == capacity) grow(size+1); }
@@ -96,14 +127,14 @@ public class MethodGen implements CGConst {
         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;
@@ -129,17 +160,17 @@ public class MethodGen implements CGConst {
     /** Adds a bytecode, <i>op</i>, with argument <i>arg</i> 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);
+    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)
+        @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
+    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)
+        @see #add(byte, Object)
     */
-    public final int add(byte op, int 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++; }
     
     /** Gets the bytecode at position <i>pos</i>
         @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
@@ -154,24 +185,24 @@ public class MethodGen implements CGConst {
     */    
     public final Object getArg(int pos) { return arg[pos]; }
     
-    /** Sets the argument for <i>pos</i> to <i>arg</i>. This is equivalent to set(pos,op,new Integer(arg)), but optimized to prevent the allocation when possible.
+    /** Sets the argument for <i>pos</i> to <i>arg</i>. 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)); }
+        @see #setArg(int, Object) */
+    public final void setArg(int pos, int arg) { set(pos, op[pos], N(arg)); }
     /** Sets the argument for <i>pos</i> to <i>arg</i>.
         @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size()
     */
-    public final void setArg(int pos, Object arg) { set(pos,op[pos],arg); }
+    public final void setArg(int pos, Object arg) { set(pos, op[pos], arg); }
     
     /** Sets the bytecode and argument  at <i>pos</i> to <i>op</i> and <i>arg</i> respectivly. 
-        This is equivalent to set(pos,op,arg?1:0) 
+        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); }
+    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)
+    // 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 <i>pos</i> to <i>op</i> and <i>n</i> respectivly.
-        This is equivalent to set(pos,op, new Integer(n)), but optimized to prevent the allocation when possible.
+        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) {
@@ -193,6 +224,7 @@ public class MethodGen implements CGConst {
                 break;
             case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD:
             case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE:
+                if(n >= maxLocals) maxLocals = n + 1;
                 if(n >= 0 && n <= 3) {
                     byte base = 0;
                     switch(op) {
@@ -209,12 +241,11 @@ public class MethodGen implements CGConst {
                     }
                     op = (byte)((base&0xff) + n);
                 } else {
-                    if(n >= maxLocals) maxLocals = n + 1;
                     arg = N(n);
                 }
                 break;
             default:
-                set(pos,op,N(n));
+                set(pos, op, N(n));
                 return;
         }            
         this.op[pos] = op;
@@ -228,13 +259,13 @@ public class MethodGen implements CGConst {
         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());
+                // 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; }
+                // 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();
@@ -244,13 +275,15 @@ public class MethodGen implements CGConst {
                 
                 if(arg instanceof Long || arg instanceof Double) op = LDC2_W;
                 break;
-            case INVOKEINTERFACE:
-                if(arg instanceof MethodRef) arg = new MethodRef.I((MethodRef)arg);
+            case INVOKEINTERFACE: {
                 break;
+            }
         }
         int opdata = OP_DATA[op&0xff];
-        if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent))
-            arg = cp.add(arg);
+        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;
@@ -261,7 +294,7 @@ public class MethodGen implements CGConst {
         @see MethodGen.TSI
         @see MethodGen.LSI
     */
-    public static class SI {
+    public static abstract class SI {
         public final Object[] targets;
         public Object defaultTarget;
 
@@ -273,7 +306,9 @@ public class MethodGen implements CGConst {
         public int size() { return targets.length; }
         
         public int getTarget(int pos) { return ((Integer)targets[pos]).intValue(); }
-        public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); }        
+        public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); }   
+        
+        abstract int length();
     }
     
     /** This class represents the arguments to the TABLESWITCH bytecode */
@@ -285,8 +320,10 @@ public class MethodGen implements CGConst {
             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); }
+        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
     }
     
     /** This class represents the arguments to the LOOKUPSWITCH bytecode */
@@ -297,6 +334,8 @@ public class MethodGen implements CGConst {
            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. */
@@ -305,6 +344,14 @@ public class MethodGen implements CGConst {
         public int i2;
         public Pair(int i1, int i2) { this.i1 = i1; this.i2 = i2; }
     }
+    
+    public static class Wide {
+        public final byte op;
+        public final int varNum;
+        public final int n;
+        Wide(byte op, int varNum) { this(op, varNum, 0); }
+        Wide(byte op, int varNum, int n) { this.op = op; this.varNum = varNum; this.n = n; }
+    }
         
     /** Sets the maximum number of locals in the function to <i>maxLocals</i>. 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 */
@@ -341,15 +388,17 @@ public class MethodGen implements CGConst {
     private void _finish() throws IOException {
         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, widen some insns, resolve any unresolved jumps, etc
-        for(i=0,p=0;i<size;i++) {
+        for(i=0, p=0;i<size;i++) {
             byte op = this.op[i];
             int opdata = OP_DATA[op&0xff];
             int j;
@@ -365,39 +414,59 @@ public class MethodGen implements CGConst {
             }
             
             switch(op) {
+                // Speical caculations
                 case GOTO:
-                case JSR:
-                    p += 3;
-                    break;
+                case JSR: {
+                    int arg = ((Integer)this.arg[i]).intValue();
+                    if(arg < i && p - maxpc[arg] <= 32768) p += 3; 
+                    else p += 5;
+                    continue;
+                }
                 case NOP:
                     if(EMIT_NOPS) p++;
-                    break;
+                    continue;
                 case LOOKUPSWITCH:
                 case TABLESWITCH: {
                     SI si = (SI) arg[i];
                     Object[] targets = si.targets;
                     for(j=0;j<targets.length;j++) targets[j] = resolveTarget(targets[j]);
                     si.defaultTarget = resolveTarget(si.defaultTarget);
-                    p += 1 + 3 + 4; // opcode itself, padding, default
-                    if(op == TABLESWITCH) p += 4 + 4 + targets.length * 4; // lo, hi, targets
-                    else p += 4 + targets.length * 4 * 2; // count, key,val * targets
-                    if(op == LOOKUPSWITCH) {
+                    p += 1 + 3 + si.length(); // opcode itself, padding, data
+                    if(op == LOOKUPSWITCH) { // verify sanity of lookupswitch vals
                         int[] vals = ((LSI)si).vals;
                         for(j=1;j<vals.length;j++)
                             if(vals[j] <= vals[j-1])
                                 throw new IllegalStateException("out of order/duplicate lookupswitch values");
                     }
+                    continue;
+                }
+                // May need widening
+                case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD:
+                case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE:
+                case RET: {
+                    int arg = ((Integer)this.arg[i]).intValue();
+                    if(arg > 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 = ((CPGen.Ent)arg[i]).getIndex();
+                    j = cp.getIndex((CPGen.Ent)arg[i]);
                     if(j >= 256) this.op[i] = op = LDC_W;
-                    // fall through
-                default:
-                    if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here");
-                    p += 1 + j;
                     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
@@ -415,7 +484,7 @@ public class MethodGen implements CGConst {
         }
         
         // Pass3 - Calculate actual pc
-        for(i=0,p=0;i<size;i++) {
+        for(i=0, p=0;i<size;i++) {
             byte op = this.op[i];
             pc[i] = p;
             switch(op) {
@@ -429,9 +498,12 @@ public class MethodGen implements CGConst {
                     p = (p + 3) & ~3; // padding
                     p += 4; // default
                     if(op == TABLESWITCH) p += 4 + 4 + si.size() * 4; // lo, hi, targets
-                    else p += 4 + si.size() * 4 * 2; // count, key,val * targets
+                    else p += 4 + si.size() * 4 * 2; // count, key, val * targets
                     break;
                 }
+                case WIDE:
+                    p += 2 + (((Wide)arg[i]).op == IINC ? 4 : 2);
+                    break;                
                 default: {
                     int l = OP_DATA[op&0xff] & OP_ARG_LENGTH_MASK;
                     if(l == 7) throw new Error("shouldn't be here");
@@ -439,10 +511,9 @@ public class MethodGen implements CGConst {
                 }
             }
         }
-        
         int codeSize = p;
         
-        if(codeSize >= 65536) throw new ClassGen.Exn("method too large in size");
+        if(codeSize >= 65536) throw new ClassFile.Exn("method too large in size");
         
         o.writeShort(maxStack);
         o.writeShort(maxLocals);
@@ -453,8 +524,7 @@ public class MethodGen implements CGConst {
             byte op = this.op[i];
             int opdata = OP_DATA[op&0xff];
             if(op == NOP && !EMIT_NOPS) continue;
-            
-            o.writeByte(op&0xff);
+            o.writeByte(op);
             int argLength = opdata & OP_ARG_LENGTH_MASK;
             
             if(argLength == 0) continue; // skip if no args
@@ -465,7 +535,7 @@ public class MethodGen implements CGConst {
             switch(op) {
                 case IINC: {
                     Pair pair = (Pair) arg;
-                    if(pair.i1 > 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassGen.Exn("overflow of iinc 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;
@@ -491,14 +561,19 @@ public class MethodGen implements CGConst {
                     }
                     break;
                 }
-                case WIDE:
-                    throw new Error("WIDE instruction not yet supported");
+                case WIDE: {
+                    Wide wide = (Wide) arg;
+                    o.writeByte(wide.op);
+                    o.writeShort(wide.varNum);
+                    if(wide.op == IINC) o.writeShort(wide.n);
+                    break;
+                }
                     
                 default:
                     if((opdata & OP_BRANCH_FLAG) != 0) {
                         int v = pc[((Integer)arg).intValue()] - pc[i];
                         if(argLength == 2) {
-                            if(v < -32768 || v > 32767) throw new ClassGen.Exn("overflow of s2 offset");
+                            if(v < -32768 || v > 32767) throw new ClassFile.Exn("overflow of s2 offset");
                             o.writeShort(v);
                         } else if(argLength == 4) {
                             o.writeInt(v);
@@ -506,7 +581,7 @@ public class MethodGen implements CGConst {
                             throw new Error("should never happen");
                         }
                     } else if((opdata & OP_CPENT_FLAG) != 0) {
-                        int v = ((CPGen.Ent)arg).getIndex();
+                        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");
@@ -515,10 +590,10 @@ public class MethodGen implements CGConst {
                     } else {
                         int iarg  = ((Integer)arg).intValue();
                         if(argLength == 1) {
-                            if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option");
+                            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 ClassGen.Exn("overflow of s/u2 option"); 
+                            if(iarg < -32768 || iarg >= 65536) throw new ClassFile.Exn("overflow of s/u2 option"); 
                             o.writeShort(iarg);
                         } else {
                             throw new Error("should never happen");
@@ -532,7 +607,7 @@ public class MethodGen implements CGConst {
         
         o.writeShort(exnTable.size());
         for(Enumeration e = exnTable.keys();e.hasMoreElements();)
-            ((ExnTableEnt)exnTable.get(e.nextElement())).dump(o,pc,codeSize);
+            ((ExnTableEnt)exnTable.get(e.nextElement())).dump(o, pc, codeSize);
         
         o.writeShort(codeAttrs.size());
         codeAttrs.dump(o);
@@ -540,13 +615,13 @@ public class MethodGen implements CGConst {
         baos.close();
         
         byte[] codeAttribute = baos.toByteArray();
-        attrs.add("Code",codeAttribute);
+        attrs.add("Code", codeAttribute);
         
         baos.reset();
         o.writeShort(thrownExceptions.size());
         for(Enumeration e = thrownExceptions.keys();e.hasMoreElements();)
-            o.writeShort(((CPGen.Ent)thrownExceptions.get(e.nextElement())).getIndex());
-        attrs.add("Exceptions",baos.toByteArray());
+            o.writeShort(cp.getIndex((CPGen.Ent)thrownExceptions.get(e.nextElement())));
+        attrs.add("Exceptions", baos.toByteArray());
         
         size = capacity = FINISHED;        
     }
@@ -554,7 +629,7 @@ public class MethodGen implements CGConst {
     void dump(DataOutput o) throws IOException {
         o.writeShort(flags);
         o.writeShort(cp.getUtf8Index(name));
-        o.writeShort(cp.getUtf8Index(getDescriptor()));
+        o.writeShort(cp.getUtf8Index(owner.getType().method(name, ret, args).getDescriptor()));
         o.writeShort(attrs.size());
         attrs.dump(o);
     }