Emit IL for AsyncResumptionStub #121456

jtschuster · 2025-11-07T21:48:36Z

Updates the AsyncResumptionStub to emit IL. The implementation was ported from the runtime's getAsyncResumptionStub

Lines 14646 to 14833 in 5668ab9

    
           CORINFO_METHOD_HANDLE CEEJitInfo::getAsyncResumptionStub(void** entryPoint) 
        
           { 
        
               CONTRACTL{ 
        
                   THROWS; 
        
                   GC_TRIGGERS; 
        
                   MODE_PREEMPTIVE; 
        
               } CONTRACTL_END; 
        
               MethodDesc* md = m_pMethodBeingCompiled; 
        
               LoaderAllocator* loaderAlloc = md->GetLoaderAllocator(); 
        
               AllocMemTracker amTracker; 
        
               Signature stubSig = BuildResumptionStubSignature(md->GetLoaderAllocator(), &amTracker); 
        
               MetaSig msig(md); 
        
               Signature calliSig = BuildResumptionStubCalliSignature(msig, md->GetMethodTable(), md->GetLoaderAllocator(), &amTracker); 
        
               SigTypeContext emptyCtx; 
        
               ILStubLinker sl(md->GetModule(), stubSig, &emptyCtx, NULL, ILSTUB_LINKER_FLAG_NONE); 
        
               ILCodeStream* pCode = sl.NewCodeStream(ILStubLinker::kDispatch); 
        
               int numArgs = 0; 
        
               if (msig.HasThis()) 
        
               { 
        
                   if (md->GetMethodTable()->IsValueType()) 
        
                   { 
        
                       pCode->EmitLDC(0); 
        
                       pCode->EmitCONV_U(); 
        
                   } 
        
                   else 
        
                   { 
        
                       pCode->EmitLDNULL(); 
        
                   } 
        
                   numArgs++; 
        
               } 
        
           #ifndef TARGET_X86 
        
               if (msig.HasGenericContextArg()) 
        
               { 
        
                   pCode->EmitLDC(0); 
        
                   numArgs++; 
        
               } 
        
               // Continuation 
        
               pCode->EmitLDARG(0); 
        
               numArgs++; 
        
           #endif 
        
               msig.Reset(); 
        
               CorElementType ty; 
        
               while ((ty = msig.NextArg()) != ELEMENT_TYPE_END) 
        
               { 
        
                   TypeHandle tyHnd = msig.GetLastTypeHandleThrowing(); 
        
                   DWORD loc = pCode->NewLocal(LocalDesc(tyHnd)); 
        
                   pCode->EmitLDLOCA(loc); 
        
                   pCode->EmitINITOBJ(pCode->GetToken(tyHnd)); 
        
                   pCode->EmitLDLOC(loc); 
        
                   numArgs++; 
        
               } 
        
           #ifdef TARGET_X86 
        
               // Continuation 
        
               pCode->EmitLDARG(0); 
        
               if (msig.HasGenericContextArg()) 
        
               { 
        
                   pCode->EmitLDC(0); 
        
                   numArgs++; 
        
               } 
        
               numArgs++; 
        
           #endif 
        
           #ifdef FEATURE_TIERED_COMPILATION 
        
               // Resumption stubs are uniquely coupled to the code version (since the 
        
               // continuation is), so we need to make sure we always keep calling the 
        
               // same version here. 
        
               PrepareCodeConfig* config = GetThread()->GetCurrentPrepareCodeConfig(); 
        
               NativeCodeVersion ncv = config->GetCodeVersion(); 
        
               if (ncv.GetOptimizationTier() == NativeCodeVersion::OptimizationTier1OSR) 
        
               { 
        
           #ifdef FEATURE_ON_STACK_REPLACEMENT 
        
                   // The OSR version needs to resume in the tier0 version. The tier0 
        
                   // version will handle setting up the frame that the OSR version 
        
                   // expects and then delegating back into the OSR version (knowing to do 
        
                   // so through information stored in the continuation). 
        
                   _ASSERTE(m_pPatchpointInfoFromRuntime != NULL); 
        
                   pCode->EmitLDC((DWORD_PTR)m_pPatchpointInfoFromRuntime->GetTier0EntryPoint()); 
        
           #else // !FEATURE_ON_STACK_REPLACEMENT 
        
                   _ASSERTE(!"Unexpected optimization tier with OSR disabled"); 
        
           #endif // FEATURE_ON_STACK_REPLACEMENT 
        
               } 
        
               else 
        
           #endif // FEATURE_TIERED_COMPILATION 
        
               { 
        
                   { 
        
                       m_finalCodeAddressSlot = (PCODE*)amTracker.Track(m_pMethodBeingCompiled->GetLoaderAllocator()->GetHighFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(PCODE)))); 
        
                   } 
        
                   pCode->EmitLDC((DWORD_PTR)m_finalCodeAddressSlot); 
        
                   pCode->EmitLDIND_I(); 
        
               } 
        
               pCode->EmitCALLI(pCode->GetSigToken(calliSig.GetRawSig(), calliSig.GetRawSigLen()), numArgs, msig.IsReturnTypeVoid() ? 0 : 1); 
        
               DWORD resultLoc = UINT_MAX; 
        
               TypeHandle resultTypeHnd; 
        
               if (!msig.IsReturnTypeVoid()) 
        
               { 
        
                   resultTypeHnd = msig.GetRetTypeHandleThrowing(); 
        
                   resultLoc = pCode->NewLocal(LocalDesc(resultTypeHnd)); 
        
                   pCode->EmitSTLOC(resultLoc); 
        
               } 
        
               TypeHandle continuationTypeHnd = CoreLibBinder::GetClass(CLASS__CONTINUATION); 
        
               DWORD newContinuationLoc = pCode->NewLocal(LocalDesc(continuationTypeHnd)); 
        
               pCode->EmitCALL(METHOD__STUBHELPERS__ASYNC_CALL_CONTINUATION, 0, 1); 
        
               pCode->EmitSTLOC(newContinuationLoc); 
        
               if (!msig.IsReturnTypeVoid()) 
        
               { 
        
                   ILCodeLabel* doneResult = pCode->NewCodeLabel(); 
        
                   pCode->EmitLDLOC(newContinuationLoc); 
        
                   pCode->EmitBRTRUE(doneResult); 
        
                   pCode->EmitLDARG(1); // resultLoc 
        
                   pCode->EmitLDLOC(resultLoc); 
        
                   pCode->EmitSTOBJ(pCode->GetToken(resultTypeHnd)); 
        
                   pCode->EmitLabel(doneResult); 
        
               } 
        
               pCode->EmitLDLOC(newContinuationLoc); 
        
               pCode->EmitRET(); 
        
               MethodDesc* result = 
        
                   ILStubCache::CreateAndLinkNewILStubMethodDesc( 
        
                       md->GetLoaderAllocator(), 
        
                       md->GetLoaderModule()->GetILStubCache()->GetOrCreateStubMethodTable(md->GetLoaderModule()), 
        
                       ILSTUB_ASYNC_RESUME, 
        
                       md->GetModule(), 
        
                       stubSig.GetRawSig(), stubSig.GetRawSigLen(), 
        
                       &emptyCtx, 
        
                       &sl); 
        
               amTracker.SuppressRelease(); 
        
               ILStubResolver *pResolver = result->AsDynamicMethodDesc()->GetILStubResolver(); 
        
               pResolver->SetStubTargetMethodDesc(m_pMethodBeingCompiled); 
        
               const char* optimizationTierName = "UnknownTier"; 
        
           #ifdef FEATURE_TIERED_COMPILATION 
        
               switch (ncv.GetOptimizationTier()) 
        
               { 
        
               case NativeCodeVersion::OptimizationTier0: optimizationTierName = "Tier0"; break; 
        
               case NativeCodeVersion::OptimizationTier1: optimizationTierName = "Tier1"; break; 
        
               case NativeCodeVersion::OptimizationTier1OSR: optimizationTierName = "Tier1OSR"; break; 
        
               case NativeCodeVersion::OptimizationTierOptimized: optimizationTierName = "Optimized"; break; 
        
               case NativeCodeVersion::OptimizationTier0Instrumented: optimizationTierName = "Tier0Instrumented"; break; 
        
               case NativeCodeVersion::OptimizationTier1Instrumented: optimizationTierName = "Tier1Instrumented"; break; 
        
               default: break; 
        
               } 
        
           #endif // FEATURE_TIERED_COMPILATION 
        
           #ifdef _DEBUG 
        
               LPCUTF8 methodName = m_pMethodBeingCompiled->GetName(); 
        
               size_t stubNameLen = STRING_LENGTH("IL_STUB_AsyncResume__"); 
        
               stubNameLen += strlen(methodName); 
        
               stubNameLen += strlen(optimizationTierName); 
        
               stubNameLen++; // "\n" 
        
               AllocMemTracker amTrackerName; 
        
               char* allocedMem = (char*)amTrackerName.Track(m_pMethodBeingCompiled->GetLoaderAllocator()->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(stubNameLen))); 
        
               sprintf_s(allocedMem, stubNameLen, "IL_STUB_AsyncResume_%s_%s", m_pMethodBeingCompiled->GetName(), optimizationTierName); 
        
               result->AsDynamicMethodDesc()->SetMethodName((LPCUTF8)allocedMem); 
        
               amTrackerName.SuppressRelease(); 
        
               LOG((LF_STUBS, LL_INFO1000, "ASYNC: Resumption stub %s created\n", allocedMem)); 
        
               sl.LogILStub(CORJIT_FLAGS()); 
        
           #endif 
        
               *entryPoint = (void*)result->GetMultiCallableAddrOfCode(); 
        
               return CORINFO_METHOD_HANDLE(result); 
        
           }

