[GR-38096] Initialize the parameters of root methods with the declared type.

PullRequest: graal/11605

Author: cstancu

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

@@ -60,13 +60,17 @@
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
 import com.oracle.graal.pointsto.flow.AllSynchronizedTypeFlow;
 import com.oracle.graal.pointsto.flow.FieldTypeFlow;
+import com.oracle.graal.pointsto.flow.FormalParamTypeFlow;
+import com.oracle.graal.pointsto.flow.InvokeTypeFlow;
+import com.oracle.graal.pointsto.flow.MethodFlowsGraph;
 import com.oracle.graal.pointsto.flow.MethodTypeFlow;
 import com.oracle.graal.pointsto.flow.MethodTypeFlowBuilder;
 import com.oracle.graal.pointsto.flow.OffsetLoadTypeFlow.AbstractUnsafeLoadTypeFlow;
 import com.oracle.graal.pointsto.flow.OffsetStoreTypeFlow.AbstractUnsafeStoreTypeFlow;
 import com.oracle.graal.pointsto.flow.TypeFlow;
 import com.oracle.graal.pointsto.flow.context.AnalysisContext;
 import com.oracle.graal.pointsto.flow.context.AnalysisContextPolicy;
+import com.oracle.graal.pointsto.infrastructure.WrappedSignature;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
@@ -443,46 +447,29 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia
 
             AnalysisType declaringClass = aMethod.getDeclaringClass();
             boolean isStatic = aMethod.isStatic();
-            int paramCount = aMethod.getSignature().getParameterCount(!isStatic);
+            WrappedSignature signature = aMethod.getSignature();
+            int paramCount = signature.getParameterCount(!isStatic);
             PointsToAnalysisMethod pointsToMethod = assertPointsToAnalysisMethod(aMethod);
