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

Introduces a number of methods that are called when initializing or
updating abstract values in an analyzer frame.

Before this commit, Analyzer.analyze and Frame.execute would always
call Interpreter.newValue for initializing or updating frame values.

Having multiple methods allows users to return more precise values
for the individual cases. For example, in a nullness analysis, the
initial value for the `this` parameter of an instance method can be
set to not-null.

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: