Include JNI reachability metadata with reflection

Author: loicottet

docs/reference-manual/native-image/ReachabilityMetadata.md

@@ -131,8 +131,7 @@ The _reachability-metadata.json_ configuration contains a single object with one
 {
   "reflection":[],
   "resources":[],
-  "bundles":[],
-  "jni":[]
+  "bundles":[]
 }
 ```
 
@@ -376,12 +375,14 @@ jclass clazz = FindClass(env, "jni/accessed/Type");
 ```
 looks up the `jni.accessed.Type` class, which can then be used to instantiate `jni.accessed.Type`, invoke its methods or access its fields.
 
-The metadata entry for the above call can *only* be provided via _reachability-metadata.json_. Specify the `type` entry in the `jni` field:
+The metadata entry for the above call can *only* be provided via _reachability-metadata.json_. Specify
+the `jniAccessible` field in the `type` entry in the `reflection` section:
 ```json
 {
-  "jni":[
+  "reflection": [
     {
-      "type": "jni.accessed.Type"
+      "type": "jni.accessed.Type",
+      "jniAccessibleType": true
     }
   ]
 }
@@ -393,13 +394,15 @@ To access field values, we need to provide field names:
 ```json
 {
   "type": "jni.accessed.Type",
+  "jniAccessible": true,
   "fields": [{"name": "value"}]
 }
 ```
 To access all fields one can use the following attributes:
 ```json
 {
   "type": "jni.accessed.Type",
+  "jniAccessible": true,
   "allDeclaredFields": true,
   "allPublicFields": true
 }
