Cache AsyncResumptionStub instances to avoid duplicate resumption stubs in the node factory

[jtschuster]

AsyncResumptionStub was created via 'new' per JIT compilation context. When a method was recompiled (e.g. via PrepareForCompilationRetry for cross-module inlining), a second CorInfoImpl created a second AsyncResumptionStub for the same target method. Since NodeCache uses reference equality, both entered the dependency graph as separate MethodWithGCInfo nodes. During sorting, their CompareToImpl returned 0 (they wrap the same target method), tripping the Debug.Assert(result != 0) in TypeSystemComparer.Compare(MethodDesc, MethodDesc). This only happened once async methods are allowed to be inlined and crossgen is passed --opt-cross-module *.

Add an AsyncResumptionStubHashtable (LockFreeReaderHashtable) to CompilerTypeSystemContext that interns AsyncResumptionStub instances by (targetMethod, owningType). Update all creation sites to use the new GetAsyncResumptionStub() method instead of 'new AsyncResumptionStub(...)'.

[Copilot]

Pull request overview

This PR fixes a NativeAOT/ReadyToRun compilation correctness issue where multiple AsyncResumptionStub instances could be created for the same target method across recompilation contexts, causing duplicate nodes and comparer assertions during dependency graph sorting. It does so by interning resumption stubs in the type system context and updating all known creation sites to use the interned instance.

Changes:

• Added an AsyncResumptionStubHashtable to CompilerTypeSystemContext to cache/intern AsyncResumptionStub instances by (targetMethod, owningType).
• Updated RyuJit and ReadyToRun JIT interface codepaths to use GetAsyncResumptionStub(...) instead of new AsyncResumptionStub(...).
• Updated the IL scanner to depend on the cached resumption stub entrypoint rather than a freshly-allocated stub.

Reviewed changes

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

File	Description
src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs	Uses the context-level cached async resumption stub instead of allocating per CorInfoImpl instance.
src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs	Switches ReadyToRun async resumption stub creation to the cached/interned implementation and keeps fixup behavior.
src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs	Ensures scanner dependencies reference the interned resumption stub entrypoint for async state machines.
src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs	Introduces the lock-free hashtable + API (GetAsyncResumptionStub) to intern resumption stubs by key.

[MichalStrehovsky]

The native AOT side doesn't strictly need this, but it's good to be uniform.

[Copilot]

Pull request overview

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

[Copilot]

AsyncResumptionStubKey has an OwningType field, but Equals only compares TargetMethod. This makes the key semantics ambiguous and can hide mismatched owningType requests for the same TargetMethod. Consider either incorporating OwningType into the key comparison, or documenting/renaming to make it clear interning is only by TargetMethod and asserting OwningType consistency at the call site.

Suggested change

	=> TargetMethod == other.TargetMethod;
	public override bool Equals(object obj)
	=> obj is AsyncResumptionStubKey other && Equals(other);
	public override int GetHashCode()
	=> TargetMethod.GetHashCode();
	}
	private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable<AsyncResumptionStubKey, AsyncResumptionStub>
	{
	protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.GetHashCode();
	protected override int GetValueHashCode(AsyncResumptionStub value) => value.TargetMethod.GetHashCode();
	protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value)
	=> key.TargetMethod == value.TargetMethod;
	protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2)
	=> value1.TargetMethod == value2.TargetMethod;
	=> TargetMethod == other.TargetMethod && OwningType == other.OwningType;
	public override bool Equals(object obj)
	=> obj is AsyncResumptionStubKey other && Equals(other);
	public override int GetHashCode()
	=> TargetMethod.GetHashCode() ^ OwningType.GetHashCode();
	}
	private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable<AsyncResumptionStubKey, AsyncResumptionStub>
	{
	protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.GetHashCode();
	protected override int GetValueHashCode(AsyncResumptionStub value)
	=> value.TargetMethod.GetHashCode() ^ value.OwningType.GetHashCode();
	protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value)
	=> key.TargetMethod == value.TargetMethod && key.OwningType == value.OwningType;
	protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2)
	=> value1.TargetMethod == value2.TargetMethod && value1.OwningType == value2.OwningType;

[Copilot]

AsyncResumptionStubKey.GetHashCode also ignores OwningType. If OwningType is meant to participate in interning, the hash and hashtable comparisons should be updated accordingly; otherwise consider removing OwningType from the key type and passing a canonical owning type when creating the stub.

Suggested change

	=> TargetMethod == other.TargetMethod;
	public override bool Equals(object obj)
	=> obj is AsyncResumptionStubKey other && Equals(other);
	public override int GetHashCode()
	=> TargetMethod.GetHashCode();
	}
	private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable<AsyncResumptionStubKey, AsyncResumptionStub>
	{
	protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.GetHashCode();
	protected override int GetValueHashCode(AsyncResumptionStub value) => value.TargetMethod.GetHashCode();
	protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value)
	=> key.TargetMethod == value.TargetMethod;
	protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2)
	=> value1.TargetMethod == value2.TargetMethod;
	=> TargetMethod == other.TargetMethod && OwningType == other.OwningType;
	public override bool Equals(object obj)
	=> obj is AsyncResumptionStubKey other && Equals(other);
	public override int GetHashCode()
	{
	unchecked
	{
	int hash = TargetMethod.GetHashCode();
	hash = (hash * 31) + OwningType.GetHashCode();
	return hash;
	}
	}
	}
	private sealed class AsyncResumptionStubHashtable : LockFreeReaderHashtable<AsyncResumptionStubKey, AsyncResumptionStub>
	{
	protected override int GetKeyHashCode(AsyncResumptionStubKey key) => key.GetHashCode();
	protected override int GetValueHashCode(AsyncResumptionStub value)
	{
	unchecked
	{
	int hash = value.TargetMethod.GetHashCode();
	hash = (hash * 31) + value.OwningType.GetHashCode();
	return hash;
	}
	}
	protected override bool CompareKeyToValue(AsyncResumptionStubKey key, AsyncResumptionStub value)
	=> key.TargetMethod == value.TargetMethod && key.OwningType == value.OwningType;
	protected override bool CompareValueToValue(AsyncResumptionStub value1, AsyncResumptionStub value2)
	=> value1.TargetMethod == value2.TargetMethod && value1.OwningType == value2.OwningType;