JIT: Refactor async-to-sync call optimization by jakobbotsch · Pull Request #124798 · dotnet/runtime

jakobbotsch · 2026-02-24T16:19:08Z

Introduce getAsyncOtherVariant JIT-EE API that returns the other async variant of an async/task-returning method
Remove the AwaitVirtual token kind that was used to allow the VM to tell the JIT to prefer a task-returning instead of async variant
Implement the same optimization on the JIT side instead using the getAsyncOtherVariant, when we notice that a call will be direct

- Introduce `getAsyncOtherVariant` JIT-EE API that returns the other async variant of an async/task-returning method - Remove the `AwaitVirtual` token kind that was used to allow the VM to tell the JIT to prefer a task-returning instead of async variant - Implement the same optimization on the JIT side instead using the `getAsyncOtherVariant`, when we notice that a call will be direct Fix dotnet#124545

dotnet-policy-service · 2026-02-24T16:20:41Z

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

Copilot

Pull request overview

Refactors the async-to-sync call optimization by removing VM-driven “prefer task-returning for direct calls” token handling and moving the decision logic into the JIT using a new JIT↔EE API (getAsyncOtherVariant).

Changes:

Add ICorJitInfo::getAsyncOtherVariant API and plumb it through VM, JIT wrappers, NativeAOT JIT interface, and SuperPMI record/replay.
Remove CORINFO_TOKENKIND_AwaitVirtual and simplify await token resolution to always request the async variant from the VM.
Teach the JIT importer to switch back to the synchronous Task-returning call for direct calls when the async variant is a thunk.

Reviewed changes

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

Show a summary per file

