Reuse ModuleBootstrap.boot2()

ivan-ristovic · ivan-ristovic · commit 1c7dde9c6ecd · 2023-02-09T15:58:34.000+01:00
diff --git a/substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/DefaultOptionHandler.java b/substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/DefaultOptionHandler.java
@@ -43,7 +43,8 @@ class DefaultOptionHandler extends NativeImage.OptionHandler<NativeImage> {
     private static final String newStyleClasspathOptionName = "--class-path";
 
     static final String addModulesOption = "--add-modules";
-    private static final String addModulesErrorMessage = " requires modules to be specified";
+    static final String limitModulesOption = "--limit-modules";
+    private static final String moduleSetModifierOptionErrorMessage = " requires modules to be specified";
 
     /* Defunct legacy options that we have to accept to maintain backward compatibility */
     private static final String noServerOption = "--no-server";
@@ -95,11 +96,20 @@ public boolean consume(ArgumentQueue args) {
                 args.poll();
                 String addModulesArgs = args.poll();
                 if (addModulesArgs == null) {
-                    NativeImage.showError(headArg + addModulesErrorMessage);
+                    NativeImage.showError(headArg + moduleSetModifierOptionErrorMessage);
                 }
                 nativeImage.addImageBuilderJavaArgs(addModulesOption, addModulesArgs);
                 nativeImage.addAddedModules(addModulesArgs);
                 return true;
+            case limitModulesOption:
+                args.poll();
+                String limitModulesArgs = args.poll();
+                if (limitModulesArgs == null) {
+                    NativeImage.showError(headArg + moduleSetModifierOptionErrorMessage);
+                }
+                nativeImage.addImageBuilderJavaArgs(limitModulesOption, limitModulesArgs);
+                nativeImage.addLimitedModules(limitModulesArgs);
+                return true;
             case "-jar":
                 args.poll();
                 String jarFilePathStr = args.poll();
@@ -179,12 +189,22 @@ public boolean consume(ArgumentQueue args) {
             args.poll();
             String addModulesArgs = headArg.substring(addModulesOption.length() + 1);
             if (addModulesArgs.isEmpty()) {
-                NativeImage.showError(headArg + addModulesErrorMessage);
+                NativeImage.showError(headArg + moduleSetModifierOptionErrorMessage);
             }
             nativeImage.addImageBuilderJavaArgs(addModulesOption, addModulesArgs);
             nativeImage.addAddedModules(addModulesArgs);
             return true;
         }
+        if (headArg.startsWith(limitModulesOption + "=")) {
+            args.poll();
+            String limitModulesArgs = headArg.substring(limitModulesOption.length() + 1);
+            if (limitModulesArgs.isEmpty()) {
+                NativeImage.showError(headArg + moduleSetModifierOptionErrorMessage);
+            }
+            nativeImage.addImageBuilderJavaArgs(limitModulesOption, limitModulesArgs);
+            nativeImage.addLimitedModules(limitModulesArgs);
+            return true;
+        }
         if (headArg.startsWith("@") && !disableAtFiles) {
             args.poll();
             headArg = headArg.substring(1);
diff --git a/substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/NativeImage.java b/substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/NativeImage.java
@@ -292,6 +292,7 @@ private static <T> String oR(OptionKey<T> option) {
 
     private final List<ExcludeConfig> excludedConfigs = new ArrayList<>();
     private final LinkedHashSet<String> addModules = new LinkedHashSet<>();
+    private final LinkedHashSet<String> limitModules = new LinkedHashSet<>();
 
     private long imageBuilderPid = -1;
 
@@ -1186,6 +1187,9 @@ private int completeImageBuild() {
         if (!addModules.isEmpty()) {
             imageBuilderJavaArgs.add("-D" + ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_ADDED_MODULES + "=" + String.join(",", addModules));
         }
+        if (!limitModules.isEmpty()) {
+            imageBuilderJavaArgs.add("-D" + ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_LIMITED_MODULES + "=" + String.join(",", limitModules));
+        }
         if (config.modulePathBuild && !finalImageClasspath.isEmpty()) {
             imageBuilderJavaArgs.add(DefaultOptionHandler.addModulesOption + "=ALL-DEFAULT");
         }
@@ -1617,6 +1621,10 @@ public void addAddedModules(String addModulesArg) {
         addModules.addAll(Arrays.asList(SubstrateUtil.split(addModulesArg, ",")));
     }
 
+    public void addLimitedModules(String limitModulesArg) {
+        limitModules.addAll(Arrays.asList(SubstrateUtil.split(limitModulesArg, ",")));
+    }
+
     void addImageBuilderClasspath(Path classpath) {
         imageBuilderClasspath.add(canonicalize(classpath));
     }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ModuleLayerFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ModuleLayerFeature.java
@@ -53,15 +53,19 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import jdk.internal.module.SystemModuleFinders;
+import org.graalvm.compiler.options.OptionValues;
 import org.graalvm.nativeimage.ImageSingletons;
 
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
+import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateUtil;
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.jdk.BootModuleLayerSupport;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
 import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.core.util.UserError;
 import com.oracle.svm.util.ModuleSupport;
 import com.oracle.svm.util.ReflectionUtil;
 
@@ -152,15 +156,10 @@ public void afterAnalysis(AfterAnalysisAccess access) {
          * Parse explicitly added modules via --add-modules. This is done early as this information
          * is required when filtering the analysis reachable module set.
          */
-        Set<String> extraModules = new HashSet<>();
-        String explicitlyAddedModules = System.getProperty(ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_ADDED_MODULES, "");
-        if (!explicitlyAddedModules.isEmpty()) {
-            extraModules.addAll(Arrays.asList(SubstrateUtil.split(explicitlyAddedModules, ",")));
-        }
-
-        List<String> nonExplicit = List.of("ALL-DEFAULT", "ALL-SYSTEM", "ALL-MODULE-PATH");
+        Set<String> extraModules = ModuleLayerFeatureUtils.parseModuleSetModifierProperty(ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_ADDED_MODULES);
 
-        Set<Module> runtimeImageModules = calculateRootModulesAndUpdateExtraModules(accessImpl, nonExplicit, extraModules);
+        Set<Module> runtimeImageModules = calculateRootModulesAndUpdateExtraModules(accessImpl, ModuleSupport.nonExplicitModules, extraModules);
+//        Set<Module> runtimeImageModules = calculateRootModules(accessImpl, extraModules);
 
         Set<Module> runtimeImageNamedModules = runtimeImageModules
                         .stream()
@@ -172,7 +171,7 @@ public void afterAnalysis(AfterAnalysisAccess access) {
          * process.
          */
         extraModules.addAll(ImageSingletons.lookup(ResourcesFeature.class).includedResourcesModules);
-        extraModules.stream().filter(Predicate.not(nonExplicit::contains)).forEach(moduleName -> {
+        extraModules.stream().filter(Predicate.not(ModuleSupport.nonExplicitModules::contains)).forEach(moduleName -> {
             Optional<?> module = accessImpl.imageClassLoader.findModule(moduleName);
             if (module.isEmpty()) {
                 VMError.shouldNotReachHere("Explicitly required module " + moduleName + " is not available");
@@ -270,6 +269,108 @@ private static Set<Module> calculateRootModulesAndUpdateExtraModules(FeatureImpl
         return rootModules.collect(Collectors.toSet());
     }
 
+    /**
+     * See jdk.internal.module.ModuleBootstrap#boot2() method for more details.
+     */
+    private Set<String> calculateRootModules(FeatureImpl.AfterAnalysisAccessImpl accessImpl, Collection<String> extraModules) {
+        String mainModule = moduleLayerFeatureUtils.getMainModuleName();
+        List<Path> appModulePath = accessImpl.imageClassLoader.applicationModulePath();
+        boolean haveAppModulePath = !appModulePath.isEmpty();
+        Set<String> limitModules = ModuleLayerFeatureUtils.parseModuleSetModifierProperty(ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_LIMITED_MODULES);
+
+        Object systemModules = null;
+        ModuleFinder systemModuleFinder;
+
+        if (!haveAppModulePath && extraModules.isEmpty() && limitModules.isEmpty()) {
+            systemModules = moduleLayerFeatureUtils.invokeSystemModuleFinderSystemModules(mainModule);
+        }
+        if (systemModules == null) {
+            // all system modules are observable
+            systemModules = moduleLayerFeatureUtils.invokeSystemModuleFinderAllSystemModules();
+        }
+        if (systemModules != null) {
+            // images build
+            systemModuleFinder = moduleLayerFeatureUtils.invokeSystemModuleFinderOf(systemModules);
+        } else {
+            // exploded build or testing
+            throw UserError.abort("Exploded builds are not supported.");
+        }
+
+        ModuleFinder appModulePathFinder = ModuleFinder.of(accessImpl.imageClassLoader.applicationModulePath().toArray(new Path[0]));
+        ModuleFinder finder = haveAppModulePath ? ModuleFinder.compose(systemModuleFinder, appModulePathFinder) : systemModuleFinder;
+
+        // The root modules to resolve
+        Set<String> roots = new HashSet<>();
+
+        // Launcher -m option to specify the main/initial module
+        if (mainModule != null)
+            roots.add(mainModule);
+
+        // Additional module(s) specified by --add-modules
+        boolean addAllDefaultModules = false;
+        boolean addAllSystemModules = false;
+        boolean addAllApplicationModules = false;
+        for (String mod : extraModules) {
+            switch (mod) {
+                case ModuleSupport.MODULE_SET_ALL_DEFAULT:
+                    addAllDefaultModules = true;
+                    break;
+                case ModuleSupport.MODULE_SET_ALL_SYSTEM:
+                    addAllSystemModules = true;
+                    break;
+                case ModuleSupport.MODULE_SET_ALL_MODULE_PATH:
+                    addAllApplicationModules = true;
+                    break;
+                default:
+                    roots.add(mod);
+            }
+        }
+
+        /*
+        // --limit-modules
+        if (!limitModules.isEmpty()) {
+            finder = limitFinder(finder, limitModules, roots);
+        }
+
+        // If there is no initial module specified then assume that the initial
+        // module is the unnamed module of the application class loader. This
+        // is implemented by resolving all observable modules that export an
+        // API. Modules that have the DO_NOT_RESOLVE_BY_DEFAULT bit set in
+        // their ModuleResolution attribute flags are excluded from the
+        // default set of roots.
+        if (mainModule == null || addAllDefaultModules) {
+            roots.addAll(DefaultRoots.compute(systemModuleFinder, finder));
+        }
+
+        // If `--add-modules ALL-SYSTEM` is specified then all observable system
+        // modules will be resolved.
+        if (addAllSystemModules) {
+            ModuleFinder f = finder;  // observable modules
+            systemModuleFinder.findAll()
+                    .stream()
+                    .map(ModuleReference::descriptor)
+                    .map(ModuleDescriptor::name)
+                    .filter(mn -> f.find(mn).isPresent())  // observable
+                    .forEach(roots::add);
+        }
+
+        // If `--add-modules ALL-MODULE-PATH` is specified then all observable
+        // modules on the application module path will be resolved.
+        if (appModulePath != null && addAllApplicationModules) {
+            ModuleFinder f = finder;  // observable modules
+            appModulePath.findAll()
+                    .stream()
+                    .map(ModuleReference::descriptor)
+                    .map(ModuleDescriptor::name)
+                    .filter(mn -> f.find(mn).isPresent())  // observable
+                    .forEach(mn -> roots.add(mn));
+        }
+
+        */
+
+        return roots;
+    }
+
     private static boolean typeIsReachable(AnalysisType t) {
         return t.isReachable() && !t.isArray();
     }
@@ -527,6 +628,9 @@ private static final class ModuleLayerFeatureUtils {
         private final Field moduleOpenPackagesField;
         private final Field moduleExportedPackagesField;
         private final Method moduleFindModuleMethod;
+        private final Method systemModuleFindersAllSystemModulesMethod;
+        private final Method systemModuleFindersOfMethod;
+        private final Method systemModuleFindersSystemModulesMethod;
         private final Constructor<ModuleLayer> moduleLayerConstructor;
         private final Field moduleLayerNameToModuleField;
         private final Field moduleLayerParentsField;
@@ -569,6 +673,10 @@ private static final class ModuleLayerFeatureUtils {
                 moduleConstructor = ReflectionUtil.lookupConstructor(Module.class, ClassLoader.class, ModuleDescriptor.class);
                 moduleFindModuleMethod = ReflectionUtil.lookupMethod(Module.class, "findModule", String.class, Map.class, Map.class, List.class);
 
+                systemModuleFindersAllSystemModulesMethod = ReflectionUtil.lookupMethod(SystemModuleFinders.class, "allSystemModules");
+                systemModuleFindersOfMethod = ReflectionUtil.lookupMethod(SystemModuleFinders.class, "of", Class.forName("jdk.internal.module.SystemModules"));
+                systemModuleFindersSystemModulesMethod = ReflectionUtil.lookupMethod(SystemModuleFinders.class, "systemModules", String.class);
+
                 moduleLayerConstructor = ReflectionUtil.lookupConstructor(ModuleLayer.class, Configuration.class, List.class, Function.class);
                 moduleLayerNameToModuleField = ReflectionUtil.lookupField(ModuleLayer.class, "nameToModule");
                 moduleLayerParentsField = ReflectionUtil.lookupField(ModuleLayer.class, "parents");
@@ -590,6 +698,15 @@ private static boolean isModuleSynthetic(Module m) {
             return m.getDescriptor().modifiers().contains(ModuleDescriptor.Modifier.SYNTHETIC);
         }
 
+        static Set<String> parseModuleSetModifierProperty(String prop) {
+            Set<String> specifiedModules = new HashSet<>();
+            String args = System.getProperty(prop, "");
+            if (!args.isEmpty()) {
+                specifiedModules.addAll(Arrays.asList(SubstrateUtil.split(args, ",")));
+            }
+            return specifiedModules;
+        }
+
         static int distanceFromBootModuleLayer(ModuleLayer layer) {
             if (layer == ModuleLayer.boot()) {
                 return 0;
@@ -601,6 +718,11 @@ static int distanceFromBootModuleLayer(ModuleLayer layer) {
                             .orElse(0);
         }
 
+        public String getMainModuleName() {
+            OptionValues parsedHostedOptions = imageClassLoader.classLoaderSupport.getParsedHostedOptions();
+            return SubstrateOptions.Module.getValue(parsedHostedOptions);
+        }
+
         public Module getRuntimeModuleForHostedModule(Module hostedModule, boolean optional) {
             if (hostedModule.isNamed()) {
                 return getRuntimeModuleForHostedModule(hostedModule.getClassLoader(), hostedModule.getName(), optional);
@@ -894,5 +1016,29 @@ ClassLoader getClassLoaderForModuleInModuleLayer(ModuleLayer hostedModuleLayer,
             Optional<Module> module = hostedModuleLayer.findModule(name);
             return module.isPresent() ? module.get().getClassLoader() : imageClassLoader.getClassLoader();
         }
+
+        Object invokeSystemModuleFinderAllSystemModules() {
+            try {
+                return systemModuleFindersAllSystemModulesMethod.invoke(null);
+            } catch (ReflectiveOperationException e) {
+                throw VMError.shouldNotReachHere("Failed to reflectively invoke SystemModuleFinders.allSystemModules().", e);
+            }
+        }
+
+        ModuleFinder invokeSystemModuleFinderOf(Object systemModules) {
+            try {
+                return (ModuleFinder) systemModuleFindersOfMethod.invoke(null, systemModules);
+            } catch (ReflectiveOperationException e) {
+                throw VMError.shouldNotReachHere("Failed to reflectively invoke SystemModuleFinders.of().", e);
+            }
+        }
+
+        Object invokeSystemModuleFinderSystemModules(String mainModule) {
+            try {
+                return systemModuleFindersSystemModulesMethod.invoke(null, mainModule);
+            } catch (ReflectiveOperationException e) {
+                throw VMError.shouldNotReachHere("Failed to reflectively invoke SystemModuleFinders.systemModules().", e);
+            }
+        }
     }
 }
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
@@ -24,6 +24,7 @@
  */
 package com.oracle.svm.util;
 
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -35,8 +36,14 @@
 
 public final class ModuleSupport {
 
+    public static final String MODULE_SET_ALL_DEFAULT = "ALL-DEFAULT";
+    public static final String MODULE_SET_ALL_SYSTEM = "ALL-SYSTEM";
+    public static final String MODULE_SET_ALL_MODULE_PATH = "ALL-MODULE-PATH";
+    public static final List<String> nonExplicitModules = List.of(MODULE_SET_ALL_DEFAULT, MODULE_SET_ALL_SYSTEM, MODULE_SET_ALL_MODULE_PATH);
+
     public static final String ENV_VAR_USE_MODULE_SYSTEM = "USE_NATIVE_IMAGE_JAVA_PLATFORM_MODULE_SYSTEM";
     public static final String PROPERTY_IMAGE_EXPLICITLY_ADDED_MODULES = "org.graalvm.nativeimage.module.addmods";
+    public static final String PROPERTY_IMAGE_EXPLICITLY_LIMITED_MODULES = "org.graalvm.nativeimage.module.limitmods";
     public static final boolean modulePathBuild = isModulePathBuild();
 
     private ModuleSupport() {

Original file line number	Diff line number	Diff line change
`@@ -292,6 +292,7 @@ private static <T> String oR(OptionKey<T> option) {`
`292`	`292`
`293`	`293`	`private final List<ExcludeConfig> excludedConfigs = new ArrayList<>();`
`294`	`294`	`private final LinkedHashSet<String> addModules = new LinkedHashSet<>();`
	`295`	`+ private final LinkedHashSet<String> limitModules = new LinkedHashSet<>();`
`295`	`296`
`296`	`297`	`private long imageBuilderPid = -1;`
`297`	`298`
`@@ -1186,6 +1187,9 @@ private int completeImageBuild() {`
`1186`	`1187`	`if (!addModules.isEmpty()) {`
`1187`	`1188`	`imageBuilderJavaArgs.add("-D" + ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_ADDED_MODULES + "=" + String.join(",", addModules));`
`1188`	`1189`	`}`
	`1190`	`+ if (!limitModules.isEmpty()) {`
	`1191`	`+ imageBuilderJavaArgs.add("-D" + ModuleSupport.PROPERTY_IMAGE_EXPLICITLY_LIMITED_MODULES + "=" + String.join(",", limitModules));`
	`1192`	`+ }`
`1189`	`1193`	`if (config.modulePathBuild && !finalImageClasspath.isEmpty()) {`
`1190`	`1194`	`imageBuilderJavaArgs.add(DefaultOptionHandler.addModulesOption + "=ALL-DEFAULT");`
`1191`	`1195`	`}`
`@@ -1617,6 +1621,10 @@ public void addAddedModules(String addModulesArg) {`
`1617`	`1621`	`addModules.addAll(Arrays.asList(SubstrateUtil.split(addModulesArg, ",")));`
`1618`	`1622`	`}`
`1619`	`1623`
	`1624`	`+ public void addLimitedModules(String limitModulesArg) {`
	`1625`	`+ limitModules.addAll(Arrays.asList(SubstrateUtil.split(limitModulesArg, ",")));`
	`1626`	`+ }`
	`1627`	`+`
`1620`	`1628`	`void addImageBuilderClasspath(Path classpath) {`
`1621`	`1629`	`imageBuilderClasspath.add(canonicalize(classpath));`
`1622`	`1630`	`}`