Add support for encoding Continuation types with specific layouts in ReadyToRun by jtschuster · Pull Request #123643 · dotnet/runtime

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschuster · 2026-01-26T21:48:31Z

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37):

Encode the GC ref map as a bit vector expanded to a byte array
Add runtime support to read continuation type fixups from R2R images:

GetContinuationTypeFromLayout decodes the blob and creates the type
LoadDynamicInfoEntry handles the new fixup kind

Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…ithToken

… token

…kReturningThunks

The generated IL thunk does not have valid tokens, so the tokens emitted in the EH handler info are invalid. It's not an invariant that there is always a reference to System.Exception or System.Object in the assembly that we are generating thunks for, so we can't always get a valid Token for the exception type token field. Instead, we can create a filter that does a type check against System.Exception. The reference to System.Exception will be filled in with a Fixup with a module override if we don't have a reference to System.Exception in the assembly.

…kReturningThunks

With these changes, we no longer need separate IL for nativeaot and readytorun

* Rework async thunks generation to cross module generics infra - Add ability for code generating an ILStub to mark that the tokens might be generated - Funnel through various details to ensure that we trigger creation of the ManifestModuleWrappedMethodIL as needed - Adjust method fixup signature generation to allow for VersionsWithMethodBody code which is in the MutableModule - Add a few todos about work we might do to allow cross module compilation of runtime async code. - Disable this for now though, since its much to complex to test without a working end-to-end scenario (See code in CrossModuleInlineableUncached * Revert logic which attempts to treat System.Exception in EH clause specially

…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

…Token == 0

…kReturningThunks

…ature

- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Encode Continuation types in R2R images using a new fixup kind (READYTORUN_FIXUP_Continuation_Layout = 0x37): - Include OwningMethod to associate the Continuation type with the correct loader allocator at runtime - Encode the GC ref map as a bit vector expanded to a byte array - Add AsyncContinuationLayoutAlgorithm for field layout computation Add runtime support to read continuation type fixups from R2R images: - GetContinuationTypeFromLayout decodes the blob and creates the type - LoadDynamicInfoEntry handles the new fixup kind Also adds helper constants for future continuation allocation helpers. Note: These code paths are not yet exercised as async2 methods are not currently compiled to ReadyToRun images.

…g unneeded method parameters and simplifying type resolution logic.

…ationTypeFixup

Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton

Other than the bits of PR #123975 to remove from this change, I think this is good.

Copilot

Pull request overview

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

…onLayout signature

Copilot

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

…ReadyToRun (dotnet#123643) Enable encoding and decoding of async continuation type layouts in ReadyToRun images, allowing the R2R compiler to emit continuation types that were previously only supported at JIT time. ## Crossgen2 (compile-time) changes - **New fixup kind `ContinuationLayout = 0x37`**: Added to `ReadyToRunFixupKind` in both native (`readytorun.h`) and managed (`ReadyToRunConstants.cs`) headers to represent the layout of an async method continuation type. - **Remove `NotImplementedException` for `getContinuationType` in R2R**: The `#if READYTORUN` guard that blocked `getContinuationType` is removed from `CorInfoImpl.cs`, enabling continuation type creation during R2R compilation. - **Initialize `_continuationTypeHashtable` in R2R compiler context**: The hashtable is now constructed in the `CompilerTypeSystemContext` R2R partial constructor so continuation types can be created and cached. - **Short-circuit loadability checks for continuation types**: Newly created `AsyncContinuationType` instances are added to `_validTypes` in the `ContinuationTypeHashtable` to bypass loadability verification, since these types are always valid by construction. - **Intercept `AsyncContinuationType` in `embedClassHandle`**: In `CorInfoImpl.ReadyToRun.cs`, when embedding a class handle for an `AsyncContinuationType`, emit a `PrecodeHelperImport` with the new `ContinuationLayout` fixup instead of attempting the normal type handle encoding path. - **`ContinuationTypeSymbol` and `NodeCache` in `ReadyToRunSymbolNodeFactory`**: Adds a node cache and public accessor to create `PrecodeHelperImport` nodes for continuation type fixups. - **Guard against encoding continuations on the normal type signature path**: `SignatureBuilder.EmitTypeSignature` now throws `InvalidOperationException` if it encounters an `AsyncContinuationType`, since these must go through the dedicated `ContinuationLayout` fixup path. - **`EncodeContinuationTypeLayout` in `TypeFixupSignature`**: Encodes the continuation's GC pointer map as a bit vector packed into a byte array, along with size and alignment flags. The `ContinuationLayout` fixup emits the base `Continuation` EcmaType followed by this layout blob. ## Runtime (load-time) changes - **`GetContinuationTypeFromLayout` in `jitinterface.cpp`**: Decodes the continuation layout blob from the R2R image — reads flags, size, and GC ref map bitmap — expands the bitmap back to a `bool` array, and calls into the continuation type creation infrastructure. - **`LoadDynamicInfoEntry` handles `READYTORUN_FIXUP_Continuation_Layout`**: Calls `GetContinuationTypeFromLayout` to materialize the continuation `MethodTable` at runtime when the fixup is resolved. - **Refactor `LookupOrCreateContinuationMethodTable` to accept `Module*` instead of `MethodDesc*`**: The `MethodDesc*`-taking overload of `CreateNewContinuationMethodTable` is removed and its debug naming logic is inlined into `LookupOrCreateContinuationMethodTable`, which now takes a `Module* loaderModule` directly. This enables creation of continuation types from R2R fixup decoding where no `MethodDesc` is available. A corresponding static `getContinuationType` helper is extracted from `CEEInfo::getContinuationType` for reuse by `GetContinuationTypeFromLayout`. ## Diagnostic / tooling changes - **`ReadyToRunSignature.cs` refactoring**: The inline type layout parsing logic for `Check_TypeLayout`/`Verify_TypeLayout` is extracted into a shared `ParseTypeLayout` method, which is also reused for the new `ContinuationLayout` fixup kind. Adds display of `" Align native"` and `" GCLayout 0x00 (Empty)"` for improved diagnostic output. > **Note:** These code paths are not yet exercised end-to-end, as async2 methods are not currently compiled into ReadyToRun images. Co-authored-by: David Wrighton <davidwr@microsoft.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com>

jtschusterand others added 28 commits December 18, 2025 10:03

Handle continuation parameter in R2R GCRefMaps
0f2cdb5

Add helper extension methods
5be88cb

Emit Task-returning thunks in crossgen2
d048346

Merge branch 'main' ofhttps://github.com/dotnet/runtimeinto MethodW…
e947ed4
…ithToken

Undo additional changes
b779849

Ensure type doesn't version with module group before finding external…
3f87ad6
… token

Punt on generic async thunks, skip all async-variant methods
7df757a

Get PrimaryMethodDesc for ShouldCodeNotBeCompiled
73de02d

Merge branch 'main' ofhttps://github.com/dotnet/runtimeinto EmitTas…
2982051
…kReturningThunks

Skip non-task-returning async methods instead of throwing.
04f28df

Use class token EHInfo in NAOT, filter in R2R
03ace75

Merge branch 'main' ofhttps://github.com/dotnet/runtimeinto EmitTas…
31ea783
…kReturningThunks

Emit null token to represent catching a System.Exception
c87316a
With these changes, we no longer need separate IL for nativeaot and readytorun

Undo extra ClassToken == 0 check
3ee2e57

Add the emission logic in crossgen
04fcdac

Update src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorIn…
ba0405f
…foImpl.ReadyToRun.cs Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Encode/decode ClassToken of 0 as System.Exception for async thunks
5586607

Use COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION flag instead of Class…
7551267
…Token == 0

Merge branch 'main' ofhttps://github.com/dotnet/runtimeinto EmitTas…
20801c9
…kReturningThunks

Remove unneeded code
0a72cbf

Use MutableModule token for resolving owning type, def token for sign…
08a32ae
…ature

Remove aot.slnx
5bb847a

Address PR feedback for R2R_SYSTEM_EXCEPTION EH clause encoding
55a1c84
- Clear ClassTokenOrOffset when setting R2R_SYSTEM_EXCEPTION flag - Add COR_ILEXCEPTION_CLAUSE_R2R_SYSTEM_EXCEPTION to R2R dumper

Refactor continuation type handling for ReadyToRun support by removin…
25a4a90
…g unneeded method parameters and simplifying type resolution logic.

Merge branch 'main' ofhttps://github.com/dotnet/runtimeinto Continu…
eb9a764
…ationTypeFixup

jtschuster requested review from davidwrighton and jakobbotsch January 26, 2026 21:48

build-analysisBot mentioned this pull request Jan 28, 2026
[Test][UserEvents] Trace file does not contain expected events #123442
Closed

MichalStrehovsky reviewed Jan 28, 2026
View reviewed changes

Comment thread...tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs Outdated
Comment threadsrc/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/CompilerTypeSystemContext.ReadyToRun.cs Outdated

jakobbotsch reviewed Jan 28, 2026
View reviewed changes

Comment threadsrc/coreclr/vm/jitinterface.cpp Outdated

Don't use layout algorithm for Continuation
e6859c5

MichalStrehovsky reviewed Jan 29, 2026
View reviewed changes

Comment threadsrc/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs Outdated
Comment threadsrc/coreclr/tools/Common/Compiler/AsyncContinuationType.cs Outdated

PR Feedback:
457bfff
Make getContinuationType static Move _validType.TryAdd to CreateValueFromKey Remove unnecessary using

davidwrighton reviewed Feb 4, 2026
View reviewed changes

Comment threadsrc/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs Outdated

davidwrighton reviewed Feb 4, 2026
View reviewed changes

Comment threadsrc/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunSignature.cs Outdated

This was referenced Feb 4, 2026
iOS.Device test WorkItemExecutions #122874
Closed
XHarness package install failure on iOS due to devicectl NSPOSIXErrorDomain error 49 #123796
Open

davidwrighton approved these changes Feb 4, 2026
View reviewed changes

build-analysisBot mentioned this pull request Feb 4, 2026
System.Collections.Concurrent.Tests.IntRangePartitionerTests.CheckGetPartitions - GetPartitions element mismatch #123912
Closed

Remove AllocContinuation changes
ecb9f1e

CopilotAI review requested due to automatic review settings February 4, 2026 00:15

Copilotstarted reviewing on behalf of jtschuster February 4, 2026 00:15 View session

CopilotAI reviewed Feb 4, 2026
View reviewed changes

Comment thread...tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs Outdated
Comment threadsrc/coreclr/vm/jitinterface.cpp Outdated

jtschuster added 2 commits February 3, 2026 16:31

Format and remove dead code
35700a3

Return false from LoadDynamicInfoEntry when unable to read Continuati…
dc4368c
…onLayout signature

CopilotAI review requested due to automatic review settings February 4, 2026 18:22

Copilotstarted reviewing on behalf of jtschuster February 4, 2026 18:22 View session

CopilotAI reviewed Feb 4, 2026
View reviewed changes

Don't do validation in R2Rdump and share type layout parsing
38e395b

This was referenced Feb 6, 2026
System.IO.Tests.Directory_Create_Tests.FileSystemWatcher_Directory_Create_InNestedDirectory fails with "Created event did not occur as expected" #103630
Closed
Tests failing on tvos with "The app 'net.dot.System.Runtime.Tests' terminated with signal 11" #124072
Closed

jtschuster merged commit a528763 into dotnet:mainFeb 6, 2026
98 of 101 checks passed

github-project-automationBot moved this to Done in AppModel Feb 6, 2026

dotnet-maestroBot mentioned this pull request Feb 7, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#4719
Merged

github-actionsBot locked and limited conversation to collaborators Mar 9, 2026