8307125: compiler/jvmci/compilerToVM/MaterializeVirtualObjectTest.java hits assert(!Continuation::is_frame_in_continuation(thread(), fr())) failed: No support for deferred values in continuations

Reviewed-by: never

Author: Doug Simon

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/code/stack/InspectedFrame.java

@@ -51,6 +51,10 @@ public interface InspectedFrame {
     /**
      * This method will materialize all virtual objects, deoptimize the stack frame and make sure
      * that subsequent execution of the deoptimized frame uses the materialized values.
+     *
+     * @see StackIntrospection#canMaterializeVirtualObjects
+     * @throws IllegalArgumentException if stack introspection does not support
+     *             materialization of virtual objects for this frame
      */
     void materializeVirtualObjects(boolean invalidateCode);
 

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/code/stack/StackIntrospection.java

@@ -43,4 +43,12 @@ public interface StackIntrospection {
      *         should stop), or null if the whole stack was iterated.
      */
     <T> T iterateFrames(ResolvedJavaMethod[] initialMethods, ResolvedJavaMethod[] matchingMethods, int initialSkip, InspectedFrameVisitor<T> visitor);
+
+    /**
+     * Determines if {@link InspectedFrame#materializeVirtualObjects(boolean)} can be called for frames
+     * visited by {@link #iterateFrames}.
+     */
+    default boolean canMaterializeVirtualObjects() {
+        return true;
+    }
 }

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotStackFrameReference.java

@@ -63,6 +63,9 @@ public boolean isVirtual(int index) {
 
     @Override
     public void materializeVirtualObjects(boolean invalidateCode) {
+        if (Thread.currentThread().isVirtual()) {
+            throw new IllegalArgumentException("cannot materialize frames of a virtual thread");
+        }
         compilerToVM.materializeVirtualObjects(this, invalidateCode);
     }
 

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotStackIntrospection.java

@@ -39,4 +39,10 @@ public <T> T iterateFrames(ResolvedJavaMethod[] initialMethods, ResolvedJavaMeth
         CompilerToVM compilerToVM = runtime.getCompilerToVM();
         return compilerToVM.iterateFrames(initialMethods, matchingMethods, initialSkip, visitor);
     }
+
+    @Override
+    public boolean canMaterializeVirtualObjects() {
+        // Virtual threads do not support materializing locals (JDK-8307125)
+        return !Thread.currentThread().isVirtual();
+    }
 }

test/hotspot/jtreg/ProblemList-Virtual.txt

@@ -24,7 +24,6 @@
 ####
 # Bugs
 
-compiler/jvmci/compilerToVM/MaterializeVirtualObjectTest.java 8307125 generic-all
 serviceability/AsyncGetCallTrace/MyPackage/ASGCTBaseTest.java 8308026 generic-all
 serviceability/jvmti/GetThreadListStackTraces/OneGetThreadListStackTraces.java 8308027 generic-all
 serviceability/jvmti/Heap/IterateHeapWithEscapeAnalysisEnabled.java 8264699 generic-all

test/hotspot/jtreg/compiler/jvmci/common/patches/jdk.internal.vm.ci/jdk/vm/ci/hotspot/CompilerToVMHelper.java

@@ -277,11 +277,6 @@ public static <T> T iterateFrames(
         return CTVM.iterateFrames(initialMethods, matchingMethods, initialSkip, visitor);
     }
 
-    public static void materializeVirtualObjects(
-            HotSpotStackFrameReference stackFrame, boolean invalidate) {
-        CTVM.materializeVirtualObjects(stackFrame, invalidate);
-    }
-
     public static int getVtableIndexForInterfaceMethod(HotSpotResolvedObjectType type,
             HotSpotResolvedJavaMethod method) {
         return CTVM.getVtableIndexForInterfaceMethod((HotSpotResolvedObjectTypeImpl) type, (HotSpotResolvedJavaMethodImpl) method);

test/hotspot/jtreg/compiler/jvmci/compilerToVM/MaterializeVirtualObjectTest.java

@@ -157,7 +157,11 @@ public static void main(String[] args) {
             throw new SkippedException("Test needs compilation level 4");
         }
 
-        new MaterializeVirtualObjectTest().test();
+        try {
+            new MaterializeVirtualObjectTest().test();
+        } catch (MaterializationNotSupported e) {
+            Asserts.assertTrue(Thread.currentThread().isVirtual());
+        }
     }
 
     private static String getName() {
@@ -168,7 +172,6 @@ private static String getName() {
     }
 
     private void test() {
-        System.out.println(getName());
         Asserts.assertFalse(WB.isMethodCompiled(MATERIALIZED_METHOD),
                 getName() + " : materialized method is compiled");
         Asserts.assertFalse(WB.isMethodCompiled(NOT_MATERIALIZED_METHOD),
@@ -230,6 +233,14 @@ private void recurse(int depth, int iteration) {
         }
     }
 
+    private static void materializeVirtualObjects(InspectedFrame f, boolean invalidateCode) {
+        try {
+            f.materializeVirtualObjects(invalidateCode);
+        } catch (IllegalArgumentException e) {
+            throw new MaterializationNotSupported(e);
+        }
+    }
+
     private void checkStructure(boolean materialize) {
         boolean[] framesSeen = new boolean[2];
         Object[] helpers = new Object[1];
@@ -248,7 +259,7 @@ private void checkStructure(boolean materialize) {
                     Asserts.assertEQ(((Helper) f.getLocal(3)).string, "foo", "innerHelper.string should be foo");
                     helpers[0] = f.getLocal(1);
                     if (materialize) {
-                        f.materializeVirtualObjects(false);
+                        materializeVirtualObjects(f, false);
                     }
                     return null; //continue
                 } else {
@@ -306,7 +317,7 @@ private void check(int iteration) {
             Asserts.assertTrue(notMaterialized.hasVirtualObjects(), getName()
                     + ": notMaterialized frame has no virtual object before materialization");
             // materialize
-            CompilerToVMHelper.materializeVirtualObjects(materialized, INVALIDATE);
+            materializeVirtualObjects(materialized, INVALIDATE);
             // check that only not materialized frame has virtual objects
             Asserts.assertFalse(materialized.hasVirtualObjects(), getName()
                     + " : materialized has virtual object after materialization");
@@ -331,4 +342,10 @@ public Helper(String s) {
             this.string = s;
         }
     }
+
+    static class MaterializationNotSupported extends RuntimeException {
+        public MaterializationNotSupported(Throwable cause) {
+            super(cause);
+        }
+    }
 }