Review fixes

Author: Christian Wimmer

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

@@ -31,6 +31,7 @@
 import static org.graalvm.compiler.replacements.StandardGraphBuilderPlugins.registerInvocationPlugins;
 
 import java.io.IOException;
+import java.lang.annotation.Annotation;
 import java.lang.ref.Reference;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -292,6 +293,7 @@
 import com.oracle.svm.hosted.substitute.DeletedFieldsPlugin;
 import com.oracle.svm.hosted.substitute.UnsafeAutomaticSubstitutionProcessor;
 import com.oracle.svm.util.AnnotationExtracter;
+import com.oracle.svm.util.ClassUtil;
 import com.oracle.svm.util.ImageBuildStatistics;
 import com.oracle.svm.util.ReflectionUtil;
 import com.oracle.svm.util.ReflectionUtil.ReflectionUtilError;
@@ -1602,7 +1604,7 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP
 
         for (Method method : loader.findAnnotatedMethods(CConstant.class)) {
             if (LibCBase.isMethodProvidedInCurrentLibc(method)) {
-                classInitializationSupport.initializeAtBuildTime(method.getDeclaringClass(), "classes with " + CConstant.class.getSimpleName() + " annotations are always initialized");
+                initializeAtBuildTime(method.getDeclaringClass(), classInitializationSupport, CConstant.class);
                 nativeLibs.loadJavaMethod(metaAccess.lookupJavaMethod(method));
             }
         }
@@ -1613,38 +1615,38 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(CStruct.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CStruct.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, CStruct.class);
                 nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));
             }
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(RawStructure.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + RawStructure.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, RawStructure.class);
                 nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));
             }
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(CPointerTo.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CPointerTo.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, CPointerTo.class);
                 nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));
             }
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(RawPointerTo.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + RawPointerTo.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, RawPointerTo.class);
                 nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));
             }
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(CEnum.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
                 ResolvedJavaType type = metaAccess.lookupJavaType(clazz);
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CEnum.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, CEnum.class);
                 nativeLibs.loadJavaType(type);
             }
         }
         for (Class<?> clazz : loader.findAnnotatedClasses(CContext.class, false)) {
             if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {
-                classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CContext.class.getSimpleName() + " are always initialized");
+                initializeAtBuildTime(clazz, classInitializationSupport, CContext.class);
             }
         }
         nativeLibs.processCLibraryAnnotations(loader);
@@ -1653,6 +1655,12 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP
         nativeLibs.reportErrors();
     }
 
+    private static void initializeAtBuildTime(Class<?> clazz, ClassInitializationSupport classInitializationSupport, Class<? extends Annotation> annotationForMessage) {
+        String message = "classes annotated with " + ClassUtil.getUnqualifiedName(annotationForMessage) + " are always initialized at image build time";
+        classInitializationSupport.initializeAtBuildTime(clazz, message);
+        classInitializationSupport.forceInitializeHosted(clazz, message, false);
+    }
+
     public AbstractImage getBuiltImage() {
         return image;
     }

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

@@ -34,7 +34,6 @@
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.ImageClassLoader;
 
-import jdk.internal.misc.Unsafe;
 import jdk.vm.ci.meta.MetaAccessProvider;
 
 class AllowAllHostedUsagesClassInitializationSupport extends ClassInitializationSupport {
@@ -43,23 +42,42 @@ class AllowAllHostedUsagesClassInitializationSupport extends ClassInitialization
         super(metaAccess, loader);
     }
 
+    @Override
+    public void initializeAtBuildTime(Class<?> aClass, String reason) {
+        UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");
+        Class<?> cur = aClass;
+        do {
+            classInitializationConfiguration.insert(cur.getTypeName(), InitKind.BUILD_TIME, cur == aClass ? reason : "super type of " + aClass.getTypeName(), true);
+            initializeInterfacesAtBuildTime(cur.getInterfaces(), "interface of " + aClass.getTypeName());
+            cur = cur.getSuperclass();
+        } while (cur != null);
+    }
+
+    private void initializeInterfacesAtBuildTime(Class<?>[] interfaces, String reason) {
+        for (Class<?> iface : interfaces) {
+            if (metaAccess.lookupJavaType(iface).declaresDefaultMethods()) {
+                classInitializationConfiguration.insert(iface.getTypeName(), InitKind.BUILD_TIME, reason, true);
+            }
+            initializeInterfacesAtBuildTime(iface.getInterfaces(), reason);
+        }
+    }
+
     @Override
     public void initializeAtRunTime(Class<?> clazz, String reason) {
         UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");
         classInitializationConfiguration.insert(clazz.getTypeName(), InitKind.RUN_TIME, reason, true);
-        setSubclassesAsRunTime(clazz);
     }
 
     @Override
     public void rerunInitialization(Class<?> clazz, String reason) {
-        UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");
-        classInitializationConfiguration.insert(clazz.getTypeName(), InitKind.RERUN, reason, true);
+        /* There is no more difference between RUN_TIME and RERUN. */
+        initializeAtRunTime(clazz, reason);
+    }
 