jkotas · 2025-11-07T21:52:37Z

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

+
+            // Ported from jitinterface.cpp CEEJitInfo::getAsyncResumptionStub
+            // Emitted IL:
+            // if (!_owningMethod.Signature.IsStatic)


I do not think this comment useful. You can easily tell what the IL is from the actual emitter below. It can only get out of sync overtime.

dotnet-policy-service · 2025-11-07T21:54:17Z

Tagging subscribers to this area: @agocke, @MichalStrehovsky, @jkotas
See info in area-owners.md if you want to be subscribed.

jkotas · 2025-11-07T21:54:21Z

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

    {
        private readonly MethodDesc _owningMethod;
        private MethodSignature _signature;
+        private MethodIL _methodIL;


We do not store IL on the ILStubMethods. There is a cache in the ILProvider.

jkotas · 2025-11-07T21:57:47Z

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

+                ilStream.EmitStLoc(resultLocal);
+            }
+
+            MethodDesc asyncCallContinuation = Context.SystemModule.GetKnownType("System.StubHelpers"u8, "StubHelpers"u8)


Can we move this to AsyncHelpers so that we do not have to add StubHelpers.cs to NativeAOT?

StubHelpers in CoreCLR is everything-in-the-kitchen-sink type. It is not pretty.

Copilot

