Make filter swap-out deterministic.

Author: cstancu

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/DefaultAnalysisPolicy.java

@@ -248,7 +248,7 @@ public void onObservedSaturated(BigBang bb, TypeFlow<?> observed) {
 
             /*
              * The receiver object flow of the invoke operation is saturated; it will stop sending
-             * notificatons. Swap the invoke flow with the unique, context-insensitive invoke flow
+             * notifications. Swap the invoke flow with the unique, context-insensitive invoke flow
              * corresponding to the target method, which is already registered as an observer for
              * the type flow of the receiver type and therefore saturated. This is a conservative
              * approximation and this invoke will reach all possible callees.

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/FieldFilterTypeFlow.java

@@ -62,6 +62,16 @@ protected void onInputSaturated(BigBang bb, TypeFlow<?> input) {
         swapOut(bb, declaredType.getTypeFlow(bb, true));
     }
 
+    @Override
+    protected void notifyUseOfSaturation(BigBang bb, TypeFlow<?> use) {
+        swapAtUse(bb, declaredType.getTypeFlow(bb, true), use);
+    }
+
+    @Override
+    protected void notifyObserverOfSaturation(BigBang bb, TypeFlow<?> observer) {
+        swapAtObserver(bb, declaredType.getTypeFlow(bb, true), observer);
+    }
+
     @Override
     public String toString() {
         return "FieldFilterTypeFlow<" + source + ">";

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/FilterTypeFlow.java

@@ -102,28 +102,32 @@ public TypeState filter(BigBang bb, TypeState update) {
     @Override
     protected void onInputSaturated(BigBang bb, TypeFlow<?> input) {
         if (isAssignable) {
-            TypeFlow<?> sourceFlow = declaredType.getTypeFlow(bb, includeNull);
-
-            /*
-             * First mark this flow as saturated, then swap it out at its uses/observers with its
-             * declared type flow. Marking this flow as saturated first is important: if there are
-             * any uses or observers *in-flight*, i.e., not yet registered at this point, trying to
-             * swap-out will have no effect on those. However, if this flow is already marked as
-             * saturated when the use or observer *lands*, even if that happens while/after
-             * swapping-out, then the corresponding use or observer will be notified of its input
-             * saturation. Otherwise it may neither get the saturation signal OR get swapped-out.
-             * 
-             * The downside in the later case is that the input/observer will lose the more precise
-             * type information that swapping-out would have provided and will just use the more
-             * conservative approximation, e.g., the target method declared type for invokes.
-             */
+            /* Swap this flow out at its uses/observers with its declared type flow. */
             setSaturated();
-            swapOut(bb, sourceFlow);
+            swapOut(bb, declaredType.getTypeFlow(bb, includeNull));
         } else {
             super.onInputSaturated(bb, input);
         }
     }
 
