Emit IL for AsyncResumptionStub

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

@@ -150,6 +150,10 @@ public static partial class AsyncHelpers
         [Intrinsic]
         private static void AsyncSuspend(Continuation continuation) => throw new UnreachableException();
 
+        [Intrinsic]
+        [BypassReadyToRun]
+        internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic
+
         // Used during suspensions to hold the continuation chain and on what we are waiting.
         // Methods like FinalizeTaskReturningThunk will unlink the state and wrap into a Task.
         private struct RuntimeAsyncAwaitState

src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs

@@ -1610,9 +1610,6 @@ internal static void MulticastDebuggerTraceHelper(object o, int count)
 
         [Intrinsic]
         internal static IntPtr NextCallReturnAddress() => throw new UnreachableException(); // Unconditionally expanded intrinsic
-
-        [Intrinsic]
-        internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic
     }  // class StubHelpers
 
 #if FEATURE_COMINTEROP

src/coreclr/jit/gentree.cpp

@@ -2265,7 +2265,7 @@ bool GenTreeCall::HasSideEffects(Compiler* compiler, bool ignoreExceptions, bool
 //   those cases the JIT does not know (and does not need to know) which arg is
 //   the async continuation.
 //
-//   The VM also uses the StubHelpers.AsyncCallContinuation() intrinsic in the
+//   The VM also uses the AsyncHelpers.AsyncCallContinuation() intrinsic in the
 //   stubs discussed above. The JIT must take care in those cases to still mark
 //   the preceding call as an async call; this is required for correct LSRA
 //   behavior and GC reporting around the returned async continuation. This is

src/coreclr/jit/importercalls.cpp

@@ -3323,7 +3323,7 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE    clsHnd,
         return new (this, GT_LABEL) GenTree(GT_LABEL, TYP_I_IMPL);
     }
 
-    if (ni == NI_System_StubHelpers_AsyncCallContinuation)
+    if (ni == NI_System_Runtime_CompilerServices_AsyncHelpers_AsyncCallContinuation)
     {
         GenTree* node = new (this, GT_ASYNC_CONTINUATION) GenTree(GT_ASYNC_CONTINUATION, TYP_REF);
         node->SetHasOrderingSideEffect();
@@ -10872,6 +10872,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                             {
                                 result = NI_System_Runtime_CompilerServices_AsyncHelpers_Await;
                             }
+                            else if (strcmp(methodName, "AsyncCallContinuation") == 0)
+                            {
+                                result = NI_System_Runtime_CompilerServices_AsyncHelpers_AsyncCallContinuation;
+                            }
                         }
                         else if (strcmp(className, "StaticsHelpers") == 0)
                         {
@@ -11129,10 +11133,6 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                         {
                             result = NI_System_StubHelpers_NextCallReturnAddress;
                         }
-                        else if (strcmp(methodName, "AsyncCallContinuation") == 0)
-                        {
-                            result = NI_System_StubHelpers_AsyncCallContinuation;
-                        }
                     }
                 }
                 else if (strcmp(namespaceName, "Text") == 0)

src/coreclr/jit/namedintrinsiclist.h

@@ -107,7 +107,6 @@ enum NamedIntrinsic : unsigned short
     NI_System_RuntimeType_get_TypeHandle,
     NI_System_StubHelpers_GetStubContext,
     NI_System_StubHelpers_NextCallReturnAddress,
-    NI_System_StubHelpers_AsyncCallContinuation,
 
     NI_Array_Address,
     NI_Array_Get,
@@ -126,6 +125,7 @@ enum NamedIntrinsic : unsigned short
 
     NI_System_Runtime_CompilerServices_AsyncHelpers_AsyncSuspend,
     NI_System_Runtime_CompilerServices_AsyncHelpers_Await,
+    NI_System_Runtime_CompilerServices_AsyncHelpers_AsyncCallContinuation,
 
     NI_System_Runtime_CompilerServices_StaticsHelpers_VolatileReadAsByref,
 

src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncResumptionStub.cs