-        try {
-            Unsafe.getUnsafe().ensureClassInitialized(clazz);
-        } catch (Throwable ex) {
-            throw UserError.abort(ex, "Class initialization failed for %s. The class is requested for re-running (reason: %s)", clazz.getTypeName(), reason);
-        }
+    @Override
+    public void rerunInitialization(String name, String reason) {
+        /* There is no more difference between RUN_TIME and RERUN. */
+        initializeAtRunTime(name, reason);
     }
 
     @Override
@@ -75,21 +93,6 @@ String reasonForClass(Class<?> clazz) {
         }
     }
 
-    private void setSubclassesAsRunTime(Class<?> clazz) {
-        if (clazz.isInterface() && !metaAccess.lookupJavaType(clazz).declaresDefaultMethods()) {
-            /*
-             * An interface that does not declare a default method is independent from a class
-             * initialization point of view, i.e., it is not initialized when a class implementing
-             * that interface is initialized.
-             */
-            return;
-        }
-        loader.findSubclasses(clazz, false).stream()
-                        .filter(c -> !c.equals(clazz))
-                        .filter(c -> !(c.isInterface() && !metaAccess.lookupJavaType(c).declaresDefaultMethods()))
-                        .forEach(c -> classInitializationConfiguration.insert(c.getTypeName(), InitKind.RUN_TIME, "subtype of " + clazz.getTypeName(), true));
-    }
-
     @Override
     public void forceInitializeHosted(Class<?> clazz, String reason, boolean allowInitializationErrors) {
         if (clazz == null) {
@@ -149,11 +152,6 @@ InitKind computeInitKindAndMaybeInitializeClass(Class<?> clazz, boolean memoize)
             return InitKind.BUILD_TIME;
         }
 
-        if (clazz.getTypeName().contains("$$StringConcat")) {
-            forceInitializeHosted(clazz, "string concatenation classes are initialized at build time", false);
-            return InitKind.BUILD_TIME;
-        }
-
         InitKind specifiedInitKind = specifiedInitKindFor(clazz);
         InitKind clazzResult = specifiedInitKind != null ? specifiedInitKind : InitKind.RUN_TIME;
 
@@ -175,18 +173,10 @@ InitKind computeInitKindAndMaybeInitializeClass(Class<?> clazz, boolean memoize)
                 result = result.max(ensureClassInitialized(clazz, false));
             }
 
-            /*
-             * Unfortunately, the computation of canInitializeWithoutSideEffects is not completely
-             * deterministic: Consider a class A whose class initializer depends on class B. Assume
-             * class B has no other dependencies and can therefore be initialized at build time.
-             * When class A is analyzed after class B has been initialized, it can also be
-             * initialized at build time. But when class A is analyzed before class B has been
-             * initialized, it cannot. Since two threads can analyze class A at the same time (there
-             * is no per-class locking) and another thread can initialize B at the same time, we can
-             * have a conflicting initialization status. In that case, BUILD_TIME must win over
-             * RUN_TIME because one thread has already initialized class A.
-             */
-            result = classInitKinds.merge(clazz, result, InitKind::min);
+            InitKind previous = classInitKinds.putIfAbsent(clazz, result);
+            if (previous != null && previous != result) {
+                throw VMError.shouldNotReachHere("Conflicting class initialization kind: " + previous + " != " + result + " for " + clazz);
+            }
         }
         return result;
     }

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

@@ -318,13 +318,6 @@ static String getTraceString(StackTraceElement[] trace) {
         return b.toString();
     }
 
-    @Override
-    public void initializeAtBuildTime(Class<?> aClass, String reason) {
-        UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");
-        classInitializationConfiguration.insert(aClass.getTypeName(), InitKind.BUILD_TIME, reason, true);
-        forceInitializeHosted(aClass, reason, false);
-    }
-
     @Override
     public void reportClassInitialized(Class<?> clazz, StackTraceElement[] stackTrace) {
         assert TraceClassInitialization.hasBeenSet();

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

@@ -188,6 +188,13 @@ public void rerunInitialization(Class<?> clazz, String reason) {
         }
     }
 
+    @Override
+    public void initializeAtBuildTime(Class<?> aClass, String reason) {
+        UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");
+        classInitializationConfiguration.insert(aClass.getTypeName(), InitKind.BUILD_TIME, reason, true);
+        forceInitializeHosted(aClass, reason, false);
+    }
+
     private void setSubclassesAsRunTime(Class<?> clazz) {
         if (clazz.isInterface() && !metaAccess.lookupJavaType(clazz).declaresDefaultMethods()) {
             /*