Delay reachability handlers callback execution until analysis is started.

Author: cstancu

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapScanner.java

@@ -130,33 +130,36 @@ public void scanEmbeddedRoot(JavaConstant root, BytecodePosition position) {
     public void onFieldRead(AnalysisField field) {
         assert field.isRead() : field;
         /* Check if the value is available before accessing it. */
-        AnalysisType declaringClass = field.getDeclaringClass();
         if (field.isStatic()) {
-            FieldScan reason = new FieldScan(field);
-            if (!field.installableInLayer()) {
-                /*
-                 * For non-installable static fields we do not scan the constant value, but instead
-                 * inject its type state in the field flow. This will be propagated to any
-                 * corresponding field loads.
-                 * 
-                 * GR-52421: the field state needs to be serialized from the base layer analysis
-                 */
-                if (field.getStorageKind().isObject()) {
-                    bb.injectFieldTypes(field, List.of(field.getType()), true);
-                } else if (bb.trackPrimitiveValues() && field.getStorageKind().isPrimitive()) {
-                    ((PointsToAnalysisField) field).saturatePrimitiveField();
-                }
-            } else if (isValueAvailable(field)) {
-                JavaConstant fieldValue = readStaticFieldValue(field);
-                if (fieldValue instanceof ImageHeapConstant imageHeapConstant && field.isFinal()) {
-                    AnalysisError.guarantee(imageHeapConstant.getOrigin() != null, "The origin of the constant %s should have been registered before", imageHeapConstant);
-                }
-                markReachable(fieldValue, reason);
-                notifyAnalysis(field, null, fieldValue, reason);
-            }
+            postTask(() -> onStaticFieldRead(field));
         } else {
             /* Trigger field scanning for the already processed objects. */
-            postTask(() -> onInstanceFieldRead(field, declaringClass));
+            postTask(() -> onInstanceFieldRead(field, field.getDeclaringClass()));
+        }
+    }
+
+    private void onStaticFieldRead(AnalysisField field) {
+        FieldScan reason = new FieldScan(field);
+        if (!field.installableInLayer()) {
+            /*
+             * For non-installable static fields we do not scan the constant value, but instead
+             * inject its type state in the field flow. This will be propagated to any corresponding
+             * field loads.
+             * 
+             * GR-52421: the field state needs to be serialized from the base layer analysis
+             */
+            if (field.getStorageKind().isObject()) {
+                bb.injectFieldTypes(field, List.of(field.getType()), true);
+            } else if (bb.trackPrimitiveValues() && field.getStorageKind().isPrimitive()) {
+                ((PointsToAnalysisField) field).saturatePrimitiveField();
+            }
+        } else if (isValueAvailable(field)) {
+            JavaConstant fieldValue = readStaticFieldValue(field);
+            if (fieldValue instanceof ImageHeapConstant imageHeapConstant && field.isFinal()) {
+                AnalysisError.guarantee(imageHeapConstant.getOrigin() != null, "The origin of the constant %s should have been registered before", imageHeapConstant);
+            }
+            markReachable(fieldValue, reason);
+            notifyAnalysis(field, null, fieldValue, reason);
         }
     }
 
@@ -890,9 +893,10 @@ protected AnalysisField lookupJavaField(String className, String fieldName) {
      *
      * In the (legacy) Feature.duringAnalysis state, the executor is not running and we must not
      * schedule new tasks, because that would be treated as "the analysis has not finished yet". So
-     * in that case we execute the task directly.
+     * in that case we execute the task directly. A task that runs in the Feature.duringAnalysis
+     * stage and modifies the analysis state should itself trigger an additional analysis iteration.
      */
-    private void maybeRunInExecutor(CompletionExecutor.DebugContextRunnable task) {
+    protected void maybeRunInExecutor(CompletionExecutor.DebugContextRunnable task) {
         if (bb.executorIsStarted()) {
             bb.postTask(task);
         } else {

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

@@ -787,6 +787,9 @@ public void setConcurrentAnalysisAccess(DuringAnalysisAccess access) {
     }
 
     public DuringAnalysisAccess getConcurrentAnalysisAccess() {
+        AnalysisError.guarantee(concurrentAnalysisAccess != null, "The requested DuringAnalysisAccess object is not available. " +
+                        "This means that an analysis task is executed too eagerly, before analysis. " +
+                        "Make sure that all analysis tasks are posted to the analysis execution engine.");
         return concurrentAnalysisAccess;
     }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/BuildPhaseProvider.java

@@ -35,6 +35,7 @@ public final class BuildPhaseProvider {
 
     private boolean featureRegistrationFinished;
     private boolean setupFinished;
+    private boolean analysisStarted;
     private boolean analysisFinished;
     private boolean hostedUniverseBuilt;
     private boolean readyForCompilation;
@@ -69,6 +70,14 @@ public static boolean isSetupFinished() {
         return ImageSingletons.contains(BuildPhaseProvider.class) && singleton().setupFinished;
     }
 
+    public static void markAnalysisStarted() {
+        singleton().analysisStarted = true;
+    }
+
+    public static boolean isAnalysisStarted() {
+        return ImageSingletons.contains(BuildPhaseProvider.class) && singleton().analysisStarted;
+    }
+
     public static void markAnalysisFinished() {
         singleton().analysisFinished = true;
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java

@@ -838,6 +838,8 @@ protected boolean runPointsToAnalysis(String imageName, OptionValues options, De
                          */
                         HostedImageLayerBuildingSupport.singleton().getLoader().relinkTransformedStaticFinalFieldValues();
                     }
+                    /* All pre-analysis set-up is done and the fixed-point analysis can start. */
+                    BuildPhaseProvider.markAnalysisStarted();
                     bb.runAnalysis(debug, (universe) -> {
                         try (StopTimer t2 = TimerCollection.createTimerAndStart(TimerCollection.Registry.FEATURES)) {
                             bb.getHostVM().notifyClassReachabilityListener(universe, config);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/analysis/NativeImagePointsToAnalysis.java

@@ -128,7 +128,7 @@ public AnnotationSubstitutionProcessor getAnnotationSubstitutionProcessor() {
 
     @Override
     public void onFieldAccessed(AnalysisField field) {
-        customTypeFieldHandler.handleField(field);
+        postTask(() -> customTypeFieldHandler.handleField(field));
     }
 
     @Override

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/SVMImageHeapScanner.java

@@ -40,6 +40,8 @@
 import com.oracle.graal.pointsto.heap.ImageHeapScanner;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
+import com.oracle.graal.pointsto.util.CompletionExecutor;
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.hosted.ImageClassLoader;
 import com.oracle.svm.hosted.ameta.AnalysisConstantReflectionProvider;
@@ -132,4 +134,17 @@ protected void onObjectReachable(ImageHeapConstant imageHeapConstant, ScanReason
             reflectionSupport.registerHeapDynamicHub(hub, reason);
         }
     }
+
+    @Override
+    protected void maybeRunInExecutor(CompletionExecutor.DebugContextRunnable task) {
+        if (BuildPhaseProvider.isAnalysisStarted()) {
+            super.maybeRunInExecutor(task);
+        } else {
+            /*
+             * Before the analysis is started post all scanning tasks to the executor. They will be
+             * executed after the analysis starts.
+             */
+            bb.postTask(task);
+        }
+    }
 }