Merge graalvm-community-jdk21u into mandrel/23.1

Author: jerboaa

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/nodes/PiNode.java

@@ -27,6 +27,8 @@
 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_0;
 import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_0;
 
+import java.util.List;
+
 import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
 import org.graalvm.compiler.core.common.type.ObjectStamp;
 import org.graalvm.compiler.core.common.type.Stamp;
@@ -307,7 +309,9 @@ private static void tryEvacuate(SimplifierTool tool, GuardingNode guard, boolean
         if (guardNode.hasNoUsages()) {
             return;
         }
-        for (PiNode pi : guardNode.usages().filter(PiNode.class).snapshot()) {
+
+        List<PiNode> pis = guardNode.usages().filter(PiNode.class).snapshot();
+        for (PiNode pi : pis) {
             if (!pi.isAlive()) {
                 continue;
             }
@@ -317,6 +321,8 @@ private static void tryEvacuate(SimplifierTool tool, GuardingNode guard, boolean
             }
 
             /*
+             * RECURSE CALL
+             *
              * If there are PiNodes still anchored at this guard then either they must simplify away
              * because they are no longer necessary or this node must be replaced with a
              * ValueAnchorNode because the type injected by the PiNode is only true at this point in
@@ -330,6 +336,16 @@ private static void tryEvacuate(SimplifierTool tool, GuardingNode guard, boolean
                     tryEvacuate(tool, otherGuard, false);
                 }
             }
+            /*
+             * A note on the RECURSE CALL above: When we have pis with input pis on the same guard
+             * (which should actually be combined) it can be that the recurse call (processing the
+             * same pis again) already deletes this node (very special stamp setups necessary).
+             * Thus, it can be that pi is dead at this point already, so we have to check for this
+             * again.
+             */
+            if (!pi.isAlive()) {
+                continue;
+            }
             Node canonical = pi.canonical(tool);
             if (canonical != pi) {
                 if (!canonical.isAlive()) {

regex/src/com.oracle.truffle.regex.test/src/com/oracle/truffle/regex/tregex/test/OracleDBTests.java

@@ -1387,6 +1387,7 @@ public void generatedTests() {
         test("()(a*\\1+)*", "", "aaa", 0, true, 0, 3, 0, 0, 3, 3);
         test("(a(\\2b|)?)+\\1c", "", "aaabaaac", 0, true, 0, 8, 5, 6, 6, 6);
         test("((|ab)+?w\\Z|^c)de()d", "", "ffffff", 0, false);
+        test("\u0282\\\ud807\udfdd+\u1cf2", "", "\u0282\ud807\udfdd\ud807\udfdd\u1cf2", 0, true, 0, 13);
         test("(a{1100,1100})\\1", "i", "a".repeat(2400), 0, true, 0, 2200, 0, 1100);
 
         /* GENERATED CODE END - KEEP THIS MARKER FOR AUTOMATIC UPDATES */

regex/src/com.oracle.truffle.regex/src/com/oracle/truffle/regex/tregex/parser/flavors/OracleDBRegexLexer.java

@@ -424,7 +424,7 @@ protected int parseCustomEscapeChar(char c, boolean inCharClass) {
         } else {
             // outside character classes, all escaped characters are simply treated as literals,
             // there are no escape sequences in oracleDB
-            return c;
+            return Character.isHighSurrogate(c) ? finishSurrogatePair(c) : c;
         }
     }
 

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapScanner.java

@@ -174,8 +174,15 @@ public TypeData computeTypeData(AnalysisType type) {
         return data;
     }
 
-    void markTypeInstantiated(AnalysisType type, ScanReason reason) {
+    void markTypeReachable(AnalysisType type, ScanReason reason) {
         if (universe.sealed() && !type.isReachable()) {
+            throw AnalysisError.typeNotFound(type);
+        }
+        type.registerAsReachable(reason);
+    }
+
+    void markTypeInstantiated(AnalysisType type, ScanReason reason) {
+        if (universe.sealed() && !type.isInstantiated()) {
             throw AnalysisError.shouldNotReachHere("Universe is sealed. New type reachable: " + type.toJavaName());
         }
         universe.getBigbang().registerTypeAsInHeap(type, reason);
@@ -254,7 +261,7 @@ protected ImageHeapConstant createImageHeapObject(JavaConstant constant, ScanRea
             newImageHeapConstant = createImageHeapInstance(constant, type, reason);
             AnalysisType typeFromClassConstant = (AnalysisType) constantReflection.asJavaType(constant);
             if (typeFromClassConstant != null) {
-                typeFromClassConstant.registerAsReachable(reason);
+                markTypeReachable(typeFromClassConstant, reason);
             }
         }
         return newImageHeapConstant;
@@ -277,7 +284,7 @@ private ImageHeapArray createImageHeapObjectArray(JavaConstant constant, Analysi
 
     private ImageHeapInstance createImageHeapInstance(JavaConstant constant, AnalysisType type, ScanReason reason) {
         /* We are about to query the type's fields, the type must be marked as reachable. */
-        type.registerAsReachable(reason);
+        markTypeReachable(type, reason);
         ResolvedJavaField[] instanceFields = type.getInstanceFields(true);
         ImageHeapInstance instance = new ImageHeapInstance(type, constant, instanceFields.length);
         for (ResolvedJavaField javaField : instanceFields) {

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

@@ -37,6 +37,7 @@
 import com.oracle.svm.core.heap.PhysicalMemory;
 import com.oracle.svm.core.heap.ReferenceAccess;
 import com.oracle.svm.core.util.TimeUtils;
+import com.oracle.svm.core.util.UnsignedUtils;
 import com.oracle.svm.core.util.VMError;
 
 /** Basic/legacy garbage collection policies. */
@@ -109,9 +110,7 @@ public final UnsignedWord getMaximumHeapSize() {
                 int maximumHeapSizePercent = HeapParameters.getMaximumHeapSizePercent();
                 /* Do not cache because `-Xmx` option parsing may not have happened yet. */
                 UnsignedWord result = physicalMemorySize.unsignedDivide(100).multiply(maximumHeapSizePercent);
-                if (result.belowThan(addressSpaceSize)) {
-                    return result;
-                }
+                return UnsignedUtils.min(result, addressSpaceSize);
             }
             return addressSpaceSize;
         }

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

@@ -55,6 +55,10 @@
  * list. Memory for unaligned chunks is released immediately.
  */
 final class HeapChunkProvider {
+    /** These {@link OutOfMemoryError}s are only needed for legacy code, see GR-59639. */
+    private static final OutOfMemoryError ALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an aligned heap chunk");
+    private static final OutOfMemoryError UNALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an unaligned heap chunk");
+
     /**
      * The head of the linked list of unused aligned chunks. Chunks are chained using
      * {@link HeapChunk#getNext}.
@@ -79,10 +83,6 @@ public UnsignedWord getBytesInUnusedChunks() {
         return numUnusedAlignedChunks.get().multiply(HeapParameters.getAlignedHeapChunkSize());
     }
 
-    private static final OutOfMemoryError ALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an aligned heap chunk");
-
-    private static final OutOfMemoryError UNALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an unaligned heap chunk");
-
     /** Acquire a new AlignedHeapChunk, either from the free list or from the operating system. */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     AlignedHeader produceAlignedChunk() {

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

@@ -109,13 +109,13 @@ public static int getHeapChunkHeaderPadding() {
 
     static int getMaximumYoungGenerationSizePercent() {
         int result = SerialAndEpsilonGCOptions.MaximumYoungGenerationSizePercent.getValue();
-        VMError.guarantee((result >= 0) && (result <= 100), "MaximumYoungGenerationSizePercent should be in [0 ..100]");
+        VMError.guarantee(result >= 0 && result <= 100, "MaximumYoungGenerationSizePercent should be in [0..100]");
         return result;
     }
 
     static int getMaximumHeapSizePercent() {
         int result = SerialAndEpsilonGCOptions.MaximumHeapSizePercent.getValue();
-        VMError.guarantee((result >= 0) && (result <= 100), "MaximumHeapSizePercent should be in [0 ..100]");
+        VMError.guarantee(result >= 0 && result <= 100, "MaximumHeapSizePercent should be in [0..100]");
         return result;
     }
 

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

@@ -194,18 +194,14 @@ void setIdentityHashInField(Object o) {
     @Uninterruptible(reason = "Prevent a GC interfering with the object's identity hash state.", callerMustBe = true)
     @Override
     public void setIdentityHashFromAddress(Pointer ptr, Word currentHeader) {
-        if (GraalDirectives.inIntrinsic()) {
-            ReplacementsUtil.staticAssert(!hasFixedIdentityHashField(), "must always access field");
-        } else {
-            VMError.guarantee(!hasFixedIdentityHashField());
-            assert !hasIdentityHashFromAddress(currentHeader);
-        }
+        VMError.guarantee(!hasFixedIdentityHashField());
+        assert !hasIdentityHashFromAddress(currentHeader) : "must not already have a hashcode";
+
         UnsignedWord fromAddressState = IDHASH_STATE_FROM_ADDRESS.shiftLeft(IDHASH_STATE_SHIFT);
         UnsignedWord newHeader = currentHeader.and(IDHASH_STATE_BITS.not()).or(fromAddressState);
         writeHeaderToObject(ptr.toObjectNonNull(), newHeader);
-        if (!GraalDirectives.inIntrinsic()) {
-            assert hasIdentityHashFromAddress(readHeaderFromObject(ptr));
-        }
+
+        assert hasIdentityHashFromAddress(readHeaderFromPointer(ptr));
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)

substratevm/src/com.oracle.svm.core.windows/src/com/oracle/svm/core/windows/WindowsPhysicalMemorySupportImpl.java

@@ -24,10 +24,13 @@
  */
 package com.oracle.svm.core.windows;
 
+import static com.oracle.svm.core.Uninterruptible.CALLED_FROM_UNINTERRUPTIBLE_CODE;
+
 import org.graalvm.nativeimage.c.struct.SizeOf;
 import org.graalvm.word.UnsignedWord;
 import org.graalvm.word.WordFactory;
 
+import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
 import com.oracle.svm.core.graal.stackvalue.UnsafeStackValue;
 import com.oracle.svm.core.heap.PhysicalMemory.PhysicalMemorySupport;
@@ -37,6 +40,7 @@
 class WindowsPhysicalMemorySupportImpl implements PhysicalMemorySupport {
 
     @Override
+    @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
     public UnsignedWord size() {
         SysinfoAPI.MEMORYSTATUSEX memStatusEx = UnsafeStackValue.get(SysinfoAPI.MEMORYSTATUSEX.class);
         memStatusEx.set_dwLength(SizeOf.get(SysinfoAPI.MEMORYSTATUSEX.class));

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

@@ -429,8 +429,9 @@ private static CCharPointer startsWith(CCharPointer input, CCharPointer prefix)
 
     @Fold
     public static int getOptionIndex(RuntimeOptionKey<?> key) {
-        for (int i = 0; i < OPTIONS.length; i++) {
-            if (OPTIONS[i] == key) {
+        RuntimeOptionKey<?>[] options = OPTIONS;
+        for (int i = 0; i < options.length; i++) {
+            if (options[i] == key) {
                 return i;
             }
         }