[GR-36602] Add AnnotationSupport guarantees.

PullRequest: graal/10905

Author: cstancu

compiler/src/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java

@@ -2304,7 +2304,7 @@ private boolean tryNodePluginForInvocation(ValueNode[] args, ResolvedJavaMethod
      * Otherwise, it returns the {@link InlineInfo} that lead to the decision to not inline it, or
      * {@code null} if there is no {@link InlineInfo} for this method.
      */
-    private InlineInfo tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod) {
+    protected InlineInfo tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod) {
         boolean canBeInlined = forceInliningEverything || parsingIntrinsic() || targetMethod.canBeInlined();
         if (!canBeInlined) {
             return null;

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

@@ -315,7 +315,7 @@ public static String asString(BigBang bb, JavaConstant constant, boolean appendT
         if (obj == null) {
             return "null";
         }
-        String str = obj.getClass().getTypeName() + '@' + Integer.toHexString(System.identityHashCode(obj));
+        String str = analysisType(bb, obj).toJavaName() + '@' + Integer.toHexString(System.identityHashCode(obj));
         if (appendToString) {
             try {
                 str += ": " + limit(obj.toString(), 80).replace(System.lineSeparator(), "");
@@ -431,8 +431,8 @@ public ScanReason getPrevious() {
     }
 
     public static class OtherReason extends ScanReason {
-        public static final ScanReason RESCAN = new OtherReason("Manually triggered rescan");
-        public static final ScanReason HUB = new OtherReason("DynamicHub scan");
+        public static final ScanReason RESCAN = new OtherReason("manually triggered rescan");
+        public static final ScanReason HUB = new OtherReason("scanning a class constant");
 
         final String reason;
 

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

@@ -718,6 +718,7 @@ public void runAnalysis(DebugContext debugContext, Function<AnalysisUniverse, Bo
                     }
                     /* Outer analysis loop is done. Check if heap verification modifies analysis. */
                     if (!analysisModified()) {
+                        assert universe.getHeapVerifier().checkTypes();
                         return;
                     }
                 }

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

@@ -63,6 +63,7 @@ static class Options {
     private boolean analysisModified;
 
     private final int verbosity;
+    private int iterations;
 
     public HeapSnapshotVerifier(BigBang bb, ImageHeap imageHeap, ImageHeapScanner scanner) {
         this.bb = bb;
@@ -76,6 +77,7 @@ public boolean requireAnalysisIteration(CompletionExecutor executor) throws Inte
         info("Verifying the heap snapshot...");
         analysisModified = false;
         heapPatched = false;
+        iterations++;
         scannedObjects.reset();
         ObjectScanner objectScanner = new ObjectScanner(bb, executor, scannedObjects, new ScanningObserver());
         executor.start();
@@ -91,14 +93,24 @@ public boolean requireAnalysisIteration(CompletionExecutor executor) throws Inte
         if (analysisModified) {
             info("Heap verification modified the analysis state. Executing an additional analysis iteration.");
         } else {
-            info("Heap verification didn't modify the analysis state. Exiting analysis.");
+            info("Heap verification didn't modify the analysis state. Heap state stabilized after " + iterations + " iterations.");
+            info("Exiting analysis.");
         }
         return analysisModified;
     }
 
     protected void scanTypes(@SuppressWarnings("unused") ObjectScanner objectScanner) {
     }
 
+    public boolean checkTypes() {
+        for (AnalysisType t : bb.getUniverse().getTypes()) {
+            if (t.isReachable() && !initializationInfoComputed(t)) {
+                throw AnalysisError.shouldNotReachHere("Type is not initialized " + t.getName());
+            }
+        }
+        return true;
+    }
+
     public void cleanupAfterAnalysis() {
         scannedObjects = null;
     }
@@ -209,34 +221,56 @@ public void forEmbeddedRoot(JavaConstant root, ScanReason reason) {
 
         @Override
         public void forScannedConstant(JavaConstant value, ScanReason reason) {
-            AnalysisFuture<ImageHeapObject> task = imageHeap.getTask(value);
             Object object = constantAsObject(bb, value);
-            if (object.getClass().equals(Class.class)) {
+            Class<?> objectClass = object.getClass();
+            if (objectClass.equals(Class.class)) {
+                /*
+                 * Ensure that java.lang.Class constants are fully initialized and scanned. If a
+                 * type is marked as reachable during the verification then it's class
+                 * initialization info will be missing since
+                 * ClassInitializationFeature.buildClassInitializationInfo() hasn't processed it
+                 * yet.
+                 */
                 AnalysisType type = bb.getMetaAccess().lookupJavaType((Class<?>) object);
-                if (type.isReachable() && !initializationInfoComputed(type)) {
-                    /*
-                     * This means that the type has been marked as reachable during the verification
-                     * and ClassInitializationFeature.buildClassInitializationInfo() hasn't
-                     * processed it yet. Allow ClassInitializationFeature to build the
-                     * DynamicHub.classInitializationInfo.
-                     */
-                    onNoInitInfoForHub(value, reason);
+                if (!initializationInfoComputed(type)) {
+                    onNoInitInfoForClassConstant(type, reason);
+                } else {
+                    ensureTypeScanned(value, type, reason);
                 }
-                /* Make sure the DynamicHub value is scanned. */
-                if (task == null) {
-                    onNoTaskForHub(value, reason);
-                    scanner.toImageHeapObject(value, reason, null);
-                    heapPatched = true;
+            } else {
+                /*
+                 * Ensure that the Class of any other constants are also fully initialized and
+                 * scanned. An object replacer can introduce new types which otherwise could be
+                 * missed by the verifier. For example
+                 * com.oracle.svm.hosted.annotation.AnnotationObjectReplacer creates annotation
+                 * proxy types on the fly for constant annotation objects.
+                 */
+                AnalysisType type = bb.getMetaAccess().lookupJavaType(objectClass);
+                if (!initializationInfoComputed(type)) {
+                    onNoInitInfoForObjectType(value, type, reason);
                 } else {
-                    if (task.isDone()) {
-                        JavaConstant snapshot = task.guardedGet().getObject();
-                        if (!Objects.equals(snapshot, value)) {
-                            throw error(reason, "Value mismatch for hub snapshot: %s %n new value: %s %n", snapshot, value);
-                        }
-                    } else {
-                        /* If there is a task for the hub it should have been triggered. */
-                        throw error(reason, "Snapshot not yet computed for hub %n new value: %s %n", value);
+                    ensureTypeScanned(bb.getConstantReflectionProvider().asJavaClass(type), type, reason);
+                }
+            }
+        }
+
+        private void ensureTypeScanned(JavaConstant value, AnalysisType type, ScanReason reason) {
+            AnalysisError.guarantee(type.isReachable(), "The heap snapshot verifier discovered a type not marked as reachable " + type.toJavaName());
+            AnalysisFuture<ImageHeapObject> task = imageHeap.getTask(value);
+            /* Make sure the DynamicHub value is scanned. */
+            if (task == null) {
+                onNoTaskForClassConstant(value, reason);
+                scanner.toImageHeapObject(value, reason, null);
+                heapPatched = true;
+            } else {
+                if (task.isDone()) {
+                    JavaConstant snapshot = task.guardedGet().getObject();
+                    if (!Objects.equals(snapshot, value)) {
+                        throw error(reason, "Value mismatch for class constant snapshot: %s %n new value: %s %n", snapshot, value);
                     }
+                } else {
+                    /* If there is a task for the hub it should have been triggered. */
+                    throw error(reason, "Snapshot not yet computed for class constant %n new value: %s %n", value);
                 }
             }
         }
@@ -246,17 +280,24 @@ protected boolean initializationInfoComputed(@SuppressWarnings("unused") Analysi
         return true;
     }
 
-    private void onNoInitInfoForHub(JavaConstant value, ScanReason reason) {
+    private void onNoInitInfoForClassConstant(AnalysisType type, ScanReason reason) {
+        analysisModified = true;
+        if (printAll()) {
+            warning(reason, "No initialization info computed for class constant %s %n", type.toJavaName());
+        }
+    }
+
+    private void onNoInitInfoForObjectType(JavaConstant object, AnalysisType type, ScanReason reason) {
         analysisModified = true;
         if (printAll()) {
-            warning(reason, "No initialization info computed for hub %s %n", value);
+            warning(reason, "No initialization info computed for class %s of object %s %n", type.toJavaName(), object);
         }
     }
 
-    private void onNoTaskForHub(JavaConstant value, ScanReason reason) {
+    private void onNoTaskForClassConstant(JavaConstant value, ScanReason reason) {
         analysisModified = true;
         if (printAll()) {
-            warning(reason, "No snapshot task found for hub %s %n", value);
+            warning(reason, "No snapshot task found for class constant %s %n", value);
         }
     }
 

substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/FieldsOffsetsFeature.java

@@ -45,6 +45,8 @@
 import org.graalvm.nativeimage.hosted.Feature;
 
 import com.oracle.graal.pointsto.api.DefaultUnsafePartition;
+import com.oracle.graal.pointsto.meta.AnalysisField;
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
 import com.oracle.svm.core.graal.GraalEdgeUnsafePartition;
 import com.oracle.svm.core.util.VMError;
@@ -162,6 +164,9 @@ private static Object replaceFieldsOffsets(Object source) {
     /* Invoked once for every class that is reachable in the native image. */
     private static void classReachabilityListener(DuringAnalysisAccess a, Class<?> newlyReachableClass) {
         DuringAnalysisAccessImpl access = (DuringAnalysisAccessImpl) a;
+        if (BuildPhaseProvider.isAnalysisFinished()) {
+            throw VMError.shouldNotReachHere("New class reachable after analysis: " + newlyReachableClass);
+        }
 
         if (Node.class.isAssignableFrom(newlyReachableClass) && newlyReachableClass != Node.class) {
             FieldsOffsetsFeature.<NodeClass<?>> registerClass(newlyReachableClass, GraalSupport.get().nodeClasses, NodeClass::get, false, access);
@@ -214,7 +219,9 @@ private static void registerFields(Fields fields, UnsafePartitionKind partitionK
         getReplacements().put(fields.getOffsets(), new FieldsOffsetsReplacement(fields));
 
         for (int i = 0; i < fields.getCount(); i++) {
-            config.registerAsUnsafeAccessed(config.getMetaAccess().lookupJavaField(findField(fields, i)), partitionKind);
+            AnalysisField aField = config.getMetaAccess().lookupJavaField(findField(fields, i));
+            aField.getType().registerAsReachable();
+            config.registerAsUnsafeAccessed(aField, partitionKind);
         }
     }
 

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

@@ -83,6 +83,7 @@
 import com.oracle.graal.pointsto.meta.HostedProviders;
 import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy;
 import com.oracle.graal.pointsto.util.GraalAccess;
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.RuntimeAssertionsSupport;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateUtil;
@@ -272,6 +273,9 @@ public void initializeType(AnalysisType analysisType) {
         if (!analysisType.isReachable()) {
             throw VMError.shouldNotReachHere("Registering and initializing a type that was not yet marked as reachable: " + analysisType);
         }
+        if (BuildPhaseProvider.isAnalysisFinished()) {
+            throw VMError.shouldNotReachHere("Initializing type after analysis: " + analysisType);
+        }
 
         /* Decide when the type should be initialized. */
         classInitializationSupport.maybeInitializeHosted(analysisType);

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ameta/AnalysisConstantReflectionProvider.java

@@ -38,6 +38,7 @@
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.util.AnalysisError;
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.RuntimeAssertionsSupport;
 import com.oracle.svm.core.annotate.InjectAccessors;
 import com.oracle.svm.core.graal.meta.SharedConstantReflectionProvider;
@@ -327,6 +328,9 @@ protected static void registerAsReachable(SVMHost hostVM, DynamicHub dynamicHub)
         assert dynamicHub != null;
         /* Make sure that the DynamicHub of this type ends up in the native image. */
         AnalysisType valueType = hostVM.lookupType(dynamicHub);
+        if (!valueType.isReachable() && BuildPhaseProvider.isAnalysisFinished()) {
+            throw VMError.shouldNotReachHere("Registering type as reachable after analysis: " + valueType);
+        }
         valueType.registerAsReachable();
     }
 

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

@@ -42,10 +42,12 @@
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
 import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.hub.AnnotatedSuperInfo;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.GenericInfo;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
+import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.SVMHost;
 import com.oracle.svm.util.ReflectionUtil;
 
@@ -93,6 +95,9 @@ public DynamicHubInitializer(AnalysisMetaAccess metaAccess, UnsupportedFeatures
 
     public void initializeMetaData(ImageHeapScanner heapScanner, AnalysisType type) {
         assert type.isReachable() : "Type " + type.toJavaName(true) + " is not marked as reachable.";
+        if (BuildPhaseProvider.isAnalysisFinished()) {
+            throw VMError.shouldNotReachHere("Initializing type metadata after analysis: " + type);
+        }
 
         Class<?> javaClass = type.getJavaClass();
         heapScanner.rescanObject(javaClass.getPackage());

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

@@ -70,7 +70,7 @@ private static boolean imageStateModified() {
 
     @Override
     protected void scanTypes(ObjectScanner objectScanner) {
-        SVMHost svmHost = (SVMHost) bb.getHostVM();
+        SVMHost svmHost = svmHost();
         /* First make sure that all DynamicHub fields are initialized and scanned. */
         bb.getUniverse().getTypes().stream().filter(AnalysisType::isReachable).forEach(((NativeImagePointsToAnalysis) bb)::initializeMetaData);
         /* Then verify the snapshots of reachable types, i.e., compare them with hosted values. */
@@ -84,7 +84,11 @@ private static void verifyHub(SVMHost svmHost, ObjectScanner objectScanner, Anal
 
     @Override
     protected boolean initializationInfoComputed(AnalysisType type) {
-        DynamicHub hub = ((SVMHost) bb.getHostVM()).dynamicHub(type);
+        DynamicHub hub = svmHost().dynamicHub(type);
         return hub.getClassInitializationInfo() != null;
     }
+
+    private SVMHost svmHost() {
+        return (SVMHost) bb.getHostVM();
+    }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SubstrateGraphBuilderPhase.java

@@ -27,12 +27,17 @@
 import org.graalvm.compiler.java.BytecodeParser;
 import org.graalvm.compiler.java.GraphBuilderPhase;
 import org.graalvm.compiler.nodes.StructuredGraph;
+import org.graalvm.compiler.nodes.ValueNode;
 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration;
+import org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo;
 import org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext;
 import org.graalvm.compiler.nodes.spi.CoreProviders;
 import org.graalvm.compiler.phases.OptimisticOptimizations;
 import org.graalvm.compiler.word.WordTypes;
 
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.graal.pointsto.meta.AnalysisType;
+
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 public class SubstrateGraphBuilderPhase extends SharedGraphBuilderPhase {
@@ -52,5 +57,20 @@ public SubstrateBytecodeParser(GraphBuilderPhase.Instance graphBuilderInstance,
                         IntrinsicContext intrinsicContext, boolean explicitExceptionEdges) {
             super(graphBuilderInstance, graph, parent, method, entryBCI, intrinsicContext, explicitExceptionEdges);
         }
+
+        @Override
+        protected InlineInfo tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod) {
+            InlineInfo inlineInfo = super.tryInline(args, targetMethod);
+            if (inlineInfo == InlineInfo.DO_NOT_INLINE_WITH_EXCEPTION && targetMethod instanceof AnalysisMethod) {
+                /*
+                 * The target methods of intrinsified calls are still present in the image so their
+                 * type is reachable. The methods are used as keys in the
+                 * InvocationPlugins.resolvedRegistrations map reachable from
+                 * SubstrateReplacements.snippetInvocationPlugins.
+                 */
+                ((AnalysisType) targetMethod.getDeclaringClass()).registerAsReachable();
+            }
+            return inlineInfo;
+        }
     }
 }