Merge branch 'community-backports-jdk21u' into Mandrel 23.1

.github/workflows/main.yml

@@ -119,25 +119,25 @@ jobs:
       MX_RUNS_STYLE: ${{ contains(matrix.env.GATE_TAGS, 'style') || matrix.env.GATE_TAGS == '' }}
     steps:
     - name: Checkout oracle/graal
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         ref: ${{ github.ref }} # Lock ref to current branch to avoid fetching others
         fetch-depth: "${{ env.MX_RUNS_STYLE && '0' || '1' }}" # The style gate needs the full commit history for checking copyright years
     - name: Determine mx version
       run: echo "MX_VERSION=$(jq -r '.mx_version' common.json)" >> ${GITHUB_ENV}
     - name: Checkout graalvm/mx
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         repository: graalvm/mx.git
         ref: ${{ env.MX_VERSION }}
         fetch-depth: 1
         path: ${{ env.MX_PATH }}
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.8'
     - name: Update mx cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: ~/.mx
         key: ${{ runner.os }}-mx-${{ hashFiles('**/suite.py') }}

compiler/mx.compiler/suite.py

@@ -4,7 +4,7 @@
   "sourceinprojectwhitelist" : [],
 
   "groupId" : "org.graalvm.compiler",
-  "version" : "23.1.4.1",
+  "version" : "23.1.5.0",
   "release" : False,
   "url" : "http://www.graalvm.org/",
   "developer" : {

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

@@ -112,7 +112,7 @@ public CompareAndSwapOp(AArch64Kind accessKind, MemoryOrderMode memoryOrder, boo
         }
 
         /**
-         * Both cas and ld(a)xr produce a zero-extended value. Since comparisons must be at minimum
+         * Both cas and ldxr produce a zero-extended value. Since comparisons must be at minimum
          * 32-bits, the expected value must also be zero-extended to produce an accurate comparison.
          */
         private static void emitCompare(AArch64MacroAssembler masm, int memAccessSize, Register result, Register expected) {
@@ -169,53 +169,64 @@ public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) {
                     throw GraalError.shouldNotReachHereUnexpectedValue(memoryOrder); // ExcludeFromJacocoGeneratedReport
             }
 
+            int moveSize = Math.max(memAccessSize, 32);
             if (AArch64LIRFlags.useLSE(masm)) {
-                masm.mov(Math.max(memAccessSize, 32), result, expected);
+                masm.mov(moveSize, result, expected);
                 moveSPAndEmitCode(masm, asRegister(newValue), newVal -> {
                     masm.cas(memAccessSize, result, newVal, address, acquire, release);
                 });
                 if (setConditionFlags) {
                     emitCompare(masm, memAccessSize, result, expected);
                 }
             } else {
+
+                try (ScratchRegister scratchRegister1 = masm.getScratchRegister(); ScratchRegister scratchRegister2 = masm.getScratchRegister()) {
+                    Label retry = new Label();
+                    masm.bind(retry);
+                    Register scratch2 = scratchRegister2.getRegister();
+                    Register newValueReg = asRegister(newValue);
+                    if (newValueReg.equals(sp)) {
+                        /*
+                         * SP cannot be used in csel or stl(x)r.
+                         *
+                         * Since csel overwrites scratch2, newValue must be newly loaded each loop
+                         * iteration. However, unless under heavy contention, the storeExclusive
+                         * should rarely fail.
+                         */
+                        masm.mov(moveSize, scratch2, newValueReg);
+                        newValueReg = scratch2;
+                    }
+                    masm.loadExclusive(memAccessSize, result, address, false);
+
+                    emitCompare(masm, memAccessSize, result, expected);
+                    masm.csel(moveSize, scratch2, newValueReg, result, AArch64Assembler.ConditionFlag.EQ);
+
+                    /*
+                     * STLXR must be used also if acquire is set to ensure prior ldaxr/stlxr
+                     * instructions are not reordered after it.
+                     */
+                    Register scratch1 = scratchRegister1.getRegister();
+                    masm.storeExclusive(memAccessSize, scratch1, scratch2, address, acquire || release);
+                    // if scratch1 == 0 then write successful, else retry.
+                    masm.cbnz(32, scratch1, retry);
+                }
+
                 /*
-                 * Because the store is only conditionally emitted, a dmb is needed for performing a
-                 * release.
-                 *
-                 * Furthermore, even if the stlxr is emitted, if both acquire and release semantics
-                 * are required, then a dmb is anyways needed to ensure that the instruction
-                 * sequence:
+                 * From the Java perspective, the (ldxr, cmp, csel, stl(x)r) is a single atomic
+                 * operation which must abide by all requested semantics. Therefore, when acquire
+                 * semantics are needed, we use a full barrier after the store to guarantee that
+                 * instructions following the store cannot execute before it and violate acquire
+                 * semantics.
                  *
-                 * A -> ldaxr -> stlxr -> B
-                 *
-                 * cannot be executed as:
-                 *
-                 * ldaxr -> B -> A -> stlxr
+                 * Note we could instead perform a conditional branch and when the comparison fails
+                 * skip the store, but this introduces an opportunity for branch mispredictions, and
+                 * also, when release semantics are needed, requires a barrier to be inserted before
+                 * the operation.
                  */
-                if (release) {
+
+                if (acquire) {
                     masm.dmb(AArch64Assembler.BarrierKind.ANY_ANY);
                 }
-
-                moveSPAndEmitCode(masm, asRegister(newValue), newVal -> {
-                    try (ScratchRegister scratchRegister = masm.getScratchRegister()) {
-                        Register scratch = scratchRegister.getRegister();
-                        Label retry = new Label();
-                        Label fail = new Label();
-                        masm.bind(retry);
-                        masm.loadExclusive(memAccessSize, result, address, acquire);
-                        emitCompare(masm, memAccessSize, result, expected);
-                        masm.branchConditionally(AArch64Assembler.ConditionFlag.NE, fail);
-                        /*
-                         * Even with the prior dmb, for releases it is still necessary to use stlxr
-                         * instead of stxr to guarantee subsequent lda(x)r/stl(x)r cannot be hoisted
-                         * above this instruction and thereby violate volatile semantics.
-                         */
-                        masm.storeExclusive(memAccessSize, scratch, newVal, address, release);
-                        // if scratch == 0 then write successful, else retry.
-                        masm.cbnz(32, scratch, retry);
-                        masm.bind(fail);
-                    }
-                });
             }
         }
     }