@@ -18,8 +18,7 @@ public partial class AsyncResumptionStub : ILStubMethod
 
         public AsyncResumptionStub(MethodDesc owningMethod)
         {
-            Debug.Assert(owningMethod.IsAsyncVariant()
-                || (owningMethod.IsAsync && !owningMethod.Signature.ReturnsTaskOrValueTask()));
+            Debug.Assert(owningMethod.IsAsyncCall());
             _owningMethod = owningMethod;
         }
 
@@ -41,13 +40,62 @@ private MethodSignature InitializeSignature()
 
         public override MethodIL EmitIL()
         {
-            var emitter = new ILEmitter();
-            ILCodeStream codeStream = emitter.NewCodeStream();
+            ILEmitter ilEmitter = new ILEmitter();
+            ILCodeStream ilStream = ilEmitter.NewCodeStream();
 
-            // TODO: match getAsyncResumptionStub from CoreCLR VM
-            codeStream.EmitCallThrowHelper(emitter, Context.GetHelperEntryPoint("ThrowHelpers"u8, "ThrowNotSupportedException"u8));
+            // Ported from jitinterface.cpp CEEJitInfo::getAsyncResumptionStub
+            if (!_owningMethod.Signature.IsStatic)
+            {
+                if (_owningMethod.OwningType.IsValueType)
+                {
+                    ilStream.EmitLdc(0);
+                    ilStream.Emit(ILOpcode.conv_u);
+                }
+                else
+                {
+                    ilStream.Emit(ILOpcode.ldnull);
+                }
+            }
 
-            return emitter.Link(this);
+            foreach (var param in _owningMethod.Signature)
+            {
+                var local = ilEmitter.NewLocal(param);
+                ilStream.EmitLdLoca(local);
+                ilStream.Emit(ILOpcode.initobj, ilEmitter.NewToken(param));
+                ilStream.EmitLdLoc(local);
+            }
+            ilStream.Emit(ILOpcode.ldftn, ilEmitter.NewToken(_owningMethod));
+            ilStream.Emit(ILOpcode.calli, ilEmitter.NewToken(this.Signature));
+
+            bool returnsVoid = _owningMethod.Signature.ReturnType != Context.GetWellKnownType(WellKnownType.Void);
+            Internal.IL.Stubs.ILLocalVariable resultLocal = default;
+            if (!returnsVoid)
+            {
+                resultLocal = ilEmitter.NewLocal(_owningMethod.Signature.ReturnType);
+                ilStream.EmitStLoc(resultLocal);
+            }
+
+            MethodDesc asyncCallContinuation = Context.SystemModule.GetKnownType("System.Runtime.CompilerServices"u8, "AsyncHelpers"u8)
+                .GetKnownMethod("AsyncCallContinuation"u8, null);
+            TypeDesc continuation = Context.SystemModule.GetKnownType("System.Runtime.CompilerServices"u8, "Continuation"u8);
+            var newContinuationLocal = ilEmitter.NewLocal(continuation);
+            ilStream.Emit(ILOpcode.call, ilEmitter.NewToken(asyncCallContinuation));
+            ilStream.EmitStLoc(newContinuationLocal);
+
+            if (!returnsVoid)
+            {
+                var doneResult = ilEmitter.NewCodeLabel();
+                ilStream.EmitLdLoca(newContinuationLocal);
+                ilStream.Emit(ILOpcode.brtrue, doneResult);
+                ilStream.EmitLdArg(1);
+                ilStream.EmitLdLoc(resultLocal);
+                ilStream.Emit(ILOpcode.stobj, ilEmitter.NewToken(_owningMethod.Signature.ReturnType));
+                ilStream.EmitLabel(doneResult);
+            }
+            ilStream.EmitLdLoc(newContinuationLocal);
+            ilStream.Emit(ILOpcode.ret);
+
+            return ilEmitter.Link(this);
         }
     }
 }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj

@@ -45,6 +45,9 @@
     <Compile Include="..\..\Common\System\FormattingHelpers.cs" Link="Common\FormattingHelpers.cs" />
     <Compile Include="..\..\Common\TypeSystem\IL\ILProvider.cs" Link="IL\ILProvider.cs" />
     <Compile Include="..\..\Common\TypeSystem\IL\ILReader.cs" Link="IL\ILReader.cs" />
