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

Author: dougxc

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

@@ -415,15 +415,17 @@ This table shows the level of optimizations the Java runtimes currently provide:
 |-----------------------------------------------|---------------------------------------------------|
 | Oracle GraalVM                                | Optimized with additional compiler passes         |
 | GraalVM Community Edition                     | Optimized                                         |
-| Oracle JDK                                    | Optimized if enabled via experimental VM option   |
-| OpenJDK                                       | Optimized if enabled via experimental VM option   |
+| Oracle JDK                                    | Optimized via VM option                           |
+| OpenJDK                                       | Optimized via VM option and upgrade-module-path   |
 | JDK without JVMCI capability                  | No runtime optimizations (interpreter-only)       |
 
 ### Explanations
 
 * **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 via VM option:** Optimization is enabled by specifying `-XX:+EnableJVMCI` to the `java` launcher.
+* **Optimized via VM option and upgrade-module-path:** Optimization is enabled by specifying `-XX:+EnableJVMCI` to the `java` launcher.
+  In addition, 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,62 @@ 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'
-                        ])
-            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'])
+    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':
+                # As of JDK-8345826, the JVMCI module must be explicitly
+                # added to the root set if libgraal is in use
+                vm_options.append('--add-modules=jdk.internal.vm.ci')
+                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'
+                    ])
         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', '-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 +1035,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 +1112,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}"')

sdk/src/org.graalvm.launcher.native/src/launcher.cc

@@ -824,6 +824,9 @@ static int jvm_main_thread(struct MainThreadArgs& parsedArgs) {
             // GR-59703: Migrate sun.misc.* usages.
             vmArgs.push_back("--sun-misc-unsafe-memory-access=allow");
         }
+
+        // Required as of JDK-8345826, harmless on earlier versions.
+        vmArgs.push_back("-XX:+EnableJVMCI");
     }
 
     // Convert vmArgs to JavaVMInitArgs

truffle/mx.truffle/mx_truffle.py

@@ -494,8 +494,13 @@ def _truffle_gate_runner(args, tasks):
 
 
 def gate_truffle_jvm(tasks):
-    if mx_sdk.GraalVMJDKConfig.is_libgraal_jdk(mx.get_jdk(tag='default').home):
+    default_jdk = mx.get_jdk(tag='default')
+    if mx_sdk.GraalVMJDKConfig.is_libgraal_jdk(default_jdk.home):
         additional_jvm_args = ['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCI', '-XX:+UseJVMCINativeLibrary', '-XX:-UnlockExperimentalVMOptions']
+    elif default_jdk.javaCompliance >= '25':
+        # As of JDK-8345826, -XX:+EnableJVMCI must be on the command line
+        # to load the JVMCI module if libgraal is in use
+        additional_jvm_args = ['-XX:+EnableJVMCI']
     else:
         additional_jvm_args = []
     # GR-62632: Debug VM exception translation failure

vm/mx.vm/mx_vm_gate.py

@@ -406,6 +406,7 @@ def _test_libgraal_CompilationTimeout_Truffle(extra_vm_arguments):
                   f'-Dpolyglot.log.file={truffle_log_file}',
                    '-Ddebug.graal.CompilationWatchDog=true', # helps debug failure
                    '-Dgraalvm.locatorDisabled=true',
+                   '-XX:+EnableJVMCI',            # JDK-8345826: Required to load the JVMCI module if libgraal is in use
                    '-XX:-UseJVMCICompiler',       # Stop compilation timeout being applied to JIT
                    '-XX:+UseJVMCINativeLibrary']  # but ensure libgraal is still used by Truffle