Compile runtime async versions of synchronous task-returning methods by jakobbotsch · Pull Request #128384 · dotnet/runtime

jakobbotsch · 2026-05-19T20:00:54Z

Instead of delegating from runtime async callable thunks to the original task returning methods this PR compiles a fully separate runtime async version. It then adds a guaranteed optimization to make tail calls in the synchronous task-returning methods into runtime async calls.

This is one potential approach to fix #115771.

Copilot

Pull request overview

This PR extends the JIT↔EE async infrastructure so the JIT can compile a dedicated “runtime async version” of synchronous Task/ValueTask-returning methods, including a tail-position optimization that turns eligible tail calls/returns into runtime-async awaits.

Changes:

Adds a new JIT↔EE interface API (getAwaitReturnCall) and plumbs it through SuperPMI and generated wrappers/shims.
Updates CoreCLR async thunk IL generation and AsyncHelpers to separate “suspend” helpers from typed TransparentAwait(...) helpers used by the JIT.
Updates the JIT importer to recognize “async-version tail await” patterns and to wrap async-version returns in an await via the new EE callback.

Reviewed changes

Copilot reviewed 33 out of 33 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
src/tests/async/reflection/reflection.cs	Disables several assertions related to reflection/stack behavior for await-on-task-returning paths.
src/coreclr/vm/prestub.cpp	Adjusts IL header retrieval logic for async variant methods.
src/coreclr/vm/method.hpp	Changes IL-header eligibility rules for async/thunk/return-dropping methods; exposes `GetAsyncThunkResultTypeSig`.
src/coreclr/vm/metasig.h	Adds metasig entries for `Task`/`ValueTask` TransparentAwait helper signatures.
src/coreclr/vm/jitinterface.h	Adds helper declarations related to runtime lookup computation for new await-return support.
src/coreclr/vm/jitinterface.cpp	Implements `getAwaitReturnCall` and runtime-lookup computation for generic await helpers; sets `CORINFO_ASYNC_VERSION` for applicable methods.
src/coreclr/vm/corelib.h	Adds/updates CoreLibBinder entries for new suspend/await AsyncHelpers methods with proper signatures.
src/coreclr/vm/asyncthunks.cpp	Switches thunk-emitted calls from `TransparentAwait` to `TransparentSuspendFor` helpers.
src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp	Records/replays the new `getAwaitReturnCall` API for SuperPMI.
src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp	Forwards the new API in the simple shim.
src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp	Counts/forwards the new API in the counter shim.
src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp	Records the new API in the collector shim.
src/coreclr/tools/superpmi/superpmi-shared/spmirecordhelper.h	Makes lookup restore helpers take `const&` and updates corresponding implementations.
src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h	Adds recording/replay plumbing for `getAwaitReturnCall`.
src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp	Implements record/dump/replay for `getAwaitReturnCall`.
src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h	Registers the new lightweight-map packet for `GetAwaitReturnCall`.
src/coreclr/tools/superpmi/superpmi-shared/agnostic.h	Adds agnostic structs for `CORINFO_LOOKUP*` and the await-return result payload.
src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncThunks.cs	Updates IL stub emitter to use `TransparentSuspendFor*` helper names.
src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt	Adds the new interface method to thunk generation input.
src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs	Adds a stub managed implementation of `getAwaitReturnCall` for the managed JIT interface.
src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs	Adds unmanaged callback plumbing for `getAwaitReturnCall`.
src/coreclr/tools/aot/jitinterface/jitinterface_generated.h	Adds the new callback and wrapper method to the AOT jitinterface wrapper.
src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs	Renames “suspend” helpers and adds typed `TransparentAwait(...)` overloads used by the JIT.
src/coreclr/jit/importercalls.cpp	Adds tail-await handling for async-version tail-await prefix and blocks inlining of async-version callees.
src/coreclr/jit/importer.cpp	Adds async-version tail-call recognition, wraps async-version returns in an await via `getAwaitReturnCall`, and introduces `impWrapTopOfStackInAwait`.
src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp	Adds wrapper forwarding for `getAwaitReturnCall`.
src/coreclr/jit/ICorJitInfo_names_generated.h	Adds name entry for `getAwaitReturnCall`.
src/coreclr/jit/fginline.cpp	Minor whitespace change near async flag handling for inlinee compilation.
src/coreclr/jit/compiler.h	Introduces `PREFIX_IS_ASYNC_VERSION_TAIL_AWAIT`, `impWrapTopOfStackInAwait`, and `compIsAsyncVersion()`.
src/coreclr/jit/compiler.cpp	Adds verbose printing when compiling an async-version method.
src/coreclr/inc/jiteeversionguid.h	Updates JIT↔EE version GUID due to interface change.
src/coreclr/inc/icorjitinfoimpl_generated.h	Adds `getAwaitReturnCall` override to the generated `ICorJitInfo` impl header.
src/coreclr/inc/corinfo.h	Adds `CORINFO_ASYNC_VERSION` and the new `ICorStaticInfo::getAwaitReturnCall` method.

