Improve Crema with --exact-reachability-metadata

Author: gilles-duboscq

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/ClassLoading.java

@@ -69,13 +69,38 @@ public static ArbitraryClassLoadingScope allowArbitraryClassLoading() {
         if (!isSupported()) {
             throw new IllegalStateException("Runtime class loading is not supported. It must be enabled at build-time with -H:+RuntimeClassLoading.");
         }
-        return new ArbitraryClassLoadingScope();
+        return new RealArbitraryClassLoadingScope();
     }
 
-    public static final class ArbitraryClassLoadingScope implements AutoCloseable {
+    /**
+     * Conditionally opens a scope in which class loading is not constrained by the reflection
+     * configuration. If {@code allowArbitraryClassLoading} is true, behaves like
+     * {@link #allowArbitraryClassLoading()}. Otherwise, it has no effect.
+     *
+     * @throws IllegalStateException if class loading is not {@linkplain #isSupported() supported}
+     *             and {@code allowArbitraryClassLoading} is true.
+     *
+     * @see #allowArbitraryClassLoading()
+     */
+    public static ArbitraryClassLoadingScope allowArbitraryClassLoading(boolean allowArbitraryClassLoading) {
+        if (allowArbitraryClassLoading) {
+            return allowArbitraryClassLoading();
+        }
+        return NoopScope.INSTANCE;
+    }
+
+    public abstract static class ArbitraryClassLoadingScope implements AutoCloseable {
+        private ArbitraryClassLoadingScope() {
+        }
+
+        @Override
+        public abstract void close();
+    }
+
+    public static final class RealArbitraryClassLoadingScope extends ArbitraryClassLoadingScope {
         private boolean closed;
 
-        ArbitraryClassLoadingScope() {
+        RealArbitraryClassLoadingScope() {
             if (!ImageInfo.inImageRuntimeCode()) {
                 return;
             }
@@ -94,4 +119,12 @@ public void close() {
             ClassLoadingSupport.singleton().endIgnoreReflectionConfigurationScope();
         }
     }
+
+    private static final class NoopScope extends ArbitraryClassLoadingScope {
+        private static final NoopScope INSTANCE = new NoopScope();
+
+        @Override
+        public void close() {
+        }
+    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaSupport.java

@@ -39,10 +39,10 @@
 import com.oracle.svm.espresso.classfile.descriptors.Symbol;
 import com.oracle.svm.espresso.classfile.descriptors.Type;
 
-import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.UnresolvedJavaType;
 
 public interface CremaSupport {
     @Platforms(Platform.HOSTED_ONLY.class)
@@ -88,23 +88,23 @@ interface CremaDispatchTable {
 
     Class<?> toClass(ResolvedJavaType resolvedJavaType);
 
-    default Class<?> resolveOrThrow(JavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
+    default Class<?> resolveOrThrow(UnresolvedJavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
         ByteSequence type = ByteSequence.create(unresolvedJavaType.getName());
         Symbol<Type> symbolicType = SymbolsSupport.getTypes().getOrCreateValidType(type);
         return resolveOrThrow(symbolicType, accessingClass);
     }
 
     Class<?> resolveOrThrow(Symbol<Type> type, ResolvedJavaType accessingClass);
 
-    default Class<?> resolveOrNull(JavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
+    default Class<?> resolveOrNull(UnresolvedJavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
         ByteSequence type = ByteSequence.create(unresolvedJavaType.getName());
         Symbol<Type> symbolicType = SymbolsSupport.getTypes().getOrCreateValidType(type);
         return resolveOrNull(symbolicType, accessingClass);
     }
 
     Class<?> resolveOrNull(Symbol<Type> type, ResolvedJavaType accessingClass);
 
-    default Class<?> findLoadedClass(JavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
+    default Class<?> findLoadedClass(UnresolvedJavaType unresolvedJavaType, ResolvedJavaType accessingClass) {
         ByteSequence type = ByteSequence.create(unresolvedJavaType.getName());
         Symbol<Type> symbolicType = SymbolsSupport.getTypes().getOrCreateValidType(type);
         return findLoadedClass(symbolicType, accessingClass);

substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaFieldImpl.java

@@ -24,6 +24,8 @@
  */
 package com.oracle.svm.interpreter.metadata;
 
+import org.graalvm.nativeimage.impl.ClassLoading;
+
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.crema.CremaResolvedJavaField;
 import com.oracle.svm.core.hub.crema.CremaSupport;
@@ -78,8 +80,10 @@ public JavaType getType() {
     @Override
     public InterpreterResolvedJavaType getResolvedType() {
         if (resolvedType == null) {
-            Class<?> cls = CremaSupport.singleton().resolveOrThrow(getSymbolicType(), getDeclaringClass());
-            resolvedType = (InterpreterResolvedJavaType) DynamicHub.fromClass(cls).getInterpreterType();
+            try (var _ = ClassLoading.allowArbitraryClassLoading()) {
+                Class<?> cls = CremaSupport.singleton().resolveOrThrow(getSymbolicType(), getDeclaringClass());
+                resolvedType = (InterpreterResolvedJavaType) DynamicHub.fromClass(cls).getInterpreterType();
+            }
         }
         return resolvedType;
     }

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/CremaRuntimeAccess.java

@@ -27,6 +27,8 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 
+import org.graalvm.nativeimage.impl.ClassLoading;
+
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
@@ -94,9 +96,11 @@ public RuntimeException throwError(ErrorType errorType, String messageFormat, Ob
 
     @Override
     public InterpreterResolvedObjectType lookupOrLoadType(Symbol<Type> type, InterpreterResolvedJavaType accessingClass) {
-        Class<?> result = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
-        assert !result.isPrimitive();
-        return (InterpreterResolvedObjectType) DynamicHub.fromClass(result).getInterpreterType();
+        try (var _ = ClassLoading.allowArbitraryClassLoading()) {
+            Class<?> result = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
+            assert !result.isPrimitive();
+            return (InterpreterResolvedObjectType) DynamicHub.fromClass(result).getInterpreterType();
+        }
     }
 
     @Override

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/RuntimeInterpreterConstantPool.java

@@ -26,6 +26,9 @@
 
 import java.lang.invoke.MethodType;
 
+import org.graalvm.nativeimage.impl.ClassLoading;
+
+import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
 import com.oracle.svm.core.methodhandles.Target_java_lang_invoke_MethodHandleNatives;
@@ -137,32 +140,41 @@ private String resolveStringConstant(int stringIndex, @SuppressWarnings("unused"
         return string;
     }
 
-    private InterpreterResolvedJavaType resolveClassConstant(int classIndex, InterpreterResolvedJavaType accessingKlass) {
+    private static InterpreterResolvedObjectType resolveObjectType(Symbol<Type> type, InterpreterResolvedObjectType accessingClass) {
+        DynamicHub hub = DynamicHub.fromClass(CremaSupport.singleton().resolveOrThrow(type, accessingClass));
+        assert !hub.isPrimitive();
+        return (InterpreterResolvedObjectType) hub.getInterpreterType();
+    }
+
+    private InterpreterResolvedJavaType resolveClassConstant(int classIndex, InterpreterResolvedObjectType accessingKlass) {
         assert accessingKlass != null;
         assert tagAt(classIndex) == Tag.CLASS;
 
         Object entry = this.cachedEntries[classIndex];
         Symbol<Type> type = null;
 
+        boolean allowArbitraryClassLoading;
         if (entry == null) {
             // CP comes from dynamically loaded .class file.
             Symbol<Name> className = this.className(classIndex);
             type = SymbolsSupport.getTypes().fromClassNameEntry(className);
+            allowArbitraryClassLoading = true;
         } else if (entry instanceof UnresolvedJavaType unresolvedJavaType) {
             Throwable cause = unresolvedJavaType.getCause();
             if (cause != null) {
                 throw uncheckedThrow(cause);
             }
             // CP comes from build-time JVMCI type, derive type from UnresolvedJavaType.
             type = SymbolsSupport.getTypes().getOrCreateValidType(unresolvedJavaType.getName());
+            allowArbitraryClassLoading = false;
         } else {
             throw VMError.shouldNotReachHere("Invalid cached CP entry, expected unresolved type, but got " + entry);
         }
 
         assert type != null;
 
-        try {
-            InterpreterResolvedObjectType result = CremaRuntimeAccess.getInstance().lookupOrLoadType(type, accessingKlass);
+        try (var _ = ClassLoading.allowArbitraryClassLoading(allowArbitraryClassLoading)) {
+            InterpreterResolvedObjectType result = resolveObjectType(type, accessingKlass);
             return result;
         } catch (LinkageError e) {
             // Comment from Hotspot:
@@ -201,7 +213,7 @@ private InterpreterResolvedJavaField resolveFieldRefConstant(int fieldIndex, Int
             Symbol<Type> holderType = SymbolsSupport.getTypes().getOrCreateValidType(unresolvedJavaField.getDeclaringClass().getName());
             assert !TypeSymbols.isPrimitive(holderType) && !TypeSymbols.isArray(holderType);
             // Perf. note: The holder is re-resolved every-time (never cached).
-            holder = CremaRuntimeAccess.getInstance().lookupOrLoadType(holderType, accessingClass);
+            holder = resolveObjectType(holderType, accessingClass);
         } else {
             throw VMError.shouldNotReachHere("Invalid cached CP entry, expected unresolved field, but got " + entry);
         }
@@ -237,7 +249,7 @@ private InterpreterResolvedJavaMethod resolveClassMethodRefConstant(int methodIn
             methodSignature = SymbolsSupport.getSignatures().getOrCreateValidSignature(unresolvedJavaMethod.getSignature().toMethodDescriptor());
             Symbol<Type> holderType = SymbolsSupport.getTypes().getOrCreateValidType(unresolvedJavaMethod.getDeclaringClass().getName());
             // Perf. note: The holder is re-resolved every-time (never cached).
-            holder = CremaRuntimeAccess.getInstance().lookupOrLoadType(holderType, accessingClass);
+            holder = resolveObjectType(holderType, accessingClass);
         } else {
             throw VMError.shouldNotReachHere("Invalid cached CP entry, expected unresolved method, but got " + entry);
         }
@@ -275,7 +287,7 @@ private InterpreterResolvedJavaMethod resolveInterfaceMethodRefConstant(int inte
             methodSignature = SymbolsSupport.getSignatures().getOrCreateValidSignature(unresolvedJavaMethod.getSignature().toMethodDescriptor());
             Symbol<Type> holderType = SymbolsSupport.getTypes().getOrCreateValidType(unresolvedJavaMethod.getDeclaringClass().getName());
             // Perf. note: The holder is re-resolved every-time (never cached).
-            holder = CremaRuntimeAccess.getInstance().lookupOrLoadType(holderType, accessingClass);
+            holder = resolveObjectType(holderType, accessingClass);
         } else {
             throw VMError.shouldNotReachHere("Invalid cached CP entry, expected unresolved method, but got " + entry);
         }
@@ -322,8 +334,10 @@ public static MethodType signatureToMethodType(Symbol<Type>[] signature, Interpr
     }
 
     private static Class<?> resolveSymbolAndAccessCheck(InterpreterResolvedObjectType accessingClass, Symbol<Type> type) {
-        Class<?> clazz = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
-        // GR-62339 check access
-        return clazz;
+        try (var _ = ClassLoading.allowArbitraryClassLoading()) {
+            Class<?> clazz = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
+            // GR-62339 check access
+            return clazz;
+        }
     }
 }