Enable devirtualization of async methods in crossgen2 by jtschuster · Pull Request #125420 · dotnet/runtime

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster · 2026-03-10T22:51:36Z

Crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching ilc.

Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch.

Without the fix, interface dispatch on a newobj-allocated type (CallOnNewOpenInterfaceImpl test) emits a VIRTUAL_ENTRY indirect dispatch:

 lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY)

With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call:

 call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY)

The other calls still require runtime dispatch.

Fixes#124620

crossgen2's CompilerTypeSystemContext was using MetadataVirtualMethodAlgorithm, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to AsyncAwareVirtualMethodResolutionAlgorithm, matching the NativeAOT compiler. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Fixesdotnet#124620 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR fixes crossgen2 devirtualization for awaited virtual/interface methods by switching ReadyToRun’s CompilerTypeSystemContext to an async-variant-aware virtual method resolution algorithm (matching ilc). It also adds an async test intended to exercise devirtualization scenarios involving sealed dispatch and interface/generic constrained dispatch.

Changes:

Switch ReadyToRun’s virtual method algorithm from MetadataVirtualMethodAlgorithm to AsyncAwareVirtualMethodResolutionAlgorithm.
Add a new async test project covering multiple async virtual dispatch shapes (class, interface, and constrained generic calls).

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs	Uses async-aware virtual method resolution so crossgen2 can resolve/devirtualize async variant methods.
src/tests/async/devirtualize/devirtualize.csproj	Adds a new async test project for devirtualization scenarios.
src/tests/async/devirtualize/devirtualize.cs	Introduces async virtual/interface dispatch scenarios meant to exercise crossgen2 devirtualization paths.

Move the field declaration from the R2R and NativeAOT partial class files to the shared CompilerTypeSystemContext.cs, since both now use the same AsyncAwareVirtualMethodResolutionAlgorithm type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Crossgen2's `CompilerTypeSystemContext` was using `MetadataVirtualMethodAlgorithm`, which does not handle async variant methods. This prevented devirtualization of async virtual methods during R2R compilation. Switch to `AsyncAwareVirtualMethodResolutionAlgorithm`, matching ilc. Add a devirtualize test for async methods exercising sealed class virtual dispatch, sealed interface dispatch, and generic constrained dispatch. Without the fix, interface dispatch on a newobj-allocated type (`CallOnNewOpenInterfaceImpl` test) emits a VIRTUAL_ENTRY indirect dispatch: ``` lea r11, [0x70a0] // [ASYNC] IAsyncInterface.GetValue() (VIRTUAL_ENTRY) ``` With the fix, crossgen2 resolves the async variant through the interface and devirtualizes to a direct call: ``` call qword ptr [0x6290] // [ASYNC] OpenInterfaceImpl.GetValue() (METHOD_ENTRY) ``` The other calls still require runtime dispatch. Fixes#124620 --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Add 5 new tests covering key runtime-async crossgen2 PRs: - RuntimeAsyncMethodEmission (dotnet#124203): Validates [ASYNC] variant entries for Task/ValueTask-returning methods - RuntimeAsyncContinuationLayout (dotnet#123643): Validates ContinuationLayout and ResumptionStubEntryPoint fixups for methods with GC refs across awaits - RuntimeAsyncDevirtualize (dotnet#125420): Validates async virtual method devirtualization produces [ASYNC] entries for sealed/interface dispatch - RuntimeAsyncNoYield (dotnet#124203): Validates async methods without await still produce [ASYNC] variants - RuntimeAsyncCrossModule (dotnet#121679): Validates MutableModule async references work with cross-module inlining of runtime-async methods Infrastructure changes: - Add Roslyn feature flag support (runtime-async=on) to R2RTestCaseCompiler - Add R2RExpectations for async variants, resumption stubs, continuation layouts, and arbitrary fixup kinds - Add MainExtraSourceResourceNames to R2RTestCase for shared source files - Add null guard for method.Fixups in CheckFixupKinds All 9 tests pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

jtschuster requested review from MichalStrehovsky, Copilot and davidwrighton March 10, 2026 22:51

github-actionsBot added the area-ReadyToRun label Mar 10, 2026

dotnet-policy-serviceBot assigned jtschuster Mar 10, 2026

github-project-automationBot added this to AppModel Mar 10, 2026

Copilotstarted reviewing on behalf of jtschuster March 10, 2026 22:52 View session

CopilotAI reviewed Mar 10, 2026
View reviewed changes

Comment threadsrc/tests/async/devirtualize/devirtualize.cs

MichalStrehovsky approved these changes Mar 10, 2026
View reviewed changes

Comment threadsrc/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilerContext.cs Outdated

jtschuster merged commit 8f06b3c into dotnet:mainMar 12, 2026
111 checks passed

github-project-automationBot moved this to Done in AppModel Mar 12, 2026

dotnet-maestroBot mentioned this pull request Mar 12, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#5408
Merged

github-actionsBot locked and limited conversation to collaborators Apr 11, 2026