replace +EnableJVMCI with --add-modules=jdk.internal.vm.ci

Author: dougxc

compiler/CHANGELOG.md

@@ -3,6 +3,8 @@
 This changelog summarizes newly introduced optimizations and other compiler related changes.
 
 ## GraalVM for JDK 25 (Internal Version 25.0.0)
+* [(JDK-8345826)](https://bugs.openjdk.org/browse/JDK-8345826): To run jargraal now requires specifying `--add-modules=jdk.internal.vm.ci`
+  to the `java` launcher as `-XX:+EnableJVMCI` no longer automatically adds this module to the root module set.
 * (GR-60088): This PR adds the `org.graalvm.nativeimage.libgraal` SDK module. With this module, all logic for building
   libgraal has been moved into the compiler suite in a new `jdk.graal.compiler.libgraal` module
   which has no dependency on Native Image internals. This

compiler/mx.compiler/mx_compiler.py

@@ -264,7 +264,7 @@ def _ctw_jvmci_export_args(arg_prefix='--'):
 def _ctw_system_properties_suffix():
     out = mx.OutputCapture()
     out.data = 'System properties for CTW:\n\n'
-    args = ['-XX:+EnableJVMCI'] + _ctw_jvmci_export_args()
+    args = ['--add-modules=jdk.internal.vm.ci'] + _ctw_jvmci_export_args()
     cp = _remove_redundant_entries(mx.classpath('GRAAL_TEST', jdk=jdk))
     args.extend(['-cp', cp, '-DCompileTheWorld.Help=true', 'jdk.graal.compiler.hotspot.test.CompileTheWorld'])
     run_java(args, out=out, addDefaultArgs=False)
@@ -280,7 +280,7 @@ def ctw(args, extraVMarguments=None):
     args, vmargs = parser.parse_known_args(args)
     vmargs.extend(_remove_empty_entries(extraVMarguments))
 
-    vmargs.append('-XX:+EnableJVMCI')
+    vmargs.append('--add-modules=jdk.internal.vm.ci')
 
     # Disable JVMCICompiler by default if not specified
     if _get_XX_option_value(vmargs, 'UseJVMCICompiler', None) is None:
@@ -1154,7 +1154,7 @@ def collate_metrics(args):
 def run_java(args, out=None, err=None, addDefaultArgs=True, command_mapper_hooks=None, jdk=None, **kw_args):
     graaljdk = jdk or get_graaljdk()
     vm_args = _parseVmArgs(args, addDefaultArgs=addDefaultArgs)
-    args = ['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCI', '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler'] + vm_args
+    args = ['-XX:+UnlockExperimentalVMOptions', '--add-modules=jdk.internal.vm.ci', '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler'] + vm_args
     _check_bootstrap_config(args)
     cmd = get_vm_prefix() + [graaljdk.java] + ['-server'] + args
     map_file = join(graaljdk.home, 'proguard.map')

compiler/mx.compiler/mx_graal_benchmark.py

@@ -59,21 +59,21 @@
     ('avx2', ['-XX:UseAVX=2'], 11),
     ('avx3', ['-XX:UseAVX=3'], 11),
 ]
-mx_sdk_benchmark.build_jvmci_vm_variants('server', 'graal-core', ['-server', '-XX:+EnableJVMCI', '-Djdk.graal.CompilerConfiguration=community', '-Djvmci.Compiler=graal'], _graal_variants, suite=_suite, priority=15)
+mx_sdk_benchmark.build_jvmci_vm_variants('server', 'graal-core', ['-server', '--add-modules=jdk.internal.vm.ci', '-Djdk.graal.CompilerConfiguration=community', '-Djvmci.Compiler=graal'], _graal_variants, suite=_suite, priority=15)
 
 # On 64 bit systems -client is not supported. Nevertheless, when running with -server, we can
 # force the VM to just compile code with C1 but not with C2 by adding option -XX:TieredStopAtLevel=1.
 # This behavior is the closest we can get to the -client vm configuration.
 mx_benchmark.add_java_vm(JvmciJdkVm('client', 'default', ['-server', '-XX:-EnableJVMCI', '-XX:TieredStopAtLevel=1']), suite=_suite, priority=1)
