Emit IL for AsyncResumptionStub

[jtschuster]

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

runtime/src/coreclr/vm/jitinterface.cpp

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);
	}

[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).

[jtschuster]

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

[MichalStrehovsky]

Pushed changes that generates a dummy MethodDesc with an explicit Continuation parameter which is called in the async resumption stubs. It looks like ilc compiles basic methods, but throws during scanning with "Scanning Failure". Using this in ReadyToRun will require more work on the Task-returning stubs to resolve the required intrinsics, so this PR will focus on ilc. I'll work on the ilc issues tomorrow.

Optimizations are currently broken. Make sure not to run ilc with -O, it will not work. Drop <Optimize>true</Optimize> from the async tests if you're running them.

[MichalStrehovsky]

Looks like this would work otherwise!

[Copilot]

Pull Request Overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 2 comments.

[Copilot]

The Signature property should follow the null-coalescing pattern like other properties in the codebase. Use return _signature ??= InitializeSignature(); instead of explicit null check and separate assignment.

Suggested change

	if (_signature is null)
	return InitializeSignature();
	return _signature;
	return _signature ??= InitializeSignature();

[Copilot]

The ExplicitContinuationAsyncMethod class lacks a mangling partial class file. Based on the codebase pattern (AsyncResumptionStub, AsyncMethodVariant, etc.), internal call methods that can be referenced should implement IPrefixMangledMethod. Consider adding an AsyncResumptionStub.Mangling.cs partial class for ExplicitContinuationAsyncMethod to provide proper name mangling support.