@@ -291,14 +302,10 @@ public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) {
                 }
             }
             /*
-             * Use a full barrier for the acquire semantics instead of ldaxr to guarantee that the
-             * instruction sequence:
-             *
-             * A -> ldaxr -> stlxr -> B
-             *
-             * cannot be executed as:
-             *
-             * ldaxr -> B -> A -> stlxr
+             * From the Java perspective, the (ldxr, add, stlxr) is a single atomic operation which
+             * must abide by both acquire and release semantics. Therefore, we use a full barrier
+             * after the store to guarantee that instructions following the store cannot execute
+             * before it and violate acquire semantics.
              */
             masm.dmb(AArch64Assembler.BarrierKind.ANY_ANY);
         }
@@ -406,14 +413,10 @@ public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) {
                         // if scratch == 0 then write successful, else retry
                         masm.cbnz(32, scratch, retry);
                         /*
-                         * Use a full barrier for the acquire semantics instead of ldaxr to
-                         * guarantee that the instruction sequence:
-                         *
-                         * A -> ldaxr -> stlxr -> B
-                         *
-                         * cannot be executed as:
-                         *
-                         * ldaxr -> B -> A -> stlxr
+                         * From the Java perspective, the (ldxr, stlxr) is a single atomic operation
+                         * which must abide by both acquire and release semantics. Therefore, we use
+                         * a full barrier after the store to guarantee that instructions following
+                         * the store cannot execute before it and violate acquire semantics.
                          */
                         masm.dmb(AArch64Assembler.BarrierKind.ANY_ANY);
                     }

espresso/mx.espresso/suite.py