-mx_benchmark.add_java_vm(JvmciJdkVm('client', 'hosted', ['-server', '-XX:+EnableJVMCI', '-XX:TieredStopAtLevel=1']), suite=_suite, priority=1)
+mx_benchmark.add_java_vm(JvmciJdkVm('client', 'hosted', ['-server', '--add-modules=jdk.internal.vm.ci', '-XX:TieredStopAtLevel=1']), suite=_suite, priority=1)
 
 
 mx_benchmark.add_java_vm(JvmciJdkVm('server', 'default', ['-server', '-XX:-EnableJVMCI']), _suite, 2)
 mx_benchmark.add_java_vm(JvmciJdkVm('server', 'default-serialgc', ['-server', '-XX:-EnableJVMCI', '-XX:+UseSerialGC']), _suite, 2)
 mx_benchmark.add_java_vm(JvmciJdkVm('server', 'default-pargc', ['-server', '-XX:-EnableJVMCI', '-XX:+UseParallelGC']), _suite, 2)
 mx_benchmark.add_java_vm(JvmciJdkVm('server', 'default-zgc', ['-server', '-XX:-EnableJVMCI', '-XX:+UseZGC']), _suite, 2)
 mx_benchmark.add_java_vm(JvmciJdkVm('server', 'default-no-tiered-comp', ['-server', '-XX:-EnableJVMCI', '-XX:-TieredCompilation']), _suite, 2)
-mx_benchmark.add_java_vm(JvmciJdkVm('server', 'hosted', ['-server', '-XX:+EnableJVMCI']), _suite, 3)
+mx_benchmark.add_java_vm(JvmciJdkVm('server', 'hosted', ['-server', '--add-modules=jdk.internal.vm.ci']), _suite, 3)
 
 
 class CompilerMetricsBenchmarkMixin:

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/GetCompilerConfig.java

