[GR-31953] Support predefinition of classes with subtype and outer class relationships.

PullRequest: graal/9189

Author: peter-hofer

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeClassInitialization.java

@@ -96,7 +96,7 @@ public final class RuntimeClassInitialization {
     public static void initializeAtRunTime(Class<?>... classes) {
         StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
         for (Class<?> aClass : classes) {
-            ImageSingletons.lookup(RuntimeClassInitializationSupport.class).initializeAtRunTime(aClass, classReason(stacktrace, aClass.getSimpleName() + ".class'"));
+            ImageSingletons.lookup(RuntimeClassInitializationSupport.class).initializeAtRunTime(aClass, classReason(stacktrace, aClass.getSimpleName() + ".class"));
         }
     }
 
@@ -115,7 +115,7 @@ public static void initializeAtRunTime(Class<?>... classes) {
     public static void initializeAtBuildTime(Class<?>... classes) {
         StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
         for (Class<?> aClass : classes) {
-            ImageSingletons.lookup(RuntimeClassInitializationSupport.class).initializeAtBuildTime(aClass, classReason(stacktrace, aClass.getSimpleName() + ".class'"));
+            ImageSingletons.lookup(RuntimeClassInitializationSupport.class).initializeAtBuildTime(aClass, classReason(stacktrace, aClass.getSimpleName() + ".class"));
         }
     }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/ClassForNameSupport.java

@@ -72,6 +72,11 @@ public static Class<?> forName(String className, boolean initialize, ClassLoader
         }
         return result;
     }
+
+    /** Whether a call to {@link Class#forName} for the given class can be folded to a constant. */
+    public static boolean canBeFolded(Class<?> clazz) {
+        return !PredefinedClassesSupport.isPredefined(clazz);
+    }
 }
 
 @AutomaticFeature

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHub.java

@@ -747,6 +747,10 @@ private ClassLoader getClassLoader0() {
         return (ClassLoader) classLoader;
     }
 
+    boolean hasClassLoader() {
+        return classLoader != FROM_COMPANION || (companion.isPresent() && companion.get().hasClassLoader());
+    }
+
     void setClassLoaderAtRuntime(ClassLoader loader) {
         companion.get().setClassLoader(loader);
     }
