[GR-42220] Support compiling substratevm with JDK 20.

ci/ci_common/common.jsonnet

@@ -119,11 +119,11 @@ local add_jdk_version(name) =
   for name in std.objectFieldsAll(jdks)
 } + {
   # Aliases to edition specific labsjdks
-  labsjdk17::            self["labsjdk-" + repo_config.graalvm_edition + "-17"],
+  labsjdk17::            self["labsjdk-ee-17"],
   labsjdk19::            self["labsjdk-" + repo_config.graalvm_edition + "-19"],
-  labsjdk17Debug::       self["labsjdk-" + repo_config.graalvm_edition + "-17Debug"],
+  labsjdk17Debug::       self["labsjdk-ee-17Debug"],
   labsjdk19Debug::       self["labsjdk-" + repo_config.graalvm_edition + "-19Debug"],
-  labsjdk17LLVM::        self["labsjdk-" + repo_config.graalvm_edition + "-17-llvm"],
+  labsjdk17LLVM::        self["labsjdk-ee-17-llvm"],
   labsjdk19LLVM::        self["labsjdk-" + repo_config.graalvm_edition + "-19-llvm"],
 
   # Only CE exists for JDK 20 until JDK 20 GA.

common.json

@@ -5,25 +5,22 @@
 
   "jdks": {
     "oraclejdk17":        {"name": "jpg-jdk",   "version": "17.0.1",  "build_id": "12", "release": true, "platformspecific": true, "extrabundles": ["static-libs"]},
-    "labsjdk-ce-17":      {"name": "labsjdk",   "version": "ce-17.0.6+2-jvmci-23.0-b04", "platformspecific": true },
-    "labsjdk-ce-17Debug": {"name": "labsjdk",   "version": "ce-17.0.6+2-jvmci-23.0-b04-debug", "platformspecific": true },
-    "labsjdk-ce-17-llvm": {"name": "labsjdk",   "version": "ce-17.0.6+2-jvmci-23.0-b04-sulong", "platformspecific": true },
-    "labsjdk-ee-17":      {"name": "labsjdk",   "version": "ee-17.0.6+7-jvmci-23.0-b04", "platformspecific": true },
-    "labsjdk-ee-17Debug": {"name": "labsjdk",   "version": "ee-17.0.6+7-jvmci-23.0-b04-debug", "platformspecific": true },
-    "labsjdk-ee-17-llvm": {"name": "labsjdk",   "version": "ee-17.0.6+7-jvmci-23.0-b04-sulong", "platformspecific": true },
+    "labsjdk-ee-17":      {"name": "labsjdk",   "version": "ee-17.0.6+9-jvmci-22.3-b11", "platformspecific": true },
+    "labsjdk-ee-17Debug": {"name": "labsjdk",   "version": "ee-17.0.6+9-jvmci-22.3-b11-debug", "platformspecific": true },
+    "labsjdk-ee-17-llvm": {"name": "labsjdk",   "version": "ee-17.0.6+9-jvmci-22.3-b11-sulong", "platformspecific": true },
 
     "oraclejdk19":        {"name": "jpg-jdk",   "version": "19",      "build_id": "26", "release": true, "platformspecific": true, "extrabundles": ["static-libs"]},
     "labsjdk-ce-19":      {"name": "labsjdk",   "version": "ce-19.0.1+10-jvmci-23.0-b04", "platformspecific": true },
     "labsjdk-ce-19Debug": {"name": "labsjdk",   "version": "ce-19.0.1+10-jvmci-23.0-b04-debug", "platformspecific": true },
     "labsjdk-ce-19-llvm": {"name": "labsjdk",   "version": "ce-19.0.1+10-jvmci-23.0-b04-sulong", "platformspecific": true },
-    "labsjdk-ee-19":      {"name": "labsjdk",   "version": "ee-19.0.2+6-jvmci-23.0-b04", "platformspecific": true },
-    "labsjdk-ee-19Debug": {"name": "labsjdk",   "version": "ee-19.0.2+6-jvmci-23.0-b04-debug", "platformspecific": true },
-    "labsjdk-ee-19-llvm": {"name": "labsjdk",   "version": "ee-19.0.2+6-jvmci-23.0-b04-sulong", "platformspecific": true },
+    "labsjdk-ee-19":      {"name": "labsjdk",   "version": "ee-19.0.2+7-jvmci-23.0-b05", "platformspecific": true },
+    "labsjdk-ee-19Debug": {"name": "labsjdk",   "version": "ee-19.0.2+7-jvmci-23.0-b05-debug", "platformspecific": true },
+    "labsjdk-ee-19-llvm": {"name": "labsjdk",   "version": "ee-19.0.2+7-jvmci-23.0-b05-sulong", "platformspecific": true },
 
     "oraclejdk20":        {"name": "jpg-jdk",   "version": "20",      "build_id": "24", "release": true, "platformspecific": true, "extrabundles": ["static-libs"]},
-    "labsjdk-ce-20":      {"name": "labsjdk",   "version": "ce-20+25-jvmci-23.0-b04", "platformspecific": true },
-    "labsjdk-ce-20Debug": {"name": "labsjdk",   "version": "ce-20+25-jvmci-23.0-b04-debug", "platformspecific": true },
-    "labsjdk-ce-20-llvm": {"name": "labsjdk",   "version": "ce-20+25-jvmci-23.0-b04-sulong", "platformspecific": true }
+    "labsjdk-ce-20":      {"name": "labsjdk",   "version": "ce-20+26-jvmci-23.0-b05", "platformspecific": true },
+    "labsjdk-ce-20Debug": {"name": "labsjdk",   "version": "ce-20+26-jvmci-23.0-b05-debug", "platformspecific": true },
+    "labsjdk-ce-20-llvm": {"name": "labsjdk",   "version": "ce-20+26-jvmci-23.0-b05-sulong", "platformspecific": true }
   },
 
   "COMMENT.devkits" : "The devkits versions reflect those used to build the JVMCI JDKs (e.g., see devkit_platform_revisions in <jdk>/make/conf/jib-profiles.js)",

compiler/src/org.graalvm.compiler.core.aarch64.test/src/org/graalvm/compiler/core/aarch64/test/AArch64TestBitAndBranchTest.java

@@ -248,7 +248,7 @@ protected void run(
     protected void checkLIR(String methodName, Predicate<LIRInstruction> predicate, int expected) {
         compile(getResolvedJavaMethod(methodName), null);
         int actualOpNum = 0;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (predicate.test(ins)) {
                 actualOpNum++;
             }

compiler/src/org.graalvm.compiler.core.amd64.test/src/org/graalvm/compiler/core/amd64/test/AMD64MatchRuleTest.java

@@ -26,7 +26,7 @@
 
 import static org.junit.Assume.assumeTrue;
 
-import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
+import org.graalvm.compiler.core.common.cfg.BasicBlock;
 import org.graalvm.compiler.core.test.MatchRuleTest;
 import org.graalvm.compiler.lir.LIR;
 import org.graalvm.compiler.lir.LIRInstruction;
@@ -66,7 +66,7 @@ public void test1() {
         compile(getResolvedJavaMethod("test1Snippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof MemoryConstOp && ((MemoryConstOp) ins).getOpcode().toString().equals("CMP")) {
                 assertFalse("MemoryConstOp expected only once in first block", found);
                 found = true;
@@ -101,7 +101,7 @@ public void testVolatileExtension() {
         compile(getResolvedJavaMethod("testVolatileExtensionSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof AMD64Unary.MemoryOp) {
                 ins.visitEachOutput((value, mode, flags) -> assertTrue(value.getPlatformKind().toString(), value.getPlatformKind().equals(AMD64Kind.QWORD)));
                 assertFalse("MemoryOp expected only once in first block", found);
@@ -131,7 +131,7 @@ public void testLoadTestNoMatch() {
         compile(getResolvedJavaMethod("testLoadTestNoMatchSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof ConstOp && ((ConstOp) ins).getOpcode().toString().equals("CMP")) {
                 assertFalse("CMP expected only once in first block", found);
                 found = true;
@@ -158,7 +158,7 @@ public void testAddLoad() {
         compile(getResolvedJavaMethod("testAddLoadSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof AMD64Binary.MemoryTwoOp && ((AMD64Binary.MemoryTwoOp) ins).getOpcode().toString().equals("ADD")) {
                 assertFalse("MemoryTwoOp expected only once in first block", found);
                 found = true;
@@ -181,7 +181,7 @@ public void testAddLoadNoMatch() {
         compile(getResolvedJavaMethod("testAddLoadNoMatchSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof AMD64Binary.CommutativeTwoOp && ((AMD64Binary.CommutativeTwoOp) ins).getOpcode().toString().equals("ADD")) {
                 assertFalse("CommutativeTwoOp expected only once in first block", found);
                 found = true;
@@ -207,7 +207,7 @@ public void testVolatileExtensionDifferentBlocks() {
         compile(getResolvedJavaMethod("testVolatileExtensionDifferentBlocksSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof AMD64Unary.MemoryOp) {
                 ins.visitEachOutput((value, mode, flags) -> assertTrue(value.getPlatformKind().toString(), value.getPlatformKind().equals(AMD64Kind.QWORD)));
                 assertFalse("MemoryOp expected only once in first block", found);
@@ -234,7 +234,8 @@ public void testAddLoadDifferentBlocksNoMatch() {
         compile(getResolvedJavaMethod("testAddLoadDifferentBlocksNoMatchSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (AbstractBlockBase<?> b : lir.codeEmittingOrder()) {
+        for (int blockId : lir.codeEmittingOrder()) {
+            BasicBlock<?> b = lir.getBlockById(blockId);
             for (LIRInstruction ins : lir.getLIRforBlock(b)) {
                 if (ins instanceof AMD64Binary.CommutativeTwoOp && ((AMD64Binary.CommutativeTwoOp) ins).getOpcode().toString().equals("ADD")) {
                     assertFalse("CommutativeTwoOp expected only once in first block", found);
@@ -262,7 +263,7 @@ public void testAddLoadDifferentBlocks() {
         compile(getResolvedJavaMethod("testAddLoadDifferentBlocksSnippet"), null);
         LIR lir = getLIR();
         boolean found = false;
-        for (LIRInstruction ins : lir.getLIRforBlock(lir.codeEmittingOrder()[0])) {
+        for (LIRInstruction ins : lir.getLIRforBlock(lir.getControlFlowGraph().getBlocks()[lir.codeEmittingOrder()[0]])) {
             if (ins instanceof AMD64Binary.MemoryTwoOp && ((AMD64Binary.MemoryTwoOp) ins).getOpcode().toString().equals("ADD")) {
                 assertFalse("MemoryTwoOp expected only once in first block", found);
                 found = true;

compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/UseTrappingDivPhase.java

@@ -47,7 +47,7 @@
 import org.graalvm.compiler.nodes.calc.IntegerEqualsNode;
 import org.graalvm.compiler.nodes.calc.SignedDivNode;
 import org.graalvm.compiler.nodes.calc.SignedRemNode;
-import org.graalvm.compiler.nodes.cfg.Block;
+import org.graalvm.compiler.nodes.cfg.HIRBlock;
 import org.graalvm.compiler.nodes.extended.MultiGuardNode;
 import org.graalvm.compiler.nodes.memory.address.AddressNode;
 import org.graalvm.compiler.nodes.util.GraphUtil;
@@ -86,6 +86,7 @@ public Optional<NotApplicable> notApplicableTo(GraphState graphState) {
 
     @Override
     protected void run(StructuredGraph graph, LowTierContext context) {
+        graph.clearLastSchedule();
         if (!GraalOptions.FloatingDivNodes.getValue(graph.getOptions())) {
             return;
         }
@@ -118,8 +119,8 @@ protected void run(StructuredGraph graph, LowTierContext context) {
                             // condition ensures that divisor is dominated by condition, now do
                             // the
                             // same for the dividend
-                            Block ifBlock = sched.getNodeToBlockMap().get(ifNode);
-                            Block dividendBlock = sched.getNodeToBlockMap().get(dividend);
+                            HIRBlock ifBlock = sched.getNodeToBlockMap().get(ifNode);
+                            HIRBlock dividendBlock = sched.getNodeToBlockMap().get(dividend);
                             if (dividendBlock == null) {
                                 assert dividend instanceof PhiNode;
                                 dividendBlock = sched.getNodeToBlockMap().get(((PhiNode) dividend).merge());

compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/NumUtil.java

@@ -259,4 +259,24 @@ public static long minUnsigned(long a, long b) {
     public static boolean sameSign(long a, long b) {
         return a < 0 == b < 0;
     }
+
+    /**
+     * Converts a hex string to a byte array. Two characters are converted to a byte at a time.
+     *
+     * @param hex the hex string
+     * @return byte array
+     */
+    public static byte[] hexStringToBytes(String hex) {
+        int len = hex.length() / 2;
+        byte[] bytes = new byte[len];
+        for (int i = 0; i < len; i++) {
+            // need to parse as int, because parseByte will throw on values > 127
+            int val = Integer.parseInt(hex.substring(i << 1, (i << 1) + 2), 16);
+            if (val < 0 || val > 255) {
+                throw new NumberFormatException("Value out of range: " + val);
+            }
+            bytes[i] = (byte) val;
+        }
+        return bytes;
+    }
 }

compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/alloc/BasicBlockOrderUtils.java

@@ -29,7 +29,7 @@
 import java.util.Comparator;
 import java.util.PriorityQueue;
 
-import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
+import org.graalvm.compiler.core.common.cfg.BasicBlock;
 import org.graalvm.compiler.core.common.cfg.CodeEmissionOrder.ComputationTime;
 import org.graalvm.compiler.debug.GraalError;
 
@@ -50,7 +50,7 @@ public final class BasicBlockOrderUtils {
     /**
      * Initializes the priority queue used for the work list of blocks and adds the start block.
      */
-    protected static <T extends AbstractBlockBase<T>> PriorityQueue<T> initializeWorklist(T startBlock, BitSet visitedBlocks) {
+    protected static <T extends BasicBlock<T>> PriorityQueue<T> initializeWorklist(T startBlock, BitSet visitedBlocks) {
         PriorityQueue<T> result = new PriorityQueue<>(INITIAL_WORKLIST_CAPACITY, new BlockOrderComparator<>());
         result.add(startBlock);
         visitedBlocks.set(startBlock.getId());
@@ -60,36 +60,36 @@ protected static <T extends AbstractBlockBase<T>> PriorityQueue<T> initializeWor
     /**
      * Checks that the ordering contains the expected number of blocks.
      */
-    protected static boolean checkOrder(BlockList<? extends AbstractBlockBase<?>> order, int expectedBlockCount) {
+    protected static boolean checkOrder(BlockList<? extends BasicBlock<?>> order, int expectedBlockCount) {
         GraalError.guarantee(order.size() == expectedBlockCount, "Number of blocks in ordering (%d) does not match expected block count (%d)", order.size(), expectedBlockCount);
         return true;
     }
 
     /**
      * Checks that the ordering starts with the expected start block.
      */
-    protected static <T extends AbstractBlockBase<T>> boolean checkStartBlock(BlockList<T> order, T startBlock) {
+    protected static <T extends BasicBlock<T>> boolean checkStartBlock(BlockList<T> order, T startBlock) {
         GraalError.guarantee(order.first() == startBlock, "First block of ordering (%s) does not match expected start block %s", order.first(), startBlock);
         return true;
     }
 
     /**
      * Find the highest likely unvisited successor block of a given block.
      */
-    protected static <T extends AbstractBlockBase<T>> T findAndMarkMostLikelySuccessor(T block, BlockList<T> order, BitSet visitedBlocks) {
+    protected static <T extends BasicBlock<T>> T findAndMarkMostLikelySuccessor(T block, BlockList<T> order, BitSet visitedBlocks) {
         return findAndMarkMostLikelySuccessor(block, order, visitedBlocks, ComputationTime.BEFORE_CONTROL_FLOW_OPTIMIZATIONS, null);
     }
 
-    protected static <T extends AbstractBlockBase<T>> T findAndMarkMostLikelySuccessor(T block, BlockList<T> order, BitSet visitedBlocks, ComputationTime computationTime,
+    protected static <T extends BasicBlock<T>> T findAndMarkMostLikelySuccessor(T block, BlockList<T> order, BitSet visitedBlocks, ComputationTime computationTime,
                     PriorityQueue<T> worklist) {
         T result = null;
         double maxSuccFrequency = -1.0;
         double maxScheduledSuccProbability = -1.0;
         boolean isTriangle = false;
         if (block.getSuccessorCount() == 2 && computationTime == ComputationTime.AFTER_CONTROL_FLOW_OPTIMIZATIONS) {
             double thisFrequency = block.getRelativeFrequency();
-            T left = block.getSuccessors()[0];
-            T right = block.getSuccessors()[1];
+            T left = block.getSuccessorAt(0);
+            T right = block.getSuccessorAt(1);
             // Check if we have a control flow triangle merging up at one of these successors. See
             // usage of isTriangle below for explanation.
             if (Math.abs(left.getRelativeFrequency() - thisFrequency) < 0.0001 && right.getPredecessorCount() == 1) {
@@ -99,8 +99,8 @@ protected static <T extends AbstractBlockBase<T>> T findAndMarkMostLikelySuccess
             }
         }
         for (int i = 0; i < block.getSuccessorCount(); i++) {
-            T successor = block.getSuccessors()[i];
-            double succProbability = block.getSuccessorProbabilities()[i];
+            T successor = block.getSuccessorAt(i);
+            double succProbability = block.getSuccessorProbabilityAt(i);
             double succFrequency = successor.getRelativeFrequency();
             assert succFrequency >= 0.0 : "Relative frequencies must be positive";
             if (computationTime == ComputationTime.AFTER_CONTROL_FLOW_OPTIMIZATIONS) {
@@ -252,8 +252,9 @@ protected static <T extends AbstractBlockBase<T>> T findAndMarkMostLikelySuccess
     /**
      * Add successor blocks into the given work list if they are not already marked as visited.
      */
-    protected static <T extends AbstractBlockBase<T>> void enqueueSuccessors(T block, PriorityQueue<T> worklist, BitSet visitedBlocks) {
-        for (T successor : block.getSuccessors()) {
+    protected static <T extends BasicBlock<T>> void enqueueSuccessors(T block, PriorityQueue<T> worklist, BitSet visitedBlocks) {
+        for (int i = 0; i < block.getSuccessorCount(); i++) {
+            T successor = block.getSuccessorAt(i);
             if (!visitedBlocks.get(successor.getId())) {
                 visitedBlocks.set(successor.getId());
                 worklist.add(successor);
@@ -264,7 +265,7 @@ protected static <T extends AbstractBlockBase<T>> void enqueueSuccessors(T block
     /**
      * Comparator for sorting blocks based on loop depth and probability.
      */
-    public static class BlockOrderComparator<T extends AbstractBlockBase<T>> implements Comparator<T> {
+    public static class BlockOrderComparator<T extends BasicBlock<T>> implements Comparator<T> {
         private static final double EPSILON = 1E-6;
 
         @Override
@@ -291,7 +292,7 @@ public int compare(T a, T b) {
      * A data structure combining an append-only list of blocks and a bit set for efficiently
      * checking which blocks have been added.
      */
-    protected static class BlockList<T extends AbstractBlockBase<T>> {
+    protected static class BlockList<T extends BasicBlock<T>> {
         private final ArrayList<T> order;
         private final BitSet scheduledBlocks;
 
@@ -318,8 +319,20 @@ public boolean isScheduled(T block) {
             return scheduledBlocks.get(block.getId());
         }
 
-        public AbstractBlockBase<?>[] toArray() {
-            return order.toArray(new AbstractBlockBase<?>[0]);
+        public BasicBlock<?>[] toArray() {
+            return order.toArray(new BasicBlock<?>[0]);
+        }
+
+        public char[] toIdArray() {
+            char[] orderIndices = new char[order.size()];
+            for (int i = 0; i < order.size(); i++) {
+                orderIndices[i] = order.get(i).getId();
+            }
+            return orderIndices;
+        }
+
+        public ArrayList<T> getOrder() {
+            return order;
         }
     }
 }