Refactor Native Image heap scanning.

sdk/src/org.graalvm.nativeimage/snapshot.sigtest

@@ -893,6 +893,7 @@ CLSS public abstract interface static org.graalvm.nativeimage.hosted.Feature$Dur
 intf org.graalvm.nativeimage.hosted.Feature$BeforeAnalysisAccess
 intf org.graalvm.nativeimage.hosted.Feature$QueryReachabilityAccess
 meth public abstract void requireAnalysisIteration()
+meth public abstract void rescanObject(java.lang.Object)
 
 CLSS public abstract interface static org.graalvm.nativeimage.hosted.Feature$DuringSetupAccess
  outer org.graalvm.nativeimage.hosted.Feature

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java

@@ -277,6 +277,13 @@ interface DuringAnalysisAccess extends BeforeAnalysisAccess, QueryReachabilityAc
          * @since 19.0
          */
         void requireAnalysisIteration();
+
+        /**
+         * Rescan an object to be included in the image heap.
+         *
+         * @since 22.0
+         */
+        void rescanObject(Object obj);
     }
 
     /**

substratevm/ci_includes/gate.hocon

@@ -69,6 +69,7 @@ builds += [
   }
   ${labsjdk-ce-17} ${svm-common-gate} ${svm-common-windows-jdk17} ${svmUnittest} {
     name: "gate-svm-windows-basics"
+    timelimit: "1:30:00"
     run: [
       ${svm-cmd-gate} ["build,helloworld,test,svmjunit"]
     ]

substratevm/mx.substratevm/suite.py

@@ -1155,7 +1155,9 @@
                         "sun.reflect.generics.reflectiveObjects",
                         "sun.reflect.generics.repository",
                         "sun.reflect.generics.tree",
+                        "sun.reflect.generics.scope",
                         "sun.util.calendar",
+                        "sun.util.locale",
                         "sun.security.jca",
                         "sun.security.util",
                         "sun.security.provider",
@@ -1457,6 +1459,8 @@
               "exports" : [
                 "com.oracle.graal.pointsto",
                 "com.oracle.graal.pointsto.api",
+                "com.oracle.graal.pointsto.heap",
+                "com.oracle.graal.pointsto.heap.value",
                 "com.oracle.graal.pointsto.reports",
                 "com.oracle.graal.pointsto.constraints",
                 "com.oracle.graal.pointsto.util",

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

@@ -24,6 +24,7 @@
  */
 package com.oracle.graal.pointsto;
 
+import com.oracle.graal.pointsto.ObjectScanner.ScanReason;
 import com.oracle.graal.pointsto.flow.ArrayElementsTypeFlow;
 import com.oracle.graal.pointsto.flow.FieldTypeFlow;
 import com.oracle.graal.pointsto.flow.context.object.AnalysisObject;
@@ -42,23 +43,25 @@ public AnalysisObjectScanningObserver(BigBang bb) {
     }
 
     @Override
-    public void forRelocatedPointerFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue) {
+    public boolean forRelocatedPointerFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue, ScanReason reason) {
         if (!field.isWritten()) {
-            field.registerAsWritten(null);
+            return field.registerAsWritten(null);
         }
+        return false;
     }
 
     @Override
-    public void forNullFieldValue(JavaConstant receiver, AnalysisField field) {
+    public boolean forNullFieldValue(JavaConstant receiver, AnalysisField field, ScanReason reason) {
         FieldTypeFlow fieldTypeFlow = getFieldTypeFlow(field, receiver);
         if (!fieldTypeFlow.getState().canBeNull()) {
             /* Signal that the field can contain null. */
-            fieldTypeFlow.addState(getAnalysis(), TypeState.forNull());
+            return fieldTypeFlow.addState(getAnalysis(), TypeState.forNull());
         }
+        return false;
     }
 
     @Override
-    public void forNonNullFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue) {
+    public boolean forNonNullFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue, ScanReason reason) {
         PointsToAnalysis analysis = getAnalysis();
         AnalysisType fieldType = analysis.getMetaAccess().lookupJavaType(analysis.getSnippetReflectionProvider().asObject(Object.class, fieldValue).getClass());
         assert fieldType.isInstantiated() : fieldType;
@@ -69,8 +72,9 @@ public void forNonNullFieldValue(JavaConstant receiver, AnalysisField field, Jav
         if (!fieldTypeFlow.getState().containsObject(constantObject)) {
             /* Add the new constant to the field's flow state. */
             TypeState constantTypeState = TypeState.forNonNullObject(analysis, constantObject);
-            fieldTypeFlow.addState(analysis, constantTypeState);
+            return fieldTypeFlow.addState(analysis, constantTypeState);
         }
+        return false;
     }
 
     /**
@@ -94,25 +98,27 @@ private FieldTypeFlow getFieldTypeFlow(AnalysisField field, JavaConstant receive
     }
 
     @Override
-    public void forNullArrayElement(JavaConstant array, AnalysisType arrayType, int elementIndex) {
+    public boolean forNullArrayElement(JavaConstant array, AnalysisType arrayType, int elementIndex, ScanReason reason) {
         ArrayElementsTypeFlow arrayObjElementsFlow = getArrayElementsFlow(array, arrayType);
         if (!arrayObjElementsFlow.getState().canBeNull()) {
             /* Signal that the constant array can contain null. */
-            arrayObjElementsFlow.addState(getAnalysis(), TypeState.forNull());
+            return arrayObjElementsFlow.addState(getAnalysis(), TypeState.forNull());
         }
