8380921: [lworld] compiler/stable/TestStableArrayMembars.java IR mismatch with preview enabled

Reviewed-by: thartmann

Author: mhaessig

src/hotspot/share/opto/compile.cpp

@@ -2002,7 +2002,7 @@ static bool return_val_keeps_allocations_alive(Node* ret_val) {
                n->in(1)->is_Proj() &&
                n->in(1)->in(0)->is_Allocate()) {
       some_allocations = true;
-    } else if (n->is_CheckCastPP()) {
+    } else if (n->is_CheckCastPP() || n->is_CastPP()) {
       wq.push(n->in(1));
     }
   }
@@ -3275,10 +3275,13 @@ void Compile::Optimize() {
     if (failing()) {
       return;
     }
-    process_inline_types(igvn);
   }
   assert(_late_inlines.length() == 0, "late inline queue must be drained");
 
+  // Process inline types before macro expansion. Otherwise, we will not be able to
+  // remove unused allocations because it cannot match the expanded allocation.
+  process_inline_types(igvn);
+
   {
     TracePhase tp(_t_macroExpand);
     PhaseMacroExpand mex(igvn);

test/hotspot/jtreg/ProblemList-enable-preview.txt

@@ -39,7 +39,6 @@
 compiler/c2/ReachabilityFenceFlagsTest.java                                                      8382503 generic-all
 compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaField.java      8372605 generic-all
 compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java       8372605 generic-all
-compiler/stable/TestStableArrayMembars.java                                                      8380921 generic-all
 
 # Runtime:
 runtime/cds/appcds/aotCode/AOTCodeFlags.java#default_gc 8382398 generic-all

test/hotspot/jtreg/compiler/stable/TestStableArrayMembars.java

@@ -27,27 +27,40 @@
  * @summary Test that membars are eliminated when loading from a stable array.
  * @library /test/lib /
  * @modules java.base/jdk.internal.misc
+ * @modules java.base/jdk.internal.value
  * @modules java.base/jdk.internal.vm.annotation
  * @run driver ${test.main.class}
  */
 
 package compiler.stable;
 
 import java.util.Objects;
+import java.util.Set;
 
 import jdk.internal.misc.Unsafe;
+import jdk.internal.value.ValueClass;
 import jdk.internal.vm.annotation.Stable;
 
+import jdk.test.lib.Asserts;
 import compiler.lib.ir_framework.*;
 
 public class TestStableArrayMembars {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
 
+    private static final int THE_VALUE = 42;
+
     public static void main(String[] args) {
         TestFramework tf = new TestFramework();
         tf.addTestClassesToBootClassPath();
-        tf.addFlags( "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED");
+        tf.addFlags("--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",
+                    "--add-exports=java.base/jdk.internal.value=ALL-UNNAMED");
+        if (Integer.class.isValue()) {
+            tf.addCrossProductScenarios(Set.of("", "-XX:-UseArrayFlattening",
+                                               "-XX:-UseArrayFlattening -XX:-InlineTypePassFieldsAsArgs",
+                                               "-XX:-UseArrayFlattening -XX:-InlineTypeReturnedAsFields",
+                                               "-XX:-UseArrayFlattening -XX:-InlineTypePassFieldsAsArgs -XX:-InlineTypeReturnedAsFields"));
+        }
         tf.start();
     }
 
@@ -61,45 +74,70 @@ static final class LazyIntArray {
 
         @ForceInline
         Integer get(int idx) {
-            Integer i = contentsAcquire(offsetFor(idx));
+            Integer i = contentsAcquire(offsetFor(arr, idx));
             return i == null ? slowPath(arr, idx) : i;
         }
 
         @ForceInline
         private Integer contentsAcquire(long offset) {
-            return (Integer) UNSAFE.getReferenceAcquire(arr, offset);
+            return (Integer) (ValueClass.isFlatArray(arr) ?
+                UNSAFE.getFlatValueAcquire(arr, offset, UNSAFE.arrayLayout(arr), Integer.class) :
+                UNSAFE.getReferenceAcquire(arr, offset));
         }
 
         @ForceInline
-        private static long offsetFor(long index) {
-            return Unsafe.ARRAY_OBJECT_BASE_OFFSET + Unsafe.ARRAY_OBJECT_INDEX_SCALE * index;
+        private static long offsetFor(Integer[] arr, long index) {
+            return UNSAFE.arrayInstanceBaseOffset(arr) + UNSAFE.arrayInstanceIndexScale(arr) * index;
         }
 
         static Integer slowPath(final Integer[] array, final int index) {
-            final long offset = offsetFor(index);
+            final long offset = offsetFor(array, index);
             final Integer t = array[index];
             if (t == null) {
-                final Integer newValue = Integer.valueOf(42);
+                final Integer newValue = Integer.valueOf(THE_VALUE);
                 Objects.requireNonNull(newValue);
-                set(array, index, newValue);
+                set(array, index, offset, newValue);
 
                 return newValue;
             }
             return t;
         }
 
-        static void set(Integer[] array, int index, Integer newValue) {
+        static void set(Integer[] array, int index, long offset, Integer newValue) {
             if (array[index] == null) {
-                UNSAFE.putReferenceRelease(array, Unsafe.ARRAY_OBJECT_BASE_OFFSET + Unsafe.ARRAY_OBJECT_INDEX_SCALE * (long) index, newValue);
+                if (!ValueClass.isFlatArray(array)) {
+                    UNSAFE.putReferenceRelease(array, offset, newValue);
+                } else {
+                    UNSAFE.putFlatValueRelease(array, offset, UNSAFE.arrayLayout(array), Integer.class, newValue);
+                }
             }
         }
     }
 
     static final LazyIntArray la = new LazyIntArray();
 
     @Test
-    @IR(failOn = { IRNode.LOAD, IRNode.MEMBAR })
+    // We cannot eliminate all barriers with flat arrays, because Unsafe.getFlatValueAcquire()
+    // explicitly adds a loadFence() in Java. Hence, there is no way for C2 to correlate those
+    // barriers to an eliminated memory access and thus no way to remove them.
+    // The barrier elimination only works with tiered compilation as the profiling information
+    // is nessecary to inline the low-frequency Unsafe.put* methods.
+    @IR(failOn = { IRNode.LOAD, IRNode.MEMBAR },
+        applyIfAnd = {"enable-valhalla", "false",
+                      "TieredCompilation", "true"})
+    @IR(failOn = { IRNode.LOAD, IRNode.MEMBAR },
+        applyIfAnd = {"UseArrayFlattening", "false",
+                      "TieredCompilation", "true"})
+    @IR(counts = { IRNode.MEMBAR, ">0",
+                   IRNode.LOAD, "=1"}, // There is exactly one load fence, but no load
+        applyIfAnd = {"enable-valhalla", "true",
+                      "UseArrayFlattening", "true"})
     static Integer test() {
         return la.get(0);
     }
+
+    @Check(test = "test")
+    static void check(Integer testResult) {
+        Asserts.assertEQ(THE_VALUE, testResult.intValue(), "Incorrect result from LazyIntArray");
+    }
 }