Emit IL for AsyncResumptionStub

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/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/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.cs

@@ -237,5 +237,8 @@
         [RequiresPreviewFeatures]
         public static T Await<T>(System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable<T> configuredAwaitable) { throw new NotImplementedException(); }
 #endif
+        [Intrinsic]
+        [BypassReadyToRun]
+        internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic
     }
 }