Merge pull request #6 from lrytz/newValue

[asm-cherry-pick] Multiple methods for initializing analysis values

Author: lrytz

src/main/java/scala/tools/asm/tree/analysis/Analyzer.java

@@ -158,21 +158,26 @@ public Frame<V>[] analyze(final String owner, final MethodNode m)
         // initializes the data structures for the control flow analysis
         Frame<V> current = newFrame(m.maxLocals, m.maxStack);
         Frame<V> handler = newFrame(m.maxLocals, m.maxStack);
-        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)));
+        current.setReturn(interpreter.newReturnTypeValue(Type.getReturnType(m.desc)));
         Type[] args = Type.getArgumentTypes(m.desc);
         int local = 0;
-        if ((m.access & ACC_STATIC) == 0) {
+        boolean isInstanceMethod = (m.access & ACC_STATIC) == 0;
+        if (isInstanceMethod) {
             Type ctype = Type.getObjectType(owner);
-            current.setLocal(local++, interpreter.newValue(ctype));
+            current.setLocal(local, interpreter.newParameterValue(isInstanceMethod, local, ctype));
+            local++;
         }
         for (int i = 0; i < args.length; ++i) {
-            current.setLocal(local++, interpreter.newValue(args[i]));
+            current.setLocal(local, interpreter.newParameterValue(isInstanceMethod, local, args[i]));
+            local++;
             if (args[i].getSize() == 2) {
-                current.setLocal(local++, interpreter.newValue(null));
+                current.setLocal(local, interpreter.newEmptyValueAfterSize2Local(local));
+                local++;
             }
         }
         while (local < m.maxLocals) {
-            current.setLocal(local++, interpreter.newValue(null));
+            current.setLocal(local, interpreter.newEmptyNonParameterLocalValue(local));
+            local++;
         }
         merge(0, current, null);
 
@@ -285,7 +290,7 @@ public Frame<V>[] analyze(final String owner, final MethodNode m)
                         if (newControlFlowExceptionEdge(insn, tcb)) {
                             handler.init(f);
                             handler.clearStack();
-                            handler.push(interpreter.newValue(type));
+                            handler.push(interpreter.newExceptionValue(tcb, handler, type));
                             merge(jump, handler, subroutine);
                         }
                     }

src/main/java/scala/tools/asm/tree/analysis/Frame.java

@@ -312,12 +312,12 @@ public void execute(final AbstractInsnNode insn,
             var = ((VarInsnNode) insn).var;
             setLocal(var, value1);
             if (value1.getSize() == 2) {
-                setLocal(var + 1, interpreter.newValue(null));
+                setLocal(var + 1, interpreter.newEmptyValueAfterSize2Local(var + 1));
             }
             if (var > 0) {
                 Value local = getLocal(var - 1);
                 if (local != null && local.getSize() == 2) {
-                    setLocal(var - 1, interpreter.newValue(null));
+                    setLocal(var - 1, interpreter.newEmptyValueForPreviousSize2Local(var - 1));
                 }
             }
             break;

src/main/java/scala/tools/asm/tree/analysis/Interpreter.java

@@ -33,6 +33,7 @@
 
 import scala.tools.asm.Type;
 import scala.tools.asm.tree.AbstractInsnNode;
+import scala.tools.asm.tree.TryCatchBlockNode;
 
 /**
  * A semantic bytecode interpreter. More precisely, this interpreter only
@@ -70,6 +71,55 @@ protected Interpreter(final int api) {
      */
     public abstract V newValue(Type type);
 
+    /**
+     * Called by the analyzer for initializing the return type value of a frame.
+     */
+    public V newReturnTypeValue(Type type) {
+        return newValue(type);
+    }
+
+    /**
+     * Called by the analyzer when initializing the value of a parameter in a frame.
+     */
+    public V newParameterValue(boolean isInstanceMethod, int local, Type type) {
+        return newValue(type);
+    }
+
+    /**
+     * Called by the analyzer when initializing a non-parameter local in a frame.
+     * This method has to return a size-1 value representing an empty slot.
+     */
+    public V newEmptyNonParameterLocalValue(int local) {
+        return newValue(null);
+    }
+
+    /**
+     * Called by the analyzer and the interpreter. When initializing or setting the value of a
+     * size-2 local, the value of the subsequent slot is reset using this method.
+     * This method has to return a size-1 value representing an empty slot.
+     */
+    public V newEmptyValueAfterSize2Local(int local) {
+        return newValue(null);
+    }
+
+    /**
+     * Called by the interpreter. When setting the value of a local variable, the interpreter checks
+     * whether the current value stored at the preceding index is of size-2. In this case, the
+     * preceding size-2 value is no longer valid and reset using this method.
+     * This method has to return a size-1 value representing an empty slot.
+     */
+    public V newEmptyValueForPreviousSize2Local(int local) {
+        return newValue(null);
+    }
+
+    /**
+     * Called by the analyzer when initializing the exception value on the call stack at the entry
+     * of an exception handler.
+     */
+    public V newExceptionValue(TryCatchBlockNode tryCatchBlockNode, Frame handlerFrame, Type exceptionType) {
+        return newValue(exceptionType);
+    }
+
     /**
      * Interprets a bytecode instruction without arguments. This method is
      * called for the following opcodes: