From 04990c7d500dece4f31837e3d245042993ac83ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20W=C3=B6gerer?= Date: Fri, 10 Dec 2021 15:10:54 +0100 Subject: [PATCH 1/4] Ensure modules from module path can resolve their system module dependencies --- .../oracle/svm/hosted/ModuleLayerFeature.java | 25 ++----------------- ...veImageClassLoaderSupportJDK11OrLater.java | 7 +++--- 2 files changed, 5 insertions(+), 27 deletions(-) diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java index 7105fed83840..0cff090e41c5 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java @@ -308,8 +308,8 @@ private static List findApplicationModules(ModuleLayer runtimeBootLayer, } private static Configuration synthesizeRuntimeBootLayerConfiguration(List mp, Set reachableModules) { - ModuleFinder beforeFinder = new BootModuleLayerModuleFinder(); - ModuleFinder afterFinder = ModuleFinder.of(mp.toArray(Path[]::new)); + ModuleFinder beforeFinder = ModuleFinder.of(mp.toArray(Path[]::new)); + ModuleFinder afterFinder = ModuleFinder.ofSystem(); try { ModuleFinder composed = ModuleFinder.compose(beforeFinder, afterFinder); @@ -346,27 +346,6 @@ private void patchRuntimeBootLayer(ModuleLayer runtimeBootLayer, Map find(String name) { - return ModuleLayer.boot() - .configuration() - .findModule(name) - .map(ResolvedModule::reference); - } - - @Override - public Set findAll() { - return ModuleLayer.boot() - .configuration() - .modules() - .stream() - .map(ResolvedModule::reference) - .collect(Collectors.toSet()); - } - } - private static final class HostedRuntimeModulePair { static HostedRuntimeModulePair withReplicatedHostedModule(Module module) { return new HostedRuntimeModulePair(module, module); diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java index d8cf83267e92..9d3790099240 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java @@ -86,10 +86,9 @@ public NativeImageClassLoaderSupportJDK11OrLater(ClassLoader defaultSystemClassL } private static ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader parent) { - ModuleFinder finder = ModuleFinder.of(modulePaths); - List parents = List.of(ModuleLayer.boot().configuration()); - Set moduleNames = finder.findAll().stream().map(moduleReference -> moduleReference.descriptor().name()).collect(Collectors.toSet()); - Configuration configuration = Configuration.resolve(finder, parents, finder, moduleNames); + ModuleFinder modulePathsFinder = ModuleFinder.of(modulePaths); + Set moduleNames = modulePathsFinder.findAll().stream().map(moduleReference -> moduleReference.descriptor().name()).collect(Collectors.toSet()); + Configuration configuration = ModuleLayer.boot().configuration().resolve(modulePathsFinder, ModuleFinder.ofSystem(), moduleNames); /** * For the modules we want to build an image for, a ModuleLayer is needed that can be * accessed with a single classloader so we can use it for {@link ImageClassLoader}. From cfcebde3158b4d0e4ddb9f386bc961e003cd8f25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20W=C3=B6gerer?= Date: Fri, 10 Dec 2021 16:22:54 +0100 Subject: [PATCH 2/4] Ensure classes from system modules are excluded from ReflectionInvocationCheck --- .../com/oracle/svm/hosted/FallbackFeature.java | 16 ++++++++++++---- .../src/com/oracle/svm/util/ModuleSupport.java | 13 +++++++++++++ .../src/com/oracle/svm/util/ModuleSupport.java | 12 ++++++++++++ 3 files changed, 37 insertions(+), 4 deletions(-) diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java index 9feb5a4a3d22..9044c278bd15 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java @@ -46,6 +46,7 @@ import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.FeatureImpl.AfterAnalysisAccessImpl; import com.oracle.svm.hosted.FeatureImpl.BeforeAnalysisAccessImpl; +import com.oracle.svm.util.ModuleSupport; import jdk.vm.ci.code.BytecodePosition; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -62,6 +63,8 @@ public class FallbackFeature implements Feature { private final List proxyCalls = new ArrayList<>(); private final List serializationCalls = new ArrayList<>(); + private final Set systemModuleDescriptors = ModuleSupport.getSystemModuleDescriptors(); + private static class AutoProxyInvoke { private final ResolvedJavaMethod method; private final int bci; @@ -103,7 +106,7 @@ private interface InvokeChecker { void check(ReflectionInvocationCheck check, BytecodePosition invokeLocation); } - private static class ReflectionInvocationCheck { + private class ReflectionInvocationCheck { private final Method reflectionMethod; private final InvokeChecker checker; private AnalysisMethod trackedReflectionMethod; @@ -120,10 +123,15 @@ void trackMethod(AnalysisMetaAccess metaAccess) { } void apply(BytecodePosition invokeLocation) { - ClassLoader classLoader = ((AnalysisMethod) invokeLocation.getMethod()).getDeclaringClass().getJavaClass().getClassLoader(); - if (NativeImageSystemClassLoader.singleton().isNativeImageClassLoader(classLoader)) { - checker.check(this, invokeLocation); + Class javaClass = ((AnalysisMethod) invokeLocation.getMethod()).getDeclaringClass().getJavaClass(); + if (systemModuleDescriptors.contains(ModuleSupport.getModuleDescriptor(javaClass))) { + return; + } + ClassLoader classLoader = javaClass.getClassLoader(); + if (!NativeImageSystemClassLoader.singleton().isNativeImageClassLoader(classLoader)) { + return; } + checker.check(this, invokeLocation); } String locationString(BytecodePosition invokeLocation) { diff --git a/substratevm/src/com.oracle.svm.util.jdk11/src/com/oracle/svm/util/ModuleSupport.java b/substratevm/src/com.oracle.svm.util.jdk11/src/com/oracle/svm/util/ModuleSupport.java index 477f4e449790..2f289c6b135c 100644 --- a/substratevm/src/com.oracle.svm.util.jdk11/src/com/oracle/svm/util/ModuleSupport.java +++ b/substratevm/src/com.oracle.svm.util.jdk11/src/com/oracle/svm/util/ModuleSupport.java @@ -24,9 +24,12 @@ */ package com.oracle.svm.util; +import java.lang.module.ModuleFinder; +import java.lang.module.ModuleReference; import java.util.NoSuchElementException; import java.util.Optional; import java.util.Set; +import java.util.stream.Collectors; import org.graalvm.nativeimage.Platform; import org.graalvm.nativeimage.Platforms; @@ -124,4 +127,14 @@ public static void exportAndOpenPackageToUnnamed(String name, String pkg, boolea public static String getModuleName(Class clazz) { return clazz.getModule().getName(); } + + public static Object getModuleDescriptor(Class clazz) { + return clazz.getModule().getDescriptor(); + } + + public static Set getSystemModuleDescriptors() { + return ModuleFinder.ofSystem().findAll().stream() + .map(ModuleReference::descriptor) + .collect(Collectors.toSet()); + } } diff --git a/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java b/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java index 512fe2af9f99..185ad90da74c 100644 --- a/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java +++ b/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java @@ -24,7 +24,9 @@ */ package com.oracle.svm.util; +import java.util.Collections; import java.util.NoSuchElementException; +import java.util.Set; import org.graalvm.compiler.serviceprovider.JavaVersionUtil; import org.graalvm.nativeimage.Platform; @@ -86,4 +88,14 @@ public static String getModuleName(Class clazz) { assert JavaVersionUtil.JAVA_SPEC <= 8; return null; } + + public static Object getModuleDescriptor(Class clazz) { + assert JavaVersionUtil.JAVA_SPEC <= 8; + return null; + } + + public static Set getSystemModuleDescriptors() { + assert JavaVersionUtil.JAVA_SPEC <= 8; + return Collections.emptySet(); + } } From b00e02f7157977fd08e485504be7a4f9182b3a33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20W=C3=B6gerer?= Date: Fri, 10 Dec 2021 18:36:27 +0100 Subject: [PATCH 3/4] Ensure jdk.module.upgrade.path is accounted for in ModuleLayerFeature and NativeImageClassLoaderSupport ModuleLayer creation --- .../oracle/svm/hosted/ModuleLayerFeature.java | 11 +-- ...veImageClassLoaderSupportJDK11OrLater.java | 82 ++++++++++--------- .../com/oracle/svm/util/ModuleSupport.java | 1 + 3 files changed, 50 insertions(+), 44 deletions(-) diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java index 0cff090e41c5..49e226560ec5 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java @@ -62,6 +62,7 @@ import com.oracle.svm.core.jdk.JDK11OrLater; import com.oracle.svm.core.jdk11.BootModuleLayerSupport; import com.oracle.svm.core.util.VMError; +import com.oracle.svm.hosted.jdk.NativeImageClassLoaderSupportJDK11OrLater; import com.oracle.svm.util.ModuleSupport; import com.oracle.svm.util.ReflectionUtil; @@ -209,7 +210,10 @@ private static Stream extractRequiredModuleNames(Module m) { } private ModuleLayer synthesizeRuntimeBootLayer(ImageClassLoader cl, Set reachableModules, Set syntheticModules) { - Configuration cf = synthesizeRuntimeBootLayerConfiguration(cl.modulepath(), reachableModules); + NativeImageClassLoaderSupportJDK11OrLater classLoaderSupport = (NativeImageClassLoaderSupportJDK11OrLater) cl.classLoaderSupport; + ModuleFinder beforeFinder = classLoaderSupport.modulepathModuleFinder; + ModuleFinder afterFinder = classLoaderSupport.upgradeAndSystemModuleFinder; + Configuration cf = synthesizeRuntimeBootLayerConfiguration(beforeFinder, afterFinder, reachableModules); try { ModuleLayer runtimeBootLayer = moduleLayerConstructor.newInstance(cf, List.of(), null); Map nameToModule = moduleLayerFeatureUtils.synthesizeNameToModule(runtimeBootLayer, cl.getClassLoader()); @@ -307,10 +311,7 @@ private static List findApplicationModules(ModuleLayer runtimeBootLayer, return applicationModules; } - private static Configuration synthesizeRuntimeBootLayerConfiguration(List mp, Set reachableModules) { - ModuleFinder beforeFinder = ModuleFinder.of(mp.toArray(Path[]::new)); - ModuleFinder afterFinder = ModuleFinder.ofSystem(); - + private static Configuration synthesizeRuntimeBootLayerConfiguration(ModuleFinder beforeFinder, ModuleFinder afterFinder, Set reachableModules) { try { ModuleFinder composed = ModuleFinder.compose(beforeFinder, afterFinder); List missingModules = new ArrayList<>(); diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java index 9d3790099240..cf914559c59b 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java @@ -70,8 +70,12 @@ public class NativeImageClassLoaderSupportJDK11OrLater extends AbstractNativeIma private final List buildmp; private final ClassLoader classLoader; + + public final ModuleFinder upgradeAndSystemModuleFinder; public final ModuleLayer moduleLayerForImageBuild; + public final ModuleFinder modulepathModuleFinder; + public NativeImageClassLoaderSupportJDK11OrLater(ClassLoader defaultSystemClassLoader, String[] classpath, String[] modulePath) { super(defaultSystemClassLoader, classpath); @@ -79,16 +83,21 @@ public NativeImageClassLoaderSupportJDK11OrLater(ClassLoader defaultSystemClassL buildmp = Optional.ofNullable(System.getProperty("jdk.module.path")).stream() .flatMap(s -> Arrays.stream(s.split(File.pathSeparator))).map(Paths::get).collect(Collectors.toUnmodifiableList()); + upgradeAndSystemModuleFinder = createUpgradeAndSystemModuleFinder(); ModuleLayer moduleLayer = createModuleLayer(imagemp.toArray(Path[]::new), classPathClassLoader); adjustBootLayerQualifiedExports(moduleLayer); moduleLayerForImageBuild = moduleLayer; + classLoader = getSingleClassloader(moduleLayer); + + modulepathModuleFinder = ModuleFinder.of(modulepath().toArray(Path[]::new)); } - private static ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader parent) { + private ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader parent) { ModuleFinder modulePathsFinder = ModuleFinder.of(modulePaths); Set moduleNames = modulePathsFinder.findAll().stream().map(moduleReference -> moduleReference.descriptor().name()).collect(Collectors.toSet()); - Configuration configuration = ModuleLayer.boot().configuration().resolve(modulePathsFinder, ModuleFinder.ofSystem(), moduleNames); + + Configuration configuration = ModuleLayer.boot().configuration().resolve(modulePathsFinder, upgradeAndSystemModuleFinder, moduleNames); /** * For the modules we want to build an image for, a ModuleLayer is needed that can be * accessed with a single classloader so we can use it for {@link ImageClassLoader}. @@ -96,6 +105,36 @@ private static ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader par return ModuleLayer.defineModulesWithOneLoader(configuration, List.of(ModuleLayer.boot()), parent).layer(); } + /** + * Gets a finder that locates the upgrade modules and the system modules, in that order. + */ + private static ModuleFinder createUpgradeAndSystemModuleFinder() { + ModuleFinder finder = ModuleFinder.ofSystem(); + ModuleFinder upgradeModulePath = finderFor("jdk.module.upgrade.path"); + if (upgradeModulePath != null) { + finder = ModuleFinder.compose(upgradeModulePath, finder); + } + return finder; + } + + /** + * Creates a finder from a module path specified by the {@code prop} system property. + */ + private static ModuleFinder finderFor(String prop) { + String s = System.getProperty(prop); + if (s == null || s.isEmpty()) { + return null; + } else { + String[] dirs = s.split(File.pathSeparator); + Path[] paths = new Path[dirs.length]; + int i = 0; + for (String dir : dirs) { + paths[i++] = Path.of(dir); + } + return ModuleFinder.of(paths); + } + } + private static void adjustBootLayerQualifiedExports(ModuleLayer layer) { /* * For all qualified exports packages of modules in the the boot layer we check if layer @@ -349,41 +388,6 @@ public ClassLoader getClassLoader() { return classLoader; } - private static ModuleFinder upgradeAndSystemModuleFinder; - - /** - * Creates a finder from a module path specified by the {@code prop} system property. - */ - private static ModuleFinder finderFor(String prop) { - String s = System.getProperty(prop); - if (s == null || s.isEmpty()) { - return null; - } else { - String[] dirs = s.split(File.pathSeparator); - Path[] paths = new Path[dirs.length]; - int i = 0; - for (String dir : dirs) { - paths[i++] = Path.of(dir); - } - return ModuleFinder.of(paths); - } - } - - /** - * Gets a finder that locates the upgrade modules and the system modules, in that order. - */ - private static ModuleFinder getUpgradeAndSystemModuleFinder() { - if (upgradeAndSystemModuleFinder == null) { - ModuleFinder finder = ModuleFinder.ofSystem(); - ModuleFinder upgradeModulePath = finderFor("jdk.module.upgrade.path"); - if (upgradeModulePath != null) { - finder = ModuleFinder.compose(upgradeModulePath, finder); - } - upgradeAndSystemModuleFinder = finder; - } - return upgradeAndSystemModuleFinder; - } - private class ClassInitWithModules extends ClassInit { ClassInitWithModules(ForkJoinPool executor, ImageClassLoader imageClassLoader) { @@ -396,12 +400,12 @@ protected void init() { "jdk.internal.vm.ci", "jdk.internal.vm.compiler", "com.oracle.graal.graal_enterprise", "org.graalvm.sdk", "org.graalvm.truffle"); - for (ModuleReference moduleReference : getUpgradeAndSystemModuleFinder().findAll()) { + for (ModuleReference moduleReference : upgradeAndSystemModuleFinder.findAll()) { if (requiresInit.contains(moduleReference.descriptor().name())) { initModule(moduleReference); } } - for (ModuleReference moduleReference : ModuleFinder.of(modulepath().toArray(Path[]::new)).findAll()) { + for (ModuleReference moduleReference : modulepathModuleFinder.findAll()) { initModule(moduleReference); } diff --git a/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java b/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java index 185ad90da74c..5d9c3b77d4a7 100644 --- a/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java +++ b/substratevm/src/com.oracle.svm.util/src/com/oracle/svm/util/ModuleSupport.java @@ -89,6 +89,7 @@ public static String getModuleName(Class clazz) { return null; } + @SuppressWarnings("unused") public static Object getModuleDescriptor(Class clazz) { assert JavaVersionUtil.JAVA_SPEC <= 8; return null; From eaeb641aa32349ccc890d2b38d1e2a6ca7828d0a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20W=C3=B6gerer?= Date: Mon, 13 Dec 2021 18:35:13 +0100 Subject: [PATCH 4/4] Document code --- .../src/com/oracle/svm/hosted/ModuleLayerFeature.java | 4 ++++ .../jdk/NativeImageClassLoaderSupportJDK11OrLater.java | 10 +++++++++- .../src/com/oracle/svm/hosted/FallbackFeature.java | 3 +++ 3 files changed, 16 insertions(+), 1 deletion(-) diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java index 49e226560ec5..4cfc40c7a0af 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/ModuleLayerFeature.java @@ -210,6 +210,10 @@ private static Stream extractRequiredModuleNames(Module m) { } private ModuleLayer synthesizeRuntimeBootLayer(ImageClassLoader cl, Set reachableModules, Set syntheticModules) { + /** + * For consistent module lookup we reuse the {@link ModuleFinder}s defined and used in + * {@link NativeImageClassLoaderSupportJDK11OrLater}. + */ NativeImageClassLoaderSupportJDK11OrLater classLoaderSupport = (NativeImageClassLoaderSupportJDK11OrLater) cl.classLoaderSupport; ModuleFinder beforeFinder = classLoaderSupport.modulepathModuleFinder; ModuleFinder afterFinder = classLoaderSupport.upgradeAndSystemModuleFinder; diff --git a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java index cf914559c59b..49eff2b7bdfe 100644 --- a/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java +++ b/substratevm/src/com.oracle.svm.hosted.jdk11/src/com/oracle/svm/hosted/jdk/NativeImageClassLoaderSupportJDK11OrLater.java @@ -97,6 +97,13 @@ private ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader parent) { ModuleFinder modulePathsFinder = ModuleFinder.of(modulePaths); Set moduleNames = modulePathsFinder.findAll().stream().map(moduleReference -> moduleReference.descriptor().name()).collect(Collectors.toSet()); + /** + * When building a moduleLayer for the module-path passed to native-image we need to be able + * to resolve against system modules that are not used by the moduleLayer in which the + * image-builder got loaded into. To do so we use {@link upgradeAndSystemModuleFinder} as + * {@code ModuleFinder after} in + * {@link Configuration#resolve(ModuleFinder, ModuleFinder, Collection)}. + */ Configuration configuration = ModuleLayer.boot().configuration().resolve(modulePathsFinder, upgradeAndSystemModuleFinder, moduleNames); /** * For the modules we want to build an image for, a ModuleLayer is needed that can be @@ -106,7 +113,8 @@ private ModuleLayer createModuleLayer(Path[] modulePaths, ClassLoader parent) { } /** - * Gets a finder that locates the upgrade modules and the system modules, in that order. + * Gets a finder that locates the upgrade modules and the system modules, in that order. Upgrade + * modules are used when mx environment variable {@code MX_BUILD_EXPLODED=true} is used. */ private static ModuleFinder createUpgradeAndSystemModuleFinder() { ModuleFinder finder = ModuleFinder.ofSystem(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java index 9044c278bd15..ee44ae1b9969 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FallbackFeature.java @@ -125,12 +125,15 @@ void trackMethod(AnalysisMetaAccess metaAccess) { void apply(BytecodePosition invokeLocation) { Class javaClass = ((AnalysisMethod) invokeLocation.getMethod()).getDeclaringClass().getJavaClass(); if (systemModuleDescriptors.contains(ModuleSupport.getModuleDescriptor(javaClass))) { + /* Ensure all JDK system modules are excluded from reporting reflection use. */ return; } ClassLoader classLoader = javaClass.getClassLoader(); if (!NativeImageSystemClassLoader.singleton().isNativeImageClassLoader(classLoader)) { + /* Classes not loaded by NativeImageClassLoader are also excluded. */ return; } + /* Collect reflection use in application classes. */ checker.check(this, invokeLocation); }