@@ -410,6 +413,7 @@ To call Java methods from JNI, we must provide metadata for the method signature
 ```json
 {
   "type": "jni.accessed.Type",
+  "jniAccessible": true,
   "methods": [
     {"name": "<methodName1>", "parameterTypes": ["<param-type1>", "<param-typeI>", "<param-typeN>"]},
     {"name": "<methodName2>", "parameterTypes": ["<param-type1>", "<param-typeI>", "<param-typeN>"]}
@@ -420,6 +424,7 @@ As a convenience, one can allow method invocation for groups of methods by addin
 ```json
 {
   "type": "jni.accessed.Type",
+  "jniAccessible": true,
   "allDeclaredConstructors": true,
   "allPublicConstructors": true,
   "allDeclaredMethods": true,
@@ -429,7 +434,8 @@ As a convenience, one can allow method invocation for groups of methods by addin
 `allDeclaredConstructors` and `allDeclaredMethods` allow calls invocations of methods declared on a given type.
 `allPublicConstructors` and `allPublicMethods` allow invocations of all public methods defined on a type and all of its supertypes.
 
-To allocate objects of a type with `AllocObject`, the metadata must be stored in the `reflection` section:
+To allocate objects of a type with `AllocObject`, the `unsafeAllocated` field must be set, but the `jniAccessible` field
+is not required:
 ```json
 {
   "reflection": [

docs/reference-manual/native-image/assets/reachability-metadata-schema-v1.1.0.json

@@ -207,6 +207,11 @@
             "title": "Allow objects of this class to be serialized and deserialized",
             "type": "boolean",
             "default": false
+          },
+          "jniAccessible": {
+            "title": "Register the type, including all registered fields and methods, for runtime JNI access",
+            "type": "boolean",
+            "default": false
           }
         },
         "additionalProperties": false

substratevm/CHANGELOG.md

@@ -18,6 +18,7 @@ This changelog summarizes major changes to GraalVM Native Image.
 * (GR-63494) Recurring callback support is no longer enabled by default. If this feature is needed, please specify `-H:+SupportRecurringCallback` at image build-time.
 * (GR-60209) New syntax for configuration of the [Foreign Function & Memory API](https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/ForeignInterface.md)
 * (GR-64584) Experimental option `-H:+RelativeCodePointers` to significantly reduce relocation entries in position-independent executables and shared libraries.
+* (GR-60238) JNI registration is now included as part of the `"reflection"` section of _reachability-metadata.json_ using the `"jniAccessible"` attribute. Registrations performed through the `"jni"` section of _reachability-metadata.json_ and through _jni-config.json_ will still be accepted and parsed correctly.
 
 ## GraalVM for JDK 24 (Internal Version 24.2.0)
 * (GR-59717) Added `DuringSetupAccess.registerObjectReachabilityHandler` to allow registering a callback that is executed when an object of a specified type is marked as reachable during heap scanning.

substratevm/src/com.oracle.svm.configure.test/src/com/oracle/svm/configure/test/config/OmitPreviousConfigTests.java

@@ -97,7 +97,6 @@ public void testSameConfig() {
         ConfigurationSet config = loadTraceProcessorFromResourceDirectory(PREVIOUS_CONFIG_DIR_NAME, omittedConfig);
         config = config.copyAndSubtract(omittedConfig);
 
-        assertTrue(config.getJniConfiguration().isEmpty());
         assertTrue(config.getReflectionConfiguration().isEmpty());
         assertTrue(config.getProxyConfiguration().isEmpty());
         assertTrue(config.getResourceConfiguration().isEmpty());
@@ -112,7 +111,7 @@ public void testConfigDifference() {
         config = config.copyAndSubtract(omittedConfig);
 
         doTestGeneratedTypeConfig();
-        doTestTypeConfig(config.getJniConfiguration());
+        doTestTypeConfig(config.getReflectionConfiguration());
 
         doTestProxyConfig(config.getProxyConfiguration());
 
@@ -242,8 +241,8 @@ class TypeMethodsWithFlagsTest {
     final Map<ConfigurationMethod, ConfigurationMemberDeclaration> methodsThatMustExist = new HashMap<>();
     final Map<ConfigurationMethod, ConfigurationMemberDeclaration> methodsThatMustNotExist = new HashMap<>();
 
-    final TypeConfiguration previousConfig = new TypeConfiguration("");
-    final TypeConfiguration currentConfig = new TypeConfiguration("");
+    final TypeConfiguration previousConfig = new TypeConfiguration();
+    final TypeConfiguration currentConfig = new TypeConfiguration();
 
     TypeMethodsWithFlagsTest(ConfigurationMemberDeclaration methodKind) {
         this.methodKind = methodKind;

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/ConditionalConfigurationParser.java

@@ -78,7 +78,7 @@ protected UnresolvedConfigurationCondition parseCondition(EconomicMap<String, Ob
         return UnresolvedConfigurationCondition.alwaysTrue();
     }
 
-    private NamedConfigurationTypeDescriptor checkConditionType(ConfigurationTypeDescriptor type) {
+    private static NamedConfigurationTypeDescriptor checkConditionType(ConfigurationTypeDescriptor type) {
         if (!(type instanceof NamedConfigurationTypeDescriptor)) {
             failOnSchemaError("condition should be a fully qualified class name.");
         }

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/ConfigurationFile.java

@@ -38,7 +38,7 @@ public enum ConfigurationFile {
     REFLECTION("reflect", REFLECTION_KEY, true, true),
     RESOURCES("resource", RESOURCES_KEY, true, true),
     SERIALIZATION("serialization", SERIALIZATION_KEY, true, true),
-    JNI("jni", JNI_KEY, true, true),
+    JNI("jni", JNI_KEY, false, true),
     /* Deprecated metadata categories */
     DYNAMIC_PROXY("proxy", null, true, false),
     PREDEFINED_CLASSES_NAME("predefined-classes", null, true, false),

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/ConfigurationParserOption.java

@@ -47,5 +47,10 @@ public enum ConfigurationParserOption {
     /**
      * Treat the "name" entry in a legacy reflection configuration as a "type" entry.
      */
-    TREAT_ALL_NAME_ENTRIES_AS_TYPE
+    TREAT_ALL_NAME_ENTRIES_AS_TYPE,
+
+    /**
+     * Parse the given type configuration file as a JNI configuration.
+     */
+    JNI_PARSER
 }

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/LegacyReflectionConfigurationParser.java

@@ -97,29 +97,30 @@ protected void parseClass(EconomicMap<String, Object> data) {
         T clazz = result.get();
         delegate.registerType(conditionResult.get(), clazz);
 
-        registerIfNotDefault(data, false, clazz, "allDeclaredConstructors", () -> delegate.registerDeclaredConstructors(condition, false, clazz));
-        registerIfNotDefault(data, false, clazz, "allPublicConstructors", () -> delegate.registerPublicConstructors(condition, false, clazz));
-        registerIfNotDefault(data, false, clazz, "allDeclaredMethods", () -> delegate.registerDeclaredMethods(condition, false, clazz));
-        registerIfNotDefault(data, false, clazz, "allPublicMethods", () -> delegate.registerPublicMethods(condition, false, clazz));
-        registerIfNotDefault(data, false, clazz, "allDeclaredFields", () -> delegate.registerDeclaredFields(condition, false, clazz));
-        registerIfNotDefault(data, false, clazz, "allPublicFields", () -> delegate.registerPublicFields(condition, false, clazz));
+        boolean jniAccessible = checkOption(ConfigurationParserOption.JNI_PARSER);
+        registerIfNotDefault(data, false, clazz, "allDeclaredConstructors", () -> delegate.registerDeclaredConstructors(condition, false, jniAccessible, clazz));
+        registerIfNotDefault(data, false, clazz, "allPublicConstructors", () -> delegate.registerPublicConstructors(condition, false, jniAccessible, clazz));
+        registerIfNotDefault(data, false, clazz, "allDeclaredMethods", () -> delegate.registerDeclaredMethods(condition, false, jniAccessible, clazz));
+        registerIfNotDefault(data, false, clazz, "allPublicMethods", () -> delegate.registerPublicMethods(condition, false, jniAccessible, clazz));
+        registerIfNotDefault(data, false, clazz, "allDeclaredFields", () -> delegate.registerDeclaredFields(condition, false, jniAccessible, clazz));
+        registerIfNotDefault(data, false, clazz, "allPublicFields", () -> delegate.registerPublicFields(condition, false, jniAccessible, clazz));
         registerIfNotDefault(data, isType, clazz, "allDeclaredClasses", () -> delegate.registerDeclaredClasses(queryCondition, clazz));
         registerIfNotDefault(data, isType, clazz, "allRecordComponents", () -> delegate.registerRecordComponents(queryCondition, clazz));
         registerIfNotDefault(data, isType, clazz, "allPermittedSubclasses", () -> delegate.registerPermittedSubclasses(queryCondition, clazz));
         registerIfNotDefault(data, isType, clazz, "allNestMembers", () -> delegate.registerNestMembers(queryCondition, clazz));
         registerIfNotDefault(data, isType, clazz, "allSigners", () -> delegate.registerSigners(queryCondition, clazz));
         registerIfNotDefault(data, isType, clazz, "allPublicClasses", () -> delegate.registerPublicClasses(queryCondition, clazz));
-        registerIfNotDefault(data, isType, clazz, "queryAllDeclaredConstructors", () -> delegate.registerDeclaredConstructors(queryCondition, true, clazz));
-        registerIfNotDefault(data, isType, clazz, "queryAllPublicConstructors", () -> delegate.registerPublicConstructors(queryCondition, true, clazz));
-        registerIfNotDefault(data, isType, clazz, "queryAllDeclaredMethods", () -> delegate.registerDeclaredMethods(queryCondition, true, clazz));
-        registerIfNotDefault(data, isType, clazz, "queryAllPublicMethods", () -> delegate.registerPublicMethods(queryCondition, true, clazz));
+        registerIfNotDefault(data, isType, clazz, "queryAllDeclaredConstructors", () -> delegate.registerDeclaredConstructors(queryCondition, true, jniAccessible, clazz));
+        registerIfNotDefault(data, isType, clazz, "queryAllPublicConstructors", () -> delegate.registerPublicConstructors(queryCondition, true, jniAccessible, clazz));
+        registerIfNotDefault(data, isType, clazz, "queryAllDeclaredMethods", () -> delegate.registerDeclaredMethods(queryCondition, true, jniAccessible, clazz));
+        registerIfNotDefault(data, isType, clazz, "queryAllPublicMethods", () -> delegate.registerPublicMethods(queryCondition, true, jniAccessible, clazz));
         if (isType) {
             /*
              * Fields cannot be registered as queried only by the user, we register them
              * unconditionally if the class is registered via "type".
              */
-            delegate.registerDeclaredFields(queryCondition, true, clazz);
-            delegate.registerPublicFields(queryCondition, true, clazz);
+            delegate.registerDeclaredFields(queryCondition, true, jniAccessible, clazz);
+            delegate.registerPublicFields(queryCondition, true, jniAccessible, clazz);
         }
         registerIfNotDefault(data, false, clazz, "unsafeAllocated", () -> delegate.registerUnsafeAllocated(condition, clazz));
         MapCursor<String, Object> cursor = data.getEntries();
@@ -129,13 +130,13 @@ protected void parseClass(EconomicMap<String, Object> data) {
             try {
                 switch (name) {
                     case "methods":
-                        parseMethods(condition, false, asList(value, "Attribute 'methods' must be an array of method descriptors"), clazz);
+                        parseMethods(condition, false, asList(value, "Attribute 'methods' must be an array of method descriptors"), clazz, jniAccessible);
                         break;
                     case "queriedMethods":
-                        parseMethods(condition, true, asList(value, "Attribute 'queriedMethods' must be an array of method descriptors"), clazz);
+                        parseMethods(condition, true, asList(value, "Attribute 'queriedMethods' must be an array of method descriptors"), clazz, jniAccessible);
                         break;
                     case "fields":
-                        parseFields(condition, asList(value, "Attribute 'fields' must be an array of field descriptors"), clazz);
+                        parseFields(condition, asList(value, "Attribute 'fields' must be an array of field descriptors"), clazz, jniAccessible);
                         break;
                 }
             } catch (LinkageError e) {

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/ReflectionConfigurationParser.java

@@ -45,6 +45,7 @@
  */
 public abstract class ReflectionConfigurationParser<C, T> extends ConditionalConfigurationParser {
     private static final String CONSTRUCTOR_NAME = "<init>";
+    private static final String PARAMETER_TYPES_KEY = "parameterTypes";
 
     protected final ConfigurationConditionResolver<C> conditionResolver;
     protected final ReflectionConfigurationParserDelegate<C, T> delegate;
@@ -59,14 +60,15 @@ public ReflectionConfigurationParser(ConfigurationConditionResolver<C> condition
     protected EnumSet<ConfigurationParserOption> supportedOptions() {
         EnumSet<ConfigurationParserOption> base = super.supportedOptions();
         base.add(ConfigurationParserOption.PRINT_MISSING_ELEMENTS);
+        base.add(ConfigurationParserOption.JNI_PARSER);
         return base;
     }
 
-    public static <C, T> ReflectionConfigurationParser<C, T> create(String combinedFileKey, boolean combinedFileSchema,
+    public static <C, T> ReflectionConfigurationParser<C, T> create(boolean combinedFileSchema,
                     ConfigurationConditionResolver<C> conditionResolver, ReflectionConfigurationParserDelegate<C, T> delegate,
                     EnumSet<ConfigurationParserOption> parserOptions) {
         if (combinedFileSchema) {
-            return new ReflectionMetadataParser<>(combinedFileKey, conditionResolver, delegate, parserOptions);
+            return new ReflectionMetadataParser<>(conditionResolver, delegate, parserOptions);
         } else {
             return new LegacyReflectionConfigurationParser<>(conditionResolver, delegate, parserOptions);
         }
@@ -80,47 +82,48 @@ protected void parseClassArray(List<Object> classes) {
 
     protected abstract void parseClass(EconomicMap<String, Object> data);
 
-    protected void registerIfNotDefault(EconomicMap<String, Object> data, boolean defaultValue, T clazz, String propertyName, Runnable register) {
+    protected boolean registerIfNotDefault(EconomicMap<String, Object> data, boolean defaultValue, T clazz, String propertyName, Runnable register) {
         if (data.containsKey(propertyName) ? asBoolean(data.get(propertyName), propertyName) : defaultValue) {
             try {
                 register.run();
+                return true;
             } catch (LinkageError e) {
                 handleMissingElement("Could not register " + delegate.getTypeName(clazz) + ": " + propertyName + " for reflection.", e);
             }
         }
+        return false;
     }
 
-    protected void parseFields(C condition, List<Object> fields, T clazz) {
+    protected void parseFields(C condition, List<Object> fields, T clazz, boolean jniAccessible) {
         for (Object field : fields) {
-            parseField(condition, asMap(field, "Elements of 'fields' array must be field descriptor objects"), clazz);
+            parseField(condition, asMap(field, "Elements of 'fields' array must be field descriptor objects"), clazz, jniAccessible);
         }
     }
 
-    private void parseField(C condition, EconomicMap<String, Object> data, T clazz) {
+    private void parseField(C condition, EconomicMap<String, Object> data, T clazz, boolean jniAccessible) {
         checkAttributes(data, "reflection field descriptor object", Collections.singleton("name"), Arrays.asList("allowWrite", "allowUnsafeAccess"));
         String fieldName = asString(data.get("name"), "name");
         boolean allowWrite = data.containsKey("allowWrite") && asBoolean(data.get("allowWrite"), "allowWrite");
 
         try {
-            delegate.registerField(condition, clazz, fieldName, allowWrite);
+            delegate.registerField(condition, clazz, fieldName, allowWrite, jniAccessible);
         } catch (NoSuchFieldException e) {
             handleMissingElement("Field " + formatField(clazz, fieldName) + " not found.");
         } catch (LinkageError e) {
             handleMissingElement("Could not register field " + formatField(clazz, fieldName) + " for reflection.", e);
         }
     }
 
-    protected void parseMethods(C condition, boolean queriedOnly, List<Object> methods, T clazz) {
+    protected void parseMethods(C condition, boolean queriedOnly, List<Object> methods, T clazz, boolean jniAccessible) {
         for (Object method : methods) {
-            parseMethod(condition, queriedOnly, asMap(method, "Elements of 'methods' array must be method descriptor objects"), clazz);
+            parseMethod(condition, queriedOnly, asMap(method, "Elements of 'methods' array must be method descriptor objects"), clazz, jniAccessible);
         }
     }
 
-    private void parseMethod(C condition, boolean queriedOnly, EconomicMap<String, Object> data, T clazz) {
-        checkAttributes(data, "reflection method descriptor object", Collections.singleton("name"), Collections.singleton("parameterTypes"));
-        String methodName = asString(data.get("name"), "name");
+    private void parseMethod(C condition, boolean queriedOnly, EconomicMap<String, Object> data, T clazz, boolean jniAccessible) {
+        String methodName = asString(data.get(NAME_KEY), NAME_KEY);
         List<T> methodParameterTypes = null;
-        Object parameterTypes = data.get("parameterTypes");
+        Object parameterTypes = data.get(PARAMETER_TYPES_KEY);
         if (parameterTypes != null) {
             methodParameterTypes = parseMethodParameters(clazz, methodName, asList(parameterTypes, "Attribute 'parameterTypes' must be a list of type names"));
             if (methodParameterTypes == null) {
@@ -132,9 +135,9 @@ private void parseMethod(C condition, boolean queriedOnly, EconomicMap<String, O
         if (methodParameterTypes != null) {
             try {
                 if (isConstructor) {
-                    delegate.registerConstructor(condition, queriedOnly, clazz, methodParameterTypes);
+                    delegate.registerConstructor(condition, queriedOnly, clazz, methodParameterTypes, jniAccessible);
                 } else {
-                    delegate.registerMethod(condition, queriedOnly, clazz, methodName, methodParameterTypes);
+                    delegate.registerMethod(condition, queriedOnly, clazz, methodName, methodParameterTypes, jniAccessible);
                 }
             } catch (NoSuchMethodException e) {
                 handleMissingElement("Method " + formatMethod(clazz, methodName, methodParameterTypes) + " not found.");
@@ -145,9 +148,9 @@ private void parseMethod(C condition, boolean queriedOnly, EconomicMap<String, O
             try {
                 boolean found;
                 if (isConstructor) {
-                    found = delegate.registerAllConstructors(condition, queriedOnly, clazz);
+                    found = delegate.registerAllConstructors(condition, queriedOnly, jniAccessible, clazz);
                 } else {
-                    found = delegate.registerAllMethodsWithName(condition, queriedOnly, clazz, methodName);
+                    found = delegate.registerAllMethodsWithName(condition, queriedOnly, jniAccessible, clazz, methodName);
                 }
                 if (!found) {
                     throw new JsonParserException("Method " + formatMethod(clazz, methodName) + " not found");