Emit Async Methods in crossgen2

src/coreclr/inc/corcompile.h

@@ -110,6 +110,7 @@ enum EncodeMethodSigFlags
     ENCODE_METHOD_SIG_OwnerType                 = 0x40,
     ENCODE_METHOD_SIG_UpdateContext             = 0x80,
     ENCODE_METHOD_SIG_AsyncVariant             = 0x100,
+    ENCODE_METHOD_SIG_ResumptionStub           = 0x200,
 };
 
 enum EncodeFieldSigFlags

src/coreclr/inc/readytorun.h

@@ -468,9 +468,10 @@ enum ReadyToRunHelper
 
     READYTORUN_HELPER_GetCurrentManagedThreadId = 0x112,
 
-    READYTORUN_HELPER_AllocContinuation = 0x113,
-    READYTORUN_HELPER_AllocContinuationClass = 0x114,
-    READYTORUN_HELPER_AllocContinuationMethod = 0x115,
+    // Async continuation helpers
+    READYTORUN_HELPER_AllocContinuation         = 0x113,
+    READYTORUN_HELPER_AllocContinuationClass    = 0x114,
+    READYTORUN_HELPER_AllocContinuationMethod   = 0x115,
 };
 
 #include "readytoruninstructionset.h"

src/coreclr/inc/readytorunhelpers.h

@@ -20,6 +20,7 @@ HELPER(READYTORUN_HELPER_RngChkFail,                CORINFO_HELP_RNGCHKFAIL,
 HELPER(READYTORUN_HELPER_FailFast,                  CORINFO_HELP_FAIL_FAST,                         OPTIMIZEFORSIZE)
 HELPER(READYTORUN_HELPER_ThrowNullRef,              CORINFO_HELP_THROWNULLREF,                      OPTIMIZEFORSIZE)
 HELPER(READYTORUN_HELPER_ThrowDivZero,              CORINFO_HELP_THROWDIVZERO,                      OPTIMIZEFORSIZE)
+HELPER(READYTORUN_HELPER_ThrowExact,                CORINFO_HELP_THROWEXACT,                        OPTIMIZEFORSIZE)
 
 HELPER(READYTORUN_HELPER_WriteBarrier,              CORINFO_HELP_ASSIGN_REF,                        )
 HELPER(READYTORUN_HELPER_CheckedWriteBarrier,       CORINFO_HELP_CHECKED_ASSIGN_REF,                )

src/coreclr/tools/Common/Compiler/AsyncMethodVariant.cs

@@ -79,9 +79,9 @@ public static bool IsAsyncVariant(this MethodDesc method)
             return method.GetTypicalMethodDefinition() is AsyncMethodVariant;
         }
 
-        public static bool IsAsyncThunk(this MethodDesc method)
+        public static bool IsCompilerGeneratedILBodyForAsync(this MethodDesc method)
         {
-            return method.IsAsyncVariant() ^ method.IsAsync;
+            return (method.IsAsyncVariant() ^ method.IsAsync) || method is AsyncResumptionStub;
         }
 
         public static MethodDesc GetAsyncVariant(this MethodDesc method)

src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs

@@ -203,6 +203,7 @@ protected override bool CompareValueToValue(AsyncMethodVariant value1, AsyncMeth
         public MetadataType GetContinuationType(GCPointerMap pointerMap)
         {
             var cont = _continuationTypeHashtable.GetOrCreateValue(pointerMap);
+            _validTypes.TryAdd(cont);
             return cont;
         }
 

src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs

@@ -54,6 +54,7 @@ public enum ReadyToRunMethodSigFlags : uint
         READYTORUN_METHOD_SIG_OwnerType = 0x40,
         READYTORUN_METHOD_SIG_UpdateContext = 0x80,
         READYTORUN_METHOD_SIG_AsyncVariant = 0x100,
+        READYTORUN_METHOD_SIG_ResumptionStub = 0x200,
     }
 
     [Flags]

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

@@ -27,6 +27,7 @@
 using ILCompiler.DependencyAnalysis;
 
 #if READYTORUN
+using ILCompiler.ReadyToRun.TypeSystem;
 using System.Reflection.Metadata.Ecma335;
 using ILCompiler.DependencyAnalysis.ReadyToRun;
 #endif