-            final MethodTypeFlow methodFlow = pointsToMethod.getTypeFlow();
-
-            /*
-             * Add the initial parameter flows as uses to the type flow of their respective types.
-             * The initial parameter flows will be linked to the concrete parameter flows after the
-             * method is parsed and the method type flow is linked. This code is shared between
-             * static and non-static methods and the differentiation is made below when the methods
-             * are linked.
-             * 
-             * The parameter iteration skips the primitive parameters, as these are not modeled, and
-             * the receiver for virtual invokes which will be linked below.
-             * 
-             * Note: the Signature doesn't count the receiver of a virtual invoke as a parameter
-             * whereas the MethodTypeFlow does, hence when accessing the parameter type below we use
-             * idx-offset but when setting the initial parameter flow we simply use idx.
-             */
-            int offset = 0;
-            if (!isStatic) {
-                methodFlow.setInitialReceiverFlow(this, aMethod.getDeclaringClass());
-                offset = 1;
-            }
-            for (int idx = offset; idx < paramCount; idx++) {
-                AnalysisType declaredParamType = (AnalysisType) aMethod.getSignature().getParameterType(idx - offset, declaringClass);
-                if (declaredParamType.getJavaKind() == JavaKind.Object) {
-                    methodFlow.setInitialParameterFlow(this, declaredParamType, idx);
-                }
-            }
 
             if (isStatic) {
                 /*
                  * For static methods trigger analysis in the empty context. This will trigger
-                 * parsing and will add the actual parameter flows as uses to the initial parameter
-                 * flows initialized above.
+                 * parsing and return the method flows graph. Then the method parameter type flows
+                 * are initialized with the corresponding parameter declared type.
                  */
                 postTask(() -> {
                     pointsToMethod.registerAsDirectRootMethod();
                     pointsToMethod.registerAsImplementationInvoked(null);
-                    methodFlow.addContext(PointsToAnalysis.this, PointsToAnalysis.this.contextPolicy().emptyContext());
+                    MethodTypeFlow methodFlow = pointsToMethod.getTypeFlow();
+                    MethodFlowsGraph methodFlowsGraph = methodFlow.addContext(PointsToAnalysis.this, PointsToAnalysis.this.contextPolicy().emptyContext());
+                    for (int idx = 0; idx < paramCount; idx++) {
+                        AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx, declaringClass);
+                        FormalParamTypeFlow parameter = methodFlowsGraph.getParameter(idx);
+                        if (declaredParamType.getJavaKind() == JavaKind.Object && parameter != null) {
+                            TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
+                            initialParameterFlow.addUse(this, parameter);
+                        }
+                    }
                 });
             } else {
                 if (invokeSpecial && pointsToMethod.isAbstract()) {
@@ -498,10 +485,10 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia
                  * state it will get notified for any future reachable subtypes and will resolve the
                  * method in each subtype.
                  * 
-                 * In both cases when a callee is resolved the method is parsed and the
-                 * corresponding actual parameter flows are added as uses to the initial parameter
-                 * flows initialized above. Then the callee is linked and registered as
-                 * implementation-invoked.
+                 * In both cases the context-insensitive invoke parameters are initialized with the
+                 * corresponding declared type state. When a callee is resolved the method is parsed
+                 * and the actual parameter type state is propagated to the formal parameters. Then
+                 * the callee is linked and registered as implementation-invoked.
                  */
                 postTask(() -> {
                     BytecodePosition location = new BytecodePosition(null, pointsToMethod, 0);
@@ -510,7 +497,30 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia
                     } else {
                         pointsToMethod.registerAsVirtualRootMethod();
                     }
-                    pointsToMethod.initAndGetContextInsensitiveInvoke(PointsToAnalysis.this, location, invokeSpecial);
+                    InvokeTypeFlow invoke = pointsToMethod.initAndGetContextInsensitiveInvoke(PointsToAnalysis.this, location, invokeSpecial);
+                    /*
+                     * Initialize the type flow of the invoke's actual parameters with the
+                     * corresponding parameter declared type. Thus, when the invoke links callees it
+                     * will propagate the parameter types too.
+                     * 
+                     * The parameter iteration skips the primitive parameters, as these are not
+                     * modeled. The type flow of the receiver is set to the receiver type already
+                     * when the invoke is created.
+                     */
+                    for (int idx = 1; idx < paramCount; idx++) {
+                        /*
+                         * Note: the Signature doesn't count the receiver of a virtual invoke as a
+                         * parameter whereas the MethodTypeFlow does, hence when accessing the
+                         * parameter type below we use idx-1 but when accessing the actual parameter
+                         * flow we simply use idx.
+                         */
+                        AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx - 1, declaringClass);
+                        TypeFlow<?> actualParameterFlow = invoke.getActualParameter(idx);
+                        if (declaredParamType.getJavaKind() == JavaKind.Object && actualParameterFlow != null) {
+                            TypeFlow<?> initialParameterFlow = declaredParamType.getTypeFlow(this, true);
+                            initialParameterFlow.addUse(this, actualParameterFlow);
+                        }
+                    }
                 });
             }
         }

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

