Ensure AnalysisType initialization status is stable between layers.

Author: cstancu

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

@@ -363,10 +363,12 @@ private ImageHeapArray createImageHeapObjectArray(JavaConstant constant, Analysi
 
     public void registerBaseLayerValue(ImageHeapConstant constant, Object reason) {
         JavaConstant hostedValue = constant.getHostedObject();
+        AnalysisError.guarantee(hostedValue.isNonNull(), "A relinked constant cannot have a NULL_CONSTANT hosted value.");
         Object existingSnapshot = imageHeap.getSnapshot(hostedValue);
         if (existingSnapshot != null) {
             AnalysisError.guarantee(existingSnapshot == constant || existingSnapshot instanceof AnalysisFuture<?> task && task.ensureDone() == constant,
-                            "Found unexpected snapshot value for base layer value. Reason: %s.", reason);
+                            "Found unexpected snapshot value for base layer value.%nExisting value: %s.%nNew value: %s.%nHosted value: %s.%nReason: %s.",
+                            existingSnapshot, constant, hostedValue, reason);
         } else {
             imageHeap.setValue(hostedValue, constant);
         }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/imagelayer/NativeImageLayers.md

@@ -201,6 +201,16 @@ native-image --module-path target/AwesomeLib-1.0-SNAPSHOT.jar --shared
 - A shared layer is using the _.so_ extension to conform with the standard OS loader restrictions. However, it is not a
   standard shared library file, and it cannot be used with other applications.
 
+### Class Initialization
+
+With Native Image Layers class initialization needs to be coherent between layers.
+To achieve this we enforce that the initialization state of types in shared layers stays exactly the same in the
+subsequent dependent layers.
+More concretely if a class `A` is initialized at build time in a base layer, then it will be automatically
+initialized at build time in the extension layers. The same holds for run time initialization.
+In the future we plan to relax this restriction and allow run-time initialized types in base layers to be promoted
+into build-time initialized types in the extension layers.
+
 ## Packaging Native Image Layers
 
 At build time a shared layer is stored in a layer archive that contains the following artifacts:

substratevm/src/com.oracle.svm.hosted/resources/SharedLayerSnapshotCapnProtoSchema.capnp

@@ -1,3 +1,7 @@
+# Schema file for the layer snapshot.
+# After modifying this file regenerate the schema SharedLayerSnapshotCapnProtoSchemaHolder.java file with:
+# mx capnp-compile
+
 @0x9eb32e19f86ee174;
 using Java = import "/capnp/java.capnp";
 $Java.package("com.oracle.svm.hosted.imagelayer");
@@ -21,6 +25,7 @@ struct PersistedAnalysisType {
   # Most of these fields apply only to instances and could be in a union or a separate structure:
   isInterface @7 :Bool;
   isEnum @8 :Bool;
+  # True if the type's initialization status was computed as BUILD_TIME. Build-time initialized types are not simulated.
   isInitialized @9 :Bool;
   isLinked @10 :Bool;
   sourceFileName @11 :Text;

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/ClassInitializationSupport.java

@@ -409,19 +409,22 @@ public void forceInitializeHosted(Class<?> clazz, String reason, boolean allowIn
 
         classInitializationConfiguration.insert(clazz.getTypeName(), InitKind.BUILD_TIME, reason, true);
         InitKind initKind = ensureClassInitialized(clazz, allowInitializationErrors);
-        if (ImageLayerBuildingSupport.buildingApplicationLayer() && initKind == InitKind.RUN_TIME) {
-            /*
-             * Special case for application layer building. If a base layer class was configured
-             * with --initialize-at-build-time but its initialization failed, then the computed init
-             * kind will be RUN_TIME, different from its configured init kind of BUILD_TIME. In the
-             * app layer the computed init kind from the previous layer is registered as the
-             * configured init kind, but if the --initialize-at-build-time was already processed for
-             * the class then it will already have a conflicting configured init kind of BUILD_TIME.
-             * Update the configuration registry to allow the RUN_TIME registration coming from the
-             * base layer. (GR-65405)
-             */
+        if (initKind == InitKind.RUN_TIME) {
             assert allowInitializationErrors || !LinkAtBuildTimeSupport.singleton().linkAtBuildTime(clazz);
-            classInitializationConfiguration.updateStrict(clazz.getTypeName(), InitKind.BUILD_TIME, InitKind.RUN_TIME, "Build time initialization failed.");
+            if (ImageLayerBuildingSupport.buildingApplicationLayer()) {
+                /*
+                 * Special case for application layer building. If a base layer class was configured
+                 * with --initialize-at-build-time but its initialization failed, then the computed
+                 * init kind will be RUN_TIME, different from its configured init kind of
+                 * BUILD_TIME. In the app layer the computed init kind from the previous layer is
+                 * registered as the configured init kind, but if the --initialize-at-build-time was
+                 * already processed for the class then it will already have a conflicting
+                 * configured init kind of BUILD_TIME. Update the configuration registry to allow
+                 * the RUN_TIME registration coming from the base layer. (GR-65405)
+                 */
+                classInitializationConfiguration.updateStrict(clazz.getTypeName(), InitKind.BUILD_TIME, InitKind.RUN_TIME,
+                                "Allow the registration of the computed run time initialization kind from a previous layer for classes whose build time initialization fails.");
+            }
         }
         classInitKinds.put(clazz, initKind);
 

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/imagelayer/SVMImageLayerLoader.java

@@ -69,6 +69,7 @@
 import com.oracle.graal.pointsto.heap.ImageHeapPrimitiveArray;
 import com.oracle.graal.pointsto.heap.ImageHeapRelocatableConstant;
 import com.oracle.graal.pointsto.heap.value.ValueSupplier;
+import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider;
 import com.oracle.graal.pointsto.infrastructure.ResolvedSignature;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
@@ -166,6 +167,7 @@ public class SVMImageLayerLoader extends ImageLayerLoader {
 
     private HostedUniverse hostedUniverse;
 
+    /** Maps from the previous layer element id to the linked elements in this layer. */
     protected final Map<Integer, AnalysisType> types = new ConcurrentHashMap<>();
     protected final Map<Integer, AnalysisMethod> methods = new ConcurrentHashMap<>();
     protected final Map<Integer, AnalysisField> fields = new ConcurrentHashMap<>();
@@ -679,6 +681,7 @@ private int getBaseLayerTypeId(AnalysisType type) {
             /* The type was not reachable in the base image */
             return -1;
         }
+        initializeBaseLayerTypeBeforePublishing(type, typeData);
         int id = typeData.getId();
         int hubIdentityHashCode = typeData.getHubIdentityHashCode();
         typeToHubIdentityHashCode.put(id, hubIdentityHashCode);
@@ -696,6 +699,39 @@ protected PersistedAnalysisType.Reader findBaseLayerType(AnalysisType type) {
         return findType(typeId);
     }
 
+    /**
+     * This method is invoked *before* the {@link AnalysisType} is published in the
+     * {@link AnalysisUniverse}. The side effects of this method are visible to other threads that
+     * are consuming the {@link AnalysisType} object.
+     */
+    @SuppressWarnings("try")
+    private void initializeBaseLayerTypeBeforePublishing(AnalysisType type, PersistedAnalysisType.Reader typeData) {
+        assert !(type.getWrapped() instanceof BaseLayerType);
+        /*
+         * For types reachable in this layer register the *computed* initialization kind extracted
+         * from the previous layer. This will cause base layer types to have a *strict*
+         * initialization kind in this layer which will prevent further changes to the
+         * initialization kind, even in ways that would otherwise be considered compatible, e.g.,
+         * RUN_TIME -> BUILD_TIME. Similarly, if a different initialization kind was already
+         * registered in this layer registration will fail.
+         * 
+         * Note that this is done after the app-layer class initialization specification is applied,
+         * so we don't have to traverse all types. Moreover, for package-level specification this
+         * should also be OK, because package-level specification is only a suggestion and the
+         * base-layer will always win as it is going over user classes.
+         */
+        Class<?> clazz = OriginalClassProvider.getJavaClass(type);
+        if (typeData.getIsInitialized()) {
+            classInitializationSupport.withUnsealedConfiguration(() -> classInitializationSupport.initializeAtBuildTime(clazz, "computed in a previous layer"));
+        } else {
+            classInitializationSupport.withUnsealedConfiguration(() -> classInitializationSupport.initializeAtRunTime(clazz, "computed in a previous layer"));
+        }
+    }
+
+    /**
+     * This method is invoked *after* the {@link AnalysisType} is published in the
+     * {@link AnalysisUniverse} and it may execute concurrently with other threads using the type.
+     */
     @Override
     public void initializeBaseLayerType(AnalysisType type) {
         int id = getBaseLayerTypeId(type);
@@ -1304,6 +1340,19 @@ private ImageHeapConstant getOrCreateConstant(int id, JavaConstant parentReachab
             throw GraalError.shouldNotReachHere("The constant was not reachable in the base image");
         }
 
+        /*
+         * Important: If this is a constant originating from a static final field ensure that the
+         * field declaring type is initialized before the field type is accessed below. This is to
+         * avoid issue with class initialization execution order in class initialization cycles.
+         */
+        if (baseLayerConstant.isObject() && !baseLayerConstant.getIsSimulated()) {
+            Relinking.Reader relinking = baseLayerConstant.getObject().getRelinking();
+            if (relinking.isFieldConstant()) {
+                AnalysisField analysisField = getAnalysisFieldForBaseLayerId(relinking.getFieldConstant().getOriginFieldId());
+                VMError.guarantee(analysisField.getDeclaringClass().isInitialized());
+            }
+        }
+
         AnalysisType type = getAnalysisTypeForBaseLayerId(baseLayerConstant.getTypeId());
 
         long objectOffset = baseLayerConstant.getObjectOffset();
@@ -1581,31 +1630,18 @@ private JavaConstant lookupHostedObject(PersistedConstant.Reader baseLayerConsta
         } else if (relinking.isFieldConstant()) {
             var fieldConstant = relinking.getFieldConstant();
             AnalysisField analysisField = getAnalysisFieldForBaseLayerId(fieldConstant.getOriginFieldId());
-            if (!(analysisField.getWrapped() instanceof BaseLayerField) && !AnnotationAccess.isAnnotationPresent(analysisField, Delete.class)) {
-                VMError.guarantee(!baseLayerConstant.getIsSimulated(), "Should not alter the initialization status for simulated constants.");
+            if (shouldRelinkField(analysisField)) {
+                VMError.guarantee(!baseLayerConstant.getIsSimulated(), "Cannot relink simulated constants.");
                 /*
                  * The declaring type of relinked fields was already initialized in the previous
                  * layer (see SVMImageLayerWriter#shouldRelinkField).
                  */
-                if (fieldConstant.getRequiresLateLoading()) {
-                    /*
-                     * Fields with a field value transformer are relinked later, after all possible
-                     * transformers have been registered. *Guarantee* that the declaring type has
-                     * been initialized by now. Note that reading the field below will prevent a
-                     * transformer to be installed at a later time.
-                     */
-                    VMError.guarantee(analysisField.getDeclaringClass().isInitialized());
-                } else {
-                    /*
-                     * All other fields are relinked earlier, before the constant is needed. *Force*
-                     * the build time initialization of the declaring type before reading the field
-                     * value.
-                     */
-                    Class<?> fieldDeclaringClass = analysisField.getDeclaringClass().getJavaClass();
-                    classInitializationSupport.initializeAtBuildTime(fieldDeclaringClass, "Already initialized in base layer.");
-                }
+                VMError.guarantee(analysisField.getDeclaringClass().isInitialized());
                 /* Read fields through the hostedValueProvider and apply object replacement. */
-                return hostedValuesProvider.readFieldValueWithReplacement(analysisField, null);
+                JavaConstant javaConstant = hostedValuesProvider.readFieldValueWithReplacement(analysisField, null);
+                VMError.guarantee(javaConstant.isNonNull(), "Found NULL_CONSTANT when reading the hosted value of relinked field %s. " +
+                                "Since relinked fields should have a concrete non-null value there may be a class initialization mismatch.", analysisField);
+                return javaConstant;
             }
         } else if (clazz.equals(Class.class)) {
             /* DynamicHub corresponding to $$TypeSwitch classes are not relinked */
@@ -1630,6 +1666,11 @@ private JavaConstant lookupHostedObject(PersistedConstant.Reader baseLayerConsta
         return null;
     }
 
+    private static boolean shouldRelinkField(AnalysisField field) {
+        VMError.guarantee(field.isInBaseLayer());
+        return !(field.getWrapped() instanceof BaseLayerField) && !AnnotationAccess.isAnnotationPresent(field, Delete.class);
+    }
+
     @SuppressWarnings("unchecked")
     private Enum<?> getEnumValue(Text.Reader className, Text.Reader name) {
         Class<?> enumClass = imageLayerBuildingSupport.lookupClass(false, className.toString());