@@ -120,7 +121,7 @@ public LikelyClassMethodRecord(IntPtr handle, uint likelihood)
         private static extern uint getLikelyClasses(LikelyClassMethodRecord* pLikelyClasses, uint maxLikelyClasses, PgoInstrumentationSchema* schema, uint countSchemaItems, byte*pInstrumentationData, int ilOffset);
 
         [DllImport(JitLibrary)]
-        private static extern uint getLikelyMethods(LikelyClassMethodRecord* pLikelyMethods, uint maxLikelyMethods, PgoInstrumentationSchema* schema, uint countSchemaItems, byte*pInstrumentationData, int ilOffset);
+        private static extern uint getLikelyMethods(LikelyClassMethodRecord* pLikelyMethods, uint maxLikelyMethods, PgoInstrumentationSchema* schema, uint countSchemaItems, byte* pInstrumentationData, int ilOffset);
 
         [DllImport(JitSupportLibrary)]
         private static extern IntPtr GetJitHost(IntPtr configProvider);
@@ -1384,8 +1385,10 @@ private bool resolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO* info)
                 // a safe condition, and we could delete this assert. This assert exists in order to help identify
                 // cases where the virtual function resolution algorithm either does not function, or is not used
                 // correctly.
+                // TODO: Async variant devirtualization algorithm
 #if DEBUG
