Fix GraalVM version parsing for JDK 26-based builds

jerboaa · jerboaa · commit 3a4a310b27a1 · 2025-06-17T15:57:37.000+02:00
JDK 26+ based GraalVM builds won't have a version mapping any more. They use the JDK version scheme instead. Closes: #48403
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/GraalVM.java b/core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/GraalVM.java
@@ -28,7 +28,6 @@ static final class VersionParseHelper {
         private static final String OPT = "(?:-(?<OPT>[-a-zA-Z0-9.]+))?";
         private static final String VSTR_FORMAT = VNUM + PRE + BUILD + OPT;
 
-        private static final String VNUM_GROUP = "VNUM";
         private static final String VENDOR_VERSION_GROUP = "VENDOR";
         private static final String BUILD_INFO_GROUP = "BUILDINFO";
 
@@ -67,7 +66,7 @@ static Version parse(List<String> lines) {
 
                 String vendorVersion = secondMatcher.group(VENDOR_VERSION_GROUP);
 
-                String graalVersion = graalVersion(javaVersion, v.feature());
+                String graalVersion = graalVersion(javaVersion, v);
                 if (vendorVersion.contains("-dev")) {
                     graalVersion = graalVersion + "-dev";
                 }
@@ -137,7 +136,7 @@ private static String matchVersion(String version) {
             return null;
         }
 
-        private static String graalVersion(String buildInfo, int jdkFeature) {
+        private static String graalVersion(String buildInfo, Runtime.Version v) {
             if (buildInfo == null) {
                 return null;
             }
@@ -152,7 +151,10 @@ private static String graalVersion(String buildInfo, int jdkFeature) {
             if (versMatcher.find()) {
                 return matchVersion(version);
             } else {
-                return Version.GRAAL_MAPPING.get(Integer.toString(jdkFeature));
+                // Only versions from JDK 22 to JDK 25 had GraalVM version mappings.
+                // Use the JDK version triplet for JDK N where N > 25.
+                String fullJDKVersion = String.format("%d.%d.%d", v.feature(), v.interim(), v.update());
+                return Version.GRAAL_MAPPING.getOrDefault(Integer.toString(v.feature()), fullJDKVersion);
             }
         }
 
diff --git a/core/deployment/src/test/java/io/quarkus/deployment/pkg/steps/GraalVMTest.java b/core/deployment/src/test/java/io/quarkus/deployment/pkg/steps/GraalVMTest.java
@@ -7,6 +7,7 @@
 
 import java.util.stream.Stream;
 
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -18,8 +19,21 @@
 
 public class GraalVMTest {
 
+    public static final String GRAALVM_VENDOR_VERSION_PROP = "org.graalvm.vendorversion";
+
+    @AfterAll
+    public static void tearDownAfterAll() {
+        System.clearProperty(GRAALVM_VENDOR_VERSION_PROP);
+    }
+
     @Test
     public void testGraalVMVersionDetected() {
+        // Version detection after JDK 25 which no longer uses a GraalVM version mapping,
+        // but uses the JDK version instead
+        assertVersion(new Version("GraalVM 26.0.0", "26.0.0", GRAALVM), GRAALVM,
+                Version.of(Stream.of(("native-image 26 2026-03-17\n"
+                        + "GraalVM Runtime Environment GraalVM CE 26-dev+1.1 (build 26+1-jvmci-b01)\n"
+                        + "Substrate VM GraalVM CE 26-dev+1.1 (build 26+1, serial gc)").split("\\n"))));
         // Version detection after: https://github.com/oracle/graal/pull/6302 (3 lines of version output)
         assertVersion(new Version("GraalVM 23.0.0", "23.0.0", GRAALVM), MANDREL,
                 Version.of(Stream.of(("native-image 17.0.6 2023-01-17\n"
@@ -168,6 +182,19 @@ public void testGraalVM23_1CommunityVersionParser() {
         assertThat(version.javaVersion.update()).isEqualTo(5);
     }
 
+    @Test
+    public void testGraalVM26CommunityVersionParser() {
+        final Version version = Version.of(Stream.of(("native-image 26 2026-03-17\n"
+                + "GraalVM Runtime Environment GraalVM CE 26-dev+1.1 (build 26+1-jvmci-b01)\n"
+                + "Substrate VM GraalVM CE 26-dev+1.1 (build 26+1, serial gc)").split("\\n")));
+        assertThat(version.toString().contains(GRAALVM.name()));
+        assertThat(version.getVersionAsString()).isEqualTo("26.0.0-dev");
+        assertThat(version.javaVersion.toString()).isEqualTo("26+1-jvmci-b01");
+        assertThat(version.javaVersion.feature()).isEqualTo(26);
+        assertThat(version.javaVersion.interim()).isEqualTo(0);
+        assertThat(version.javaVersion.update()).isEqualTo(0);
+    }
+
     @Test
     public void testGraalVMVersionsOlderThan() {
         assertOlderThan("native-image 21 2023-09-19\n" +
@@ -184,6 +211,40 @@ public void testGraalVMVersionsOlderThan() {
                         "Substrate VM GraalVM CE 21+35.1 (build 21+35, serial gc)\n");
     }
 
+    /*
+     * Exercise the code path used at native-image build time where the org.graalvm.vendorversion
+     * property is being fed to the GraalVM version parsing machinery.
+     */
+    @ParameterizedTest
+    // @formatter:off
+    @ValueSource(strings = {
+    // GraalVM CE/Community
+    "GraalVM CE 26-dev+1.1 |26.0|26|0",
+    "GraalVM CE 25-dev+26.1|25.0|25|0",
+    "GraalVM CE 24.0.1+9.1 |24.2|24|1",
+    // Mandrel
+    "Mandrel-24.2.1.0-Final|24.2|24|1",
+    "Mandrel-23.1.7.0-1b2  |23.1|21|7",
+    // Liberica-NIK
+    "Liberica-NIK-23.1.7-1 |23.1|21|7",
+    "Liberica-NIK-24.2.1-1 |24.2|24|1",
+    })
+    // @formatter:on
+    public void testGraalVMRuntimeVersion(String param) {
+        String tokens[] = param.split("\\|", 4);
+        Assertions.assertTrue(tokens.length == 4);
+        String propertyVal = tokens[0].trim();
+        String expectedMajorMinor = tokens[1].trim();
+        int expectedJDKFeature = Integer.parseInt(tokens[2].trim());
+        int expectedJDKUpdate = Integer.parseInt(tokens[3].trim());
+
+        System.setProperty(GRAALVM_VENDOR_VERSION_PROP, propertyVal);
+        io.quarkus.runtime.graal.GraalVM.Version v = io.quarkus.runtime.graal.GraalVM.Version.getCurrent();
+        Assertions.assertEquals(expectedMajorMinor, v.getMajorMinorAsString());
+        Assertions.assertEquals(expectedJDKFeature, v.javaVersion.feature());
+        Assertions.assertEquals(expectedJDKUpdate, v.javaVersion.update());
+    }
+
     /**
      * Asserts that one version is older than the other.
      */
diff --git a/core/runtime/src/main/java/io/quarkus/runtime/graal/GraalVM.java b/core/runtime/src/main/java/io/quarkus/runtime/graal/GraalVM.java
@@ -1,7 +1,10 @@
 package io.quarkus.runtime.graal;
 
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -40,16 +43,23 @@ static final class VersionParseHelper {
 
         private static final String VERSION_GROUP = "VNUM";
 
-        private static final Version UNKNOWN_VERSION = null;
-
         static Version parse(String value) {
             Matcher versionMatcher = VENDOR_VERS_PATTERN.matcher(value);
             if (versionMatcher.find()) {
                 String vendor = versionMatcher.group(VENDOR_PREFIX_GROUP);
                 if (GRAALVM_CE_VERS_PREFIX.equals(vendor) || ORACLE_GRAALVM_VERS_PREFIX.equals(vendor)) {
                     String version = versionMatcher.group(VERSION_GROUP);
-                    String jdkFeature = version.split("\\.", 2)[0];
-                    return new Version(value, Version.GRAAL_MAPPING.get(jdkFeature), Distribution.GRAALVM);
+                    String tokens[] = version.split("\\.", 3);
+                    String jdkFeature = tokens[0];
+                    String jdkVers = jdkFeature;
+                    if (tokens.length == 3) {
+                        String interim = tokens[1];
+                        String update = tokens[2].split("\\+")[0];
+                        jdkVers = String.format("%s.%s.%s", jdkFeature, interim, update);
+                    }
+                    // For JDK 26+ there is no more version mapping use the JDK version
+                    String versionMapping = Version.GRAAL_MAPPING.getOrDefault(jdkFeature, version);
+                    return new Version(value, versionMapping, jdkVers, Distribution.GRAALVM);
                 } else if (LIBERICA_NIK_VERS_PREFIX.equals(vendor)) {
                     return new Version(value, versionMatcher.group(VERSION_GROUP), Distribution.LIBERICA);
                 } else if (MANDREL_VERS_PREFIX.equals(vendor)) {
@@ -78,8 +88,18 @@ public static class Version implements Comparable<Version> {
                 "21", "23.1",
                 "22", "24.0",
                 "23", "24.1",
-                "24", "24.2",
-                "25", "25.0");
+                "24", "24.2");
+        // Mapping of community major.minor pair to the JDK major version based on
+        // GRAAL_MAPPING
+        private static final Map<String, String> MANDREL_JDK_REV_MAP;
+
+        static {
+            Map<String, String> reverseMap = new HashMap<>(GRAAL_MAPPING.size());
+            for (Entry<String, String> entry : GRAAL_MAPPING.entrySet()) {
+                reverseMap.put(entry.getValue(), entry.getKey());
+            }
+            MANDREL_JDK_REV_MAP = Collections.unmodifiableMap(reverseMap);
+        }
 
         /**
          * The minimum version of GraalVM supported by Quarkus.
@@ -97,14 +117,18 @@ public static class Version implements Comparable<Version> {
          */
         public static final Version MINIMUM_SUPPORTED = CURRENT;
 
+        private static final String DEFAULT_JDK_VERSION = "21";
         protected final String fullVersion;
         public final Runtime.Version javaVersion;
         protected final Distribution distribution;
         private int[] versions;
         private String suffix;
 
         Version(String fullVersion, String version, Distribution distro) {
-            this(fullVersion, version, "21", distro);
+            this(fullVersion, version,
+                    distro == Distribution.MANDREL || distro == Distribution.LIBERICA ? communityJDKvers(version)
+                            : DEFAULT_JDK_VERSION,
+                    distro);
         }
 
         Version(String fullVersion, String version, String javaVersion, Distribution distro) {
@@ -127,6 +151,33 @@ private void breakdownVersion(String version) {
             this.versions = Arrays.stream(version.split("\\.")).mapToInt(Integer::parseInt).toArray();
         }
 
+        /*
+         * Reconstruct the JDK version from the given GraalVM community version (Mandrel or Liberica)
+         */
+        private static String communityJDKvers(String communityVersion) {
+            try {
+                String[] parts = communityVersion.split("\\.", 4);
+                int major = Integer.parseInt(parts[0]);
+                int minor = Integer.parseInt(parts[1]);
+                if ((major == 23 && minor > 0) ||
+                        major > 23) {
+                    String mandrelMajorMinor = String.format("%s.%s", parts[0], parts[1]);
+                    // If we don't find a reverse mapping we use a JDK version >= 25, thus
+                    // the feature version is the first part of the quadruple.
+                    String feature = MANDREL_JDK_REV_MAP.getOrDefault(mandrelMajorMinor, parts[0]);
+                    // Heuristic: The update version of Mandrel and the JDK match.
+                    // Interim is usually 0 for the JDK version.
+                    return String.format("%s.%s.%s", feature, "0", parts[2]);
+                }
+            } catch (Throwable e) {
+                // fall-through do default
+                Log.warnf("Failed to parse JDK version from GraalVM version: %s. Defaulting to currently supported version %s ",
+                        communityVersion,
+                        DEFAULT_JDK_VERSION);
+            }
+            return DEFAULT_JDK_VERSION;
+        }
+
         @Override
         public int compareTo(Version o) {
             return compareTo(o.versions);

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,6 @@ static final class VersionParseHelper {`
`28`	`28`	`private static final String OPT = "(?:-(?<OPT>[-a-zA-Z0-9.]+))?";`
`29`	`29`	`private static final String VSTR_FORMAT = VNUM + PRE + BUILD + OPT;`
`30`	`30`
`31`		`- private static final String VNUM_GROUP = "VNUM";`
`32`	`31`	`private static final String VENDOR_VERSION_GROUP = "VENDOR";`
`33`	`32`	`private static final String BUILD_INFO_GROUP = "BUILDINFO";`
`34`	`33`
`@@ -67,7 +66,7 @@ static Version parse(List<String> lines) {`
`67`	`66`
`68`	`67`	`String vendorVersion = secondMatcher.group(VENDOR_VERSION_GROUP);`
`69`	`68`
`70`		`- String graalVersion = graalVersion(javaVersion, v.feature());`
	`69`	`+ String graalVersion = graalVersion(javaVersion, v);`
`71`	`70`	`if (vendorVersion.contains("-dev")) {`
`72`	`71`	`graalVersion = graalVersion + "-dev";`
`73`	`72`	`}`
`@@ -137,7 +136,7 @@ private static String matchVersion(String version) {`
`137`	`136`	`return null;`
`138`	`137`	`}`
`139`	`138`
`140`		`- private static String graalVersion(String buildInfo, int jdkFeature) {`
	`139`	`+ private static String graalVersion(String buildInfo, Runtime.Version v) {`
`141`	`140`	`if (buildInfo == null) {`
`142`	`141`	`return null;`
`143`	`142`	`}`
`@@ -152,7 +151,10 @@ private static String graalVersion(String buildInfo, int jdkFeature) {`
`152`	`151`	`if (versMatcher.find()) {`
`153`	`152`	`return matchVersion(version);`
`154`	`153`	`} else {`
`155`		`- return Version.GRAAL_MAPPING.get(Integer.toString(jdkFeature));`
	`154`	`+ // Only versions from JDK 22 to JDK 25 had GraalVM version mappings.`
	`155`	`+ // Use the JDK version triplet for JDK N where N > 25.`
	`156`	`+ String fullJDKVersion = String.format("%d.%d.%d", v.feature(), v.interim(), v.update());`
	`157`	`+ return Version.GRAAL_MAPPING.getOrDefault(Integer.toString(v.feature()), fullJDKVersion);`
`156`	`158`	`}`
`157`	`159`	`}`
`158`	`160`