File	Description
src/coreclr/vm/jitinterface.cpp	Removes AwaitVirtual-specific resolution logic; adds EE implementation of `getAsyncOtherVariant`.
src/coreclr/jit/importer.cpp	Implements JIT-side “avoid thunk for direct calls” logic using `getAsyncOtherVariant`.
src/coreclr/jit/ee_il_dll.hpp	Replaces `combine(...)` helper with `CORINFO_CALLINFO_FLAGS` `operator
src/coreclr/inc/corinfo.h	Removes `CORINFO_TOKENKIND_AwaitVirtual`; adds `ICorStaticInfo::getAsyncOtherVariant`.
src/coreclr/inc/icorjitinfoimpl_generated.h	Declares the new EE-side virtual method override.
src/coreclr/inc/jiteeversionguid.h	Updates the JIT/EE interface version GUID for the API shape change.
src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp	Adds wrapper forwarding for `getAsyncOtherVariant`.
src/coreclr/jit/ICorJitInfo_names_generated.h	Adds name for the new API.
src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp	Adds SuperPMI ICJI forwarding/recording hook.
src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp	Adds shim forwarding for the new API.
src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp	Adds shim call counting + forwarding for the new API.
src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp	Records/replays `getAsyncOtherVariant` including `variantIsThunk`.
src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h	Adds record/replay declarations + packet ID for `getAsyncOtherVariant`.
src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp	Implements record/replay storage for `getAsyncOtherVariant`.
src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h	Adds LWM map entry for `GetAsyncOtherVariant`.
src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt	Adds new API to thunk generator inputs.
src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs	Removes `CORINFO_TOKENKIND_AwaitVirtual` from managed enum mirror.
src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs	Adds unmanaged callback plumbing for `getAsyncOtherVariant`.
src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs	Updates await-token handling; adds (currently stubbed) `getAsyncOtherVariant` managed implementation.
src/coreclr/tools/aot/jitinterface/jitinterface_generated.h	Adds callback pointer + wrapper method for `getAsyncOtherVariant`.
src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs	Removes NativeAOT scanner-side “avoid thunk for direct calls” logic.
src/coreclr/interpreter/compiler.cpp	Removes AwaitVirtual usage in interpreter async-call peep token resolution.
src/coreclr/tools/aot/ilc.slnx	Adds ILLink.CodeFixProvider project to the solution.
src/coreclr/tools/aot/crossgen2.slnx	Adds ILLink.CodeFixProvider project to the solution.

Copilot · 2026-02-24T16:28:56Z

src/coreclr/tools/aot/crossgen2.slnx

+  <Project Path="../../../tools/illink/src/ILLink.CodeFix/ILLink.CodeFixProvider.csproj">
+    <BuildType Solution="Checked|*" Project="Debug" />
+  </Project>


This adds ILLink.CodeFixProvider to the crossgen2 solution. This appears unrelated to the PR's described JIT/EE async-variant work; please confirm it's intentional (and if not, revert it to keep the PR focused).

Copilot · 2026-02-24T16:28:57Z

src/coreclr/vm/jitinterface.cpp

+         pAsyncOtherVariant = pMD->GetAsyncOtherVariant();
+    }
+    result = (CORINFO_METHOD_HANDLE)pAsyncOtherVariant;
+    *variantIsThunk = pAsyncOtherVariant != NULL && pAsyncOtherVariant->IsAsyncThunkMethod();


CEEInfo::getAsyncOtherVariant always returns NULL because result is never assigned, and it unconditionally dereferences variantIsThunk (nullptr is allowed by some shims). This breaks the API contract and can crash callers that pass nullptr; set result to the other variant handle (or NULL) and only write through variantIsThunk when it is non-null.

Suggested change

*variantIsThunk = pAsyncOtherVariant != NULL && pAsyncOtherVariant->IsAsyncThunkMethod();

if (variantIsThunk != NULL)

{

*variantIsThunk = (pAsyncOtherVariant != NULL) && pAsyncOtherVariant->IsAsyncThunkMethod();

}

Copilot · 2026-02-24T16:28:57Z

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

+        private CORINFO_METHOD_STRUCT_* getAsyncOtherVariant(CORINFO_METHOD_STRUCT_* ftn, ref bool variantIsThunk)
+        {
+            MethodDesc method = HandleToObject(ftn);
+            if (method.IsAsyncVariant())


getAsyncOtherVariant is wired into the JIT callback table, and the JIT importer now calls it for await-pattern direct calls. Throwing NotImplementedException here will break NativeAOT/ReadyToRun compilation of async methods; implement this by mapping between the async variant and task-returning variant (and set variantIsThunk based on IsAsyncThunk()/IsAsync on the returned variant).

Copilot · 2026-02-24T16:28:58Z

src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs

+            var _this = GetThis(thisHandle);
+            try
+            {
+                return _this.getAsyncOtherVariant(ftn, ref *variantIsThunk);


The unmanaged entrypoint for getAsyncOtherVariant dereferences variantIsThunk (ref *variantIsThunk) without a null check. The native signature allows callers to pass nullptr (and some shims already treat it as optional), so this can AV; handle a null pointer by using a local temporary bool and only writing back when non-null.

Suggested change

return _this.getAsyncOtherVariant(ftn, ref *variantIsThunk);

bool localVariantIsThunk = variantIsThunk is not null && *variantIsThunk;

CORINFO_METHOD_STRUCT_* result = _this.getAsyncOtherVariant(ftn, ref localVariantIsThunk);

if (variantIsThunk is not null)

{

*variantIsThunk = localVariantIsThunk;

}

return result;

Copilot · 2026-02-24T16:28:58Z

src/coreclr/interpreter/compiler.cpp

-    CorInfoTokenKind tokenKind =
-        ip[0] == CEE_CALL ? CORINFO_TOKENKIND_Await : CORINFO_TOKENKIND_AwaitVirtual;
-    ResolveToken(getU4LittleEndian(ip + 1), tokenKind, &m_resolvedAsyncCallToken);
+    ResolveToken(getU4LittleEndian(ip + 1), CORINFO_TOKENKIND_Await, &m_resolvedAsyncCallToken);


With CORINFO_TOKENKIND_AwaitVirtual removed, ResolveAsyncCallToken now always resolves using CORINFO_TOKENKIND_Await (even for direct CEE_CALL). Previously the VM could avoid returning an async-thunk variant for direct calls; now the interpreter may end up calling thunks unnecessarily. Consider applying the same direct-call check as the JIT importer (after getCallInfo: if callInfo.kind==CORINFO_CALL and the async variant is a thunk, fall back to resolving the regular method token).

Suggested change

ResolveToken(getU4LittleEndian(ip + 1), CORINFO_TOKENKIND_Await, &m_resolvedAsyncCallToken);

const uint8_t opcode = *ip;

const unsigned token = getU4LittleEndian(ip + 1);

if (opcode == CEE_CALL)

{

ResolveToken(token, CORINFO_TOKENKIND_Method, &m_resolvedAsyncCallToken);

}

else

{

ResolveToken(token, CORINFO_TOKENKIND_Await, &m_resolvedAsyncCallToken);

}

Copilot · 2026-02-24T16:28:58Z

src/coreclr/tools/aot/ilc.slnx

+  <Project Path="../../../tools/illink/src/ILLink.CodeFix/ILLink.CodeFixProvider.csproj">
+    <BuildType Solution="Checked|*" Project="Debug" />
+  </Project>


This adds ILLink.CodeFixProvider to the ilc solution. This seems unrelated to the PR's stated JIT/EE async-variant refactor and may affect solution build time/dependencies; please confirm this is intentional and, if not, remove it from the PR.

Copilot

Pull request overview

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

Copilot · 2026-02-24T16:40:23Z

src/coreclr/jit/importer.cpp

+                    {
+                        assert(callInfo.sig.isAsyncCall());
+                        bool isSyncCallThunk;
+                        info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);


The return value of getAsyncOtherVariant is not being captured or used. The code re-resolves the token with CORINFO_TOKENKIND_Method instead of using the returned method handle directly. While this may work correctly in most cases, there could be edge cases where re-resolving doesn't give the exact same specialized method descriptor, particularly in generic contexts. Consider capturing and using the return value directly to avoid the redundant token resolution and ensure correctness.

Suggested change

info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);

CORINFO_METHOD_HANDLE asyncOtherVariant =

info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);

if ((asyncOtherVariant != nullptr) && !isSyncCallThunk)

{

callInfo.hMethod = asyncOtherVariant;

}

Copilot · 2026-02-24T16:40:23Z

src/coreclr/jit/importer.cpp

+                        bool isSyncCallThunk;
+                        info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);
+                        if (!isSyncCallThunk)


The variable name isSyncCallThunk is misleading. When getAsyncOtherVariant is called on an async method, it returns the sync (task-returning) variant. The bool parameter indicates whether that returned sync variant is a thunk. Consider renaming to otherVariantIsThunk or syncVariantIsThunk to make the meaning clearer.

Suggested change

bool isSyncCallThunk;

info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);

if (!isSyncCallThunk)

bool syncVariantIsThunk;

info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &syncVariantIsThunk);

if (!syncVariantIsThunk)

Copilot · 2026-02-24T16:40:24Z

src/coreclr/tools/aot/crossgen2.slnx

+  <Project Path="../../../tools/illink/src/ILLink.CodeFix/ILLink.CodeFixProvider.csproj">
+    <BuildType Solution="Checked|*" Project="Debug" />
+  </Project>


This change adds ILLink.CodeFix project references to the solution files. This appears unrelated to the async-to-sync call optimization that is the focus of this PR. If this is an intentional change, it should be mentioned in the PR description or done in a separate commit/PR for clarity.

Copilot AI review requested due to automatic review settings February 24, 2026 16:19

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

dotnet-policy-service bot assigned jakobbotsch Feb 24, 2026

Copilot started reviewing on behalf of jakobbotsch February 24, 2026 16:20 View session

jakobbotsch added 2 commits February 24, 2026 17:22

Managed type system impl

8ef22c8

Fix

1460458

Copilot AI reviewed Feb 24, 2026

View reviewed changes

jakobbotsch added 2 commits February 24, 2026 17:31

Disallow null variantIsThunk

d3f8649

Run jit-format

2a664b1

Copilot AI review requested due to automatic review settings February 24, 2026 16:34

Copilot started reviewing on behalf of jakobbotsch February 24, 2026 16:35 View session

Copilot AI reviewed Feb 24, 2026

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Comments

JIT: Refactor async-to-sync call optimization#124798

JIT: Refactor async-to-sync call optimization#124798
jakobbotsch wants to merge 5 commits intodotnet:mainfrom
jakobbotsch:fix-static-virtuals-2

jakobbotsch commented Feb 24, 2026

Uh oh!

dotnet-policy-service bot commented Feb 24, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Copilot AI Feb 24, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

-    *variantIsThunk = pAsyncOtherVariant != NULL && pAsyncOtherVariant->IsAsyncThunkMethod();
+    if (variantIsThunk != NULL)
+    {
+        *variantIsThunk = (pAsyncOtherVariant != NULL) && pAsyncOtherVariant->IsAsyncThunkMethod();
+    }

-                return _this.getAsyncOtherVariant(ftn, ref *variantIsThunk);
+                bool localVariantIsThunk = variantIsThunk is not null && *variantIsThunk;
+                CORINFO_METHOD_STRUCT_* result = _this.getAsyncOtherVariant(ftn, ref localVariantIsThunk);
+                if (variantIsThunk is not null)
+                {
+                    *variantIsThunk = localVariantIsThunk;
+                }
+                return result;

-    ResolveToken(getU4LittleEndian(ip + 1), CORINFO_TOKENKIND_Await, &m_resolvedAsyncCallToken);
+    const uint8_t opcode = *ip;
+    const unsigned token = getU4LittleEndian(ip + 1);
+    if (opcode == CEE_CALL)
+    {
+        ResolveToken(token, CORINFO_TOKENKIND_Method, &m_resolvedAsyncCallToken);
+    }
+    else
+    {
+        ResolveToken(token, CORINFO_TOKENKIND_Await, &m_resolvedAsyncCallToken);
+    }

-                        info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);
+                        CORINFO_METHOD_HANDLE asyncOtherVariant =
+                            info.compCompHnd->getAsyncOtherVariant(callInfo.hMethod, &isSyncCallThunk);
+                        if ((asyncOtherVariant != nullptr) && !isSyncCallThunk)
+                        {
+                            callInfo.hMethod = asyncOtherVariant;
+                        }

Comments

Conversation

jakobbotsch commented Feb 24, 2026

Uh oh!

dotnet-policy-service bot commented Feb 24, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

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 Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 24, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant