Merge upstream tag 'vm-23.1.8' into mandrel/23.1

Community source release of GraalVM 23.1.8 for JDK 21

Author: jerboaa

compiler/mx.compiler/suite.py

@@ -5,7 +5,7 @@
 
   "groupId" : "org.graalvm.compiler",
   "version" : "23.1.8.0",
-  "release" : False,
+  "release" : True,
   "url" : "http://www.graalvm.org/",
   "developer" : {
     "name" : "GraalVM Development",

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/hotspot/aarch64/AArch64HotSpotMove.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -30,7 +30,6 @@
 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.HINT;
 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.ILLEGAL;
 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG;
-import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.STACK;
 
 import org.graalvm.compiler.asm.Label;
 import org.graalvm.compiler.asm.aarch64.AArch64Assembler;
@@ -52,7 +51,7 @@ public static class LoadHotSpotObjectConstantInline extends AArch64LIRInstructio
         public static final LIRInstructionClass<LoadHotSpotObjectConstantInline> TYPE = LIRInstructionClass.create(LoadHotSpotObjectConstantInline.class);
 
         private HotSpotConstant constant;
-        @Def({REG, STACK}) AllocatableValue result;
+        @Def({REG}) AllocatableValue result;
 
         public LoadHotSpotObjectConstantInline(HotSpotConstant constant, AllocatableValue result) {
             super(TYPE);
@@ -80,6 +79,11 @@ public AllocatableValue getResult() {
         public Constant getConstant() {
             return constant;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            return false;
+        }
     }
 
     /**

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/hotspot/amd64/AMD64HotSpotMove.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -41,7 +41,6 @@
 import org.graalvm.compiler.lir.StandardOp.LoadConstantOp;
 import org.graalvm.compiler.lir.amd64.AMD64LIRInstruction;
 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
-
 import jdk.vm.ci.code.Register;
 import jdk.vm.ci.hotspot.HotSpotMetaspaceConstant;
 import jdk.vm.ci.hotspot.HotSpotObjectConstant;
@@ -104,6 +103,16 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            /*
+             * This is slightly too lenient, formally we would also need to check if the target
+             * allows inlining objects. In practice that is always true, and we do not have access
+             * to the relevant information here.
+             */
+            return input.isCompressed();
+        }
     }
 
     public static final class BaseMove extends AMD64LIRInstruction {
@@ -167,6 +176,11 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            return input.isCompressed();
+        }
     }
 
     public static void decodeKlassPointer(AMD64MacroAssembler masm, Register register, Register scratch, AMD64Address address, GraalHotSpotVMConfig config) {

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/StandardOp.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -292,6 +292,14 @@ static boolean isLoadConstantOp(LIRInstruction op) {
             return op.isLoadConstantOp();
         }
 
+        /**
+         * Determine whether this constant load is safe to rematerialize directly to a stack slot.
+         * Some constant load operations have special semantics or implementations that only allow
+         * rematerialization to a register. Such operations must implement this method to return
+         * {@code false}. Simple constant loads that can be implemented using a move-immediate
+         * instruction to a stack slot, or similar, should return {@code true}.
+         */
+        boolean canRematerializeToStack();
     }
 
     /**

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/aarch64/AArch64Move.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -108,6 +108,11 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            return true;
+        }
     }
 
     @Opcode("MOVE")

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/alloc/lsra/LinearScanLifetimeAnalysisPhase.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -925,6 +925,15 @@ protected Constant getMaterializedValue(LIRInstruction op, Value operand, Interv
             LoadConstantOp move = LoadConstantOp.asLoadConstantOp(op);
 
             if (!allocator.neverSpillConstants()) {
+                if (!move.canRematerializeToStack()) {
+                    /*
+                     * This allocator cannot ensure that a rematerialized value is always assigned a
+                     * register; sometimes it rematerializes directly to a stack slot. Therefore, we
+                     * must not try to rematerialize constant loads that do not support
+                     * rematerialization to the stack.
+                     */
+                    return null;
+                }
                 /*
                  * Check if the interval has any uses which would accept an stack location (priority
                  * == ShouldHaveRegister). Rematerialization of such intervals can result in a

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/amd64/AMD64ArrayIndexOfOp.java

@@ -354,15 +354,15 @@ public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler asm) {
             case MatchAny:
                 asm.movSZx(valueSize, ZERO_EXTEND, cmpResult, arrayAddr);
                 for (int i = 0; i < nValues; i++) {
-                    cmpqAndJcc(crb, asm, cmpResult, searchValue[i], elementWiseFound, ConditionFlag.Equal, true);
+                    cmplAndJcc(crb, asm, cmpResult, searchValue[i], elementWiseFound, ConditionFlag.Equal, true);
                 }
                 break;
             case MatchRange:
                 asm.movSZx(valueSize, ZERO_EXTEND, cmpResult, arrayAddr);
                 for (int i = 0; i < nValues; i += 2) {
                     Label noMatch = new Label();
-                    cmpqAndJcc(crb, asm, cmpResult, searchValue[i], noMatch, ConditionFlag.Below, true);
-                    cmpqAndJcc(crb, asm, cmpResult, searchValue[i + 1], elementWiseFound, ConditionFlag.BelowEqual, true);
+                    cmplAndJcc(crb, asm, cmpResult, searchValue[i], noMatch, ConditionFlag.Below, true);
+                    cmplAndJcc(crb, asm, cmpResult, searchValue[i + 1], elementWiseFound, ConditionFlag.BelowEqual, true);
                     asm.bind(noMatch);
                 }
                 break;
@@ -433,8 +433,12 @@ public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler asm) {
         asm.addq(index, bulkSize);
 
         boolean bulkLoopShortJmp = !((variant == ArrayIndexOfVariant.MatchRange && nValues == 4 || variant == ArrayIndexOfVariant.Table) && stride.value > 1);
-        // check if there are enough array slots remaining for the bulk loop
-        asm.cmpqAndJcc(index, arrayLength, ConditionFlag.Greater, skipBulkVectorLoop, bulkLoopShortJmp);
+        /*
+         * Check if there are enough array slots remaining for the bulk loop. Note: The alignment
+         * following the cmpAndJcc can lead to a jump distance > 127. This prevents safely using a
+         * short jump.
+         */
+        asm.cmpqAndJcc(index, arrayLength, ConditionFlag.Greater, skipBulkVectorLoop, false);
 
         asm.align(preferredLoopAlignment(crb));
         asm.bind(bulkVectorLoop);
