Change configuration to register only invoked methods and allow detailed configuration of included method metadata.

Author: loicottet

sdk/src/org.graalvm.nativeimage/snapshot.sigtest

@@ -904,6 +904,7 @@ meth public !varargs static void register(boolean,java.lang.reflect.Field[])
  anno 0 java.lang.Deprecated()
 meth public !varargs static void register(java.lang.Class<?>[])
 meth public !varargs static void register(java.lang.reflect.Executable[])
+meth public !varargs static void registerAsQueried(java.lang.reflect.Executable[])
 meth public !varargs static void register(java.lang.reflect.Field[])
 meth public !varargs static void registerForReflectiveInstantiation(java.lang.Class<?>[])
 supr java.lang.Object

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

@@ -80,7 +80,19 @@ public static void register(Class<?>... classes) {
      * @since 19.0
      */
     public static void register(Executable... methods) {
-        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationCondition.alwaysTrue(), methods);
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationCondition.alwaysTrue(), false, methods);
+    }
+
+    /**
+     * Makes the provided methods available for reflection queries at run time. The methods will be
+     * returned by {@link Class#getMethod}, {@link Class#getMethods}, and all the other methods on
+     * {@link Class} that return a single or a list of methods, but will not be invocable and will
+     * not be considered reachable.
+     *
+     * @since 21.3
+     */
+    public static void registerAsQueried(Executable... methods) {
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationCondition.alwaysTrue(), true, methods);
     }
 
     /**

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

@@ -46,7 +46,7 @@
 public interface ReflectionRegistry {
     void register(ConfigurationCondition condition, Class<?>... classes);
 
-    void register(ConfigurationCondition condition, Executable... methods);
+    void register(ConfigurationCondition condition, boolean queriedOnly, Executable... methods);
 
     void register(ConfigurationCondition condition, boolean finalIsWritable, Field... fields);
 

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

@@ -40,6 +40,10 @@
  */
 package org.graalvm.nativeimage.impl;
 
+import java.lang.reflect.Executable;
+import java.util.Set;
+
 public interface RuntimeReflectionSupport extends ReflectionRegistry {
     // specific to java.lang.reflect reflection
+    Set<Executable> getQueriedOnlyMethods();
 }

substratevm/src/com.oracle.svm.agent/src/com/oracle/svm/agent/BreakpointInterceptor.java

