Make NativeImageSystemClassLoader able to handle having module classl…

…oader with a parent ClassPathClassLoader

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageClassLoaderSupport.java

@@ -102,13 +102,19 @@ public class NativeImageClassLoaderSupport {
  public final ModuleLayer moduleLayerForImageBuild;
  public final ModuleFinder modulepathModuleFinder;
 
+ static final class ClassPathClassLoader extends URLClassLoader {
+ ClassPathClassLoader(URL[] urls, ClassLoader parent) {
+ super(urls, parent);
+ }
+ }
+
  protected NativeImageClassLoaderSupport(ClassLoader defaultSystemClassLoader, String[] classpath, String[] modulePath) {
 
  classes = EconomicMap.create();
  packages = EconomicMap.create();
  emptySet = EconomicSet.create();
 
- classPathClassLoader = new URLClassLoader(Util.verifyClassPathAndConvertToURLs(classpath), defaultSystemClassLoader);
+ classPathClassLoader = new ClassPathClassLoader(Util.verifyClassPathAndConvertToURLs(classpath), defaultSystemClassLoader);
 
  imagecp = Arrays.stream(classPathClassLoader.getURLs())
  .map(Util::urlToPath)

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageSystemClassLoader.java

@@ -25,11 +25,13 @@
 package com.oracle.svm.hosted;
 
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.security.SecureClassLoader;
 import java.util.Collections;
 import java.util.Enumeration;
+import java.util.List;
 import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.jar.JarFile;
@@ -135,34 +137,56 @@ public boolean isDisallowedClassLoader(ClassLoader c) {
  private static final Method defineClass = ReflectionUtil.lookupMethod(ClassLoader.class, "defineClass",
  String.class, byte[].class, int.class, int.class);
 
- static Class<?> loadClass(ClassLoader classLoader, String name, boolean resolve) throws ClassNotFoundException {
- Class<?> loadedClass = null;
+ private static final Constructor<Enumeration<?>> compoundEnumerationConstructor;
+ static {
+ /* Reuse utility class defined as package-private class in java.lang.ClassLoader.java */
+ String className = "java.lang.CompoundEnumeration";
  try {
- /* invoke the "loadClass" method on the current class loader */
- loadedClass = ((Class<?>) loadClass.invoke(classLoader, name, resolve));
- } catch (Exception e) {
- if (e.getCause() instanceof ClassNotFoundException) {
- throw ((ClassNotFoundException) e.getCause());
+ @SuppressWarnings("unchecked")
+ Class<Enumeration<?>> compoundEnumerationClass = (Class<Enumeration<?>>) Class.forName(className);
+ compoundEnumerationConstructor = ReflectionUtil.lookupConstructor(compoundEnumerationClass, Enumeration[].class);
+ } catch (ClassNotFoundException | ReflectionUtil.ReflectionUtilError e) {
+ throw VMError.shouldNotReachHere("Unable to get access to class " + className, e);
+ }
+ }
+
+ private static Class<?> loadClass(List<ClassLoader> activeClassLoaders, String name, boolean resolve) throws ClassNotFoundException {
+ ClassNotFoundException classNotFoundException = null;
+ for (ClassLoader loader : activeClassLoaders) {
+ try {
+ /* invoke the "loadClass" method on the current class loader */
+ return ((Class<?>) loadClass.invoke(loader, name, resolve));
+ } catch (Exception e) {
+ if (e.getCause() instanceof ClassNotFoundException) {
+ classNotFoundException = ((ClassNotFoundException) e.getCause());
+ } else {
+ String message = String.format("Can not load class: %s, with class loader: %s", name, loader);
+ VMError.shouldNotReachHere(message, e);
+ }
  }
- String message = String.format("Can not load class: %s, with class loader: %s", name, classLoader);
- VMError.shouldNotReachHere(message, e);
  }
- return loadedClass;
+ VMError.guarantee(classNotFoundException != null);
+ throw classNotFoundException;
  }
 
- static URL findResource(ClassLoader classLoader, String name) {
- try {
- // invoke the "findResource" method on the current class loader
- return (URL) findResource.invoke(classLoader, name);
- } catch (ReflectiveOperationException e) {
- String message = String.format("Can not find resource: %s using class loader: %s", name, classLoader);
- VMError.shouldNotReachHere(message, e);
+ private static URL findResource(List<ClassLoader> activeClassLoaders, String name) {
+ for (ClassLoader loader : activeClassLoaders) {
+ try {
+ // invoke the "findResource" method on the current class loader
+ Object url = findResource.invoke(loader, name);
+ if (url != null) {
+ return (URL) url;
+ }
+ } catch (ReflectiveOperationException | ClassCastException e) {
+ String message = String.format("Can not find resource: %s using class loader: %s", name, loader);
+ VMError.shouldNotReachHere(message, e);
+ }
  }
  return null;
  }
 
  @SuppressWarnings("unchecked")
- static Enumeration<URL> findResources(ClassLoader classLoader, String name) {
+ private static Enumeration<URL> findResources(ClassLoader classLoader, String name) {
  try {
  // invoke the "findResources" method on the current class loader
  return (Enumeration<URL>) findResources.invoke(classLoader, name);
@@ -186,22 +210,38 @@ static Class<?> defineClass(ClassLoader classLoader, String name, byte[] b, int
 
  @Override
  protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
- return loadClass(getActiveClassLoader(), name, resolve);
+ return loadClass(getActiveClassLoaders(), name, resolve);
  }
 
  @Override
  protected URL findResource(String name) {
- return findResource(getActiveClassLoader(), name);
+ return findResource(getActiveClassLoaders(), name);
  }
 
  @Override
  protected Enumeration<URL> findResources(String name) throws IOException {
- return findResources(getActiveClassLoader(), name);
+ List<ClassLoader> activeClassLoaders = getActiveClassLoaders();
+ assert !activeClassLoaders.isEmpty() & activeClassLoaders.size() <= 2;
+ ClassLoader activeClassLoader = activeClassLoaders.get(0);
+ ClassLoader activeClassLoaderParent = activeClassLoaders.size() > 1 ? activeClassLoaders.get(1) : null;
+ if (activeClassLoaderParent != null) {
+ return newCompoundEnumeration(findResources(activeClassLoaderParent, name), findResources(activeClassLoader, name));
+ }
+ return findResources(activeClassLoader, name);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static <T> Enumeration<T> newCompoundEnumeration(Enumeration<?>... enums) {
+ try {
+ return (Enumeration<T>) compoundEnumerationConstructor.newInstance((Object) enums);
+ } catch (ReflectiveOperationException e) {
+ throw VMError.shouldNotReachHere("Cannot instantiate CompoundEnumeration", e);
+ }
  }
 
  public Class<?> forNameOrNull(String name, boolean initialize) {
  try {
- return Class.forName(name, initialize, getActiveClassLoader());
+ return Class.forName(name, initialize, getActiveClassLoaders().get(0));
  } catch (LinkageError | ClassNotFoundException ignored) {
  return null;
  }
@@ -212,7 +252,7 @@ public Class<?> predefineClass(String name, byte[] array, int offset, int length
  if (forNameOrNull(name, false) != null) {
  throw VMError.shouldNotReachHere("The class loader hierarchy already provides a class with the same name as the class submitted for predefinition: " + name);
  }
- return defineClass(getActiveClassLoader(), name, array, offset, length);
+ return defineClass(getActiveClassLoaders().get(0), name, array, offset, length);
  }
 
  @Override
@@ -224,11 +264,18 @@ public String toString() {
  '}';
  }
 
- private ClassLoader getActiveClassLoader() {
- ClassLoader delegate = nativeImageClassLoader;
- return delegate != null
- ? delegate
- : defaultSystemClassLoader;
+ private List<ClassLoader> getActiveClassLoaders() {
+ ClassLoader activeClassLoader = nativeImageClassLoader;
+ if (activeClassLoader != null) {
+ ClassLoader activeClassLoaderParent = activeClassLoader.getParent();
+ if (activeClassLoaderParent instanceof NativeImageClassLoaderSupport.ClassPathClassLoader) {
+ return List.of(activeClassLoader, activeClassLoaderParent);
+ } else {
+ return List.of(activeClassLoader);
+ }
+ } else {
+ return List.of(defaultSystemClassLoader);
+ }
  }
 
  /**