Pull Request Overview

This PR implements the async resumption stub for native AOT compilation by porting the CoreCLR VM implementation from jitinterface.cpp to C#. The stub is used to resume async methods after suspension.

Replaces the placeholder ThrowNotSupportedException implementation with a complete IL emission that matches CoreCLR's getAsyncResumptionStub
Adds proper caching of the generated IL and comparison logic for the stub method
Updates the constructor assertion to use a simplified IsAsyncCall() method

Comments suppressed due to low confidence (2)

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

This CompareToImpl method duplicates the existing implementation in AsyncResumptionStub.Sorting.cs (lines 13-16). Both implementations are identical and will cause a compilation error due to duplicate method definitions in the same partial class.
src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncResumptionStub.cs:127
The brtrue instruction requires an address on the stack, but EmitLdLoca loads the address of the local variable. This should be EmitLdLoc instead to load the value of the continuation for the branch condition. The CoreCLR reference implementation uses EmitLDLOC (line 14772 in jitinterface.cpp).

Copilot · 2025-11-07T21:58:35Z

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

+        public override MethodIL EmitIL()
+        {
+            return _methodIL ?? InitializeMethodIL();
+        }


The logic for returnsVoid is inverted. It should be == instead of !=. The variable is true when the return type is NOT void, which means the variable name and logic are contradictory. This will cause incorrect IL generation - the result handling code will execute when the method returns void and will be skipped when it doesn't return void.

Copilot · 2025-11-07T21:58:35Z

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

+        protected override int ClassCode => unchecked((int)0xa91ac565);
+


This ClassCode value conflicts with the existing value in AsyncResumptionStub.Sorting.cs (0x773ab1). Both implementations define ClassCode for the same partial class, creating a duplicate definition that will cause a compilation error.

Suggested change