@@ -65,10 +65,8 @@ public TypeState filter(PointsToAnalysis bb, TypeState newState) {
      * i.e., 'this' parameter, state must ONLY reflect those objects of the actual receiver that
      * generated the context for the method clone which it belongs to. A direct link would instead
      * transfer all the objects of compatible type from the actual receiver to the formal receiver.
-     * The formal receiver state for the non-initial parameters is updated through the
-     * FormalReceiverTypeFlow.addReceiverState method invoked directly from
-     * VirtualInvokeTypeFlow.update, SpecialInvokeTypeFlow.update or from
-     * InitialReceiverTypeFlow.update.
+     * The formal receiver state is updated through the FormalReceiverTypeFlow.addReceiverState
+     * method invoked directly from VirtualInvokeTypeFlow.update or SpecialInvokeTypeFlow.update.
      */
     @Override
     public boolean addState(PointsToAnalysis bb, TypeState add) {

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

@@ -58,7 +58,6 @@ public class MethodFlowsGraph {
     // parameters, sources and field loads are the possible data entry
     // points in the method
     private FormalParamTypeFlow[] parameters;
-    private InitialParamTypeFlow[] initialParameterFlows;
     private List<TypeFlow<?>> miscEntryFlows;
     private EconomicMap<EncodedNodeReference, TypeFlow<?>> nodeFlows;
     /*
@@ -98,9 +97,6 @@ public MethodFlowsGraph(PointsToAnalysisMethod analysisMethod) {
             method.getSignature().getParameterType(i - offset, method.getDeclaringClass());
         }
 
-        // initial parameter flows
-        initialParameterFlows = new InitialParamTypeFlow[parameterCount];
-
         // lookup the return type so that it is added to the universe even if the method is
         // never linked and parsed
         method.getSignature().getReturnType(method.getDeclaringClass());
@@ -134,8 +130,6 @@ public void cloneOriginalFlows(PointsToAnalysis bb) {
             }
         }
 
-        initialParameterFlows = new InitialParamTypeFlow[originalMethodFlowsGraph.initialParameterFlows.length];
-
         nodeFlows = lookupClonesOf(bb, originalMethodFlowsGraph.nodeFlows);
         returnFlow = originalMethodFlowsGraph.getReturnFlow() != null ? lookupCloneOf(bb, originalMethodFlowsGraph.getReturnFlow()) : null;
         instanceOfFlows = lookupClonesOf(bb, originalMethodFlowsGraph.instanceOfFlows);
@@ -212,15 +206,6 @@ public void linkClones(final PointsToAnalysis bb) {
 
         MethodFlowsGraph originalMethodFlowsGraph = method.getTypeFlow().originalMethodFlows;
 
-        /* Link the initial parameter flows to the parameters. */
-        for (int i = 0; i < originalMethodFlowsGraph.initialParameterFlows.length; i++) {
-            InitialParamTypeFlow initialParameterFlow = originalMethodFlowsGraph.getInitialParameterFlow(i);
-            if (initialParameterFlow != null && parameters[i] != null) {
-                initialParameterFlow.addUse(bb, parameters[i]);
-                initialParameterFlows[i] = initialParameterFlow;
-            }
-        }
-
         for (TypeFlow<?> original : originalMethodFlowsGraph.linearizedGraph) {
             TypeFlow<?> clone = lookupCloneOf(bb, original);
 
@@ -387,20 +372,6 @@ public TypeFlow<?>[] getParameters() {
         return parameters;
     }
 
-    public void setInitialParameterFlow(InitialParamTypeFlow initialParameterFlow, int i) {
-        assert i >= 0 && i < this.initialParameterFlows.length;
-        initialParameterFlows[i] = initialParameterFlow;
-    }
-
-    public InitialParamTypeFlow getInitialParameterFlow(int i) {
-        assert i >= 0 && i < this.initialParameterFlows.length;
-        return initialParameterFlows[i];
-    }
-
-    public TypeFlow<?>[] getInitialParameterFlows() {
-        return initialParameterFlows;
-    }
-
     public void addNodeFlow(EncodedNodeReference key, TypeFlow<?> flow) {
         assert flow != null && !(flow instanceof AllInstantiatedTypeFlow);
         if (nodeFlows == null) {

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

@@ -48,7 +48,6 @@
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
 import com.oracle.graal.pointsto.flow.context.AnalysisContext;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
-import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.PointsToAnalysisMethod;
 import com.oracle.graal.pointsto.typestate.TypeState;
 import com.oracle.graal.pointsto.util.AnalysisError;
@@ -158,20 +157,6 @@ public void setParameter(int index, FormalParamTypeFlow parameter) {
         originalMethodFlows.setParameter(index, parameter);
     }
 
-    public void setInitialReceiverFlow(PointsToAnalysis bb, AnalysisType declaringType) {
-        TypeFlow<?> declaringTypeFlow = declaringType.getTypeFlow(bb, false);
-        InitialReceiverTypeFlow initialReceiverFlow = new InitialReceiverTypeFlow(method, declaringType);
-        declaringTypeFlow.addUse(bb, initialReceiverFlow);
-        originalMethodFlows.setInitialParameterFlow(initialReceiverFlow, 0);
-    }
-
-    public void setInitialParameterFlow(PointsToAnalysis bb, AnalysisType declaredType, int i) {
-        TypeFlow<?> declaredTypeFlow = declaredType.getTypeFlow(bb, true);
-        InitialParamTypeFlow initialParameterFlow = new InitialParamTypeFlow(method, declaredType, i);
-        declaredTypeFlow.addUse(bb, initialParameterFlow);
-        originalMethodFlows.setInitialParameterFlow(initialParameterFlow, i);
-    }
-
     protected void addInstanceOf(Object key, InstanceOfTypeFlow instanceOf) {
         originalMethodFlows.addInstanceOf(key, instanceOf);
     }