+    @Override
+    protected void notifyUseOfSaturation(BigBang bb, TypeFlow<?> use) {
+        if (isAssignable) {
+            swapAtUse(bb, declaredType.getTypeFlow(bb, includeNull), use);
+        } else {
+            super.notifyUseOfSaturation(bb, use);
+        }
+    }
+
+    @Override
+    protected void notifyObserverOfSaturation(BigBang bb, TypeFlow<?> observer) {
+        if (isAssignable) {
+            swapAtObserver(bb, declaredType.getTypeFlow(bb, includeNull), observer);
+        } else {
+            super.notifyObserverOfSaturation(bb, observer);
+        }
+    }
+
     @Override
     public boolean addState(BigBang bb, TypeState add) {
         assert this.isClone();

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/FormalParamTypeFlow.java

@@ -78,7 +78,7 @@ public int position() {
     @Override
     public String toString() {
         StringBuilder str = new StringBuilder();
-        str.append("FormalParamFlow").append("[").append(method.format("%H.%n")).append("]").append("[").append(position).append("]<").append(getState()).append(">");
+        str.append("FormalParamFlow").append("[").append(method.format("%H.%n(%p)")).append("]").append("[").append(position).append("]<").append(getState()).append(">");
         return str.toString();
     }
 

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/TypeFlow.java

@@ -97,7 +97,7 @@ public abstract class TypeFlow<T> {
      * the type flow graph.
      * <p/>
      * A type flow can also be marked as saturated when one of its inputs has reached the saturated
-     * state and has propagated the "saturated" marker downstream. Thus, since in such a situtation
+     * state and has propagated the "saturated" marker downstream. Thus, since in such a situation
      * the input stops propagating type states, a flow's type state may be incomplete. It is up to
      * individual type flows to subscribe themselves directly to the type flows of their declared
      * types if they need further updates.
@@ -354,7 +354,7 @@ public boolean addUse(BigBang bb, TypeFlow<?> use) {
     private boolean addUse(BigBang bb, TypeFlow<?> use, boolean propagateTypeState, boolean registerInput) {
         if (isSaturated() && propagateTypeState) {
             /* Let the use know that this flow is already saturated. */
-            use.onInputSaturated(bb, this);
+            notifyUseOfSaturation(bb, use);
             return false;
         }
         if (doAddUse(bb, use, registerInput)) {
@@ -366,7 +366,7 @@ private boolean addUse(BigBang bb, TypeFlow<?> use, boolean propagateTypeState,
                      * use would have missed the saturated signal. Let the use know that this flow
                      * became saturated.
                      */
-                    use.onInputSaturated(bb, this);
+                    notifyUseOfSaturation(bb, use);
                     /* And unlink the use. */
                     removeUse(use);
                     return false;
@@ -379,6 +379,10 @@ private boolean addUse(BigBang bb, TypeFlow<?> use, boolean propagateTypeState,
         return false;
     }
 
+    protected void notifyUseOfSaturation(BigBang bb, TypeFlow<?> use) {
+        use.onInputSaturated(bb, this);
+    }
+
     protected boolean doAddUse(BigBang bb, TypeFlow<?> use, boolean registerInput) {
         if (use.isSaturated()) {
             /* The use is already saturated so it will not be linked. */
@@ -416,14 +420,14 @@ public void addObserver(BigBang bb, TypeFlow<?> observer) {
     private boolean addObserver(BigBang bb, TypeFlow<?> observer, boolean triggerUpdate, boolean registerObservees) {
         if (isSaturated() && triggerUpdate) {
             /* Let the observer know that this flow is already saturated. */
-            observer.onObservedSaturated(bb, this);
+            notifyObserverOfSaturation(bb, observer);
             return false;
         }
         if (doAddObserver(bb, observer, registerObservees)) {
             if (triggerUpdate) {
                 if (isSaturated()) {
                     /* This flow is already saturated, notify the observer. */
-                    observer.onObservedSaturated(bb, this);
+                    notifyObserverOfSaturation(bb, observer);
                     removeObserver(observer);
                     return false;
                 } else if (!this.state.isEmpty()) {
@@ -445,6 +449,10 @@ public void run(DebugContext ignore) {
         return false;
     }
 
+    protected void notifyObserverOfSaturation(BigBang bb, TypeFlow<?> observer) {
+        observer.onObservedSaturated(bb, this);
+    }
+
     private boolean doAddObserver(BigBang bb, TypeFlow<?> observer, boolean registerObservees) {
         /*
          * An observer is linked even if it is already saturated itself, hence no
@@ -603,16 +611,24 @@ private void notifySaturated(BigBang bb) {
     /** This flow will swap itself out at all uses and observers. */
     protected void swapOut(BigBang bb, TypeFlow<?> newFlow) {
         for (TypeFlow<?> use : getUses()) {
-            removeUse(use);
-            newFlow.addUse(bb, use);
+            swapAtUse(bb, newFlow, use);
         }
         for (TypeFlow<?> observer : getObservers()) {
-            removeObserver(observer);
-            /* Notify the observer that its observed flow has changed. */
-            observer.replacedObservedWith(bb, newFlow);
+            swapAtObserver(bb, newFlow, observer);
         }
     }
 
+    protected void swapAtUse(BigBang bb, TypeFlow<?> newFlow, TypeFlow<?> use) {
+        removeUse(use);
+        newFlow.addUse(bb, use);
+    }
+
+    protected void swapAtObserver(BigBang bb, TypeFlow<?> newFlow, TypeFlow<?> observer) {
+        removeObserver(observer);
+        /* Notify the observer that its observed flow has changed. */
+        observer.replacedObservedWith(bb, newFlow);
+    }
+
     /**
      * Notified by an input that it is saturated and it will stop sending updates.
      */