protected override int ClassCode => unchecked((int)0xa91ac565);

…mplementations of AsyncResumptionStub

MichalStrehovsky · 2025-11-07T22:20:39Z

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

+            MethodDesc asyncCallContinuation = Context.SystemModule.GetKnownType("System.Runtime.CompilerServices"u8, "AsyncHelpers"u8)
+                .GetKnownMethod("AsyncCallContinuation"u8, null);


For this to work you need to update JIT and the location in CoreCLR's corelib too.

(Cc @eduardo-vp since it's used in his PR too and I told him to look into getAsyncResumptionStub next. Since this one is now taken, #121443 is adding yet another IL thunk, so Eduardo, you could take that one.)

jkotas · 2025-11-07T22:22:12Z

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.cs

 #endif
+        [Intrinsic]
+        [BypassReadyToRun]
+        internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic


The JIT and VM needs to be update for the new location.

jkotas · 2025-11-07T22:27:38Z

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.cs

 #endif
+        [Intrinsic]
+        [BypassReadyToRun]
+        internal static Continuation? AsyncCallContinuation() => throw new UnreachableException(); // Unconditionally expanded intrinsic


AsyncHelpers.CoreCLR.cs would be a better place for this for the time being. Moving it there is going to fix the build break as well.

(near AsyncSuspend method in that file)

jtschuster · 2025-11-07T23:12:37Z

Created #121458 to keep the corelib changes in a separate commit.

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

VSadov · 2025-11-07T23:59:26Z

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

+                ilStream.EmitLdLoc(local);
+            }
+            ilStream.Emit(ILOpcode.ldftn, ilEmitter.NewToken(_owningMethod));
+            ilStream.Emit(ILOpcode.calli, ilEmitter.NewToken(this.Signature));


is this.Signature the signature of the stub or the method that we are resuming?

this.Signature is the stub signature. This should be changed to _owningMethod.Signature.

VSadov · 2025-11-08T00:13:43Z

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

+            }

-            return emitter.Link(this);
+            foreach (var param in _owningMethod.Signature)


On the JIT side here, between this and other arguments, we also put:

generic context arg, if present.
It is set to 0, and will not be used by the calee. Continuation has captured the real value and that will be used instead. But we need to match what the calee expects, so we need to push 0 for the context.

continuation.
it is our arg0. Per the ABI of Async* calls it goes right before the other arguments.
(unless this is x86)

On x86, as usual, there is a difference and the hidden args go after formal ones and in reverse order.

--
*Note - the resume stub is an ordinary function, but what we are resuming is an Async method, thus we shuffle the continuation from our arg0 to its predefined/hidden position in the calee signature.

VSadov · 2025-11-08T00:35:20Z

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

+                ilStream.Emit(ILOpcode.initobj, ilEmitter.NewToken(param));
+                ilStream.EmitLdLoc(local);
+            }
+            ilStream.Emit(ILOpcode.ldftn, ilEmitter.NewToken(_owningMethod));


Not sure. Maybe this is correct in NAOT, but ldftn is a bit suspicious.

If this is a metadata token for the method that we are resuming, you may end up calling the Task-returning variant.
In the JIT counterpart we load the actual address of the JITed target method.
As in:

pCode->EmitLDC((DWORD_PTR)m_finalCodeAddressSlot); pCode->EmitLDIND_I();

cc: @MichalStrehovsky - will ldftn do the right thing here?

This should be emitted as a regular call and the JIT/EE interface and/or the JIT itself should make sure that the call does the right thing.

(Once we figure out what to do here, we may want to switch the JIT counterpart to the same plan.)

Yes, this should be a regular call. The call will be to a thing with RuntimeAsync calling convention; we can make tokens for that and we will make such token here. We probably don't need to pass generic context explicitly either.

But the question is what this will do in the JIT. My expectation is that it will take similar paths as a AsyncExplicitImpl method call.

But the question is what this will do in the JIT. My expectation is that it will take similar paths as a AsyncExplicitImpl method call.

Runtime async method calls pass a null continuation in the JIT. This needs to pass an actual continuation.

"Resume" in a way is the opposite of "Call". In Call we pass formal arguments, generic context, etc.., but continuation is null. In Resume only continuation is what is not default/null.

Doing CALLI with a special-crafted signature is the technique to do a low level "unsafe cast" through call conventions in IL. I have seen it in other places (like instantiating stubs?).