@@ -115,13 +115,12 @@ public static Result from(Path javaHome) {
         List<String> command = new ArrayList<>(List.of(
                         javaExe.toFile().getAbsolutePath(),
                         "-XX:+UnlockExperimentalVMOptions",
-                        "-XX:+EnableJVMCI",
+                        "--add-modules=jdk.internal.vm.ci",
                         "-XX:-UseJVMCICompiler", // avoid deadlock with jargraal
 
                         // Required to use Modules class
                         "--add-exports=java.base/jdk.internal.module=jdk.graal.compiler",
                         addExports,
-                        "-Djdk.vm.ci.services.aot=true", // Remove after JDK-8346781
                         "-D%s=%s".formatted(ImageInfo.PROPERTY_IMAGE_CODE_KEY, ImageInfo.PROPERTY_IMAGE_CODE_VALUE_BUILDTIME)));
 
         for (var e : opens.entrySet()) {

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/GetJNIConfig.java

@@ -83,7 +83,7 @@ private GetJNIConfig(ClassLoader loader, Path libgraalJavaHome) {
         Path javaExe = getJavaExe(libgraalJavaHome);
         configFilePath = Path.of("libgraal_jniconfig.txt");
 
-        String[] command = {javaExe.toFile().getAbsolutePath(), "-XX:+UnlockExperimentalVMOptions", "-XX:+EnableJVMCI", "-XX:JVMCILibDumpJNIConfig=" + configFilePath};
+        String[] command = {javaExe.toFile().getAbsolutePath(), "-XX:+UnlockExperimentalVMOptions", "--add-modules=jdk.internal.vm.ci", "-XX:JVMCILibDumpJNIConfig=" + configFilePath};
         quotedCommand = Stream.of(command).map(e -> e.indexOf(' ') == -1 ? e : '\'' + e + '\'').collect(Collectors.joining(" "));
         ProcessBuilder pb = new ProcessBuilder(command);
         pb.redirectErrorStream(true);

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/InvokerSignatureMismatchTest.java

@@ -51,7 +51,7 @@ public void test() throws Throwable {
             args.add("--patch-module=java.base=" + temp);
             args.add("-XX:-TieredCompilation");
             args.add("-XX:+UnlockExperimentalVMOptions");
-            args.add("-XX:+EnableJVMCI");
+            args.add("--add-modules=jdk.internal.vm.ci");
             args.add("-XX:+UseJVMCICompiler");
 
             Path invokeDir = Files.createDirectories(temp.path.resolve(Paths.get("java", "lang", "invoke")));

docs/reference-manual/embedding/embed-languages.md

@@ -423,7 +423,7 @@ This table shows the level of optimizations the Java runtimes currently provide:
 
 * **Optimized:** Executed guest application code can be compiled and executed as highly efficient machine code at run time.
 * **Optimized with additional compiler passes:** Oracle GraalVM implements additional optimizations performed during runtime compilation. For example, it uses a more advanced inlining heuristic. This typically leads to better runtime performance and memory consumption.
-* **Optimized if enabled via experimental VM option:** Optimization is not enabled by default and must be enabled using `-XX:+EnableJVMCI` virtual machine option. In addition, to support compilation, the Graal compiler must be downloaded as a JAR file and put on the `--upgrade-module-path`. In this mode, the compiler runs as a Java application and may negatively affect the execution performance of the host application.
+* **Optimized if enabled via experimental VM option:** Optimization is not enabled by default and must be enabled using the `--add-modules=jdk.internal.vm.ci` virtual machine option. In addition, to support compilation on OpenJDK, the Graal compiler must be downloaded as a JAR file and put on the `--upgrade-module-path`. In this mode, the compiler runs as a Java application and may negatively affect the execution performance of the host application.
 * **No runtime optimizations:** With no runtime optimizations or if JVMCI is not enabled, the guest application code is executed in interpreter-only mode. 
 * **JVMCI:** Refers to the [Java-Level JVM Compiler Interface](https://openjdk.org/jeps/243) supported by most Java runtimes.
 

sdk/mx.sdk/mx_sdk.py

@@ -273,8 +273,7 @@ def __init__(self):
             # Oracle JDK includes the libjvmci compiler, allowing it to function as GraalVM.
             # However, the Graal compiler is disabled by default and must be explicitly enabled using the -XX:+UseJVMCICompiler option.
             graalvm_home = default_jdk.home
-            # GR-58388: Switch '-XX:+UseJVMCINativeLibrary' to '-XX:+UseGraalJIT'
-            additional_vm_args = ['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCI', '-XX:+UseJVMCINativeLibrary', '-XX:-UnlockExperimentalVMOptions']
+            additional_vm_args = ['-XX:+UnlockExperimentalVMOptions', '-XX:+UseGraalJIT', '-XX:-UnlockExperimentalVMOptions']
         else:
             graalvm_home = mx_sdk_vm.graalvm_home(fatalIfMissing=True)
             additional_vm_args = []

sdk/mx.sdk/mx_sdk_vm.py

@@ -619,29 +619,21 @@ def get_JVMCIThreadsPerNativeLibraryRuntime(jdk):
 def _probe_jlink_info(jdk, attribute_name):
     """
     Determines if the jlink executable in `jdk` supports various options such
-    as those added by JDK-8232080 and JDK-8237467.
+    as those added by JDK-8237467.
     """
-    if not hasattr(jdk, '.supports_JDK_8232080'):
+    if not hasattr(jdk, '.supports_JDK_8237467'):
         output = mx.OutputCapture()
         jlink_exe = jdk.javac.replace('javac', 'jlink')
         mx.run([jlink_exe, '--list-plugins'], out=output)
-        setattr(jdk, '.supports_JDK_8232080', '--add-options=' in output.data or '--add-options ' in output.data)
-        setattr(jdk, '.supports_save_jlink_argfiles', '--save-jlink-argfiles=' in output.data or '--save-jlink-argfiles ' in output.data)
+        setattr(jdk, '.supports_JDK_8237467', '--save-jlink-argfiles=' in output.data or '--save-jlink-argfiles ' in output.data)
         setattr(jdk, '.supports_copy_files', '--copy-files=' in output.data or '--copy-files ' in output.data)
     return getattr(jdk, attribute_name)
 
-def jlink_supports_8232080(jdk):
-    """
-    Determines if the jlink executable in `jdk` supports ``--add-options`` and
-    ``--vendor-[bug-url|vm-bug-url|version]`` added by JDK-8232080.
-    """
-    return _probe_jlink_info(jdk, '.supports_JDK_8232080')
-
 def jlink_has_save_jlink_argfiles(jdk):
     """
     Determines if the jlink executable in `jdk` supports ``--save-jlink-argfiles``.
     """
-    return _probe_jlink_info(jdk, '.supports_save_jlink_argfiles')
+    return _probe_jlink_info(jdk, '.supports_JDK_8237467')
 
 def _jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy(jdk): # pylint: disable=invalid-name
     """
@@ -813,62 +805,63 @@ def _get_image_vm_options(jdk, use_upgrade_module_path, modules, synthetic_modul
     :return list: the list of VM options to cook into the image
     """
     vm_options = []
-    if jlink_supports_8232080(jdk):
-        if mx.get_env('CONTINUOUS_INTEGRATION', None) == 'true':
-            is_gate = mx.get_env('BUILD_TARGET', None) == 'gate'
-            is_bench = 'bench-' in mx.get_env('BUILD_NAME', '')
-            if is_gate or is_bench:
-                # For gate and benchmark jobs, we want to know about each compilation failure
-                # but only exit the VM on systemic compilation failure for gate jobs.
-                vm_options.append('-Djdk.graal.CompilationFailureAction=Diagnose')
-                mx.log('Adding -Djdk.graal.CompilationFailureAction=Diagnose VM option to image')
-                if is_gate:
-                    mx.log('Adding -Djdk.graal.SystemicCompilationFailureRate=-1 VM option to image')
-                    vm_options.append('-Djdk.graal.SystemicCompilationFailureRate=-1')
-
-        if use_upgrade_module_path or _jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy(jdk):
-            vm_options.append('-XX:ThreadPriorityPolicy=1')
-        else:
-            mx.logv('[Creating JDK without -XX:ThreadPriorityPolicy=1]')
-
-        if jdk_supports_enablejvmciproduct(jdk):
-            non_synthetic_modules = [m.name for m in modules if m not in synthetic_modules]
-            if default_to_jvmci or 'jdk.graal.compiler' in non_synthetic_modules:
-                threads = get_JVMCIThreadsPerNativeLibraryRuntime(jdk)
-                vm_options.extend(['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCIProduct'])
-                if threads is not None and threads != 1:
-                    vm_options.append('-XX:JVMCIThreadsPerNativeLibraryRuntime=1')
-                if default_to_jvmci == 'lib':
-                    vm_options.append('-XX:+UseJVMCINativeLibrary')
-                vm_options.extend(['-XX:-UnlockExperimentalVMOptions'])
-                import mx_sdk_vm_impl
-                if 'jdk.graal.compiler' in non_synthetic_modules and mx_sdk_vm_impl._get_libgraal_component() is None:
-                    # If libgraal is absent, jargraal is used by default.
-                    # Use of jargraal requires exporting jdk.internal.misc to
-                    # Graal as it uses jdk.internal.misc.Unsafe. To avoid warnings
-                    # about unknown modules (e.g. in `-Xint` mode), the export target
-                    # modules must be explicitly added to the root set with `--add-modules`.
-                    if 'com.oracle.graal.graal_enterprise' in non_synthetic_modules:
-                        vm_options.extend([
-                            '--add-modules=jdk.graal.compiler,com.oracle.graal.graal_enterprise',
-                            '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler,com.oracle.graal.graal_enterprise'
-                        ])
-                    else:
-                        vm_options.extend([
-                            '--add-modules=jdk.graal.compiler',
-                            '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler'
-                        ])
+    if mx.get_env('CONTINUOUS_INTEGRATION', None) == 'true':
+        is_gate = mx.get_env('BUILD_TARGET', None) == 'gate'
+        is_bench = 'bench-' in mx.get_env('BUILD_NAME', '')
+        if is_gate or is_bench:
+            # For gate and benchmark jobs, we want to know about each compilation failure
+            # but only exit the VM on systemic compilation failure for gate jobs.
+            vm_options.append('-Djdk.graal.CompilationFailureAction=Diagnose')
+            mx.log('Adding -Djdk.graal.CompilationFailureAction=Diagnose VM option to image')
+            if is_gate:
+                mx.log('Adding -Djdk.graal.SystemicCompilationFailureRate=-1 VM option to image')
+                vm_options.append('-Djdk.graal.SystemicCompilationFailureRate=-1')
+
+    if use_upgrade_module_path or _jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy(jdk):
+        vm_options.append('-XX:ThreadPriorityPolicy=1')
+    else:
+        mx.logv('[Creating JDK without -XX:ThreadPriorityPolicy=1]')
+
+    if jdk_supports_enablejvmciproduct(jdk):
+        non_synthetic_modules = [m.name for m in modules if m not in synthetic_modules]
+        if default_to_jvmci or 'jdk.graal.compiler' in non_synthetic_modules:
+            threads = get_JVMCIThreadsPerNativeLibraryRuntime(jdk)
+            vm_options.extend(['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCIProduct'])
+            if threads is not None and threads != 1:
+                vm_options.append('-XX:JVMCIThreadsPerNativeLibraryRuntime=1')
+            if default_to_jvmci == 'lib':
+                vm_options.append('-XX:+UseJVMCINativeLibrary')
             else:
-                # Don't default to using JVMCI as JIT unless Graal is being updated in the image.
-                # This avoids unexpected issues with using the out-of-date Graal compiler in
-                # the JDK itself.
-                vm_options.extend(['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCIProduct', '-XX:-UseJVMCICompiler', '-XX:-UnlockExperimentalVMOptions'])
+                # As of JDK-8345826, jdk.internal.vm.ci must also be explicitly added.
+                vm_options.append('--add-modules=jdk.internal.vm.ci')
+            vm_options.extend(['-XX:-UnlockExperimentalVMOptions'])
+            import mx_sdk_vm_impl
+            if 'jdk.graal.compiler' in non_synthetic_modules and mx_sdk_vm_impl._get_libgraal_component() is None:
+                # If libgraal is absent, jargraal is used by default.
+                # Use of jargraal requires exporting jdk.internal.misc to
+                # Graal as it uses jdk.internal.misc.Unsafe. To avoid warnings
+                # about unknown modules (e.g. in `-Xint` mode), the export target
+                # modules must be explicitly added to the root set with `--add-modules`.
+                if 'com.oracle.graal.graal_enterprise' in non_synthetic_modules:
+                    vm_options.extend([
+                        '--add-modules=jdk.graal.compiler,com.oracle.graal.graal_enterprise',
+                        '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler,com.oracle.graal.graal_enterprise'
+                    ])
+                else:
+                    vm_options.extend([
+                        '--add-modules=jdk.graal.compiler',
+                        '--add-exports=java.base/jdk.internal.misc=jdk.graal.compiler'
+                    ])
+
         else:
-            mx.logv('[Creating JDK without -XX:+EnableJVMCIProduct]')
-        if modules and use_upgrade_module_path:
-            vm_options.append('--upgrade-module-path=' + os.pathsep.join((synthetic_modules.get(m, m.jarpath) for m in modules)))
-    elif use_upgrade_module_path:
-        mx.abort('Cannot create an image with an --upgrade-module-path setting since jlink does not support the --add-options flag')
+            # Don't default to using JVMCI as JIT unless Graal is being updated in the image.
+            # This avoids unexpected issues with using the out-of-date Graal compiler in
+            # the JDK itself.
+            vm_options.extend(['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCIProduct', '--add-modules=jdk.internal.vm.ci', '-XX:-UseJVMCICompiler', '-XX:-UnlockExperimentalVMOptions'])
+    else:
+        mx.logv('[Creating JDK without -XX:+EnableJVMCIProduct]')
+    if modules and use_upgrade_module_path:
+        vm_options.append('--upgrade-module-path=' + os.pathsep.join((synthetic_modules.get(m, m.jarpath) for m in modules)))
     return vm_options
 
 def _copy_src_zip(from_jdk, to_jdk, extra_modules, extra_modules_predicate):
@@ -1043,7 +1036,7 @@ def jlink_new_jdk(jdk, dst_jdk_dir, module_dists, ignore_dists,
         jlink_persist = []
 
         if jdk_enables_jvmci_by_default(jdk):
-            # On JDK 9+, +EnableJVMCI forces jdk.internal.vm.ci to be in the root set
+            # +EnableJVMCI forces jdk.internal.vm.ci to be in the root set
             jlink += ['-J-XX:-EnableJVMCI', '-J-XX:-UseJVMCICompiler']
 
         jlink.append('--add-modules=' + ','.join(_get_image_root_modules(root_module_names, module_names, jdk_modules.keys(), use_upgrade_module_path)))
@@ -1120,7 +1113,7 @@ def get_jmod_path_with_specified_module_info(self, m):
                 jlink.append(f'--add-options={" ".join(vm_options)}')
                 jlink_persist.append(f'--add-options="{" ".join(vm_options)}"')
 
-            if jlink_supports_8232080(jdk) and vendor_info is not None:
+            if vendor_info is not None:
                 for name, value in vendor_info.items():
                     jlink.append(f'--{name}={value}')
                     jlink_persist.append(f'--{name}="{value}"')

substratevm/docs/module-system/ModuleSystemSupportHosted.md

@@ -129,7 +129,7 @@ USE_NATIVE_IMAGE_JAVA_PLATFORM_MODULE_SYSTEM=true \
 /home/graaluser/OLabs/main/graal/sdk/mxbuild/linux-amd64/GRAALVM_427B7851E4_JAVA21/graalvm-427b7851e4-java21-24.0.0-dev/bin/java \
 -XX:+UseParallelGC \
 -XX:+UnlockExperimentalVMOptions \
--XX:+EnableJVMCI \
+--add-modules=jdk.internal.vm.ci \
 -Dtruffle.TrustAllTruffleRuntimeProviders=true \
 -Dtruffle.TruffleRuntime=com.oracle.truffle.api.impl.DefaultTruffleRuntime \
 -Dgraalvm.ForcePolyglotInvalid=true \