+    <Compile Include="..\..\Common\TypeSystem\IL\Stubs\AsyncResumptionStub.cs" Link="IL\Stubs\AsyncResumptionStub.cs" />
+    <Compile Include="..\..\Common\TypeSystem\IL\Stubs\AsyncResumptionStub.Sorting.cs" Link="IL\Stubs\AsyncResumptionStub.Sorting.cs" />
+    <Compile Include="..\..\Common\TypeSystem\IL\Stubs\AsyncResumptionStub.Mangling.cs" Link="IL\Stubs\AsyncResumptionStub.Mangling.cs" />
     <Compile Include="..\..\Common\TypeSystem\IL\Stubs\ComparerIntrinsics.cs" Link="IL\Stubs\ComparerIntrinsics.cs" />
     <Compile Include="..\..\Common\TypeSystem\IL\Stubs\InterlockedIntrinsics.cs" Link="IL\Stubs\InterlockedIntrinsics.cs" />
     <Compile Include="..\..\Common\TypeSystem\IL\Stubs\RuntimeHelpersIntrinsics.cs" Link="IL\Stubs\RuntimeHelpersIntrinsics.cs" />

src/coreclr/vm/corelib.h

@@ -747,8 +747,9 @@ DEFINE_METHOD(ASYNC_HELPERS,      COMPLETED_TASK,            CompletedTask, NoSi
 DEFINE_METHOD(ASYNC_HELPERS,      CAPTURE_EXECUTION_CONTEXT, CaptureExecutionContext, NoSig)
 DEFINE_METHOD(ASYNC_HELPERS,      RESTORE_EXECUTION_CONTEXT, RestoreExecutionContext, NoSig)
 DEFINE_METHOD(ASYNC_HELPERS,      CAPTURE_CONTINUATION_CONTEXT, CaptureContinuationContext, NoSig)
-DEFINE_METHOD(ASYNC_HELPERS,      CAPTURE_CONTEXTS, CaptureContexts, NoSig)
-DEFINE_METHOD(ASYNC_HELPERS,      RESTORE_CONTEXTS, RestoreContexts, NoSig)
+DEFINE_METHOD(ASYNC_HELPERS,      CAPTURE_CONTEXTS,          CaptureContexts, NoSig)
+DEFINE_METHOD(ASYNC_HELPERS,      RESTORE_CONTEXTS,          RestoreContexts, NoSig)
+DEFINE_METHOD(ASYNC_HELPERS,      ASYNC_CALL_CONTINUATION,   AsyncCallContinuation, SM_RetContinuation)
 
 #ifdef TARGET_BROWSER
 DEFINE_METHOD(ASYNC_HELPERS,      HANDLE_ASYNC_ENTRYPOINT, HandleAsyncEntryPoint, SM_TaskOfInt_RetInt)
@@ -1098,7 +1099,6 @@ DEFINE_METHOD(STUBHELPERS,          VALIDATE_BYREF,                     Validate
 DEFINE_METHOD(STUBHELPERS,          GET_STUB_CONTEXT,                   GetStubContext,                 SM_RetIntPtr)
 DEFINE_METHOD(STUBHELPERS,          LOG_PINNED_ARGUMENT,                LogPinnedArgument,              SM_IntPtr_IntPtr_RetVoid)
 DEFINE_METHOD(STUBHELPERS,          NEXT_CALL_RETURN_ADDRESS,           NextCallReturnAddress,          SM_RetIntPtr)
-DEFINE_METHOD(STUBHELPERS,          ASYNC_CALL_CONTINUATION,            AsyncCallContinuation,          SM_RetContinuation)
 DEFINE_METHOD(STUBHELPERS,          SAFE_HANDLE_ADD_REF,    SafeHandleAddRef,           SM_SafeHandle_RefBool_RetIntPtr)
 DEFINE_METHOD(STUBHELPERS,          SAFE_HANDLE_RELEASE,    SafeHandleRelease,          SM_SafeHandle_RetVoid)