@@ -121,6 +121,7 @@ protected int onLoadCallback(JNIJavaVM vm, JvmtiEnv jvmti, JvmtiEventCallbacks c
         boolean configurationWithOrigins = false;
         int configWritePeriod = -1; // in seconds
         int configWritePeriodInitialDelay = 1; // in seconds
+        boolean trackReflectionMetadata = true;
 
         String[] tokens = !options.isEmpty() ? options.split(",") : new String[0];
         for (String token : tokens) {
@@ -189,6 +190,10 @@ protected int onLoadCallback(JNIJavaVM vm, JvmtiEnv jvmti, JvmtiEventCallbacks c
                 build = Boolean.parseBoolean(getTokenValue(token));
             } else if (token.equals("experimental-configuration-with-origins")) {
                 configurationWithOrigins = true;
+            } else if (token.equals("track-reflection-metadata")) {
+                trackReflectionMetadata = true;
+            } else if (token.startsWith("track-reflection-metadata=")) {
+                trackReflectionMetadata = Boolean.parseBoolean(getTokenValue(token));
             } else {
                 return usage(1, "unknown option: '" + token + "'.");
             }
@@ -306,7 +311,8 @@ protected int onLoadCallback(JNIJavaVM vm, JvmtiEnv jvmti, JvmtiEventCallbacks c
         }
 
         try {
-            BreakpointInterceptor.onLoad(jvmti, callbacks, tracer, this, interceptedStateSupplier, experimentalClassLoaderSupport, experimentalClassDefineSupport);
+            BreakpointInterceptor.onLoad(jvmti, callbacks, tracer, this, interceptedStateSupplier,
+                            experimentalClassLoaderSupport, experimentalClassDefineSupport, trackReflectionMetadata);
         } catch (Throwable t) {
             return error(3, t.toString());
         }

substratevm/src/com.oracle.svm.agent/src/com/oracle/svm/agent/NativeImageAgent.java

@@ -42,6 +42,7 @@ public class NativeImageAgentJNIHandleSet extends JNIHandleSet {
 
     final JNIMethodId javaLangReflectMemberGetName;
     final JNIMethodId javaLangReflectMemberGetDeclaringClass;
+    private JNIMethodId javaLangReflectExecutableGetParameterTypes = WordFactory.nullPointer();
 
     final JNIMethodId javaUtilEnumerationHasMoreElements;
 
@@ -52,6 +53,8 @@ public class NativeImageAgentJNIHandleSet extends JNIHandleSet {
 
     final JNIMethodId javaLangObjectGetClass;
 
+    final JNIObjectHandle javaLangStackOverflowError;
+
     private JNIMethodId javaLangInvokeMethodTypeParameterArray = WordFactory.nullPointer();
     private JNIMethodId javaLangInvokeMethodTypeReturnType = WordFactory.nullPointer();
     final JNIObjectHandle javaLangIllegalAccessException;
@@ -94,11 +97,21 @@ public class NativeImageAgentJNIHandleSet extends JNIHandleSet {
         JNIObjectHandle javaLangObject = findClass(env, "java/lang/Object");
         javaLangObjectGetClass = getMethodId(env, javaLangObject, "getClass", "()Ljava/lang/Class;", false);
 
+        javaLangStackOverflowError = newClassGlobalRef(env, "java/lang/StackOverflowError");
+
         javaLangIllegalAccessException = newClassGlobalRef(env, "java/lang/IllegalAccessException");
         javaLangInvokeWrongMethodTypeException = newClassGlobalRef(env, "java/lang/invoke/WrongMethodTypeException");
         javaLangIllegalArgumentException = newClassGlobalRef(env, "java/lang/IllegalArgumentException");
     }
 
+    JNIMethodId getJavaLangReflectExecutableGetParameterTypes(JNIEnvironment env) {
+        if (javaLangReflectExecutableGetParameterTypes.isNull()) {
+            JNIObjectHandle javaLangReflectExecutable = findClass(env, "java/lang/reflect/Executable");
+            javaLangReflectExecutableGetParameterTypes = getMethodId(env, javaLangReflectExecutable, "getParameterTypes", "()[Ljava/lang/Class;", false);
+        }
+        return javaLangReflectExecutableGetParameterTypes;
+    }
+
     JNIMethodId getJavaLangInvokeMethodTypeReturnType(JNIEnvironment env) {
         if (javaLangInvokeMethodTypeReturnType.isNull()) {
             JNIObjectHandle javaLangInvokeMethodType = newClassGlobalRef(env, "java/lang/invoke/MethodType");

substratevm/src/com.oracle.svm.agent/src/com/oracle/svm/agent/NativeImageAgentJNIHandleSet.java

@@ -39,7 +39,9 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-import com.oracle.svm.configure.config.ConfigurationMemberKind;
+import com.oracle.svm.configure.config.ConfigurationMemberInfo;
+import com.oracle.svm.configure.config.ConfigurationMemberInfo.ConfigurationMemberAccessibility;
+import com.oracle.svm.configure.config.ConfigurationMemberInfo.ConfigurationMemberDeclaration;
 import com.oracle.svm.configure.config.ConfigurationMethod;
 import com.oracle.svm.configure.config.ConfigurationSet;
 import com.oracle.svm.configure.config.ConfigurationType;
@@ -125,13 +127,13 @@ public void testConfigDifference() {
     }
 
     private static void doTestGeneratedTypeConfig() {
-        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestDeclared = new TypeMethodsWithFlagsTest(ConfigurationMemberKind.DECLARED);
+        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestDeclared = new TypeMethodsWithFlagsTest(ConfigurationMemberDeclaration.DECLARED);
         typeMethodsWithFlagsTestDeclared.doTest();
 
-        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestPublic = new TypeMethodsWithFlagsTest(ConfigurationMemberKind.PUBLIC);
+        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestPublic = new TypeMethodsWithFlagsTest(ConfigurationMemberDeclaration.PUBLIC);
         typeMethodsWithFlagsTestPublic.doTest();
 
-        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestDeclaredPublic = new TypeMethodsWithFlagsTest(ConfigurationMemberKind.DECLARED_AND_PUBLIC);
+        TypeMethodsWithFlagsTest typeMethodsWithFlagsTestDeclaredPublic = new TypeMethodsWithFlagsTest(ConfigurationMemberDeclaration.DECLARED_AND_PUBLIC);
         typeMethodsWithFlagsTestDeclaredPublic.doTest();
     }
 
@@ -152,10 +154,12 @@ private static void doTestExpectedMissingTypes(TypeConfiguration typeConfig) {
 
     private static void doTestTypeFlags(TypeConfiguration typeConfig) {
         ConfigurationType flagTestHasDeclaredType = getConfigTypeOrFail(typeConfig, "FlagTestC");
-        Assert.assertTrue(flagTestHasDeclaredType.haveAllDeclaredClasses() || flagTestHasDeclaredType.haveAllDeclaredFields() || flagTestHasDeclaredType.haveAllDeclaredConstructors());
+        Assert.assertTrue(flagTestHasDeclaredType.haveAllDeclaredClasses() || flagTestHasDeclaredType.haveAllDeclaredFields() ||
+                        flagTestHasDeclaredType.getAllDeclaredConstructors() == ConfigurationMemberAccessibility.ACCESSED);
 
         ConfigurationType flagTestHasPublicType = getConfigTypeOrFail(typeConfig, "FlagTestD");
-        Assert.assertTrue(flagTestHasPublicType.haveAllPublicClasses() || flagTestHasPublicType.haveAllPublicFields() || flagTestHasPublicType.haveAllPublicConstructors());
+        Assert.assertTrue(flagTestHasPublicType.haveAllPublicClasses() || flagTestHasPublicType.haveAllPublicFields() ||
+                        flagTestHasPublicType.getAllPublicConstructors() == ConfigurationMemberAccessibility.ACCESSED);
     }
 
     private static void doTestFields(TypeConfiguration typeConfig) {
@@ -226,37 +230,37 @@ class TypeMethodsWithFlagsTest {
     static final String INTERNAL_SIGNATURE_ONE = "([Ljava/lang/String;)V";
     static final String INTERNAL_SIGNATURE_TWO = "([Ljava/lang/String;Ljava/lang/String;)V";
 
-    final ConfigurationMemberKind methodKind;
+    final ConfigurationMemberDeclaration methodKind;
 
-    final Map<ConfigurationMethod, ConfigurationMemberKind> methodsThatMustExist = new HashMap<>();
-    final Map<ConfigurationMethod, ConfigurationMemberKind> methodsThatMustNotExist = new HashMap<>();
+    final Map<ConfigurationMethod, ConfigurationMemberDeclaration> methodsThatMustExist = new HashMap<>();
+    final Map<ConfigurationMethod, ConfigurationMemberDeclaration> methodsThatMustNotExist = new HashMap<>();
 
     final TypeConfiguration previousConfig = new TypeConfiguration();
     final TypeConfiguration currentConfig = new TypeConfiguration();
 
-    TypeMethodsWithFlagsTest(ConfigurationMemberKind methodKind) {
+    TypeMethodsWithFlagsTest(ConfigurationMemberDeclaration methodKind) {
         this.methodKind = methodKind;
         generateTestMethods();
         populateConfig();
         currentConfig.removeAll(previousConfig);
     }
 
     void generateTestMethods() {
-        Map<ConfigurationMethod, ConfigurationMemberKind> targetMap;
+        Map<ConfigurationMethod, ConfigurationMemberDeclaration> targetMap;
 
-        targetMap = getMethodsMap(ConfigurationMemberKind.DECLARED);
-        targetMap.put(new ConfigurationMethod("<init>", INTERNAL_SIGNATURE_ONE), ConfigurationMemberKind.DECLARED);
-        targetMap.put(new ConfigurationMethod("testMethodDeclaredSpecificSignature", INTERNAL_SIGNATURE_ONE), ConfigurationMemberKind.DECLARED);
-        targetMap.put(new ConfigurationMethod("testMethodDeclaredMatchesAllSignature", null), ConfigurationMemberKind.DECLARED);
+        targetMap = getMethodsMap(ConfigurationMemberDeclaration.DECLARED);
+        targetMap.put(new ConfigurationMethod("<init>", INTERNAL_SIGNATURE_ONE), ConfigurationMemberDeclaration.DECLARED);
+        targetMap.put(new ConfigurationMethod("testMethodDeclaredSpecificSignature", INTERNAL_SIGNATURE_ONE), ConfigurationMemberDeclaration.DECLARED);
+        targetMap.put(new ConfigurationMethod("testMethodDeclaredMatchesAllSignature", null), ConfigurationMemberDeclaration.DECLARED);
 
-        targetMap = getMethodsMap(ConfigurationMemberKind.PUBLIC);
-        targetMap.put(new ConfigurationMethod("<init>", INTERNAL_SIGNATURE_TWO), ConfigurationMemberKind.PUBLIC);
-        targetMap.put(new ConfigurationMethod("testMethodPublicSpecificSignature", INTERNAL_SIGNATURE_ONE), ConfigurationMemberKind.PUBLIC);
-        targetMap.put(new ConfigurationMethod("testMethodPublicMatchesAllSignature", null), ConfigurationMemberKind.PUBLIC);
+        targetMap = getMethodsMap(ConfigurationMemberDeclaration.PUBLIC);
+        targetMap.put(new ConfigurationMethod("<init>", INTERNAL_SIGNATURE_TWO), ConfigurationMemberDeclaration.PUBLIC);
+        targetMap.put(new ConfigurationMethod("testMethodPublicSpecificSignature", INTERNAL_SIGNATURE_ONE), ConfigurationMemberDeclaration.PUBLIC);
+        targetMap.put(new ConfigurationMethod("testMethodPublicMatchesAllSignature", null), ConfigurationMemberDeclaration.PUBLIC);
     }
 
-    Map<ConfigurationMethod, ConfigurationMemberKind> getMethodsMap(ConfigurationMemberKind otherKind) {
-        if (methodKind.equals(otherKind) || methodKind.equals(ConfigurationMemberKind.DECLARED_AND_PUBLIC)) {
+    Map<ConfigurationMethod, ConfigurationMemberDeclaration> getMethodsMap(ConfigurationMemberDeclaration otherKind) {
+        if (methodKind.equals(otherKind) || methodKind.equals(ConfigurationMemberDeclaration.DECLARED_AND_PUBLIC)) {
             return methodsThatMustNotExist;
         }
         return methodsThatMustExist;
@@ -268,26 +272,26 @@ void populateConfig() {
         previousConfig.add(oldType);
 
         ConfigurationType newType = new ConfigurationType(ConfigurationCondition.alwaysTrue(), getTypeName());
-        for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustExist.entrySet()) {
+        for (Map.Entry<ConfigurationMethod, ConfigurationMemberDeclaration> methodEntry : methodsThatMustExist.entrySet()) {
             newType.addMethod(methodEntry.getKey().getName(), methodEntry.getKey().getInternalSignature(), methodEntry.getValue());
         }
-        for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustNotExist.entrySet()) {
+        for (Map.Entry<ConfigurationMethod, ConfigurationMemberDeclaration> methodEntry : methodsThatMustNotExist.entrySet()) {
             newType.addMethod(methodEntry.getKey().getName(), methodEntry.getKey().getInternalSignature(), methodEntry.getValue());
         }
         currentConfig.add(newType);
     }
 
     void setFlags(ConfigurationType config) {
-        if (methodKind.equals(ConfigurationMemberKind.DECLARED) || methodKind.equals(ConfigurationMemberKind.DECLARED_AND_PUBLIC)) {
+        if (methodKind.equals(ConfigurationMemberDeclaration.DECLARED) || methodKind.equals(ConfigurationMemberDeclaration.DECLARED_AND_PUBLIC)) {
             config.setAllDeclaredClasses();
-            config.setAllDeclaredConstructors();
-            config.setAllDeclaredMethods();
+            config.setAllDeclaredConstructors(ConfigurationMemberAccessibility.ACCESSED);
+            config.setAllDeclaredMethods(ConfigurationMemberAccessibility.ACCESSED);
             config.setAllDeclaredFields();
         }
-        if (methodKind.equals(ConfigurationMemberKind.PUBLIC) || methodKind.equals(ConfigurationMemberKind.DECLARED_AND_PUBLIC)) {
+        if (methodKind.equals(ConfigurationMemberDeclaration.PUBLIC) || methodKind.equals(ConfigurationMemberDeclaration.DECLARED_AND_PUBLIC)) {
             config.setAllPublicClasses();
-            config.setAllPublicConstructors();
-            config.setAllPublicMethods();
+            config.setAllPublicConstructors(ConfigurationMemberAccessibility.ACCESSED);
+            config.setAllPublicMethods(ConfigurationMemberAccessibility.ACCESSED);
             config.setAllPublicFields();
         }
     }
@@ -304,13 +308,13 @@ void doTest() {
         } else {
             Assert.assertNotNull("Generated configuration type " + name + " does not exist. Has the test code changed?", configurationType);
 
-            for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustExist.entrySet()) {
-                ConfigurationMemberKind kind = configurationType.getMethodKindIfPresent(methodEntry.getKey());
+            for (Map.Entry<ConfigurationMethod, ConfigurationMemberDeclaration> methodEntry : methodsThatMustExist.entrySet()) {
+                ConfigurationMemberDeclaration kind = configurationType.getMethodKindIfPresent(methodEntry.getKey()).getMemberKind();
                 Assert.assertNotNull("Method " + methodEntry.getKey() + " unexpectedly NOT found in the new configuration.", kind);
                 Assert.assertEquals("Method " + methodEntry.getKey() + " contains a different kind than expected in the new configuration.", kind, methodEntry.getValue());
             }
-            for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustNotExist.entrySet()) {
-                ConfigurationMemberKind kind = configurationType.getMethodKindIfPresent(methodEntry.getKey());
+            for (Map.Entry<ConfigurationMethod, ConfigurationMemberDeclaration> methodEntry : methodsThatMustNotExist.entrySet()) {
+                ConfigurationMemberInfo kind = configurationType.getMethodKindIfPresent(methodEntry.getKey());
                 Assert.assertNull("Method " + methodEntry.getKey() + " unexpectedly found in the new configuration.", kind);
             }
         }