My expectation is that it will take similar paths as a AsyncExplicitImpl method call.

Note - what we are resuming may actually be AsyncExplicitImpl.

Anything with Async call conv may need resuming. Whether it has a variant with non-async call convention is unimportant here. Just the part is that it is Async (i.e. emitted as a state machine, has async call conv).

I have seen it in other places (like instantiating stubs?).

I do not think that this trick is used anywhere in AOT compilers (just looked through all Emit(ILOpcode.calli - none of them look like that).

AsyncCallContinuation() intrinsic gets the async continuation from the last call. Can we have a counterpart that sets the async continuation for the next call?

We can try going the ldftn route, but I expect that it will hit problems with generics and the generated code won't be the best at the end if we manage to make it work. Managed function pointers in NAOT are tagged pointers. Regular calli of a managed function pointer compiles into if (ptr & tag_bit) { ptr[0](ptr[1] /* instantiating arg */, regular args); } else { ptr(regular args) }. We would probably need to suppress this for this ldftn + calli pair.

Could CALLI trick work the same as in JIT case if we clear the tag after LDFTN?

(This all assumes that we can know if the calee/resumee has a generic context parameter and can push 0 to its position)

As another wild thought - I think this IL is never exposed outside of internals of VM/JIT/AOT. Perhaps we could use an IL prefix to tag a call as a resuming call?

Ex:

// load continuation ldarg 0 // the prefix means "consume one arg as a continuation argument, pass everything else as default" // could be applied to calli as well // callee must have async callconv resume. call <token>

…ub.cs Co-authored-by: Vladimir Sadov <[email protected]>

Emit IL for AsyncResumptionStub

2abb220

jtschuster requested review from MichalStrehovsky, VSadov, jakobbotsch and jkotas November 7, 2025 21:48

jtschuster self-assigned this Nov 7, 2025

Copilot AI review requested due to automatic review settings November 7, 2025 21:48

github-actions bot added the needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners label Nov 7, 2025

jkotas reviewed Nov 7, 2025

View reviewed changes

am11 added area-NativeAOT-coreclr and removed needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners labels Nov 7, 2025

jkotas reviewed Nov 7, 2025

View reviewed changes

Remove comment describing IL

6449d07

jkotas reviewed Nov 7, 2025

View reviewed changes

Copilot AI reviewed Nov 7, 2025

View reviewed changes

jtschuster added 2 commits November 7, 2025 14:00

Don't cache methodIL on the MethodDesc object.

a9aead4

Move StubHelpers.AsyncCallContinuation to AsyncHelpers, fix partial i…

c18bc5d

…mplementations of AsyncResumptionStub

MichalStrehovsky reviewed Nov 7, 2025

View reviewed changes

jkotas reviewed Nov 7, 2025

View reviewed changes

am11 added the runtime-async label Nov 7, 2025

Update usages of AsyncCallContinuation to be in AsyncHelpers

85ff8c7

jtschuster mentioned this pull request Nov 7, 2025

Move StubHelpers.AsyncCallContinuation to AsyncHelpers. #121458

Open

VSadov reviewed Nov 7, 2025

View reviewed changes

src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncResumptionStub.cs Outdated Show resolved Hide resolved

VSadov reviewed Nov 7, 2025

View reviewed changes

VSadov reviewed Nov 8, 2025

View reviewed changes

Update src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncResumptionSt…

3da6325

…ub.cs Co-authored-by: Vladimir Sadov <[email protected]>

This was referenced Nov 8, 2025

error : HttpRequestException: The SSL connection could not be established, see inner exception. dotnet/dnceng#5015

Open

Known Test Repository Issue Sometimes Misses Test Failures dotnet/dnceng#6411

Open

	CORINFO_METHOD_HANDLE CEEJitInfo::getAsyncResumptionStub(void** entryPoint)
	{
	CONTRACTL{
	THROWS;
	GC_TRIGGERS;
	MODE_PREEMPTIVE;
	} CONTRACTL_END;

	MethodDesc* md = m_pMethodBeingCompiled;

	LoaderAllocator* loaderAlloc = md->GetLoaderAllocator();
	AllocMemTracker amTracker;

	Signature stubSig = BuildResumptionStubSignature(md->GetLoaderAllocator(), &amTracker);

	MetaSig msig(md);
	Signature calliSig = BuildResumptionStubCalliSignature(msig, md->GetMethodTable(), md->GetLoaderAllocator(), &amTracker);

	SigTypeContext emptyCtx;
	ILStubLinker sl(md->GetModule(), stubSig, &emptyCtx, NULL, ILSTUB_LINKER_FLAG_NONE);

	ILCodeStream* pCode = sl.NewCodeStream(ILStubLinker::kDispatch);

	int numArgs = 0;

	if (msig.HasThis())
	{
	if (md->GetMethodTable()->IsValueType())
	{
	pCode->EmitLDC(0);
	pCode->EmitCONV_U();
	}
	else
	{
	pCode->EmitLDNULL();
	}

	numArgs++;
	}

	#ifndef TARGET_X86
	if (msig.HasGenericContextArg())
	{
	pCode->EmitLDC(0);
	numArgs++;
	}

	// Continuation
	pCode->EmitLDARG(0);
	numArgs++;
	#endif

	msig.Reset();
	CorElementType ty;
	while ((ty = msig.NextArg()) != ELEMENT_TYPE_END)
	{
	TypeHandle tyHnd = msig.GetLastTypeHandleThrowing();
	DWORD loc = pCode->NewLocal(LocalDesc(tyHnd));
	pCode->EmitLDLOCA(loc);
	pCode->EmitINITOBJ(pCode->GetToken(tyHnd));
	pCode->EmitLDLOC(loc);
	numArgs++;
	}

	#ifdef TARGET_X86
	// Continuation
	pCode->EmitLDARG(0);

	if (msig.HasGenericContextArg())
	{
	pCode->EmitLDC(0);
	numArgs++;
	}

	numArgs++;
	#endif

	#ifdef FEATURE_TIERED_COMPILATION
	// Resumption stubs are uniquely coupled to the code version (since the
	// continuation is), so we need to make sure we always keep calling the
	// same version here.
	PrepareCodeConfig* config = GetThread()->GetCurrentPrepareCodeConfig();
	NativeCodeVersion ncv = config->GetCodeVersion();
	if (ncv.GetOptimizationTier() == NativeCodeVersion::OptimizationTier1OSR)
	{
	#ifdef FEATURE_ON_STACK_REPLACEMENT
	// The OSR version needs to resume in the tier0 version. The tier0
	// version will handle setting up the frame that the OSR version
	// expects and then delegating back into the OSR version (knowing to do
	// so through information stored in the continuation).
	_ASSERTE(m_pPatchpointInfoFromRuntime != NULL);
	pCode->EmitLDC((DWORD_PTR)m_pPatchpointInfoFromRuntime->GetTier0EntryPoint());
	#else // !FEATURE_ON_STACK_REPLACEMENT
	_ASSERTE(!"Unexpected optimization tier with OSR disabled");
	#endif // FEATURE_ON_STACK_REPLACEMENT
	}
	else
	#endif // FEATURE_TIERED_COMPILATION
	{
	{
	m_finalCodeAddressSlot = (PCODE*)amTracker.Track(m_pMethodBeingCompiled->GetLoaderAllocator()->GetHighFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(PCODE))));
	}

	pCode->EmitLDC((DWORD_PTR)m_finalCodeAddressSlot);
	pCode->EmitLDIND_I();
	}

	pCode->EmitCALLI(pCode->GetSigToken(calliSig.GetRawSig(), calliSig.GetRawSigLen()), numArgs, msig.IsReturnTypeVoid() ? 0 : 1);

	DWORD resultLoc = UINT_MAX;
	TypeHandle resultTypeHnd;
	if (!msig.IsReturnTypeVoid())
	{
	resultTypeHnd = msig.GetRetTypeHandleThrowing();
	resultLoc = pCode->NewLocal(LocalDesc(resultTypeHnd));
	pCode->EmitSTLOC(resultLoc);
	}

	TypeHandle continuationTypeHnd = CoreLibBinder::GetClass(CLASS__CONTINUATION);
	DWORD newContinuationLoc = pCode->NewLocal(LocalDesc(continuationTypeHnd));
	pCode->EmitCALL(METHOD__STUBHELPERS__ASYNC_CALL_CONTINUATION, 0, 1);
	pCode->EmitSTLOC(newContinuationLoc);

	if (!msig.IsReturnTypeVoid())
	{
	ILCodeLabel* doneResult = pCode->NewCodeLabel();
	pCode->EmitLDLOC(newContinuationLoc);
	pCode->EmitBRTRUE(doneResult);

	pCode->EmitLDARG(1); // resultLoc
	pCode->EmitLDLOC(resultLoc);
	pCode->EmitSTOBJ(pCode->GetToken(resultTypeHnd));

	pCode->EmitLabel(doneResult);
	}

	pCode->EmitLDLOC(newContinuationLoc);
	pCode->EmitRET();

	MethodDesc* result =
	ILStubCache::CreateAndLinkNewILStubMethodDesc(
	md->GetLoaderAllocator(),
	md->GetLoaderModule()->GetILStubCache()->GetOrCreateStubMethodTable(md->GetLoaderModule()),
	ILSTUB_ASYNC_RESUME,
	md->GetModule(),
	stubSig.GetRawSig(), stubSig.GetRawSigLen(),
	&emptyCtx,
	&sl);

	amTracker.SuppressRelease();

	ILStubResolver *pResolver = result->AsDynamicMethodDesc()->GetILStubResolver();
	pResolver->SetStubTargetMethodDesc(m_pMethodBeingCompiled);

	const char* optimizationTierName = "UnknownTier";
	#ifdef FEATURE_TIERED_COMPILATION
	switch (ncv.GetOptimizationTier())
	{
	case NativeCodeVersion::OptimizationTier0: optimizationTierName = "Tier0"; break;
	case NativeCodeVersion::OptimizationTier1: optimizationTierName = "Tier1"; break;
	case NativeCodeVersion::OptimizationTier1OSR: optimizationTierName = "Tier1OSR"; break;
	case NativeCodeVersion::OptimizationTierOptimized: optimizationTierName = "Optimized"; break;
	case NativeCodeVersion::OptimizationTier0Instrumented: optimizationTierName = "Tier0Instrumented"; break;
	case NativeCodeVersion::OptimizationTier1Instrumented: optimizationTierName = "Tier1Instrumented"; break;
	default: break;
	}
	#endif // FEATURE_TIERED_COMPILATION

	#ifdef _DEBUG
	LPCUTF8 methodName = m_pMethodBeingCompiled->GetName();
	size_t stubNameLen = STRING_LENGTH("IL_STUB_AsyncResume__");
	stubNameLen += strlen(methodName);
	stubNameLen += strlen(optimizationTierName);
	stubNameLen++; // "\n"

	AllocMemTracker amTrackerName;
	char* allocedMem = (char*)amTrackerName.Track(m_pMethodBeingCompiled->GetLoaderAllocator()->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(stubNameLen)));
	sprintf_s(allocedMem, stubNameLen, "IL_STUB_AsyncResume_%s_%s", m_pMethodBeingCompiled->GetName(), optimizationTierName);
	result->AsDynamicMethodDesc()->SetMethodName((LPCUTF8)allocedMem);
	amTrackerName.SuppressRelease();

	LOG((LF_STUBS, LL_INFO1000, "ASYNC: Resumption stub %s created\n", allocedMem));
	sl.LogILStub(CORJIT_FLAGS());
	#endif

	entryPoint = (void)result->GetMultiCallableAddrOfCode();
	return CORINFO_METHOD_HANDLE(result);
	}

		protected override int ClassCode => unchecked((int)0xa91ac565);

		MethodDesc asyncCallContinuation = Context.SystemModule.GetKnownType("System.Runtime.CompilerServices"u8, "AsyncHelpers"u8)
		.GetKnownMethod("AsyncCallContinuation"u8, null);

Emit IL for AsyncResumptionStub #121456

Are you sure you want to change the base?

Emit IL for AsyncResumptionStub #121456

Conversation

jtschuster commented Nov 7, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dotnet-policy-service bot commented Nov 7, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Uh oh!

Copilot AI Nov 7, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 7, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jtschuster commented Nov 7, 2025

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

VSadov Nov 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

VSadov Nov 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jkotas Nov 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jkotas Nov 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

VSadov Nov 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants

VSadov Nov 8, 2025 •

edited

Loading

VSadov Nov 8, 2025 •

edited

Loading

jkotas Nov 8, 2025 •

edited

Loading

jkotas Nov 8, 2025 •

edited

Loading

VSadov Nov 8, 2025 •

edited

Loading