-                if (info->detail == CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN)
+                if (info->detail == CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN
+                    && !decl.IsAsyncVariant())
                 {
                     Console.Error.WriteLine($"Failed devirtualization with unexpected unknown failure while compiling {MethodBeingCompiled} with decl {decl} targeting type {objType}");
                     Debug.Assert(info->detail != CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN);
@@ -3865,7 +3868,11 @@ private bool getTailCallHelpers(ref CORINFO_RESOLVED_TOKEN callToken, CORINFO_SI
 #pragma warning restore CA1822 // Mark members as static
         {
 #if READYTORUN
-            throw new NotImplementedException("Crossgen2 does not support runtime-async yet");
+            var resumptionStub = new AsyncResumptionStub(MethodBeingCompiled, MethodBeingCompiled.OwningType);
+
+            // CompiledMethodNode instead of MethodEntrypoint for the pointer to the code instead of a fixup
+            entryPoint = (void*)ObjectToHandle(_compilation.NodeFactory.CompiledMethodNode(resumptionStub));
+            return ObjectToHandle(resumptionStub);
 #else
             _asyncResumptionStub ??= new AsyncResumptionStub(MethodBeingCompiled, _compilation.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType());
 

src/coreclr/tools/Common/TypeSystem/IL/InstantiatedMethodIL.cs

@@ -18,7 +18,6 @@ public InstantiatedMethodIL(MethodDesc owningMethod, MethodIL methodIL)
         {
             Debug.Assert(methodIL.GetMethodILDefinition() == methodIL);
             Debug.Assert(owningMethod.HasInstantiation || owningMethod.OwningType.HasInstantiation);
-            Debug.Assert(owningMethod.GetTypicalMethodDefinition() == methodIL.OwningMethod);
 
             _methodIL = methodIL;
             _method = owningMethod;

src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncResumptionStub.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-
 using Internal.IL;
 using Internal.IL.Stubs;
 using Internal.TypeSystem;
@@ -26,7 +25,7 @@ public AsyncResumptionStub(MethodDesc targetMethod, TypeDesc owningType)
         }
 
         public override ReadOnlySpan<byte> Name => _targetMethod.Name;
-        public override string DiagnosticName => _targetMethod.DiagnosticName;
+        public override string DiagnosticName => "RESUME_" + _targetMethod.DiagnosticName;
 
         public override TypeDesc OwningType => _owningType;
 
@@ -36,6 +35,12 @@ public AsyncResumptionStub(MethodDesc targetMethod, TypeDesc owningType)
 
         public MethodDesc TargetMethod => _targetMethod;
 
+        /// <summary>
+        /// The hash of the async variant method is used at runtime to find the bucket of the resumption stub.
+        /// These should be identical for the async variant and the resumption stub.
+        /// </summary>
+        protected override int ComputeHashCode() => _targetMethod.GetHashCode();
+
         private MethodSignature InitializeSignature()
         {
             TypeDesc objectType = Context.GetWellKnownType(WellKnownType.Object);
@@ -109,6 +114,7 @@ public override MethodIL EmitIL()
             }
             ilStream.EmitLdLoc(newContinuationLocal);
             ilStream.Emit(ILOpcode.ret);
+            ilEmitter.SetHasGeneratedTokens();
 
             return ilEmitter.Link(this);
         }

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/StackTraceEmissionPolicy.cs

@@ -42,7 +42,7 @@ public override MethodStackTraceVisibilityFlags GetMethodVisibility(MethodDesc m
             if (method.HasCustomAttribute("System.Diagnostics", "StackTraceHiddenAttribute")
                 || (method.OwningType is MetadataType mdType && mdType.HasCustomAttribute("System.Diagnostics", "StackTraceHiddenAttribute"))
                 || (method is Internal.IL.Stubs.ILStubMethod)
-                || method.IsAsyncThunk()) // see MethodDesc::IsDiagnosticsHidden() in src/coreclr/vm/method.inl
+                || method.IsCompilerGeneratedILBodyForAsync()) // see MethodDesc::IsDiagnosticsHidden() in src/coreclr/vm/method.inl
             {
                 result |= MethodStackTraceVisibilityFlags.IsHidden;
             }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InliningInfoNode.cs

@@ -6,7 +6,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Reflection.Metadata.Ecma335;
-
+using ILCompiler.ReadyToRun.TypeSystem;
 using Internal;
 using Internal.NativeFormat;
 using Internal.ReadyToRunConstants;
@@ -67,8 +67,17 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
             foreach (MethodWithGCInfo methodNode in factory.EnumerateCompiledMethods(_module, CompiledMethodCategory.All))
             {
                 MethodDesc[] inlinees = methodNode.InlinedMethods;
+                if (inlinees.Length == 0)
+                {
+                    continue;
+                }
                 MethodDesc inliner = methodNode.Method;
-                EcmaMethod inlinerDefinition = (EcmaMethod)inliner.GetTypicalMethodDefinition();
+                if (inliner.IsCompilerGeneratedILBodyForAsync())
+                {
+                    // Async thunks are generated by crossgen and diagnostic tools don't need to worry about them
+                    continue;
+                }
+                EcmaMethod inlinerDefinition = (EcmaMethod)inliner.GetPrimaryMethodDesc().GetTypicalMethodDefinition();
 
                 if (inlinerDefinition.IsNonVersionable())
                 {

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs

@@ -7,7 +7,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection.Metadata.Ecma335;
-
+using ILCompiler.ReadyToRun.TypeSystem;
 using Internal;
 using Internal.JitInterface;
 using Internal.NativeFormat;
@@ -53,7 +53,7 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde
 
         public static byte[] BuildSignatureForMethodDefinedInModule(MethodDesc method, NodeFactory factory)
         {
-            EcmaMethod typicalMethod = (EcmaMethod)method.GetTypicalMethodDefinition();
+            EcmaMethod typicalMethod = (EcmaMethod)method.GetPrimaryMethodDesc().GetTypicalMethodDefinition();
 
             ModuleToken moduleToken;
             if (factory.CompilationModuleGroup.VersionsWithMethodBody(typicalMethod))
@@ -63,7 +63,7 @@ public static byte[] BuildSignatureForMethodDefinedInModule(MethodDesc method, N
             else
             {
                 MutableModule manifestMetadata = factory.ManifestMetadataTable._mutableModule;
-                var handle = manifestMetadata.TryGetExistingEntityHandle(method.GetTypicalMethodDefinition());
+                var handle = manifestMetadata.TryGetExistingEntityHandle(typicalMethod);
                 Debug.Assert(handle.HasValue);
                 moduleToken = new ModuleToken(factory.ManifestMetadataTable._mutableModule, handle.Value);
             }
@@ -102,7 +102,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
             foreach (MethodWithGCInfo method in factory.EnumerateCompiledMethods(null, CompiledMethodCategory.Instantiated))
             {
-                Debug.Assert(method.Method.HasInstantiation || method.Method.OwningType.HasInstantiation);
+                Debug.Assert(method.Method.HasInstantiation || method.Method.OwningType.HasInstantiation || method.Method.IsAsyncVariant() || method.Method is AsyncResumptionStub);
 
                 int methodIndex = factory.RuntimeFunctionsTable.GetIndex(method);
 

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs

@@ -113,7 +113,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
             MethodWithToken method = _method;
 
-            if (factory.CompilationModuleGroup.VersionsWithMethodBody(method.Method) && !method.Method.IsAsyncVariant())
+            // If the method can be uniquely identified by a single token in the version bubble, use that instead of the full MethodSpec.
+            if (factory.CompilationModuleGroup.VersionsWithMethodBody(method.Method) && method.Method.IsPrimaryMethodDesc())
             {
                 if (method.Token.TokenType == CorTokenType.mdtMethodSpec)
                 {

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ModuleTokenResolver.cs

@@ -12,6 +12,7 @@
 using Internal.TypeSystem.Ecma;
 using Internal.CorConstants;
 using System.Diagnostics;
+using ILCompiler.ReadyToRun.TypeSystem;
 
 namespace ILCompiler.DependencyAnalysis.ReadyToRun
 {
@@ -100,7 +101,7 @@ public ModuleToken GetModuleTokenForMethod(MethodDesc method, bool allowDynamica
         {
             method = method.GetCanonMethodTarget(CanonicalFormKind.Specific);
 
-            if (method.GetTypicalMethodDefinition() is EcmaMethod ecmaMethod)
+            if (method.GetPrimaryMethodDesc().GetTypicalMethodDefinition() is EcmaMethod ecmaMethod)
             {
                 if (_compilationModuleGroup.VersionsWithMethodBody(ecmaMethod))
                 {
@@ -160,7 +161,6 @@ public ModuleToken GetModuleTokenForField(FieldDesc field, bool allowDynamically
             }
         }
 
-
         public void AddModuleTokenForMethod(MethodDesc method, ModuleToken token)
         {
             if (token.TokenType == CorTokenType.mdtMethodSpec)
@@ -332,6 +332,10 @@ public void AddModuleTokenForType(TypeDesc type, ModuleToken token)
                     SetModuleTokenForTypeSystemEntity(_typeToRefTokens, ecmaType, token);
                 }
             }
+            else if (type.IsCanonicalDefinitionType(CanonicalFormKind.Specific))
+            {
+                return;
+            }
             else if (!specialTypeFound)
             {
                 throw new NotImplementedException(type.ToString());

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs

@@ -445,6 +445,13 @@ public void EmitMethodSignature(
             {
                 flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_AsyncVariant;
             }
+            if (method.Method is AsyncResumptionStub)
+            {
+                flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_ResumptionStub;
+                // For AsyncResumptionStubs, we want to encode the signature of the async variant method, not the resumption stub itself,
+                // so that they will share the same hash and be placed in the same bucket at runtime
+                method = new MethodWithToken(((AsyncResumptionStub)method.Method).TargetMethod, method.Token, method.ConstrainedType, method.Unboxing, method.Method);
+            }
 
             EmitMethodSpecificationSignature(method, flags, enforceDefEncoding, enforceOwningType, context);
 
@@ -615,7 +622,7 @@ public SignatureContext EmitFixup(NodeFactory factory, ReadyToRunFixupKind fixup
                 {
                     throw new InternalCompilerErrorException("Attempt to use token from a module not within the version bubble");
                 }
-                
+
                 EmitUInt((uint)factory.ManifestMetadataTable.ModuleToIndex(targetModule));
                 return new SignatureContext(targetModule, outerContext.Resolver);
             }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs

@@ -121,7 +121,7 @@ private static void EncodeTypeLayout(ObjectDataSignatureBuilder dataBuilder, Typ
                 // Encode the GC pointer map
                 GCPointerMap gcMap = GCPointerMap.FromInstanceLayout(defType);
 
-                byte[] encodedGCRefMap = new byte[(size / pointerSize + 7) / 8];
+                byte[] encodedGCRefMap = new byte[((size + (pointerSize - 1)) / pointerSize + 7) / 8];
                 int bitIndex = 0;
                 foreach (bool bit in gcMap)
                 {

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs

@@ -109,9 +109,8 @@ public bool CanInline(MethodDesc caller, MethodDesc callee)
                 }
             }
 
-            if (callee.IsAsyncThunk())
+            if (callee.IsCompilerGeneratedILBodyForAsync() || callee.IsAsyncCall())
             {
-                // Async thunks require special handling in the compiler and should not be inlined
                 return false;
             }
 
@@ -302,7 +301,7 @@ public sealed class ReadyToRunCodegenCompilation : Compilation
 
         private readonly ProfileDataManager _profileData;
         private readonly FileLayoutOptimizer _fileLayoutOptimizer;
-        private readonly HashSet<EcmaMethod> _methodsWhichNeedMutableILBodies = new HashSet<EcmaMethod>();
+        private readonly HashSet<MethodDesc> _methodsWhichNeedMutableILBodies = new HashSet<MethodDesc>();
         private readonly HashSet<MethodWithGCInfo> _methodsToRecompile = new HashSet<MethodWithGCInfo>();
 
         public ProfileDataManager ProfileData => _profileData;
@@ -695,12 +694,15 @@ protected override void ComputeDependencyNodeDependencies(List<DependencyNodeCor
                     if (dependency is MethodWithGCInfo methodCodeNodeNeedingCode)
                     {
                         var method = methodCodeNodeNeedingCode.Method;
-                        if (method.GetTypicalMethodDefinition() is EcmaMethod ecmaMethod)
+                        var typicalDef = method.GetTypicalMethodDefinition();
+                        if (typicalDef is EcmaMethod or AsyncMethodVariant or AsyncResumptionStub)
                         {
-                            if (ilProvider.NeedsCrossModuleInlineableTokens(ecmaMethod) &&
-                                !_methodsWhichNeedMutableILBodies.Contains(ecmaMethod) &&
-                                CorInfoImpl.IsMethodCompilable(this, methodCodeNodeNeedingCode.Method))
-                                _methodsWhichNeedMutableILBodies.Add(ecmaMethod);
+                            if (ilProvider.NeedsCrossModuleInlineableTokens(typicalDef) &&
+                                !_methodsWhichNeedMutableILBodies.Contains(typicalDef) &&
+                                CorInfoImpl.IsMethodCompilable(this, method))
+                            {
+                                _methodsWhichNeedMutableILBodies.Add(typicalDef);
+                            }
                         }
 
                         if (method.IsAsyncCall()
@@ -748,11 +750,11 @@ protected override void ComputeDependencyNodeDependencies(List<DependencyNodeCor
 
             void ProcessMutableMethodBodiesList()
             {
-                EcmaMethod[] mutableMethodBodyNeedList = new EcmaMethod[_methodsWhichNeedMutableILBodies.Count];
+                MethodDesc[] mutableMethodBodyNeedList = new MethodDesc[_methodsWhichNeedMutableILBodies.Count];
                 _methodsWhichNeedMutableILBodies.CopyTo(mutableMethodBodyNeedList);
                 _methodsWhichNeedMutableILBodies.Clear();
                 TypeSystemComparer comparer = TypeSystemComparer.Instance;
-                Comparison<EcmaMethod> comparison = (EcmaMethod a, EcmaMethod b) => comparer.Compare(a, b);
+                Comparison<MethodDesc> comparison = (MethodDesc a, MethodDesc b) => comparer.Compare(a, b);
                 Array.Sort(mutableMethodBodyNeedList, comparison);
                 var ilProvider = (ReadyToRunILProvider)_methodILCache.ILProvider;
 

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs

@@ -521,7 +521,7 @@ private bool CrossModuleInlineableInternal(MethodDesc method)
         private bool CrossModuleInlineableUncached(MethodDesc method)
         {
             // Async thunks and variants cannot currently be inlined cross module
-            if (method.IsAsyncVariant() || method.IsAsync || method.IsAsyncThunk())
+            if (method.IsAsyncVariant() || method.IsAsync || method.IsCompilerGeneratedILBodyForAsync())
                 return false;
 
             // Defined in corelib