Ensure that virtual thread code is unreachable when disabled.

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/LayoutEncoding.java

@@ -112,7 +112,7 @@ public static int forInstance(ResolvedJavaType type, int size) {
         guaranteeEncoding(type, size > LAST_SPECIAL_VALUE, "Instance type size must be above special values for encoding: " + size);
         int encoding = size;
         guaranteeEncoding(type, isInstance(encoding), "Instance type encoding must denote an instance");
-        guaranteeEncoding(type, !isStoredContinuation(encoding), "Instance type encoding must not denote a stored continuation");
+        guaranteeEncoding(type, !Continuation.isSupported() || !isStoredContinuation(encoding), "Instance type encoding must not denote a stored continuation");
         guaranteeEncoding(type, !isArray(encoding), "Instance type encoding must not denote an array");
         guaranteeEncoding(type, !isObjectArray(encoding), "Instance type encoding must not denote an object array");
         guaranteeEncoding(type, !isPrimitiveArray(encoding), "Instance type encoding must not denote a primitive array");
@@ -159,7 +159,7 @@ public static UnsignedWord getInstanceSize(int encoding) {
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static boolean isStoredContinuation(int encoding) {
-        return Continuation.isSupported() && encoding == STORED_CONTINUATION_VALUE;
+        return encoding == STORED_CONTINUATION_VALUE;
     }
 
     // May be inlined because it does not deal in Pointers.
@@ -221,7 +221,7 @@ public static UnsignedWord getSizeFromObjectInline(Object obj) {
         int encoding = KnownIntrinsics.readHub(obj).getLayoutEncoding();
         if (isArray(encoding)) {
             return getArraySize(encoding, ArrayLengthNode.arrayLength(obj));
-        } else if (isStoredContinuation(encoding)) {
+        } else if (Continuation.isSupported() && isStoredContinuation(encoding)) {
             return WordFactory.unsigned(StoredContinuationImpl.readSize((StoredContinuation) obj));
         } else {
             return getInstanceSize(encoding);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/ContinuationsFeature.java

@@ -45,19 +45,18 @@
 public class ContinuationsFeature implements Feature {
     @Override
     public void afterRegistration(AfterRegistrationAccess access) {
-        VirtualThreads impl;
         if (Continuation.isSupported()) {
+            VirtualThreads impl;
             if (LoomSupport.isEnabled()) {
                 impl = new LoomVirtualThreads();
             } else {
                 impl = new SubstrateVirtualThreads();
             }
+            ImageSingletons.add(VirtualThreads.class, impl);
         } else {
-            impl = new NoVirtualThreads();
             UserError.guarantee(!SubstrateOptions.UseLoom.getValue(), SubstrateOptionsParser.commandArgument(SubstrateOptions.UseLoom, "+") + " cannot be enabled without option " +
                             SubstrateOptionsParser.commandArgument(SubstrateOptions.SupportContinuations, "+"));
         }
-        ImageSingletons.add(VirtualThreads.class, impl);
     }
 
     @Override
@@ -69,12 +68,15 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
                 RuntimeReflection.register(ReflectionUtil.lookupMethod(ForkJoinPool.class, "compensatedBlock", ForkJoinPool.ManagedBlocker.class));
             }
         } else {
-            access.registerReachabilityHandler(a -> UserError.abort(
-                            "Continuation support is used, but not enabled. Use options " +
-                                            SubstrateOptionsParser.commandArgument(SubstrateOptions.SupportContinuations, "+") +
-                                            " or " + SubstrateOptionsParser.commandArgument(SubstrateOptions.UseLoom, "+") + "."),
-                            StoredContinuationImpl.class,
-                            ReflectionUtil.lookupMethod(NoVirtualThreads.class, "unreachable"));
+            access.registerReachabilityHandler(a -> abortIfUnsupported(), StoredContinuationImpl.class);
+        }
+    }
+
+    static void abortIfUnsupported() {
+        if (!Continuation.isSupported()) {
+            throw UserError.abort("Continuation support is used, but not enabled. Use options " +
+                            SubstrateOptionsParser.commandArgument(SubstrateOptions.SupportContinuations, "+") +
+                            " or " + SubstrateOptionsParser.commandArgument(SubstrateOptions.UseLoom, "+") + ".");
         }
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/JavaThreads.java

@@ -204,7 +204,7 @@ static boolean isInterrupted(Thread thread) {
     }
 
     static boolean getAndClearInterrupt(Thread thread) {
-        if (isVirtual(thread)) {
+        if (supportsVirtual() && isVirtual(thread)) {
             return VirtualThreads.get().getAndClearInterrupt(thread);
         }
         return platformGetAndClearInterrupt(thread);
@@ -272,12 +272,15 @@ public static Thread fromVMThread(IsolateThread thread) {
         return platformThread.get(thread);
     }
 
-    @AlwaysInline("Inline checks.")
+    @Fold
+    static boolean supportsVirtual() {
+        return VirtualThreads.isSupported();
+    }
+
     private static boolean isVirtual(Thread thread) {
-        return VirtualThreads.get().isVirtual(thread);
+        return supportsVirtual() && VirtualThreads.get().isVirtual(thread);
     }
 
-    @AlwaysInline("Inline checks.")
     private static boolean isVirtualDisallowLoom(Thread thread) {
         if (LoomSupport.isEnabled()) {
             assert !isVirtual(thread) : "should not see Loom virtual thread objects here";
@@ -323,7 +326,7 @@ static void join(Thread thread, long millis) throws InterruptedException {
         if (millis < 0) {
             throw new IllegalArgumentException("timeout value is negative");
         }
-        if (isVirtual(thread)) {
+        if (supportsVirtual() && isVirtual(thread)) {
             VirtualThreads.get().join(thread, millis);
             return;
         }
@@ -709,7 +712,7 @@ protected void beforeThreadRun(@SuppressWarnings("unused") Thread thread) {
     protected abstract void platformYield();
 
     void yield() {
-        if (isVirtualDisallowLoom(Thread.currentThread())) {
+        if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {
             VirtualThreads.get().yield();
         } else {
             platformYield();
@@ -914,7 +917,7 @@ static void platformUnpark(Thread thread) {
     }
 
     static void sleep(long millis) throws InterruptedException {
-        if (isVirtualDisallowLoom(Thread.currentThread())) {
+        if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {
             VirtualThreads.get().sleepMillis(millis);
         } else {
             platformSleep(millis);
@@ -986,7 +989,7 @@ static void platformInterrupt(Thread thread) {
     }
 
     static boolean isAlive(Thread thread) {
-        if (isVirtualDisallowLoom(thread)) {
+        if (supportsVirtual() && isVirtualDisallowLoom(thread)) {
             return VirtualThreads.get().isAlive(thread);
         }
         return platformIsAlive(thread);
@@ -1009,7 +1012,7 @@ static ThreadData getCurrentThreadData() {
 
     @Uninterruptible(reason = "Called from uninterruptible code.")
     public static void setCurrentThreadLockHelper(Object root) {
-        if (VirtualThreads.get().isSupported()) {
+        if (supportsVirtual()) {
             toTarget(Thread.currentThread()).lockHelper = root;
         } else {
             lockHelper.set(root);
@@ -1019,7 +1022,7 @@ public static void setCurrentThreadLockHelper(Object root) {
     @AlwaysInline("Locking fast path.")
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static Object getCurrentThreadLockHelper() {
-        if (VirtualThreads.get().isSupported()) {
+        if (supportsVirtual()) {
             return toTarget(platformThread.get()).lockHelper;
         }
         return lockHelper.get();

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/LoomVirtualThreads.java

@@ -28,36 +28,27 @@
 
 import java.util.concurrent.ThreadFactory;
 
-import org.graalvm.compiler.api.replacements.Fold;
+import org.graalvm.nativeimage.Platforms;
 
 import com.oracle.svm.core.SubstrateUtil;
-import com.oracle.svm.core.annotate.AlwaysInline;
 import com.oracle.svm.core.util.VMError;
 
 /**
  * Code specific to virtual threads is part of the {@link Thread} methods, e.g. {@code yield} or
  * {@code sleep}, and the implementation for platform threads generally in {@code yield0} or
  * {@code sleep0}, so we only substitute this platform thread code in
- * {@link Target_java_lang_Thread}, and never expect these methods to be reachable, therefore
- * extending {@link NoVirtualThreads}.
+ * {@link Target_java_lang_Thread}, and never expect these methods to be reachable.
  */
-final class LoomVirtualThreads extends NoVirtualThreads {
+final class LoomVirtualThreads implements VirtualThreads {
     private static Target_java_lang_VirtualThread cast(Thread thread) {
         return SubstrateUtil.cast(thread, Target_java_lang_VirtualThread.class);
     }
 
-    @Fold
-    @Override
-    public boolean isSupported() {
-        return true;
-    }
-
     @Override
     public ThreadFactory createFactory() {
         throw VMError.unimplemented();
     }
 
-    @AlwaysInline("Eliminate code handling virtual threads.")
     @Override
     public boolean isVirtual(Thread thread) {
         return Target_java_lang_VirtualThread.class.isInstance(thread);
@@ -70,4 +61,59 @@ public void join(Thread thread, long millis) throws InterruptedException {
             cast(thread).joinNanos(nanos);
         }
     }
+
+    @Platforms({}) // error if reachable
+    private static RuntimeException unreachable() {
+        return VMError.shouldNotReachHere();
+    }
+
+    @Override
+    public boolean getAndClearInterrupt(Thread thread) {
+        throw unreachable();
+    }
+
+    @Override
+    public void yield() {
+        throw unreachable();
+    }
+
+    @Override
+    public void sleepMillis(long millis) {
+        throw unreachable();
+    }
+
+    @Override
+    public boolean isAlive(Thread thread) {
+        throw unreachable();
+    }
+
+    @Override
+    public void unpark(Thread thread) {
+        throw unreachable();
+    }
+
+    @Override
+    public void park() {
+        throw unreachable();
+    }
+
+    @Override
+    public void parkNanos(long nanos) {
+        throw unreachable();
+    }
+
+    @Override
+    public void parkUntil(long deadline) {
+        throw unreachable();
+    }
+
+    @Override
+    public void pinCurrent() {
+        throw unreachable();
+    }
+
+    @Override
+    public void unpinCurrent() {
+        throw unreachable();
+    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/NoVirtualThreads.java

@@ -31,8 +31,6 @@
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 
-import org.graalvm.compiler.api.replacements.Fold;
-
 /** Our own implementation of virtual threads that does not need Project Loom. */
 final class SubstrateVirtualThreads implements VirtualThreads {
     private static final class CarrierThread extends ForkJoinWorkerThread {
@@ -58,12 +56,6 @@ private static SubstrateVirtualThread current() {
         return (SubstrateVirtualThread) Thread.currentThread();
     }
 
-    @Fold
-    @Override
-    public boolean isSupported() {
-        return true;
-    }
-
     @Override
     public ThreadFactory createFactory() {
         return task -> new SubstrateVirtualThread(null, task);