[RuntimeAsync] Follow up for unboxing and instantiating stubs. (#118301)

VSadov · jakobbotsch · web-flow · commit 2fa82a2f17b2 · 2025-08-12T18:50:46.000-07:00
* Support continuation arg in the portable arg shuffler

* Unboxing stubs in IL

* Instantiating stubs in IL

* fix for x86

* keep the modreq

* TOKEN_ILSTUB_TARGET_SIG_ASYNC

* Insert null continuation arg on VM side

* undo unnecessary test changes

* typo fix lost in rebase

---------

Co-authored-by: Jakob Botsch Nielsen &lt;jakob.botsch.nielsen@gmail.com&gt;
diff --git a/src/coreclr/inc/corhdr.h b/src/coreclr/inc/corhdr.h
@@ -975,7 +975,8 @@ typedef enum CorCallingConvention
     IMAGE_CEE_CS_CALLCONV_UNMANAGED     = 0x9,  // Unmanaged calling convention encoded as modopts
     IMAGE_CEE_CS_CALLCONV_GENERICINST   = 0xa,  // generic method instantiation
     IMAGE_CEE_CS_CALLCONV_NATIVEVARARG  = 0xb,  // used ONLY for 64bit vararg PInvoke calls
-    IMAGE_CEE_CS_CALLCONV_MAX           = 0xc,  // first invalid calling convention
+    IMAGE_CEE_CS_CALLCONV_ASYNC         = 0xc,  // used for calli in IL stubs
+    IMAGE_CEE_CS_CALLCONV_MAX           = 0xd,  // first invalid calling convention
 
 
         // The high bits of the calling convention convey additional info
diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp
@@ -701,6 +701,11 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
                 JITDUMP("  Continuation continues on thread pool\n");
             }
         }
+        else if (opcode == CEE_CALLI)
+        {
+            // Used for unboxing/instantiating stubs
+            JITDUMP("Call is an async calli\n");
+        }
         else
         {
             JITDUMP("Call is an async non-task await\n");
@@ -917,7 +922,9 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
                                                            .WellKnown(WellKnownArg::VarArgsCookie));
             }
 
