When BUILD_TIME init fails in app layer update the configuration registry to reflect this.

Author: cstancu

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

@@ -35,6 +35,7 @@
 import org.graalvm.collections.Pair;
 
 import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.core.util.VMError;
 
 /**
  * Maintains user and system configuration for class initialization in Native Image.
@@ -52,12 +53,47 @@
  *
  * Every node tracks a list of reasons for the set configuration. This list helps the users debug
  * conflicts in the configuration.
+ * 
+ * A {@code strict} configuration, as specified by {@link InitializationNode#strict}, defines
+ * whether an initialization kind, as specified by {@link InitializationNode#kind}, was explicitly
+ * configured for the corresponding type. A {@code non-strict} configuration is a configuration
+ * inherited from a parent package configuration.
  */
 final class ClassInitializationConfiguration {
     private static final String ROOT_QUALIFIER = "";
     private static final int MAX_NUMBER_OF_REASONS = 10;
 
-    private InitializationNode root = new InitializationNode("", null, null, false);
+    private final InitializationNode root = new InitializationNode("", null, null, false);
+
+    synchronized void updateStrict(String classOrPackage, InitKind expectedKind, InitKind newKind, String reason) {
+        updateStrictRec(root, qualifierList(classOrPackage), expectedKind, newKind, reason);
+    }
+
+    private void updateStrictRec(InitializationNode node, List<String> classOrPackage, InitKind expectedKind, InitKind newKind, String reason) {
+        assert !classOrPackage.isEmpty();
+        assert node.qualifier.equals(classOrPackage.getFirst());
+        if (classOrPackage.size() == 1) {
+            VMError.guarantee(node.strict, "Expected a strict initialization policy for %s.", qualifiedName(node), newKind);
+            VMError.guarantee(newKind != expectedKind, "The initialization policy for %s is already %s.", qualifiedName(node), newKind);
+            VMError.guarantee(node.kind == expectedKind, "Found unexpected initialization policy for %s: expected %s, found %s.", qualifiedName(node), expectedKind, node.kind);
+            updateReason(node, reason);
+            node.kind = newKind;
+        } else {
+            List<String> tail = new ArrayList<>(classOrPackage);
+            tail.removeFirst();
+            String nextQualifier = tail.getFirst();
+            VMError.guarantee(node.children.containsKey(nextQualifier), "Expected that initialization node for %s already contains a child for %s.", qualifiedName(node), nextQualifier);
+            updateStrictRec(node.children.get(nextQualifier), tail, expectedKind, newKind, reason);
+        }
+    }
+
+    private static void updateReason(InitializationNode node, String reason) {
+        if (node.reasons.size() < MAX_NUMBER_OF_REASONS) {
+            node.reasons.add(reason);
+        } else if (node.reasons.size() == MAX_NUMBER_OF_REASONS) {
+            node.reasons.add("others");
+        }
+    }
 
     public synchronized void insert(String classOrPackage, InitKind kind, String reason, boolean strict) {
         assert kind != null;
@@ -93,11 +129,7 @@ private void insertRec(InitializationNode node, List<String> classOrPackage, Ini
                 node.strict = strict;
                 node.reasons.add(reason);
             } else if (node.kind == kind) {
-                if (node.reasons.size() < MAX_NUMBER_OF_REASONS) {
-                    node.reasons.add(reason);
-                } else if (node.reasons.size() == MAX_NUMBER_OF_REASONS) {
-                    node.reasons.add("others");
-                }
+                updateReason(node, reason);
             } else {
                 if (node.strict) {
                     throw UserError.abort("Incompatible change of initialization policy for %s: trying to change %s %s to %s %s",

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

@@ -44,18 +44,19 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import jdk.graal.compiler.core.common.ContextClassLoaderScope;
-import org.graalvm.nativeimage.libgraal.hosted.LibGraalLoader;
 import org.graalvm.collections.EconomicSet;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport;
 import org.graalvm.nativeimage.impl.clinit.ClassInitializationTracking;
+import org.graalvm.nativeimage.libgraal.hosted.LibGraalLoader;
 
+import com.oracle.graal.pointsto.BigBang;
 import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.BaseLayerType;
 import com.oracle.graal.pointsto.reports.ReportUtils;
 import com.oracle.svm.core.SubstrateOptions;
+import com.oracle.svm.core.imagelayer.ImageLayerBuildingSupport;
 import com.oracle.svm.core.option.AccumulatingLocatableMultiOptionValue;
 import com.oracle.svm.core.option.SubstrateOptionsParser;
 import com.oracle.svm.core.util.UserError;
@@ -65,6 +66,7 @@
 import com.oracle.svm.util.LogUtils;
 import com.oracle.svm.util.ModuleSupport;
 
+import jdk.graal.compiler.core.common.ContextClassLoaderScope;
 import jdk.graal.compiler.java.LambdaUtils;
 import jdk.internal.misc.Unsafe;
 import jdk.vm.ci.meta.MetaAccessProvider;
@@ -73,6 +75,38 @@
 /**
  * The core class for deciding whether a class should be initialized during image building or class
  * initialization should be delayed to runtime.
+ * <p>
+ * The initialization kind for all classes is encoded in the two registries:
+ * {@link #classInitializationConfiguration}, the user-configured initialization state, and
+ * {@link #classInitKinds}, the actual computed initialization state.
+ * <p>
+ * If for example the configured initialization kind, as registered in
+ * {@link #classInitializationConfiguration}, is {@link InitKind#BUILD_TIME} but invoking
+ * {@link #ensureClassInitialized(Class, boolean)} results in an error, e.g., a
+ * {@link NoClassDefFoundError}, then the actual initialization kind registered in
+ * {@link #classInitKinds} may be {@link InitKind#RUN_TIME} depending on the error resolution policy
+ * dictated by {@link LinkAtBuildTimeSupport#linkAtBuildTime(Class)}.
+ * <p>
+ * Classes with a simulated class initializer are neither registered as initialized at
+ * {@link InitKind#RUN_TIME} nor {@link InitKind#BUILD_TIME}. Instead
+ * {@link SimulateClassInitializerSupport} queries their initialization state to decide if
+ * simulation should be tried. If a class has a computed {@link InitKind#BUILD_TIME} initialization
+ * kind, i.e., its {@link AnalysisType#isInitialized()} returns true, simulation is skipped since
+ * the type is already considered as starting out as initialized at image run time (see
+ * {@link SimulateClassInitializerSupport#trySimulateClassInitializer(BigBang, AnalysisType)}). If a
+ * class was explicitly configured as {@link InitKind#RUN_TIME} initialized this will prevent it
+ * from being simulated.
+ * <p>
+ * There are some similarities and differences between simulated and build-time initialized classes.
+ * At image execution time they both start out as initialized: there are no run-time class
+ * initialization checks and the class initializer itself is not even present, it was not AOT
+ * compiled. However, for a simulated class its initialization status in the hosting VM that runs
+ * the image generator does not matter; it may or may not have been initialized. Whereas, a
+ * build-time initialized class is by definition initialized in the hosting VM. Consequently, the
+ * static fields of a simulated class reference image heap values computed by the class initializer
+ * simulation, but they do not correspond to hosted objects. In contrast, static fields of a
+ * build-time initialized class reference image heap values that were copied from the corresponding
+ * fields in the hosting VM.
  */
 public class ClassInitializationSupport implements RuntimeClassInitializationSupport {
 
@@ -372,8 +406,23 @@ public void forceInitializeHosted(Class<?> clazz, String reason, boolean allowIn
         if (clazz == null) {
             return;
         }
+
         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)
+             */
+            assert allowInitializationErrors || !LinkAtBuildTimeSupport.singleton().linkAtBuildTime(clazz);
+            classInitializationConfiguration.updateStrict(clazz.getTypeName(), InitKind.BUILD_TIME, InitKind.RUN_TIME, "Build time initialization failed.");
+        }
         classInitKinds.put(clazz, initKind);
 
         forceInitializeHosted(clazz.getSuperclass(), "super type of " + clazz.getTypeName(), allowInitializationErrors);
@@ -391,7 +440,8 @@ private void forceInitializeInterfaces(Class<?>[] interfaces, String reason) {
             if (metaAccess.lookupJavaType(iface).declaresDefaultMethods()) {
                 classInitializationConfiguration.insert(iface.getTypeName(), InitKind.BUILD_TIME, reason, true);
 
-                ensureClassInitialized(iface, false);
+                InitKind initKind = ensureClassInitialized(iface, false);
+                VMError.guarantee(initKind == InitKind.BUILD_TIME, "Initialization of %s failed so all interfaces with default methods must be already initialized.", iface.getTypeName());
                 classInitKinds.put(iface, InitKind.BUILD_TIME);
             }
             forceInitializeInterfaces(iface.getInterfaces(), "super type of " + iface.getTypeName());