@@ -509,11 +513,11 @@ private int getNumberOfVectorsInBulkLoop() {
         }
     }
 
-    private static void cmpqAndJcc(CompilationResultBuilder crb, AMD64MacroAssembler asm, Register src1, Value src2, Label branchTarget, ConditionFlag cc, boolean isShortJmp) {
+    private static void cmplAndJcc(CompilationResultBuilder crb, AMD64MacroAssembler asm, Register src1, Value src2, Label branchTarget, ConditionFlag cc, boolean isShortJmp) {
         if (isStackSlot(src2)) {
-            asm.cmpqAndJcc(src1, (AMD64Address) crb.asAddress(src2), cc, branchTarget, isShortJmp);
+            asm.cmplAndJcc(src1, (AMD64Address) crb.asAddress(src2), cc, branchTarget, isShortJmp);
         } else {
-            asm.cmpqAndJcc(src1, asRegister(src2), cc, branchTarget, isShortJmp);
+            asm.cmplAndJcc(src1, asRegister(src2), cc, branchTarget, isShortJmp);
         }
     }
 

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/amd64/AMD64Move.java

@@ -71,6 +71,7 @@
 import jdk.vm.ci.meta.AllocatableValue;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.Value;
 
 public class AMD64Move {
@@ -171,6 +172,14 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            if (input.getJavaKind() == JavaKind.Object) {
+                return input.isNull();
+            }
+            return true;
+        }
     }
 
     @Opcode("STACKMOVE")

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/amd64/vector/AMD64VectorMove.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -161,13 +161,18 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            return true;
+        }
     }
 
     @Opcode("VMOVE")
     public static class MoveFromArrayConstOp extends AMD64LIRInstruction implements LoadConstantOp {
         public static final LIRInstructionClass<MoveFromArrayConstOp> TYPE = LIRInstructionClass.create(MoveFromArrayConstOp.class);
 
-        @Def({REG, STACK}) protected AllocatableValue result;
+        @Def({REG}) protected AllocatableValue result;
         private final DataPointerConstant input;
 
         public MoveFromArrayConstOp(AllocatableValue result, DataPointerConstant input) {
@@ -193,6 +198,11 @@ public Constant getConstant() {
         public AllocatableValue getResult() {
             return result;
         }
+
+        @Override
+        public boolean canRematerializeToStack() {
+            return false;
+        }
     }
 
     @Opcode("VSTACKMOVE")

espresso/mx.espresso/suite.py

@@ -24,7 +24,7 @@
     "mxversion": "6.44.0",
     "name": "espresso",
     "version" : "23.1.8.0",
-    "release" : False,
+    "release" : True,
     "groupId" : "org.graalvm.espresso",
     "url" : "https://www.graalvm.org/reference-manual/java-on-truffle/",
     "developer" : {