@@ -839,6 +843,7 @@ public boolean isLocalOrAnonymousClass() {
 
     @Substitute
     private Object getEnclosingClass() {
+        PredefinedClassesSupport.throwIfUnresolvable(toClass(enclosingClass), getClassLoader0());
         return enclosingClass;
     }
 
@@ -862,7 +867,7 @@ private Object getDeclaringClassInternal() {
         if (isLocalOrAnonymousClass()) {
             return null;
         } else {
-            return enclosingClass;
+            return getEnclosingClass();
         }
     }
 
@@ -1122,11 +1127,17 @@ private Method getMethod(@SuppressWarnings("hiding") String name, Class<?>... pa
 
     @Substitute
     private Class<?>[] getDeclaredClasses() {
+        for (Class<?> clazz : rd.declaredClasses) {
+            PredefinedClassesSupport.throwIfUnresolvable(clazz, getClassLoader0());
+        }
         return rd.declaredClasses;
     }
 
     @Substitute
     private Class<?>[] getClasses() {
+        for (Class<?> clazz : rd.publicClasses) {
+            PredefinedClassesSupport.throwIfUnresolvable(clazz, getClassLoader0());
+        }
         return rd.publicClasses;
     }
 
@@ -1271,6 +1282,7 @@ public AnnotatedType[] getAnnotatedInterfaces() {
     @Substitute
     private Method getEnclosingMethod() {
         if (rd.enclosingMethodOrConstructor instanceof Method) {
+            PredefinedClassesSupport.throwIfUnresolvable(rd.enclosingMethodOrConstructor.getDeclaringClass(), getClassLoader0());
             return (Method) rd.enclosingMethodOrConstructor;
         }
         return null;
@@ -1279,6 +1291,7 @@ private Method getEnclosingMethod() {
     @Substitute
     private Constructor<?> getEnclosingConstructor() {
         if (rd.enclosingMethodOrConstructor instanceof Constructor) {
+            PredefinedClassesSupport.throwIfUnresolvable(rd.enclosingMethodOrConstructor.getDeclaringClass(), getClassLoader0());
             return (Constructor<?>) rd.enclosingMethodOrConstructor;
         }
         return null;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHubCompanion.java

@@ -47,6 +47,10 @@ public String getPackageName() {
         return packageName;
     }
 
+    boolean hasClassLoader() {
+        return classLoader != null;
+    }
+
     public ClassLoader getClassLoader() {
         ClassLoader loader = classLoader;
         VMError.guarantee(loader != null);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/PredefinedClassesSupport.java

@@ -66,16 +66,18 @@ public static String hash(byte[] classData, int offset, int length) {
     private final ReentrantLock lock = new ReentrantLock();
 
     /** Predefined classes by hash. */
-    private final EconomicMap<String, Class<?>> predefinedClassesByName = ImageHeapMap.create();
+    private final EconomicMap<String, Class<?>> predefinedClassesByHash = ImageHeapMap.create();
 
     /** Predefined classes which have already been loaded, by name. */
     private final EconomicMap<String, Class<?>> loadedClassesByName = EconomicMap.create();
 
     @Platforms(Platform.HOSTED_ONLY.class)
     public static void registerClass(String hash, Class<?> clazz) {
-        Class<?> existing = singleton().predefinedClassesByName.putIfAbsent(hash, clazz);
-        VMError.guarantee(existing == null, "Can define only one class per hash");
-        singleton().predefinedClasses.add(clazz);
+        Class<?> existing = singleton().predefinedClassesByHash.putIfAbsent(hash, clazz);
+        if (existing != clazz) {
+            VMError.guarantee(existing == null, "Can define only one class per hash");
+            singleton().predefinedClasses.add(clazz);
+        }
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
@@ -85,7 +87,7 @@ public static boolean isPredefined(Class<?> clazz) {
 
     public static Class<?> loadClass(ClassLoader classLoader, String expectedName, byte[] data, int offset, int length, ProtectionDomain protectionDomain) {
         String hash = hash(data, offset, length);
-        Class<?> clazz = singleton().predefinedClassesByName.get(hash);
+        Class<?> clazz = singleton().predefinedClassesByHash.get(hash);
         if (clazz == null) {
             String name = (expectedName != null) ? expectedName : "(name not specified)";
             throw VMError.unsupportedFeature("Defining a class from new bytecodes at run time is not supported. Class " + name +
@@ -97,7 +99,7 @@ public static Class<?> loadClass(ClassLoader classLoader, String expectedName, b
     private Class<?> load(ClassLoader classLoader, ProtectionDomain protectionDomain, Class<?> clazz) {
         lock.lock();
         try {
-            boolean alreadyLoaded = singleton().loadedClassesByName.putIfAbsent(clazz.getName(), clazz) != null;
+            boolean alreadyLoaded = (loadedClassesByName.get(clazz.getName()) == clazz);
             if (alreadyLoaded) {
                 if (classLoader == clazz.getClassLoader()) {
                     throw new LinkageError("loader " + classLoader + " attempted duplicate class definition for " + clazz.getName() + " defined by " + clazz.getClassLoader());
@@ -107,6 +109,12 @@ private Class<?> load(ClassLoader classLoader, ProtectionDomain protectionDomain
                                     "been loaded by class loader: " + clazz.getClassLoader());
                 }
             }
+
+            throwIfUnresolvable(clazz.getSuperclass(), classLoader);
+            for (Class<?> intf : clazz.getInterfaces()) {
+                throwIfUnresolvable(intf, classLoader);
+            }
+
             /*
              * The following is part of the locked block so that other threads can observe only the
              * initialized values once the class can be found.
@@ -116,12 +124,33 @@ private Class<?> load(ClassLoader classLoader, ProtectionDomain protectionDomain
             if (protectionDomain != null) {
                 hub.setProtectionDomainAtRuntime(protectionDomain);
             }
+            loadedClassesByName.put(clazz.getName(), clazz);
             return clazz;
         } finally {
             lock.unlock();
         }
     }
 
+    public static void throwIfUnresolvable(Class<?> clazz, ClassLoader classLoader) {
+        if (clazz == null) {
+            return;
+        }
+        DynamicHub hub = DynamicHub.fromClass(clazz);
+        if (!hub.hasClassLoader()) {
+            throwResolutionError(clazz.getName());
+        }
+        if (!isSameOrParent(clazz.getClassLoader(), classLoader)) { // common case: same loader
+            throwResolutionError(clazz.getName());
+        }
+    }
+
+    private static void throwResolutionError(String name) {
+        // NoClassDefFoundError with ClassNotFoundException required by Java VM specification, 5.3
+        NoClassDefFoundError error = new NoClassDefFoundError(name.replace('.', '/'));
+        error.initCause(new ClassNotFoundException(name));
+        throw error;
+    }
+
     static Class<?> getLoadedForNameOrNull(String name, ClassLoader classLoader) {
         Class<?> clazz = singleton().getLoaded(name);
         if (clazz == null || !isSameOrParent(clazz.getClassLoader(), classLoader)) {
@@ -145,7 +174,7 @@ private static boolean isSameOrParent(ClassLoader parent, ClassLoader child) {
         }
         ClassLoader c = child;
         do {
-            if (c == parent) {
+            if (c == parent) { // common case
                 return true;
             }
             c = c.getParent();
@@ -155,7 +184,7 @@ private static boolean isSameOrParent(ClassLoader parent, ClassLoader child) {
 
     public static class TestingBackdoor {
         public static UnmodifiableEconomicMap<String, Class<?>> getPredefinedClasses() {
-            return singleton().predefinedClassesByName;
+            return singleton().predefinedClassesByHash;
         }
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/util/LazyFinalReference.java

@@ -63,6 +63,10 @@ public LazyFinalReference(Supplier<T> supplier) {
         this.supplier = supplier;
     }
 
+    public boolean isPresent() {
+        return value != UNINITIALIZED || UNSAFE.getObjectVolatile(this, VALUE_OFFSET) != UNINITIALIZED;
+    }
+
     @SuppressWarnings("unchecked")
     public T get() {
         T v = value;