Run escape analysis before static analysis

Author: Christian Wimmer

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

@@ -24,7 +24,7 @@
  */
 package com.oracle.graal.pointsto.flow;
 
-import org.graalvm.compiler.nodes.java.AccessFieldNode;
+import org.graalvm.compiler.nodes.ValueNode;
 
 import com.oracle.graal.pointsto.PointsToAnalysis;
 import com.oracle.graal.pointsto.meta.AnalysisField;
@@ -38,10 +38,10 @@ public abstract class AccessFieldTypeFlow extends TypeFlow<BytecodePosition> {
     /** The field that this flow stores into or loads from. */
     protected final AnalysisField field;
 
-    protected AccessFieldTypeFlow(AccessFieldNode node) {
+    protected AccessFieldTypeFlow(ValueNode node, AnalysisField field) {
         /* The declared type of a field access node is the field declared type. */
-        super(node.getNodeSourcePosition(), ((AnalysisField) node.field()).getType());
-        this.field = (AnalysisField) node.field();
+        super(node.getNodeSourcePosition(), field.getType());
+        this.field = field;
     }
 
     protected AccessFieldTypeFlow(AccessFieldTypeFlow original, MethodFlowsGraph methodFlows) {

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

@@ -141,14 +141,19 @@ public static AnalysisParsedGraph parseBytecode(BigBang bb, AnalysisMethod metho
         }
     }
 
+    @SuppressWarnings("try")
     private static AnalysisParsedGraph optimizeAndEncode(BigBang bb, AnalysisMethod method, StructuredGraph graph, boolean isIntrinsic) {
-        /*
-         * Must be called before any other thread can access the graph, i.e., before the graph is
-         * published.
-         */
-        bb.getHostVM().methodAfterParsingHook(bb, method, graph);
-
-        EncodedGraph encodedGraph = GraphEncoder.encodeSingleGraph(graph, HOST_ARCHITECTURE);
-        return new AnalysisParsedGraph(encodedGraph, isIntrinsic);
+        try (DebugContext.Scope s = graph.getDebug().scope("ClosedWorldAnalysis", graph, method)) {
+            /*
+             * Must be called before any other thread can access the graph, i.e., before the graph
+             * is published.
+             */
+            bb.getHostVM().methodAfterParsingHook(bb, method, graph);
+
+            EncodedGraph encodedGraph = GraphEncoder.encodeSingleGraph(graph, HOST_ARCHITECTURE);
+            return new AnalysisParsedGraph(encodedGraph, isIntrinsic);
+        } catch (Throwable e) {
+            throw graph.getDebug().handle(e);
+        }
     }
 }

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

@@ -28,6 +28,7 @@
 
 import com.oracle.graal.pointsto.PointsToAnalysis;
 import com.oracle.graal.pointsto.flow.context.object.AnalysisObject;
+import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.typestate.TypeState;
 
 import jdk.vm.ci.code.BytecodePosition;
@@ -38,7 +39,7 @@
 public abstract class LoadFieldTypeFlow extends AccessFieldTypeFlow {
 
     protected LoadFieldTypeFlow(LoadFieldNode node) {
-        super(node);
+        super(node, (AnalysisField) node.field());
     }
 
     protected LoadFieldTypeFlow(MethodFlowsGraph methodFlows, LoadFieldTypeFlow original) {

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

@@ -90,6 +90,10 @@
 import org.graalvm.compiler.nodes.java.UnsafeCompareAndSwapNode;
 import org.graalvm.compiler.nodes.type.StampTool;
 import org.graalvm.compiler.nodes.util.GraphUtil;
+import org.graalvm.compiler.nodes.virtual.AllocatedObjectNode;
+import org.graalvm.compiler.nodes.virtual.CommitAllocationNode;
+import org.graalvm.compiler.nodes.virtual.VirtualInstanceNode;
+import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
 import org.graalvm.compiler.phases.common.CanonicalizerPhase;
 import org.graalvm.compiler.phases.common.IterativeConditionalEliminationPhase;
 import org.graalvm.compiler.phases.graph.MergeableState;
@@ -222,6 +226,29 @@ public void registerUsedElements(boolean registerEmbeddedRoots) {
                 AnalysisType type = (AnalysisType) node.instanceClass();
                 type.registerAsAllocated(node);
 
+            } else if (n instanceof VirtualObjectNode) {
+                VirtualObjectNode node = (VirtualObjectNode) n;
+                AnalysisType type = (AnalysisType) node.type();
+                type.registerAsAllocated(node);
+
+            } else if (n instanceof CommitAllocationNode) {
+                CommitAllocationNode node = (CommitAllocationNode) n;
+                List<ValueNode> values = node.getValues();
+                int objectStartIndex = 0;
+                for (VirtualObjectNode virtualObject : node.getVirtualObjects()) {
+                    AnalysisType type = (AnalysisType) virtualObject.type();
+                    if (!type.isArray()) {
+                        for (int i = 0; i < virtualObject.entryCount(); i++) {
+                            ValueNode value = values.get(objectStartIndex + i);
+                            if (!value.isJavaConstant() || !value.asJavaConstant().isDefaultForKind()) {
+                                AnalysisField field = (AnalysisField) ((VirtualInstanceNode) virtualObject).field(i);
+                                field.registerAsWritten(methodFlow);
+                            }
+                        }
+                    }
+                    objectStartIndex += virtualObject.entryCount();
+                }
+
             } else if (n instanceof NewArrayNode) {
                 NewArrayNode node = (NewArrayNode) n;
                 AnalysisType type = ((AnalysisType) node.elementType()).getArrayClass();
@@ -766,6 +793,8 @@ protected void node(FixedNode n) {
                 if (node.result() != null && node.result().getStackKind() == JavaKind.Object) {
                     returnFlowBuilder.addUseDependency(state.lookup(node.result()));
                 }
+            } else if (n instanceof CommitAllocationNode) {
+                processCommitAllocation((CommitAllocationNode) n, state);
             } else if (n instanceof NewInstanceNode) {
                 processNewInstance((NewInstanceNode) n, state);
             } else if (n instanceof DynamicNewInstanceNode) {
@@ -883,34 +912,7 @@ protected void node(FixedNode n) {
                 }
 
             } else if (n instanceof StoreFieldNode) { // object.field = value
-                StoreFieldNode node = (StoreFieldNode) n;
-                AnalysisField field = (AnalysisField) node.field();
-                assert field.isWritten();
-                if (node.value().getStackKind() == JavaKind.Object) {
-                    TypeFlowBuilder<?> valueBuilder = state.lookup(node.value());
-
-                    TypeFlowBuilder<StoreFieldTypeFlow> storeFieldBuilder;
-                    if (node.isStatic()) {
-                        storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> {
-                            FieldTypeFlow fieldFlow = field.getStaticFieldFlow();
-                            StoreStaticFieldTypeFlow storeFieldFlow = new StoreStaticFieldTypeFlow(node, valueBuilder.get(), fieldFlow);
-                            methodFlow.addMiscEntry(storeFieldFlow);
-                            return storeFieldFlow;
-                        });
-                        storeFieldBuilder.addUseDependency(valueBuilder);
-                    } else {
-                        TypeFlowBuilder<?> objectBuilder = state.lookup(node.object());
-                        storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> {
-                            StoreInstanceFieldTypeFlow storeFieldFlow = new StoreInstanceFieldTypeFlow(node, valueBuilder.get(), objectBuilder.get());
-                            methodFlow.addMiscEntry(storeFieldFlow);
-                            return storeFieldFlow;
-                        });
-                        storeFieldBuilder.addUseDependency(valueBuilder);
-                        storeFieldBuilder.addObserverDependency(objectBuilder);
-                    }
-                    /* Field stores must not be removed. */
-                    typeFlowGraphBuilder.registerSinkBuilder(storeFieldBuilder);
-                }
+                processStoreField((StoreFieldNode) n, state);
 
             } else if (n instanceof LoadIndexedNode) {
                 LoadIndexedNode node = (LoadIndexedNode) n;
@@ -933,23 +935,7 @@ protected void node(FixedNode n) {
                 }
 
             } else if (n instanceof StoreIndexedNode) {
-                StoreIndexedNode node = (StoreIndexedNode) n;
-                if (node.value().getStackKind() == JavaKind.Object) {
-                    AnalysisType arrayType = (AnalysisType) StampTool.typeOrNull(node.array());
-                    AnalysisType nonNullArrayType = Optional.ofNullable(arrayType).orElseGet(bb::getObjectArrayType);
-                    TypeFlowBuilder<?> arrayBuilder = state.lookup(node.array());
-                    TypeFlowBuilder<?> valueBuilder = state.lookup(node.value());
-                    TypeFlowBuilder<?> storeIndexedBuilder = TypeFlowBuilder.create(bb, node, StoreIndexedTypeFlow.class, () -> {
-                        StoreIndexedTypeFlow storeIndexedFlow = new StoreIndexedTypeFlow(node, nonNullArrayType, arrayBuilder.get(), valueBuilder.get());
-                        methodFlow.addMiscEntry(storeIndexedFlow);
-                        return storeIndexedFlow;
-                    });
-                    storeIndexedBuilder.addUseDependency(valueBuilder);
-                    storeIndexedBuilder.addObserverDependency(arrayBuilder);
-
-                    /* Index stores must not be removed. */
-                    typeFlowGraphBuilder.registerSinkBuilder(storeIndexedBuilder);
-                }
+                processStoreIndexed((StoreIndexedNode) n, state);
 
             } else if (n instanceof UnsafePartitionLoadNode) {
                 UnsafePartitionLoadNode node = (UnsafePartitionLoadNode) n;
@@ -1474,43 +1460,120 @@ protected Object uniqueKey(Node node) {
         return new Object();
     }
 
+    protected void processCommitAllocation(CommitAllocationNode commitAllocationNode, TypeFlowsOfNodes state) {
+        Map<VirtualObjectNode, AllocatedObjectNode> allocatedObjects = new HashMap<>();
+        for (AllocatedObjectNode allocatedObjectNode : commitAllocationNode.usages().filter(AllocatedObjectNode.class)) {
+            AnalysisType type = (AnalysisType) allocatedObjectNode.getVirtualObject().type();
+            processNewInstance(allocatedObjectNode, type, state);
+            allocatedObjects.put(allocatedObjectNode.getVirtualObject(), allocatedObjectNode);
+        }
+
+        List<ValueNode> values = commitAllocationNode.getValues();
+        int objectStartIndex = 0;
+        for (VirtualObjectNode virtualObject : commitAllocationNode.getVirtualObjects()) {
+            AnalysisType type = (AnalysisType) virtualObject.type();
+            ValueNode object = allocatedObjects.get(virtualObject);
+            if (object == null) {
+                /*
+                 * The AllocatedObjectNode itself is not used directly, so it got removed from the
+                 * graph. We still need to register field/array stores because otherwise we can miss
+                 * types that flow into the field/array. We use the VirtualObjectNode as the
+                 * placeholder for the stores.
+                 */
+                object = virtualObject;
+            }
+            for (int i = 0; i < virtualObject.entryCount(); i++) {
+                ValueNode value = values.get(objectStartIndex + i);
+                if (!value.isJavaConstant() || !value.asJavaConstant().isDefaultForKind()) {
+                    if (type.isArray()) {
+                        processStoreIndexed(commitAllocationNode, object, value, state);
+                    } else {
+                        AnalysisField field = (AnalysisField) ((VirtualInstanceNode) virtualObject).field(i);
+                        processStoreField(commitAllocationNode, field, object, value, state);
+                    }
+                }
+            }
+            objectStartIndex += virtualObject.entryCount();
+        }
+        assert values.size() == objectStartIndex;
+    }
+
     protected void processNewInstance(NewInstanceNode node, TypeFlowsOfNodes state) {
+        /* Instance fields of a new object are initialized to null state in AnalysisField. */
+        processNewInstance(node, (AnalysisType) node.instanceClass(), state);
+    }
 
-        AnalysisType type = (AnalysisType) node.instanceClass();
+    protected void processNewArray(NewArrayNode node, TypeFlowsOfNodes state) {
+        processNewInstance(node, ((AnalysisType) node.elementType()).getArrayClass(), state);
+    }
+
+    protected void processNewInstance(ValueNode node, AnalysisType type, TypeFlowsOfNodes state) {
         assert type.isInstantiated();
         Object key = uniqueKey(node);
         BytecodeLocation allocationLabel = bb.analysisPolicy().createAllocationSite(bb, key, method);
 
         TypeFlowBuilder<?> newInstanceBuilder = TypeFlowBuilder.create(bb, node, NewInstanceTypeFlow.class, () -> {
-            NewInstanceTypeFlow newInstance = createNewInstanceTypeFlow(node, type, allocationLabel);
-            /* Instance fields of a new object are initialized to null state in AnalysisField. */
+            NewInstanceTypeFlow newInstance = new NewInstanceTypeFlow(node, type, allocationLabel);
             methodFlow.addMiscEntry(newInstance);
             return newInstance;
         });
         state.add(node, newInstanceBuilder);
     }
 
-    protected NewInstanceTypeFlow createNewInstanceTypeFlow(NewInstanceNode node, AnalysisType type, BytecodeLocation allocationLabel) {
-        return new NewInstanceTypeFlow(node, type, allocationLabel);
+    protected void processStoreField(StoreFieldNode node, TypeFlowsOfNodes state) {
+        processStoreField(node, (AnalysisField) node.field(), node.object(), node.value(), state);
     }
 
-    protected void processNewArray(NewArrayNode node, TypeFlowsOfNodes state) {
-        AnalysisType type = ((AnalysisType) node.elementType()).getArrayClass();
-        assert type.isInstantiated();
-
-        Object key = uniqueKey(node);
-        BytecodeLocation allocationLabel = bb.analysisPolicy().createAllocationSite(bb, key, method);
+    protected void processStoreField(ValueNode node, AnalysisField field, ValueNode object, ValueNode value, TypeFlowsOfNodes state) {
+        assert field.isWritten();
+        if (value.getStackKind() == JavaKind.Object) {
+            TypeFlowBuilder<?> valueBuilder = state.lookup(value);
+
+            TypeFlowBuilder<StoreFieldTypeFlow> storeFieldBuilder;
+            if (field.isStatic()) {
+                storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> {
+                    FieldTypeFlow fieldFlow = field.getStaticFieldFlow();
+                    StoreStaticFieldTypeFlow storeFieldFlow = new StoreStaticFieldTypeFlow(node, field, valueBuilder.get(), fieldFlow);
+                    methodFlow.addMiscEntry(storeFieldFlow);
+                    return storeFieldFlow;
+                });
+                storeFieldBuilder.addUseDependency(valueBuilder);
+            } else {
+                TypeFlowBuilder<?> objectBuilder = state.lookup(object);
+                storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> {
+                    StoreInstanceFieldTypeFlow storeFieldFlow = new StoreInstanceFieldTypeFlow(node, field, valueBuilder.get(), objectBuilder.get());
+                    methodFlow.addMiscEntry(storeFieldFlow);
+                    return storeFieldFlow;
+                });
+                storeFieldBuilder.addUseDependency(valueBuilder);
+                storeFieldBuilder.addObserverDependency(objectBuilder);
+            }
+            /* Field stores must not be removed. */
+            typeFlowGraphBuilder.registerSinkBuilder(storeFieldBuilder);
+        }
+    }
 
-        TypeFlowBuilder<?> newArrayBuilder = TypeFlowBuilder.create(bb, node, NewInstanceTypeFlow.class, () -> {
-            NewInstanceTypeFlow newArray = createNewArrayTypeFlow(node, type, allocationLabel);
-            methodFlow.addMiscEntry(newArray);
-            return newArray;
-        });
-        state.add(node, newArrayBuilder);
+    private void processStoreIndexed(StoreIndexedNode node, TypeFlowsOfNodes state) {
+        processStoreIndexed(node, node.array(), node.value(), state);
     }
 
-    protected NewInstanceTypeFlow createNewArrayTypeFlow(NewArrayNode node, AnalysisType type, BytecodeLocation allocationLabel) {
-        return new NewInstanceTypeFlow(node, type, allocationLabel);
+    private void processStoreIndexed(ValueNode node, ValueNode array, ValueNode value, TypeFlowsOfNodes state) {
+        if (value.getStackKind() == JavaKind.Object) {
+            AnalysisType arrayType = (AnalysisType) StampTool.typeOrNull(array);
+            AnalysisType nonNullArrayType = Optional.ofNullable(arrayType).orElseGet(bb::getObjectArrayType);
+            TypeFlowBuilder<?> arrayBuilder = state.lookup(array);
+            TypeFlowBuilder<?> valueBuilder = state.lookup(value);
+            TypeFlowBuilder<?> storeIndexedBuilder = TypeFlowBuilder.create(bb, node, StoreIndexedTypeFlow.class, () -> {
+                StoreIndexedTypeFlow storeIndexedFlow = new StoreIndexedTypeFlow(node, nonNullArrayType, arrayBuilder.get(), valueBuilder.get());
+                methodFlow.addMiscEntry(storeIndexedFlow);
+                return storeIndexedFlow;
+            });
+            storeIndexedBuilder.addUseDependency(valueBuilder);
+            storeIndexedBuilder.addObserverDependency(arrayBuilder);
+
+            /* Index stores must not be removed. */
+            typeFlowGraphBuilder.registerSinkBuilder(storeIndexedBuilder);
+        }
     }
 
     /** Hook for unsafe offset value checks. */

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

@@ -24,19 +24,20 @@
  */
 package com.oracle.graal.pointsto.flow;
 
-import org.graalvm.compiler.nodes.java.StoreFieldNode;
+import org.graalvm.compiler.nodes.ValueNode;
 
 import com.oracle.graal.pointsto.PointsToAnalysis;
 import com.oracle.graal.pointsto.flow.context.object.AnalysisObject;
+import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.typestate.TypeState;
 
 /**
  * Implements a field store operation type flow.
  */
 public abstract class StoreFieldTypeFlow extends AccessFieldTypeFlow {
 
-    protected StoreFieldTypeFlow(StoreFieldNode node) {
-        super(node);
+    protected StoreFieldTypeFlow(ValueNode node, AnalysisField field) {
+        super(node, field);
     }
 
     protected StoreFieldTypeFlow(StoreFieldTypeFlow original, MethodFlowsGraph methodFlows) {
@@ -60,8 +61,8 @@ public static class StoreStaticFieldTypeFlow extends StoreFieldTypeFlow {
         /** The flow of the input value. */
         private final TypeFlow<?> valueFlow;
 
-        StoreStaticFieldTypeFlow(StoreFieldNode node, TypeFlow<?> valueFlow, FieldTypeFlow fieldFlow) {
-            super(node);
+        StoreStaticFieldTypeFlow(ValueNode node, AnalysisField field, TypeFlow<?> valueFlow, FieldTypeFlow fieldFlow) {
+            super(node, field);
             this.valueFlow = valueFlow;
             this.fieldFlow = fieldFlow;
         }
@@ -107,8 +108,8 @@ public static class StoreInstanceFieldTypeFlow extends StoreFieldTypeFlow {
         /** The flow of the store operation receiver object. */
         private TypeFlow<?> objectFlow;
 
-        StoreInstanceFieldTypeFlow(StoreFieldNode node, TypeFlow<?> valueFlow, TypeFlow<?> objectFlow) {
-            super(node);
+        StoreInstanceFieldTypeFlow(ValueNode node, AnalysisField field, TypeFlow<?> valueFlow, TypeFlow<?> objectFlow) {
+            super(node, field);
             this.valueFlow = valueFlow;
             this.objectFlow = objectFlow;
         }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMetaAccess.java

@@ -40,6 +40,11 @@ public class AnalysisMetaAccess extends UniverseMetaAccess {
 
     public AnalysisMetaAccess(AnalysisUniverse analysisUniverse, MetaAccessProvider originalMetaAccess) {
         super(analysisUniverse, originalMetaAccess);
+
+        /* Make sure that Object type is added to the universe before any other types. */
+        lookupJavaType(Object.class);
+        /* Cloneable is needed before any other instance class can be created. */
+        lookupJavaType(Cloneable.class);
     }
 
     @Override