Copilot

Pull request overview

Copilot reviewed 32 out of 32 changed files in this pull request and generated 6 comments.

jakobbotsch · 2026-05-20T11:34:59Z

Another pattern we may want to recognize:

runtime/src/libraries/System.Linq.AsyncEnumerable/src/System/Linq/MaxAsync.cs

Lines 24 to 38 in b129b7c

    
                   public static ValueTask<TSource?> MaxAsync<TSource>( 
        
                       this IAsyncEnumerable<TSource> source, 
        
                       IComparer<TSource>? comparer = null, 
        
                       CancellationToken cancellationToken = default) 
        
                   { 
        
                       ArgumentNullException.ThrowIfNull(source); 
        
                       comparer ??= Comparer<TSource>.Default; 
        
                       // Special-case float/double/float?/double? to maintain compatibility 
        
                       // with System.Linq.Enumerable implementations. 
        
           #pragma warning disable CA2012 // Use ValueTasks correctly 
        
                       if (typeof(TSource) == typeof(float) && comparer == Comparer<TSource>.Default) 
        
                       { 
        
                           return (ValueTask<TSource?>)(object)MaxAsync((IAsyncEnumerable<float>)(object)source, cancellationToken);

Copilot

Pull request overview

Copilot reviewed 32 out of 32 changed files in this pull request and generated 3 comments.

Copilot

Pull request overview

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

+        [BypassReadyToRun]
+        [MethodImpl(MethodImplOptions.Async)]
+        private static void TransparentAwaitWithResult(Task task)


VSadov · 2026-06-09T22:28:03Z

        return opts.jitFlags->IsSet(JitFlags::JIT_FLAG_ASYNC);
    }

+    // Is this the async version of a non-async method? IL belongs to non-async method.


Can there be suspension points?
Are all awaits tail awaits in these methods?

While all awaits are in tail position, they still sometimes do result in suspension points:

When not optimizing

When NoInlining is applied we should do that too since that's often used to ensure a method shows up in stack traces (we disable normal tailcalling based on this)

Due to covariance a tail await may not be legal, e.g. Task<int> returned from Task method cannot become a tail-await

I see. It may have suspension points, but it is transparent (in context popping sense), so it can use tail awaits where possible.

The PR description says: It then adds a guaranteed optimization to make tail calls in the synchronous task-returning methods into runtime async calls.

It is not "guaranteed" then. More like "highly likely".

It isn't guaranteed that they become tail awaits, but it is guaranteed that eligible calls become runtime async calls.

VSadov · 2026-06-09T23:09:27Z


+        public static bool RequiresSaveRestoreOfAsyncContexts(this MethodDesc method)
+        {
+            return method.IsAsync && method.IsAsyncVariant();


IsAsync here means "async in IL sense" and thus RequiresSaveRestoreOfAsyncContexts does not include the new async versions of sync methods. Correct?

Correct. This was just factoring out the test since I noticed the IL scanner was a bit imprecise with this, and to align it with the VM.

VSadov · 2026-06-09T23:35:05Z

I haven't renamed IsAsyncThunk() which is a bit misleading now since these aren't thunks. Open to suggestions on what to do here. The managed type system has a SupportsAsyncVersionCodegen which checks for these specific methods, since it needed this check in more places. Let me push a commit to add a method by that name in the VM too.

They are different implementation strategy of what was async thunks. I think the issue is just in naming.

In a sense - they are still "synthetic methods with async call convention and the same functionality as corresponding sync method". Except they no longer do that by forwarding to the sync method, but by embedding it entirely and unwrapping (or not wrapping in the first place) the return values.

I guess they are not thunks, since they do not forward. Maybe we can come up with a new term that means "synthetic parallel implementation" that does not imply forwarding?

Maybe IsAsyncEntry?
(As in "async entry point for a sync method". How much of original method is embedded is implementation detail)

IsAsyncAlternative?

…ersions

jakobbotsch · 2026-06-10T15:40:51Z

                // we cannot resolve to an Async variant in such case.
                // return NULL, so that caller would re-resolve as a regular method call
-                pMD = pMD->ReturnsTaskOrValueTask() ? pMD->GetAsyncVariant(/*allowInstParam*/FALSE) : NULL;
+                pMD = pMD->ReturnsTaskOrValueTask() && !pMD->IsCLRToCOMCall() ? pMD->GetAsyncVariant(/*allowInstParam*/FALSE) : NULL;


@AaronRobinsonMSFT @jkotas When I removed EmitAsyncMethodThunk I ran into the problem that we were relying on that transient IL when calling an async variant of one of these, and the non-async variant does not have any IL so we cannot create an async version of it.

I wonder if you think this is a sufficient fix. Can we guarantee that we never try to call the async variant of these? If not do you have other suggestions for solving this problem, or should I bring back EmitAsyncMethodThunk?

It appears that what we have is basically the same thunk as before, but with the call to sync variant aggressively inlined and then applying tail-awaiting optimizations in the thunk where possible.
Maybe it is ok to keep calee uninlined into a thunk in some cases? (i.e. if sync variant has no IL)

Actually - why not simply keep the thunk as it was, but mark somehow the sync call in it as AggressivelyInline and do the same tail-await optimization after inlining?

Is it a requirement to do the optimization in importer - like it must happen before async lowering, for example?
(I am mostly just wondering why we choose one approach vs. another)

That was my original suggestion in #115771, see #115771 (comment) for some more discussion around it. Basically we wanted this optimization to be guaranteed for tier0 too.

Copilot

Pull request overview

Copilot reviewed 44 out of 44 changed files in this pull request and generated 1 comment.

`EcmaMethodIL.Create` bypasses unsafe accessor handling, so call `GetMethodIL` recursively to compensate for them or anything else we might be special casing.

The `scope ??=` path is reached when the method is abstract and the `GetMethodIL` above didn't return anything. We don't strictly need `EcmaMethodILScope` to be for an ECMA method, we just need to be able to resolve tokens in such scope.

Copilot

Pull request overview

Copilot reviewed 46 out of 46 changed files in this pull request and generated 1 comment.

jakobbotsch added 3 commits May 18, 2026 13:01

Cache Task continuation for runtime async callable task thunks

192f7ba

Compile runtime async versions of synchronous task-returning methods

74aab70

Disable some stack trace tests

5cec9e3

Copilot AI review requested due to automatic review settings May 19, 2026 20:00

github-actions Bot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 19, 2026

Copilot started reviewing on behalf of jakobbotsch May 19, 2026 20:01 View session

dotnet-policy-service Bot assigned jakobbotsch May 19, 2026

Copilot AI reviewed May 19, 2026

View reviewed changes

jakobbotsch mentioned this pull request May 19, 2026

[runtime-async] Optimize synchronous Task-returning wrappers used in async context #115771

Open

Return some code to fix crossgen2

27470b8

jakobbotsch commented May 20, 2026

View reviewed changes

Comment thread src/coreclr/jit/importer.cpp

Run jit-format

9572940

Copilot AI review requested due to automatic review settings May 20, 2026 10:46

Copilot started reviewing on behalf of jakobbotsch May 20, 2026 10:47 View session

Copilot AI reviewed May 20, 2026

View reviewed changes

am11 added the runtime-async label May 20, 2026

jakobbotsch added 2 commits May 20, 2026 13:40

Call impNormStructVal on value tasks, fix some docs

514d583

Another comment

13c2045

Copilot AI review requested due to automatic review settings May 20, 2026 11:47

Copilot started reviewing on behalf of jakobbotsch May 20, 2026 11:47 View session

Copilot AI reviewed May 20, 2026

View reviewed changes

Comment thread src/tests/async/reflection/reflection.cs

Comment thread src/coreclr/vm/asyncthunks.cpp Outdated

Comment thread src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

jakobbotsch added 3 commits May 20, 2026 14:58

Run jit-format

26c12f9

Fix bug

1cbeb65

Fix assert

e4f192a

Copilot AI review requested due to automatic review settings May 20, 2026 14:18

Copilot started reviewing on behalf of jakobbotsch May 20, 2026 14:19 View session

Copilot AI reviewed Jun 9, 2026

View reviewed changes

Comment thread src/coreclr/inc/corinfo.h

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

Comment on lines +667 to +669

[BypassReadyToRun]

[MethodImpl(MethodImplOptions.Async)]

private static void TransparentAwaitWithResult(Task task)

VSadov reviewed Jun 9, 2026

View reviewed changes

Comment thread src/coreclr/inc/corinfo.h

VSadov reviewed Jun 9, 2026

View reviewed changes

Comment thread src/coreclr/jit/compiler.cpp Outdated

VSadov reviewed Jun 9, 2026

View reviewed changes

jakobbotsch added 5 commits June 10, 2026 16:28

More verbose JITDUMP

4801b0f

Merge branch 'main' of github.com:dotnet/runtime into runtime-async-v…

a0bb532

…ersions

Try out using async version of dynamically generated IL too

28cb713

Do not use async variants of CLR to COM calls

2a95de7

Fix getEHinfo

9c92609

jakobbotsch commented Jun 10, 2026

View reviewed changes

Run jit-format

d318b19

Copilot AI review requested due to automatic review settings June 10, 2026 15:42

Copilot started reviewing on behalf of jakobbotsch June 10, 2026 15:43 View session

Copilot AI reviewed Jun 10, 2026

View reviewed changes

Comment thread src/coreclr/vm/jitinterface.cpp Outdated

Go back to having headers for async versions backed by IL

749edf3

MichalStrehovsky added 2 commits June 11, 2026 12:43

Make things work with UnsafeAccessor

ac0ef8b

`EcmaMethodIL.Create` bypasses unsafe accessor handling, so call `GetMethodIL` recursively to compensate for them or anything else we might be special casing.

Copilot AI review requested due to automatic review settings June 11, 2026 03:46

Copilot started reviewing on behalf of MichalStrehovsky June 11, 2026 03:46 View session

Copilot AI reviewed Jun 11, 2026

View reviewed changes

Comment thread src/coreclr/inc/corinfo.h

Merge branch 'main' into runtime-async-versions

d2487cd

Conversation

jakobbotsch commented May 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

jakobbotsch commented May 20, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

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!

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!

VSadov commented Jun 9, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

VSadov Jun 11, 2026 • 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 Jun 11, 2026 • 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!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

jakobbotsch commented May 19, 2026 •

edited

Loading

VSadov Jun 11, 2026 •

edited

Loading

VSadov Jun 11, 2026 •

edited

Loading