@@ -23,7 +23,7 @@
 suite = {
     "mxversion": "6.44.0",
     "name": "espresso",
-    "version" : "23.1.4.1",
+    "version" : "23.1.5.0",
     "release" : False,
     "groupId" : "org.graalvm.espresso",
     "url" : "https://www.graalvm.org/reference-manual/java-on-truffle/",

regex/mx.regex/suite.py

@@ -43,7 +43,7 @@
 
   "name" : "regex",
 
-  "version" : "23.1.4.1",
+  "version" : "23.1.5.0",
   "release" : False,
   "groupId" : "org.graalvm.regex",
   "url" : "http://www.graalvm.org/",

sdk/mx.sdk/suite.py

@@ -41,7 +41,7 @@
 suite = {
   "mxversion": "6.39.0",
   "name" : "sdk",
-  "version" : "23.1.4.1",
+  "version" : "23.1.5.0",
   "release" : False,
   "sourceinprojectwhitelist" : [],
   "url" : "https://github.com/oracle/graal",

substratevm/mx.substratevm/suite.py

@@ -2,7 +2,7 @@
 suite = {
     "mxversion": "6.27.1",
     "name": "substratevm",
-    "version" : "23.1.4.1",
+    "version" : "23.1.5.0",
     "release" : False,
     "url" : "https://github.com/oracle/graal/tree/master/substratevm",
 

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/JfrGCHeapSummaryEvent.java

@@ -55,11 +55,12 @@ private static void emit0(UnsignedWord gcEpoch, long start, UnsignedWord committ
             JfrNativeEventWriter.putLong(data, gcWhen.getId());
 
             // VirtualSpace
-            JfrNativeEventWriter.putLong(data, 0L); // start
-            JfrNativeEventWriter.putLong(data, 0L); // committedEnd
+            JfrNativeEventWriter.putLong(data, -1); // start
+            JfrNativeEventWriter.putLong(data, -1); // committedEnd
             JfrNativeEventWriter.putLong(data, committedSize.rawValue());
-            JfrNativeEventWriter.putLong(data, 0L); // reservedEnd
-            JfrNativeEventWriter.putLong(data, 0L); // reservedSize
+            JfrNativeEventWriter.putLong(data, -1); // reservedEnd
+            // Reserved heap size matches committed size
+            JfrNativeEventWriter.putLong(data, committedSize.rawValue()); // reservedSize
 
             JfrNativeEventWriter.putLong(data, heapUsed.rawValue());
             JfrNativeEventWriter.endSmallEvent(data);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/SubstrateExitHandlerFeature.java

@@ -34,7 +34,7 @@
 public class SubstrateExitHandlerFeature implements InternalFeature {
     @Override
     public void beforeAnalysis(BeforeAnalysisAccess access) {
-        if (SubstrateOptions.InstallExitHandlers.getValue()) {
+        if (SubstrateOptions.InstallExitHandlers.getValue() || VMInspectionOptions.hasJfrSupport()) {
             RuntimeSupport.getRuntimeSupport().addStartupHook(new SubstrateExitHandlerStartupHook());
         }
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/Resources.java

@@ -280,10 +280,28 @@ public void registerIncludePattern(String module, String pattern) {
         assert MissingRegistrationUtils.throwMissingRegistrationErrors();
         synchronized (includePatterns) {
             updateTimeStamp();
-            includePatterns.add(new ModuleResourcePair(module, pattern));
+            includePatterns.add(new ModuleResourcePair(module, handleEscapedCharacters(pattern)));
         }
     }
 
+    @Platforms(Platform.HOSTED_ONLY.class)//
+    private static final String BEGIN_ESCAPED_SEQUENCE = "\\Q";
+
+    @Platforms(Platform.HOSTED_ONLY.class)//
+    private static final String END_ESCAPED_SEQUENCE = "\\E";
+
+    /*
+     * This handles generated include patterns which start and end with \Q and \E. The actual
+     * resource name is located inbetween those tags.
+     */
+    @Platforms(Platform.HOSTED_ONLY.class)
+    private static String handleEscapedCharacters(String pattern) {
+        if (pattern.startsWith(BEGIN_ESCAPED_SEQUENCE) && pattern.endsWith(END_ESCAPED_SEQUENCE)) {
+            return pattern.substring(BEGIN_ESCAPED_SEQUENCE.length(), pattern.length() - END_ESCAPED_SEQUENCE.length());
+        }
+        return pattern;
+    }
+
     /**
      * Avoid pulling native file system by using {@link NativeImageResourcePath} implementation to
      * convert <code>resourceName</code> to canonical variant.

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/MissingSerializationRegistrationUtils.java

@@ -39,7 +39,9 @@
 public final class MissingSerializationRegistrationUtils {
 
     public static void missingSerializationRegistration(Class<?> cl, String... msg) {
-        report(new MissingSerializationRegistrationError(errorMessage(msg), cl));
+        MissingSerializationRegistrationError exception = new MissingSerializationRegistrationError(errorMessage(msg), cl);
+        StackTraceElement responsibleClass = getResponsibleClass(exception);
+        MissingRegistrationUtils.report(exception, responsibleClass);
     }
 
     private static String errorMessage(String... type) {
@@ -55,11 +57,6 @@ private static String errorMessage(String... type) {
                         .formatted(typeStr);
     }
 
-    private static void report(MissingSerializationRegistrationError exception) {
-        StackTraceElement responsibleClass = getResponsibleClass(exception);
-        MissingRegistrationUtils.report(exception, responsibleClass);
-    }
-
     /*
      * This is a list of all public JDK methods that end up potentially throwing missing
      * registration errors. This should be implemented using wrapping substitutions once they are

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/SerializationSupport.java

@@ -158,7 +158,7 @@ public Object getSerializationConstructorAccessor(Class<?> rawDeclaringClass, Cl
             String targetConstructorClassName = targetConstructorClass.getName();
             if (ThrowMissingRegistrationErrors.hasBeenSet()) {
                 MissingSerializationRegistrationUtils.missingSerializationRegistration(declaringClass,
-                                "type " + declaringClass.getName() + " with target constructor class: " + targetConstructorClassName);
+                                "type " + declaringClass.getTypeName() + " with target constructor class: " + targetConstructorClassName);
             } else {
                 throw VMError.unsupportedFeature("SerializationConstructorAccessor class not found for declaringClass: " + declaringClass.getName() +
                                 " (targetConstructorClass: " + targetConstructorClassName + "). Usually adding " + declaringClass.getName() +

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/serialize/SerializationFeature.java

@@ -669,9 +669,6 @@ private static Constructor<?> getExternalizableConstructor(Class<?> serializatio
 
     Class<?> addConstructorAccessor(Class<?> serializationTargetClass, Class<?> customTargetConstructorClass) {
         serializationSupport.registerSerializationTargetClass(serializationTargetClass);
-        if (serializationTargetClass.isArray() || Enum.class.isAssignableFrom(serializationTargetClass)) {
-            return null;
-        }
 
         // Don't generate SerializationConstructorAccessor class for Externalizable case
         if (Externalizable.class.isAssignableFrom(serializationTargetClass)) {

substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/jfr/AbstractJfrTest.java

@@ -41,6 +41,7 @@
 
 import org.graalvm.nativeimage.ImageInfo;
 import org.graalvm.nativeimage.hosted.Feature;
+import org.graalvm.nativeimage.hosted.RuntimeProxyCreation;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.BeforeClass;
@@ -54,6 +55,7 @@
 import jdk.jfr.Configuration;
 import jdk.jfr.consumer.RecordedEvent;
 import jdk.jfr.consumer.RecordingFile;
+import jdk.jfr.Unsigned;
 
 /** Base class for JFR unit tests. */
 public abstract class AbstractJfrTest {
@@ -196,4 +198,16 @@ public void afterRegistration(AfterRegistrationAccess access) {
          */
         ModuleSupport.accessPackagesToClass(ModuleSupport.Access.OPEN, JfrTestFeature.class, false, "jdk.internal.vm.compiler", "org.graalvm.compiler.serviceprovider");
     }
+
+    @Override
+    public void beforeAnalysis(BeforeAnalysisAccess access) {
+        /*
+         * Register proxies for event data assertion
+         *
+         * Unsigned added to be able to query RecordedObject.getLong() method, and this method
+         * checks if the value returned has the jdk.jfr.Unsigned. The jfr layer in HotSpot creates a
+         * proxy to query this information.
+         */
+        RuntimeProxyCreation.register(Unsigned.class);
+    }
 }

substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/jfr/TestGCHeapSummaryEvent.java

@@ -25,6 +25,7 @@
 
 package com.oracle.svm.test.jfr;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import java.util.List;
@@ -35,6 +36,7 @@
 
 import jdk.jfr.Recording;
 import jdk.jfr.consumer.RecordedEvent;
+import jdk.jfr.consumer.RecordedObject;
 
 public class TestGCHeapSummaryEvent extends JfrRecordingTest {
     @Test
@@ -49,5 +51,18 @@ public void test() throws Throwable {
 
     private static void validateEvents(List<RecordedEvent> events) {
         assertTrue(events.size() > 0);
+        for (RecordedEvent event : events) {
+            RecordedObject heapSpace = event.getValue("heapSpace");
+            assertEquals(-1, heapSpace.getLong("start"));
+            assertEquals(-1, heapSpace.getLong("committedEnd"));
+            assertEquals(-1, heapSpace.getLong("reservedEnd"));
+
+            long committedSize = heapSpace.getLong("committedSize");
+            assertTrue(committedSize > 0);
+            assertTrue(heapSpace.getLong("reservedSize") >= committedSize);
+            assertTrue(event.getLong("gcId") >= 0);
+            assertTrue(event.getString("when").equals("Before GC") || event.getString("when").equals("After GC"));
+            assertTrue(event.getLong("heapUsed") > 0);
+        }
     }
 }

tools/mx.tools/suite.py

@@ -26,7 +26,7 @@
     "defaultLicense" : "GPLv2-CPE",
 
     "groupId" : "org.graalvm.tools",
-    "version" : "23.1.4.1",
+    "version" : "23.1.5.0",
     "release" : False,
     "url" : "http://openjdk.java.net/projects/graal",
     "developer" : {