WIP7.

Author: cstancu

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

@@ -244,8 +244,6 @@ public enum UsageKind {
         /* The registration task initializes the type. */
         this.initializationTask = new AnalysisFuture<>(() -> universe.initializeType(this), null);
         this.typeData = new AnalysisFuture<>(() -> {
-            /* Init the type before reading its static fields. */
-            initializationTask.ensureDone();
             AnalysisError.guarantee(universe.getHeapScanner() != null, "Heap scanner is not available.");
             return universe.getHeapScanner().computeTypeData(this);
         });

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

@@ -33,6 +33,7 @@
 import org.graalvm.nativeimage.Platforms;
 import org.graalvm.word.WordBase;
 
+import com.oracle.graal.pointsto.heap.value.ValueSupplier;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
@@ -46,6 +47,7 @@
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.SVMHost;
 import com.oracle.svm.hosted.classinitialization.ClassInitializationSupport;
+import com.oracle.svm.hosted.meta.HostedMetaAccess;
 
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
@@ -102,6 +104,42 @@ public JavaConstant readValue(MetaAccessProvider suppliedMetaAccess, AnalysisFie
         return interceptValue(field, value);
     }
 
+    /** Read the field value and wrap it in a value supplier. */
+    public ValueSupplier<JavaConstant> readHostedFieldValue(AnalysisField field, HostedMetaAccess hMetaAccess, JavaConstant receiver) {
+        if (classInitializationSupport.shouldInitializeAtRuntime(field.getDeclaringClass())) {
+            if (field.isStatic()) {
+                return ValueSupplier.eagerValue(readUninitializedStaticValue(field));
+            } else {
+                /*
+                 * Classes that are initialized at run time must not have instances in the image
+                 * heap. Invoking instance methods would miss the class initialization checks. Image
+                 * generation should have been aborted earlier with a user-friendly message, this is
+                 * just a safeguard.
+                 */
+                throw VMError.shouldNotReachHere("Cannot read instance field of a class that is initialized at run time: " + field.format("%H.%n"));
+            }
+        }
+
+        if (field.wrapped instanceof ReadableJavaField) {
+            ReadableJavaField readableField = (ReadableJavaField) field.wrapped;
+            if (readableField.isValueAvailableBeforeAnalysis()) {
+                /* Materialize and return the value. */
+                return ValueSupplier.eagerValue(universe.lookup(readableField.readValue(metaAccess, receiver)));
+            } else {
+                /*
+                 * Return a lazy value. This applies to RecomputeFieldValue.Kind.FieldOffset and
+                 * RecomputeFieldValue.Kind.Custom. The value becomes available during hosted
+                 * universe building and is installed by calling
+                 * ComputedValueField.processSubstrate() or by ComputedValueField.readValue().
+                 * Attempts to materialize the value earlier will result in an error.
+                 */
+                return ValueSupplier.lazyValue(() -> universe.lookup(readableField.readValue(hMetaAccess, receiver)),
+                                readableField::isValueAvailable);
+            }
+        }
+        return ValueSupplier.eagerValue(universe.lookup(originalConstantReflection.readFieldValue(field.wrapped, receiver)));
+    }
+
     /*
      * Static fields of classes that are initialized at run time have the default (uninitialized)
      * value in the image heap. But there is one important exception:
@@ -126,7 +164,8 @@ public JavaConstant readValue(MetaAccessProvider suppliedMetaAccess, AnalysisFie
      * pretty likely (although not guaranteed) that we are not returning an unintended value for a
      * class that is re-initialized at run time.
      */
-    public static JavaConstant readUninitializedStaticValue(AnalysisField field) {
+    public JavaConstant readUninitializedStaticValue(AnalysisField field) {
+        assert classInitializationSupport.shouldInitializeAtRuntime(field.getDeclaringClass());
         JavaKind kind = field.getJavaKind();
 
         boolean canHaveConstantValueAttribute = kind.isPrimitive() || field.getType().getName().equals("Ljava/lang/String;");

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

@@ -39,14 +39,12 @@
 import com.oracle.graal.pointsto.heap.value.ValueSupplier;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
-import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.util.AnalysisFuture;
 import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.meta.ReadableJavaField;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.ImageClassLoader;
-import com.oracle.svm.hosted.SVMHost;
 import com.oracle.svm.hosted.ameta.AnalysisConstantReflectionProvider;
 import com.oracle.svm.hosted.meta.HostedMetaAccess;
 import com.oracle.svm.util.ReflectionUtil;
@@ -85,10 +83,6 @@ protected Class<?> getClass(String className) {
         return loader.findClassOrFail(className);
     }
 
-    protected boolean shouldInitializeAtRunTime(AnalysisType type) {
-        return ((SVMHost) hostVM).getClassInitializationSupport().shouldInitializeAtRuntime(type);
-    }
-
     @Override
     protected AnalysisFuture<ImageHeapObject> getOrCreateConstantReachableTask(JavaConstant javaConstant, ScanReason reason, Consumer<ScanReason> onAnalysisModified) {
         VMError.guarantee(javaConstant instanceof SubstrateObjectConstant, "Not a substrate constant " + javaConstant);
@@ -118,34 +112,8 @@ public boolean isValueAvailable(AnalysisField field) {
 
     @Override
     protected ValueSupplier<JavaConstant> readHostedFieldValue(AnalysisField field, JavaConstant receiver) {
-        if (field.isStatic() && shouldInitializeAtRunTime(field.getDeclaringClass())) {
-            /*
-             * Read the uninitialized field value. When all constant reads will be routed through
-             * the heap snapshot this can be moved to AnalysisConstantReflectionProvider, however
-             * currently we want to read raw values directly from HotSpot.
-             */
-            return ValueSupplier.eagerValue(AnalysisConstantReflectionProvider.readUninitializedStaticValue(field));
-        }
-
-        if (field.wrapped instanceof ReadableJavaField) {
-            ReadableJavaField readableField = (ReadableJavaField) field.wrapped;
-            if (readableField.isValueAvailableBeforeAnalysis()) {
-                /* Materialize and return the value. */
-                JavaConstant value = universe.lookup(readableField.readValue(metaAccess, receiver));
-                return ValueSupplier.eagerValue(value);
-            } else {
-                /*
-                 * Return a lazy value. This applies to RecomputeFieldValue.Kind.FieldOffset and
-                 * RecomputeFieldValue.Kind.Custom. The value becomes available during hosted
-                 * universe building and is installed by calling
-                 * ComputedValueField.processSubstrate() or by ComputedValueField.readValue().
-                 * Attempts to materialize the value earlier will result in an error.
-                 */
-                return ValueSupplier.lazyValue(() -> universe.lookup(readableField.readValue(hostedMetaAccess, receiver)),
-                                readableField::isValueAvailable);
-            }
-        }
-        return super.readHostedFieldValue(field, receiver);
+        AnalysisConstantReflectionProvider aConstantReflection = (AnalysisConstantReflectionProvider) this.constantReflection;
+        return aConstantReflection.readHostedFieldValue(field, hostedMetaAccess, receiver);
     }
 
     @Override