-            if (call->AsCall()->IsAsync())
+            // Add async continuation arg. For calli these are used for IL
+            // stubs and the VM inserts the arg itself.
+            if (call->AsCall()->IsAsync() && (opcode != CEE_CALLI))
             {
                 call->AsCall()->gtArgs.PushFront(this, NewCallArg::Primitive(gtNewNull(), TYP_REF)
                                                            .WellKnown(WellKnownArg::AsyncContinuation));
@@ -931,7 +938,9 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         }
         else
         {
-            if (call->AsCall()->IsAsync())
+            // Add async continuation arg. For calli these are used for IL
+            // stubs and the VM inserts the arg itself.
+            if (call->AsCall()->IsAsync() && (opcode != CEE_CALLI))
             {
                 call->AsCall()->gtArgs.PushBack(this, NewCallArg::Primitive(gtNewNull(), TYP_REF)
                                                           .WellKnown(WellKnownArg::AsyncContinuation));
diff --git a/src/coreclr/vm/callingconvention.h b/src/coreclr/vm/callingconvention.h
@@ -676,6 +676,7 @@ class ArgIteratorTemplate : public ARGITERATOR_BASE
     // explicit arguments have been scanned is platform dependent.
     void GetThisLoc(ArgLocDesc * pLoc) { WRAPPER_NO_CONTRACT; GetSimpleLoc(GetThisOffset(), pLoc); }
     void GetParamTypeLoc(ArgLocDesc * pLoc) { WRAPPER_NO_CONTRACT; GetSimpleLoc(GetParamTypeArgOffset(), pLoc); }
+    void GetAsyncContinuationLoc(ArgLocDesc * pLoc) { WRAPPER_NO_CONTRACT; GetSimpleLoc(GetAsyncContinuationArgOffset(), pLoc); }
     void GetVASigCookieLoc(ArgLocDesc * pLoc) { WRAPPER_NO_CONTRACT; GetSimpleLoc(GetVASigCookieOffset(), pLoc); }
 
 #ifndef CALLDESCR_RETBUFFARGREG
diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp
@@ -475,6 +475,18 @@ BOOL GenerateShuffleArrayPortable(MethodDesc* pMethodSrc, MethodDesc *pMethodDst
 #endif // !defined(TARGET_ARM64) || !defined(CALLDESCR_RETBUFFARGREG)
     }
 
+    // Handle async continuation argument.
+    _ASSERTE(!!sArgPlacerDst.HasAsyncContinuation() == !!sArgPlacerSrc.HasAsyncContinuation());
+    if (sArgPlacerDst.HasAsyncContinuation())
+    {
+        // The async continuation is implicit in both signatures.
+        sArgPlacerSrc.GetAsyncContinuationLoc(&sArgSrc);
+        sArgPlacerDst.GetAsyncContinuationLoc(&sArgDst);
+
+        if (!AddNextShuffleEntryToArray(sArgSrc, sArgDst, pShuffleEntryArray, shuffleType))
+            return FALSE;
+    }
+
     // Iterate all the regular arguments. mapping source registers and stack locations to the corresponding
     // destination locations.
     while ((ofsSrc = sArgPlacerSrc.GetNextOffset()) != TransitionBlock::InvalidOffset)
diff --git a/src/coreclr/vm/ilstubcache.cpp b/src/coreclr/vm/ilstubcache.cpp
@@ -70,7 +70,7 @@ void CreateModuleIndependentSignature(LoaderHeap* pCreationHeap,
 // static
 MethodDesc* ILStubCache::CreateAndLinkNewILStubMethodDesc(LoaderAllocator* pAllocator, MethodTable* pMT, DWORD dwStubFlags,
                                              Module* pSigModule, PCCOR_SIGNATURE pSig, DWORD cbSig, SigTypeContext *pTypeContext,
-                                             ILStubLinker* pStubLinker)
+                                             ILStubLinker* pStubLinker, BOOL isAsync /* = FALSE */)
 {
     CONTRACT (MethodDesc*)
     {
@@ -86,6 +86,7 @@ MethodDesc* ILStubCache::CreateAndLinkNewILStubMethodDesc(LoaderAllocator* pAllo
                                                            dwStubFlags,
                                                            pSigModule,
                                                            pSig, cbSig,
+                                                           isAsync,
                                                            pTypeContext,
                                                            &amTracker);
 
@@ -143,7 +144,7 @@ namespace
 
 // static
 MethodDesc* ILStubCache::CreateNewMethodDesc(LoaderHeap* pCreationHeap, MethodTable* pMT, DWORD dwStubFlags,
-                                             Module* pSigModule, PCCOR_SIGNATURE pSig, DWORD cbSig, SigTypeContext *pTypeContext,
+                                             Module* pSigModule, PCCOR_SIGNATURE pSig, DWORD cbSig, BOOL isAsync, SigTypeContext *pTypeContext,
                                              AllocMemTracker* pamTracker)
 {
     CONTRACT (MethodDesc*)
@@ -160,7 +161,7 @@ MethodDesc* ILStubCache::CreateNewMethodDesc(LoaderHeap* pCreationHeap, MethodTa
                                                            mcDynamic,
                                                            TRUE /* fNonVtableSlot */,
                                                            TRUE /* fNativeCodeSlot */,
-                                                           FALSE /* HasAsyncMethodData */,
+                                                           isAsync /* HasAsyncMethodData */,
                                                            pMT,
                                                            pamTracker);
 
@@ -175,6 +176,13 @@ MethodDesc* ILStubCache::CreateNewMethodDesc(LoaderHeap* pCreationHeap, MethodTa
     pMD->InitializeFlags(DynamicMethodDesc::FlagPublic | DynamicMethodDesc::FlagIsILStub);
     pMD->SetTemporaryEntryPoint(pamTracker);
 
+    if (isAsync)
+    {
+        pMD->SetHasAsyncMethodData();
+        // Async stubs are standalone methods that do not form async/task-returning variant pairs.
+        pMD->GetAddrOfAsyncMethodData()->kind = AsyncMethodKind::AsyncExplicitImpl;
+    }
+
     //
     // convert signature to a compatible signature if needed
     //
@@ -531,7 +539,8 @@ MethodDesc* ILStubCache::GetStubMethodDesc(
         }
 
         MethodTable *pStubMT = GetOrCreateStubMethodTable(pSigLoaderModule);
-        pMD = ILStubCache::CreateNewMethodDesc(m_pAllocator->GetHighFrequencyHeap(), pStubMT, dwStubFlags, pSigModule, pSig, cbSig, pTypeContext, pamTracker);
+        BOOL isAsync = pTargetMD == NULL ? FALSE: pTargetMD->IsAsyncMethod();
+        pMD = ILStubCache::CreateNewMethodDesc(m_pAllocator->GetHighFrequencyHeap(), pStubMT, dwStubFlags, pSigModule, pSig, cbSig, isAsync, pTypeContext, pamTracker);
 
         if (SF_IsSharedStub(dwStubFlags))
         {
diff --git a/src/coreclr/vm/ilstubcache.h b/src/coreclr/vm/ilstubcache.h
@@ -73,7 +73,8 @@ class ILStubCache final
         PCCOR_SIGNATURE pSig,
         DWORD cbSig,
         SigTypeContext *pTypeContext,
-        ILStubLinker* pStubLinker);
+        ILStubLinker* pStubLinker,
+        BOOL isAsync = FALSE);
 
     MethodTable * GetStubMethodTable()
     {
@@ -97,6 +98,7 @@ class ILStubCache final
         Module* pSigModule,
         PCCOR_SIGNATURE pSig,
         DWORD cbSig,
+        BOOL isAsync,
         SigTypeContext *pTypeContext,
         AllocMemTracker* pamTracker);
 
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -478,19 +478,26 @@ static void ConvToJitSig(
 
         uint32_t data;
         IfFailThrow(sig.GetCallingConvInfo(&data));
-        sigRet->callConv = (CorInfoCallConv) data;
 
 #if defined(TARGET_UNIX) || defined(TARGET_ARM)
-        if ((isCallConv(sigRet->callConv, IMAGE_CEE_CS_CALLCONV_VARARG)) ||
-            (isCallConv(sigRet->callConv, IMAGE_CEE_CS_CALLCONV_NATIVEVARARG)))
+        if ((isCallConv(data, IMAGE_CEE_CS_CALLCONV_VARARG)) ||
+            (isCallConv(data, IMAGE_CEE_CS_CALLCONV_NATIVEVARARG)))
         {
             // This signature corresponds to a method that uses varargs, which are not supported.
              COMPlusThrow(kInvalidProgramException, IDS_EE_VARARG_NOT_SUPPORTED);
         }
 #endif // defined(TARGET_UNIX) || defined(TARGET_ARM)
 
+        // We have an internal calling convention for async used for signatures
+        // in IL stubs. Translate that to the flag representation in
+        // CorInfoCallConv.
+        if (isCallConv(data, IMAGE_CEE_CS_CALLCONV_ASYNC))
+            sigRet->callConv = (CorInfoCallConv)(CORINFO_CALLCONV_DEFAULT | CORINFO_CALLCONV_ASYNCCALL | (data & ~IMAGE_CEE_CS_CALLCONV_MASK));
+        else
+            sigRet->callConv = (CorInfoCallConv) data;
+
         // Skip number of type arguments
-        if (sigRet->callConv & IMAGE_CEE_CS_CALLCONV_GENERIC)
+        if (data & IMAGE_CEE_CS_CALLCONV_GENERIC)
           IfFailThrow(sig.GetData(NULL));
 
         uint32_t numArgs;
@@ -1796,7 +1803,6 @@ CEEInfo::findSig(
     if (IsDynamicScope(scopeHnd))
     {
         sig = GetDynamicResolver(scopeHnd)->ResolveSignature(sigTok);
-        sigTok = mdTokenNil;
     }
     else
     {
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
@@ -1394,16 +1394,18 @@ PrepareCodeConfigBuffer::PrepareCodeConfigBuffer(NativeCodeVersion codeVersion)
 
 // CreateDerivedTargetSigWithExtraParams:
 // This method is used to create the signature of the target of the ILStub for
-// instantiating, unboxing, and async variant stubs, when/where we need to
-// introduce a generic context/async continuation.
-// And since the generic context/async continuations are hidden parameters,
+// instantiating and unboxing stubs, when/where we need to
+// introduce a generic context.
+// And since the generic contexts are hidden parameters,
 // we're creating a signature that looks like non-generic but with additional
 // parameters right after the thisptr
 void MethodDesc::CreateDerivedTargetSigWithExtraParams(MetaSig& msig, SigBuilder *stubSigBuilder)
 {
     STANDARD_VM_CONTRACT;
 
     BYTE callingConvention = IMAGE_CEE_CS_CALLCONV_DEFAULT;
+    if (msig.HasAsyncContinuation())
+        callingConvention = IMAGE_CEE_CS_CALLCONV_ASYNC;
     if (msig.HasThis())
         callingConvention |= IMAGE_CEE_CS_CALLCONV_HASTHIS;
     // CallingConvention
@@ -1475,9 +1477,6 @@ Stub * CreateUnboxingILStubForSharedGenericValueTypeMethods(MethodDesc* pTargetM
 
     _ASSERTE(msig.HasThis());
 
-    // TODO: (async) instantiating/unboxing stubs https://github.com/dotnet/runtime/issues/117266
-    _ASSERTE(!msig.HasAsyncContinuation());
-
     ILStubLinker sl(pTargetMD->GetModule(),
                     pTargetMD->GetSignature(),
                     &typeContext,
@@ -1499,12 +1498,17 @@ Stub * CreateUnboxingILStubForSharedGenericValueTypeMethods(MethodDesc* pTargetM
     pCode->EmitLoadThis();
     pCode->EmitLDFLDA(tokRawData);
 
-#if defined(TARGET_X86)
+#ifdef TARGET_X86
     // Push the rest of the arguments for x86
     for (unsigned i = 0; i < msig.NumFixedArgs();i++)
     {
         pCode->EmitLDARG(i);
     }
+
+    if (msig.HasAsyncContinuation())
+    {
+        pCode->EmitLDNULL();
+    }
 #endif
 
     // Push the hidden context param
@@ -1515,7 +1519,12 @@ Stub * CreateUnboxingILStubForSharedGenericValueTypeMethods(MethodDesc* pTargetM
     pCode->EmitSUB();
     pCode->EmitLDIND_I();
 
-#if !defined(TARGET_X86)
+#ifndef TARGET_X86
+    if (msig.HasAsyncContinuation())
+    {
+        pCode->EmitLDNULL();
+    }
+
     // Push the rest of the arguments for not x86
     for (unsigned i = 0; i < msig.NumFixedArgs();i++)
     {
@@ -1540,7 +1549,8 @@ Stub * CreateUnboxingILStubForSharedGenericValueTypeMethods(MethodDesc* pTargetM
                                                             pTargetMD->GetModule(),
                                                             pSig, cbSig,
                                                             &typeContext,
-                                                            &sl);
+                                                            &sl,
+                                                            pTargetMD->IsAsyncMethod());
 
     ILStubResolver *pResolver = pStubMD->AsDynamicMethodDesc()->GetILStubResolver();
 
@@ -1593,9 +1603,6 @@ Stub * CreateInstantiatingILStub(MethodDesc* pTargetMD, void* pHiddenArg)
 
     ILCodeStream *pCode = sl.NewCodeStream(ILStubLinker::kDispatch);
 
-    // TODO: (async) instantiating/unboxing stubs https://github.com/dotnet/runtime/issues/117266
-    _ASSERTE(!msig.HasAsyncContinuation());
-
     // Build the new signature
     SigBuilder stubSigBuilder;
     MethodDesc::CreateDerivedTargetSigWithExtraParams(msig, &stubSigBuilder);
@@ -1607,25 +1614,37 @@ Stub * CreateInstantiatingILStub(MethodDesc* pTargetMD, void* pHiddenArg)
         pCode->EmitLoadThis();
     }
 
-#if defined(TARGET_X86)
+#ifdef TARGET_X86
     // Push the rest of the arguments for x86
     for (unsigned i = 0; i < msig.NumFixedArgs();i++)
     {
         pCode->EmitLDARG(i);
     }
-#endif // TARGET_X86
 
+    if (msig.HasAsyncContinuation())
+    {
+        pCode->EmitLDNULL();
+    }
+
+    // Push the hidden context param
+    // InstantiatingStub
+    pCode->EmitLDC((TADDR)pHiddenArg);
+#else
     // Push the hidden context param
     // InstantiatingStub
     pCode->EmitLDC((TADDR)pHiddenArg);
 
-#if !defined(TARGET_X86)
-    // Push the rest of the arguments for not x86
+    if (msig.HasAsyncContinuation())
+    {
+        pCode->EmitLDNULL();
+    }
+
+    // Push the rest of the arguments for x86
     for (unsigned i = 0; i < msig.NumFixedArgs();i++)
     {
         pCode->EmitLDARG(i);
     }
-#endif // !TARGET_X86
+#endif
 
     // Push the target address
     pCode->EmitLDC((TADDR)pTargetMD->GetMultiCallableAddrOfCode(CORINFO_ACCESS_ANY));
@@ -1644,7 +1663,8 @@ Stub * CreateInstantiatingILStub(MethodDesc* pTargetMD, void* pHiddenArg)
                                                             pTargetMD->GetModule(),
                                                             pSig, cbSig,
                                                             &typeContext,
-                                                            &sl);
+                                                            &sl,
+                                                            pTargetMD->IsAsyncMethod());
 
     ILStubResolver *pResolver = pStubMD->AsDynamicMethodDesc()->GetILStubResolver();
 
diff --git a/src/coreclr/vm/siginfo.cpp b/src/coreclr/vm/siginfo.cpp
@@ -185,7 +185,7 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, const SigTypeCo
     {
         mdToken tk;
         IfFailThrowBF(GetToken(&tk), BFA_BAD_COMPLUS_SIG, pSigModule);
-        TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk);
+        TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk, ClassLoader::ThrowIfNotFound, ClassLoader::PermitUninstDefOrRef);
         pSigBuilder->AppendElementType(ELEMENT_TYPE_CMOD_INTERNAL);
         pSigBuilder->AppendByte(typ == ELEMENT_TYPE_CMOD_REQD); // "is required" byte
         pSigBuilder->AppendPointer(th.AsPtr());
diff --git a/src/tests/async/inst-unbox-thunks/inst-unbox-thunks.cs b/src/tests/async/inst-unbox-thunks/inst-unbox-thunks.cs
diff --git a/src/tests/async/inst-unbox-thunks/inst-unbox-thunks.csproj b/src/tests/async/inst-unbox-thunks/inst-unbox-thunks.csproj

Original file line number	Diff line number	Diff line change
`@@ -701,6 +701,11 @@ var_types Compiler::impImportCall(OPCODE opcode,`
`701`	`701`	`JITDUMP(" Continuation continues on thread pool\n");`
`702`	`702`	`}`
`703`	`703`	`}`
	`704`	`+ else if (opcode == CEE_CALLI)`
	`705`	`+ {`
	`706`	`+ // Used for unboxing/instantiating stubs`
	`707`	`+ JITDUMP("Call is an async calli\n");`
	`708`	`+ }`
`704`	`709`	`else`
`705`	`710`	`{`
`706`	`711`	`JITDUMP("Call is an async non-task await\n");`
`@@ -917,7 +922,9 @@ var_types Compiler::impImportCall(OPCODE opcode,`
`917`	`922`	`.WellKnown(WellKnownArg::VarArgsCookie));`
`918`	`923`	`}`
`919`	`924`
`920`		`- if (call->AsCall()->IsAsync())`
	`925`	`+ // Add async continuation arg. For calli these are used for IL`
	`926`	`+ // stubs and the VM inserts the arg itself.`
	`927`	`+ if (call->AsCall()->IsAsync() && (opcode != CEE_CALLI))`
`921`	`928`	`{`
`922`	`929`	`call->AsCall()->gtArgs.PushFront(this, NewCallArg::Primitive(gtNewNull(), TYP_REF)`
`923`	`930`	`.WellKnown(WellKnownArg::AsyncContinuation));`
`@@ -931,7 +938,9 @@ var_types Compiler::impImportCall(OPCODE opcode,`
`931`	`938`	`}`
`932`	`939`	`else`
`933`	`940`	`{`
`934`		`- if (call->AsCall()->IsAsync())`
	`941`	`+ // Add async continuation arg. For calli these are used for IL`
	`942`	`+ // stubs and the VM inserts the arg itself.`
	`943`	`+ if (call->AsCall()->IsAsync() && (opcode != CEE_CALLI))`
`935`	`944`	`{`
`936`	`945`	`call->AsCall()->gtArgs.PushBack(this, NewCallArg::Primitive(gtNewNull(), TYP_REF)`
`937`	`946`	`.WellKnown(WellKnownArg::AsyncContinuation));`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, const SigTypeCo`
`185`	`185`	`{`
`186`	`186`	`mdToken tk;`
`187`	`187`	`IfFailThrowBF(GetToken(&tk), BFA_BAD_COMPLUS_SIG, pSigModule);`
`188`		`- TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk);`
	`188`	`+ TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk, ClassLoader::ThrowIfNotFound, ClassLoader::PermitUninstDefOrRef);`
`189`	`189`	`pSigBuilder->AppendElementType(ELEMENT_TYPE_CMOD_INTERNAL);`
`190`	`190`	`pSigBuilder->AppendByte(typ == ELEMENT_TYPE_CMOD_REQD); // "is required" byte`
`191`	`191`	`pSigBuilder->AppendPointer(th.AsPtr());`