+        return false;
     }
 
     @Override
-    public void forNonNullArrayElement(JavaConstant array, AnalysisType arrayType, JavaConstant elementConstant, AnalysisType elementType, int elementIndex) {
+    public boolean forNonNullArrayElement(JavaConstant array, AnalysisType arrayType, JavaConstant elementConstant, AnalysisType elementType, int elementIndex, ScanReason reason) {
         assert elementType.isInstantiated() : elementType;
         ArrayElementsTypeFlow arrayObjElementsFlow = getArrayElementsFlow(array, arrayType);
         PointsToAnalysis analysis = getAnalysis();
         AnalysisObject constantObject = bb.analysisPolicy().createConstantObject(analysis, elementConstant, elementType);
         if (!arrayObjElementsFlow.getState().containsObject(constantObject)) {
             /* Add the constant element to the constant's array type flow. */
             TypeState elementTypeState = TypeState.forNonNullObject(analysis, constantObject);
-            arrayObjElementsFlow.addState(analysis, elementTypeState);
+            return arrayObjElementsFlow.addState(analysis, elementTypeState);
         }
+        return false;
     }
 
     /**
@@ -125,7 +131,7 @@ private ArrayElementsTypeFlow getArrayElementsFlow(JavaConstant array, AnalysisT
     }
 
     @Override
-    public void forScannedConstant(JavaConstant value, ObjectScanner.ScanReason reason) {
+    public void forScannedConstant(JavaConstant value, ScanReason reason) {
         PointsToAnalysis analysis = getAnalysis();
         Object valueObj = analysis.getSnippetReflectionProvider().asObject(Object.class, value);
         AnalysisType type = bb.getMetaAccess().lookupJavaType(valueObj.getClass());

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

@@ -24,22 +24,27 @@
  */
 package com.oracle.graal.pointsto;
 
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.function.Function;
+
+import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
+import org.graalvm.compiler.debug.DebugContext;
+import org.graalvm.compiler.debug.DebugHandlersFactory;
+import org.graalvm.compiler.graph.NodeSourcePosition;
+import org.graalvm.compiler.options.OptionValues;
+
 import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
+import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.graal.pointsto.meta.AnalysisType.UsageKind;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.meta.HostedProviders;
 import com.oracle.graal.pointsto.util.Timer;
-import jdk.vm.ci.meta.ConstantReflectionProvider;
-import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
-import org.graalvm.compiler.debug.DebugContext;
-import org.graalvm.compiler.debug.DebugHandlersFactory;
-import org.graalvm.compiler.graph.NodeSourcePosition;
-import org.graalvm.compiler.options.OptionValues;
 
-import java.io.PrintWriter;
-import java.util.List;
-import java.util.function.Function;
+import jdk.vm.ci.meta.ConstantReflectionProvider;
 
 /**
  * Central static analysis interface that groups together the functionality of reachability analysis
@@ -104,4 +109,20 @@ public interface BigBang extends ReachabilityAnalysis, HeapScanning {
     default boolean isCallAllowed(PointsToAnalysis bb, AnalysisMethod caller, AnalysisMethod target, NodeSourcePosition srcPosition) {
         return true;
     }
+
+    /**
+     * Callback for when a field is marked as read, written, or unsafe accessed. See
+     * {@link AnalysisField#isAccessed()} for field accessibility definition.
+     */
+    @SuppressWarnings("unused")
+    default void onFieldAccessed(AnalysisField field) {
+    }
+
+    @SuppressWarnings("unused")
+    default void onTypeInstantiated(AnalysisType type, UsageKind usageKind) {
+    }
+
+    @SuppressWarnings("unused")
+    default void onTypeScanned(AnalysisType type) {
+    }
 }

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

@@ -30,9 +30,9 @@
 import java.util.Collections;
 import java.util.List;
 
-import com.oracle.graal.pointsto.meta.PointsToAnalysisMethod;
 import org.graalvm.compiler.options.OptionValues;
 
+import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
 import com.oracle.graal.pointsto.flow.AbstractSpecialInvokeTypeFlow;
 import com.oracle.graal.pointsto.flow.AbstractVirtualInvokeTypeFlow;
 import com.oracle.graal.pointsto.flow.ActualReturnTypeFlow;
@@ -47,6 +47,7 @@
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
+import com.oracle.graal.pointsto.meta.PointsToAnalysisMethod;
 import com.oracle.graal.pointsto.typestate.TypeState;
 import com.oracle.graal.pointsto.typestore.ArrayElementsTypeStore;
 import com.oracle.graal.pointsto.typestore.FieldTypeStore;
@@ -208,7 +209,14 @@ public void onObservedUpdate(PointsToAnalysis bb) {
                     continue;
                 }
 
-                AnalysisMethod method = type.resolveConcreteMethod(getTargetMethod());
+                AnalysisMethod method = null;
+                try {
+                    method = type.resolveConcreteMethod(targetMethod);
+                } catch (UnsupportedFeatureException ex) {
+                    /* Register the ex with UnsupportedFeatures and allow analysis to continue. */
+                    bb.getUnsupportedFeatures().addMessage("resolve_" + targetMethod.format("%H.%n(%p)"), targetMethod, ex.getMessage());
+                }
+
                 if (method == null || Modifier.isAbstract(method.getModifiers())) {
                     /*
                      * Type states can be conservative, i.e., we can have receiver types that do not