Review fixes

Christian Wimmer · Christian Wimmer · commit 104d71fe2e8a · 2022-06-30T14:37:19.000-07:00
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java b/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;
@@ -1602,7 +1603,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 +1614,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 +1654,12 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP
         nativeLibs.reportErrors();
     }
 
+    private static void initializeAtBuildTime(Class<?> clazz, ClassInitializationSupport classInitializationSupport, Class<? extends Annotation> annotationForMessage) {
+        String message = "classes with " + annotationForMessage.getSimpleName() + " annotations are always initialized";
+        classInitializationSupport.initializeAtBuildTime(clazz, message);
+        classInitializationSupport.forceInitializeHosted(clazz, message, false);
+    }
+
     public AbstractImage getBuiltImage() {
         return image;
     }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/AllowAllHostedUsagesClassInitializationSupport.java b/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;
 
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/ClassInitializationSupport.java b/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();
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/ProvenSafeClassInitializationSupport.java b/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()) {
             /*

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@`
`31`	`31`	`import static org.graalvm.compiler.replacements.StandardGraphBuilderPlugins.registerInvocationPlugins;`
`32`	`32`
`33`	`33`	`import java.io.IOException;`
	`34`	`+import java.lang.annotation.Annotation;`
`34`	`35`	`import java.lang.ref.Reference;`
`35`	`36`	`import java.lang.reflect.Method;`
`36`	`37`	`import java.lang.reflect.Modifier;`
`@@ -1602,7 +1603,7 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP`
`1602`	`1603`
`1603`	`1604`	`for (Method method : loader.findAnnotatedMethods(CConstant.class)) {`
`1604`	`1605`	`if (LibCBase.isMethodProvidedInCurrentLibc(method)) {`
`1605`		`- classInitializationSupport.initializeAtBuildTime(method.getDeclaringClass(), "classes with " + CConstant.class.getSimpleName() + " annotations are always initialized");`
	`1606`	`+ initializeAtBuildTime(method.getDeclaringClass(), classInitializationSupport, CConstant.class);`
`1606`	`1607`	`nativeLibs.loadJavaMethod(metaAccess.lookupJavaMethod(method));`
`1607`	`1608`	`}`
`1608`	`1609`	`}`
`@@ -1613,38 +1614,38 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP`
`1613`	`1614`	`}`
`1614`	`1615`	`for (Class<?> clazz : loader.findAnnotatedClasses(CStruct.class, false)) {`
`1615`	`1616`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1616`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CStruct.class.getSimpleName() + " are always initialized");`
	`1617`	`+ initializeAtBuildTime(clazz, classInitializationSupport, CStruct.class);`
`1617`	`1618`	`nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));`
`1618`	`1619`	`}`
`1619`	`1620`	`}`
`1620`	`1621`	`for (Class<?> clazz : loader.findAnnotatedClasses(RawStructure.class, false)) {`
`1621`	`1622`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1622`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + RawStructure.class.getSimpleName() + " are always initialized");`
	`1623`	`+ initializeAtBuildTime(clazz, classInitializationSupport, RawStructure.class);`
`1623`	`1624`	`nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));`
`1624`	`1625`	`}`
`1625`	`1626`	`}`
`1626`	`1627`	`for (Class<?> clazz : loader.findAnnotatedClasses(CPointerTo.class, false)) {`
`1627`	`1628`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1628`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CPointerTo.class.getSimpleName() + " are always initialized");`
	`1629`	`+ initializeAtBuildTime(clazz, classInitializationSupport, CPointerTo.class);`
`1629`	`1630`	`nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));`
`1630`	`1631`	`}`
`1631`	`1632`	`}`
`1632`	`1633`	`for (Class<?> clazz : loader.findAnnotatedClasses(RawPointerTo.class, false)) {`
`1633`	`1634`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1634`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + RawPointerTo.class.getSimpleName() + " are always initialized");`
	`1635`	`+ initializeAtBuildTime(clazz, classInitializationSupport, RawPointerTo.class);`
`1635`	`1636`	`nativeLibs.loadJavaType(metaAccess.lookupJavaType(clazz));`
`1636`	`1637`	`}`
`1637`	`1638`	`}`
`1638`	`1639`	`for (Class<?> clazz : loader.findAnnotatedClasses(CEnum.class, false)) {`
`1639`	`1640`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1640`	`1641`	`ResolvedJavaType type = metaAccess.lookupJavaType(clazz);`
`1641`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CEnum.class.getSimpleName() + " are always initialized");`
	`1642`	`+ initializeAtBuildTime(clazz, classInitializationSupport, CEnum.class);`
`1642`	`1643`	`nativeLibs.loadJavaType(type);`
`1643`	`1644`	`}`
`1644`	`1645`	`}`
`1645`	`1646`	`for (Class<?> clazz : loader.findAnnotatedClasses(CContext.class, false)) {`
`1646`	`1647`	`if (LibCBase.isTypeProvidedInCurrentLibc(clazz)) {`
`1647`		`- classInitializationSupport.initializeAtBuildTime(clazz, "classes annotated with " + CContext.class.getSimpleName() + " are always initialized");`
	`1648`	`+ initializeAtBuildTime(clazz, classInitializationSupport, CContext.class);`
`1648`	`1649`	`}`
`1649`	`1650`	`}`
`1650`	`1651`	`nativeLibs.processCLibraryAnnotations(loader);`
`@@ -1653,6 +1654,12 @@ private void processNativeLibraryImports(NativeLibraries nativeLibs, MetaAccessP`
`1653`	`1654`	`nativeLibs.reportErrors();`
`1654`	`1655`	`}`
`1655`	`1656`
	`1657`	`+ private static void initializeAtBuildTime(Class<?> clazz, ClassInitializationSupport classInitializationSupport, Class<? extends Annotation> annotationForMessage) {`
	`1658`	`+ String message = "classes with " + annotationForMessage.getSimpleName() + " annotations are always initialized";`
	`1659`	`+ classInitializationSupport.initializeAtBuildTime(clazz, message);`
	`1660`	`+ classInitializationSupport.forceInitializeHosted(clazz, message, false);`
	`1661`	`+ }`
	`1662`	`+`
`1656`	`1663`	`public AbstractImage getBuiltImage() {`
`1657`	`1664`	`return image;`
`1658`	`1665`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,6 +188,13 @@ public void rerunInitialization(Class<?> clazz, String reason) {`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
	`191`	`+ @Override`
	`192`	`+ public void initializeAtBuildTime(Class<?> aClass, String reason) {`
	`193`	`+ UserError.guarantee(!configurationSealed, "The class initialization configuration can be changed only before the phase analysis.");`
	`194`	`+ classInitializationConfiguration.insert(aClass.getTypeName(), InitKind.BUILD_TIME, reason, true);`
	`195`	`+ forceInitializeHosted(aClass, reason, false);`
	`196`	`+ }`
	`197`	`+`
`191`	`198`	`private void setSubclassesAsRunTime(Class<?> clazz) {`
`192`	`199`	`if (clazz.isInterface() && !metaAccess.lookupJavaType(clazz).declaresDefaultMethods()) {`
`193`	`200`	`/*`