diff --git a/ci/common.jsonnet b/ci/common.jsonnet index 3d396640b185..613c9f05ff2d 100644 --- a/ci/common.jsonnet +++ b/ci/common.jsonnet @@ -56,7 +56,7 @@ local common_json = import "../common.json"; [name]: jdk_base + common_json.jdks[name] + { jdk_version:: 21 } for name in ["oraclejdk21"] + variants("labsjdk-ce-21") + variants("labsjdk-ee-21") } + { - 'oraclejdk23': jdk_base + common_json.jdks["oraclejdk23"] + { jdk_version:: 23 }, + 'oraclejdk24': jdk_base + common_json.jdks["oraclejdk24"] + { jdk_version:: 24 }, } + { [name]: jdk_base + common_json.jdks[name] + { jdk_version:: parse_labsjdk_version(self), jdk_name:: "jdk-latest"} for name in ["oraclejdk-latest"] + variants("labsjdk-ce-latest") + variants("labsjdk-ee-latest") diff --git a/common.json b/common.json index de37be8d04a9..3918e0fce3f3 100644 --- a/common.json +++ b/common.json @@ -43,13 +43,13 @@ "labsjdk-ee-21-llvm": {"name": "labsjdk", "version": "ee-21.0.2+13-jvmci-23.1-b33-sulong", "platformspecific": true }, "graalvm-ee-21": {"name": "graalvm-java21", "version": "23.1.6", "platformspecific": true }, - "oraclejdk23": {"name": "jpg-jdk", "version": "23", "build_id": "jdk-23+37", "platformspecific": true, "extrabundles": ["static-libs"]}, + "oraclejdk24": {"name": "jpg-jdk", "version": "24", "build_id": "jdk-24.0.1+9", "platformspecific": true, "extrabundles": ["static-libs"]}, "oraclejdk-latest": {"name": "jpg-jdk", "version": "25", "build_id": "jdk-25+22", "platformspecific": true, "extrabundles": ["static-libs"]}, - "labsjdk-ce-latest": {"name": "labsjdk", "version": "ce-25+22-jvmci-b01", "platformspecific": true }, + "labsjdk-ce-latest": {"name": "jpg-jdk", "version": "25", "build_id": "2025-05-17-2228274.doug.simon.open", "platformspecific": true, "extrabundles": ["static-libs"]}, "labsjdk-ce-latestDebug": {"name": "labsjdk", "version": "ce-25+22-jvmci-b01-debug", "platformspecific": true }, "labsjdk-ce-latest-llvm": {"name": "labsjdk", "version": "ce-25+22-jvmci-b01-sulong", "platformspecific": true }, - "labsjdk-ee-latest": {"name": "labsjdk", "version": "ee-25+22-jvmci-b01", "platformspecific": true }, + "labsjdk-ee-latest": {"name": "jpg-jdk", "version": "25", "build_id": "2025-05-17-2228274.doug.simon.open", "platformspecific": true, "extrabundles": ["static-libs"]}, "labsjdk-ee-latestDebug": {"name": "labsjdk", "version": "ee-25+22-jvmci-b01-debug", "platformspecific": true }, "labsjdk-ee-latest-llvm": {"name": "labsjdk", "version": "ee-25+22-jvmci-b01-sulong", "platformspecific": true } }, diff --git a/docs/reference-manual/embedding/embed-languages.md b/docs/reference-manual/embedding/embed-languages.md index 7a1c443edfac..e81e6c82a64b 100644 --- a/docs/reference-manual/embedding/embed-languages.md +++ b/docs/reference-manual/embedding/embed-languages.md @@ -411,19 +411,20 @@ Polyglot Truffle runtimes can be used on several host virtual machines with vary Runtime optimization of guest application code is crucial for the efficient execution of embedded guest applications. This table shows the level of optimizations the Java runtimes currently provide: -| Java Runtime | Runtime Optimization Level | -|-----------------------------------------------|---------------------------------------------------| -| 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 | -| JDK without JVMCI capability | No runtime optimizations (interpreter-only) | +| Java Runtime | Runtime Optimization Level | +|-----------------------------------------------|-----------------------------------------------------| +| Oracle GraalVM | Best (includes additional compiler optimizations) | +| GraalVM Community Edition | Optimized | +| 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. Additionally, the Graal compiler must be downloaded as a JAR file and specified to the `java` launcher with `--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. diff --git a/sdk/mx.sdk/mx_sdk.py b/sdk/mx.sdk/mx_sdk.py index 3858093e64c3..30cae70f3222 100644 --- a/sdk/mx.sdk/mx_sdk.py +++ b/sdk/mx.sdk/mx_sdk.py @@ -261,6 +261,16 @@ def jlink_new_jdk(jdk, dst_jdk_dir, module_dists, ignore_dists, default_to_jvmci=default_to_jvmci) class GraalVMJDKConfig(mx.JDKConfig): + + # 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:+UseGraalJIT option. + libgraal_additional_vm_args = [ + '-XX:+UnlockExperimentalVMOptions', + '-XX:+EnableJVMCI', + '-XX:+UseGraalJIT', + '-XX:-UnlockExperimentalVMOptions' + ] """ A JDKConfig that configures the built GraalVM as a JDK config. """ @@ -270,11 +280,8 @@ def __init__(self): graalvm_home = default_jdk.home additional_vm_args = [] elif GraalVMJDKConfig.is_libgraal_jdk(default_jdk.home): - # 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 = GraalVMJDKConfig.libgraal_additional_vm_args else: graalvm_home = mx_sdk_vm.graalvm_home(fatalIfMissing=True) additional_vm_args = [] diff --git a/sdk/mx.sdk/mx_sdk_vm.py b/sdk/mx.sdk/mx_sdk_vm.py index 1c0e288c37eb..a0fbbd5e51f1 100644 --- a/sdk/mx.sdk/mx_sdk_vm.py +++ b/sdk/mx.sdk/mx_sdk_vm.py @@ -578,20 +578,16 @@ def _probe_jvmci_info(jdk, attribute_name): sink = lambda x: x mx.run([jdk.java, '-XX:+UnlockExperimentalVMOptions', '-XX:+PrintFlagsFinal', '-version'], out=out, err=sink) enableJVMCI = False - enableJVMCIProduct = False jvmciThreadsPerNativeLibraryRuntime = None for line in out.lines: if 'EnableJVMCI' in line and 'true' in line: enableJVMCI = True - if 'EnableJVMCIProduct' in line: - enableJVMCIProduct = True if 'JVMCIThreadsPerNativeLibraryRuntime' in line: m = re.search(r'JVMCIThreadsPerNativeLibraryRuntime *= *(\d+)', line) if not m: mx.abort(f'Could not extract value of JVMCIThreadsPerNativeLibraryRuntime from "{line}"') jvmciThreadsPerNativeLibraryRuntime = int(m.group(1)) setattr(jdk, '.enables_jvmci_by_default', enableJVMCI) - setattr(jdk, '.supports_enablejvmciproduct', enableJVMCIProduct) setattr(jdk, '.jvmciThreadsPerNativeLibraryRuntime', jvmciThreadsPerNativeLibraryRuntime) return getattr(jdk, attribute_name) @@ -601,13 +597,6 @@ def jdk_enables_jvmci_by_default(jdk): """ return _probe_jvmci_info(jdk, '.enables_jvmci_by_default') -def jdk_supports_enablejvmciproduct(jdk): - """ - Determines if the jdk supports flag -XX:+EnableJVMCIProduct which isn't the case - for some OpenJDK 11u distros. - """ - return _probe_jvmci_info(jdk, '.supports_enablejvmciproduct') - def get_JVMCIThreadsPerNativeLibraryRuntime(jdk): """ Gets the value of the flag -XX:JVMCIThreadsPerNativeLibraryRuntime. @@ -616,50 +605,6 @@ def get_JVMCIThreadsPerNativeLibraryRuntime(jdk): """ return _probe_jvmci_info(jdk, '.jvmciThreadsPerNativeLibraryRuntime') -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. - """ - if not hasattr(jdk, '.supports_JDK_8232080'): - 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_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') - -def _jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy(jdk): # pylint: disable=invalid-name - """ - Determines if the `jdk` suppresses a warning about ThreadPriorityPolicy when it - is non-zero if the value is set from the jimage. - https://bugs.openjdk.java.net/browse/JDK-8235908. - """ - if not hasattr(jdk, '.omits_ThreadPriorityPolicy_warning'): - out = mx.OutputCapture() - sink = lambda x: x - tmpdir = tempfile.mkdtemp(prefix='jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy') - jlink_exe = jdk.javac.replace('javac', 'jlink') - mx.run([jlink_exe, '--add-options=-XX:ThreadPriorityPolicy=1', '--output=' + join(tmpdir, 'jdk'), '--add-modules=java.base']) - mx.run([mx.exe_suffix(join(tmpdir, 'jdk', 'bin', 'java')), '-version'], out=sink, err=out) - shutil.rmtree(tmpdir) - setattr(jdk, '.omits_ThreadPriorityPolicy_warning', '-XX:ThreadPriorityPolicy=1 may require system level permission' not in out.data) - return getattr(jdk, '.omits_ThreadPriorityPolicy_warning') - def _read_java_base_hashes(jdk): """ Read the hashes stored in the ``java.base`` module of `jdk`. @@ -813,62 +758,56 @@ 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') + + vm_options.append('-XX:ThreadPriorityPolicy=1') + + 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']) + # -XX:+EnableJVMCI must be explicitly specified to the java launcher to add + # jdk.internal.vm.ci to the root set (JDK-8345826) + vm_options.append('-XX:+EnableJVMCI') + 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: - # 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))) - 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') + 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 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): @@ -969,9 +908,8 @@ def jlink_new_jdk(jdk, dst_jdk_dir, module_dists, ignore_dists, if not isdir(jmods_dir): mx.abort('Cannot derive a new JDK from ' + jdk.home + ' since ' + jmods_dir + ' is missing or is not a directory') - # Exclude jdk.aot due to GR-10545 and JDK-8255616 # Exclude graal in case it is included in the base JDK - jdk_modules = {jmd.name: jmd for jmd in jdk.get_modules() if jmd.name != 'jdk.aot' and not jmd.name.startswith('jdk.graal.compiler')} + jdk_modules = {jmd.name: jmd for jmd in jdk.get_modules() if not jmd.name.startswith('jdk.graal.compiler')} modules = [as_java_module(dist, jdk) for dist in module_dists] module_names = frozenset((m.name for m in modules)) all_module_names = frozenset(list(jdk_modules.keys())) | module_names @@ -1043,7 +981,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 +1058,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}"') @@ -1129,11 +1067,10 @@ def get_jmod_path_with_specified_module_info(self, m): if isfile(release_file): jlink.append(f'--release-info={release_file}') - if jlink_has_save_jlink_argfiles(jdk): - jlink_persist_argfile = join(build_dir, 'jlink.persist.options') - with open(jlink_persist_argfile, 'w') as fp: - fp.write('\n'.join(jlink_persist)) - jlink.append(f'--save-jlink-argfiles={jlink_persist_argfile}') + jlink_persist_argfile = join(build_dir, 'jlink.persist.options') + with open(jlink_persist_argfile, 'w') as fp: + fp.write('\n'.join(jlink_persist)) + jlink.append(f'--save-jlink-argfiles={jlink_persist_argfile}') if exists(dst_jdk_dir): if use_upgrade_module_path and _vm_options_match(vm_options, vm_options_path): diff --git a/substratevm/mx.substratevm/mx_substratevm.py b/substratevm/mx.substratevm/mx_substratevm.py index 92339d10aee4..805f766e36f8 100644 --- a/substratevm/mx.substratevm/mx_substratevm.py +++ b/substratevm/mx.substratevm/mx_substratevm.py @@ -1481,7 +1481,6 @@ def _native_image_launcher_extra_jvm_args(): # are also added to the value of the `-imagecp` Native Image option when # building libgraal. libgraal_jar_distributions = [ - 'sdk:NATIVEBRIDGE', 'sdk:JNIUTILS', 'compiler:LIBGRAAL', 'compiler:LIBGRAAL_LOADER'] diff --git a/truffle/ci/ci.jsonnet b/truffle/ci/ci.jsonnet index de6c3c0aceac..ac7ca13a25de 100644 --- a/truffle/ci/ci.jsonnet +++ b/truffle/ci/ci.jsonnet @@ -163,7 +163,8 @@ linux_amd64 + graalVMCELatest + simple_tool_maven_project_gate, # Truffle JVM gate linux_amd64 + common.graalvmee21 + truffle_jvm_gate, - linux_amd64 + common.oraclejdk23 + truffle_jvm_gate, + # GR-65191 + # linux_amd64 + common.oraclejdk24 + truffle_jvm_gate, linux_amd64 + graalVMCELatest + truffle_jvm_gate, # Truffle Native gate linux_amd64 + common.graalvmee21 + truffle_native_gate, diff --git a/truffle/mx.truffle/mx_truffle.py b/truffle/mx.truffle/mx_truffle.py index 58d9481aee2a..0c6db8db0ba1 100644 --- a/truffle/mx.truffle/mx_truffle.py +++ b/truffle/mx.truffle/mx_truffle.py @@ -499,7 +499,7 @@ def _truffle_gate_runner(args, tasks): def gate_truffle_jvm(tasks): if mx_sdk.GraalVMJDKConfig.is_libgraal_jdk(mx.get_jdk(tag='default').home): - additional_jvm_args = ['-XX:+UnlockExperimentalVMOptions', '-XX:+EnableJVMCI', '-XX:+UseJVMCINativeLibrary', '-XX:-UnlockExperimentalVMOptions'] + additional_jvm_args = mx_sdk.GraalVMJDKConfig.libgraal_additional_vm_args else: additional_jvm_args = [] # GR-62632: Debug VM exception translation failure