Add debug information for runtime async methods

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs

@@ -195,9 +195,8 @@ private interface IRuntimeAsyncTaskOps<T>
             static abstract ref byte GetResultStorage(T task);
         }
 
-        /// <summary>
-        /// Represents a wrapped runtime async operation.
-        /// </summary>
+        // Represents execution of a chain of suspended and resuming runtime
+        // async functions.
         private sealed class RuntimeAsyncTask<T> : Task<T>, ITaskCompletionAction
         {
             public RuntimeAsyncTask()
@@ -261,9 +260,8 @@ public static void PostToSyncContext(RuntimeAsyncTask<T> task, SynchronizationCo
             }
         }
 
-        /// <summary>
-        /// Represents a wrapped runtime async operation.
-        /// </summary>
+        // Represents execution of a chain of suspended and resuming runtime
+        // async functions.
         private sealed class RuntimeAsyncTask : Task, ITaskCompletionAction
         {
             public RuntimeAsyncTask()
@@ -329,35 +327,55 @@ public static void PostToSyncContext(RuntimeAsyncTask task, SynchronizationConte
 
         private static class RuntimeAsyncTaskCore
         {
+            private unsafe struct NextContinuationData
+            {
+                public NextContinuationData* Next;
+                public Continuation* NextContinuation;
+            }
+
+            // To be used for async stack walking
+            [ThreadStatic]
+            private static unsafe NextContinuationData* t_nextContinuation;
+
             public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task, ITaskCompletionAction where TOps : IRuntimeAsyncTaskOps<T>
             {
                 ExecutionAndSyncBlockStore contexts = default;
                 contexts.Push();
                 Continuation? continuation = TOps.GetContinuationState(task);
 
+                ref NextContinuationData* nextContRef = ref t_nextContinuation;
+                NextContinuationData nextContinuationData;
+                nextContinuationData.Next = nextContRef;
+                nextContinuationData.NextContinuation = &continuation;
+
+                nextContRef = &nextContinuationData;
+
                 while (true)
                 {
                     Debug.Assert(continuation != null);
                     try
                     {
-                        ref byte resultLoc = ref continuation.Next != null ? ref continuation.Next.GetResultStorageOrNull() : ref TOps.GetResultStorage(task);
-                        Continuation? newContinuation = continuation.Resume(continuation, ref resultLoc);
+                        Continuation? curContinuation = continuation;
+                        Debug.Assert(curContinuation != null);
+                        Continuation? nextContinuation = curContinuation.Next;
+                        continuation = nextContinuation;
+
+                        ref byte resultLoc = ref nextContinuation != null ? ref nextContinuation.GetResultStorageOrNull() : ref TOps.GetResultStorage(task);
+                        Continuation? newContinuation = curContinuation.Resume(curContinuation, ref resultLoc);
 
                         if (newContinuation != null)
                         {
-                            newContinuation.Next = continuation.Next;
+                            newContinuation.Next = nextContinuation;
                             HandleSuspended<T, TOps>(task);
                             contexts.Pop();
+                            t_nextContinuation = nextContinuationData.Next;
                             return;
                         }
-
-                        continuation = continuation.Next;
                     }
                     catch (Exception ex)
                     {
-                        Debug.Assert(continuation != null);
-                        Continuation? nextContinuation = UnwindToPossibleHandler(continuation);
-                        if (nextContinuation == null)
+                        Continuation? handlerContinuation = UnwindToPossibleHandler(continuation);
+                        if (handlerContinuation == null)
                         {
                             // Tail of AsyncTaskMethodBuilderT.SetException
                             bool successfullySet = ex is OperationCanceledException oce ?
@@ -366,6 +384,8 @@ public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task,
 
                             contexts.Pop();
 
+                            t_nextContinuation = nextContinuationData.Next;
+
                             if (!successfullySet)
                             {
                                 ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
@@ -374,9 +394,8 @@ public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task,
                             return;
                         }
 
-                        nextContinuation.SetException(ex);
-
-                        continuation = nextContinuation;
+                        handlerContinuation.SetException(ex);
+                        continuation = handlerContinuation;
                     }
 
                     if (continuation == null)
@@ -385,6 +404,8 @@ public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task,
 
                         contexts.Pop();
 
+                        t_nextContinuation = nextContinuationData.Next;
+
                         if (!successfullySet)
                         {
                             ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
@@ -396,23 +417,20 @@ public static unsafe void DispatchContinuations<T, TOps>(T task) where T : Task,
                     if (QueueContinuationFollowUpActionIfNecessary<T, TOps>(task, continuation))
                     {
                         contexts.Pop();
+                        t_nextContinuation = nextContinuationData.Next;
                         return;
                     }
                 }
             }
 
-            private static Continuation? UnwindToPossibleHandler(Continuation continuation)
+            private static Continuation? UnwindToPossibleHandler(Continuation? continuation)
             {
                 while (true)
                 {
-                    Continuation? nextContinuation = continuation.Next;
-                    if (nextContinuation == null)
-                        return null;
-
-                    if ((nextContinuation.Flags & ContinuationFlags.HasException) != 0)
-                        return nextContinuation;
+                    if (continuation == null || (continuation.Flags & ContinuationFlags.HasException) != 0)
+                        return continuation;
 
-                    continuation = nextContinuation;
+                    continuation = continuation.Next;
                 }
             }
 

src/coreclr/inc/clrconfigvalues.h

@@ -715,7 +715,7 @@ RETAIL_CONFIG_DWORD_INFO(EXTERNAL_EnableRiscV64Zbb,             W("EnableRiscV64
 #endif
 
 // Runtime-async
-RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_RuntimeAsync, W("RuntimeAsync"), 0, "Enables runtime async method support")
+RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_RuntimeAsync, W("RuntimeAsync"), 1, "Enables runtime async method support")
 
 ///
 /// Uncategorized

src/coreclr/inc/cordebuginfo.h

@@ -431,4 +431,29 @@ class ICorDebugInfo
         // Source information about the IL instruction in the inlinee
         SourceTypes Source;
     };
+
+    struct AsyncContinuationVarInfo
+    {
+        // IL number of variable (or one of the special IL numbers, like TYPECTXT_ILNUM)
+        uint32_t VarNumber;
+        // Offset in continuation object where this variable is stored
+        uint32_t Offset;
+    };
+
+    struct AsyncSuspensionPoint
+    {
+        // Offset of this suspension point's resumption point.
+        uint32_t NativeResumeOffset;
+        // Logical return address of the async call (join point of synchronous and resuming paths)
+        uint32_t NativeJoinOffset;
+        // Count of AsyncContinuationVarInfo in array of locals starting where
+        // the previous suspension point's locals end.
+        uint32_t NumContinuationVars;
+    };
+
+    struct AsyncInfo
+    {
+        // Number of suspension points in the method.
+        uint32_t NumSuspensionPoints;
+    };
 };

src/coreclr/inc/corinfo.h

@@ -2912,6 +2912,16 @@ class ICorStaticInfo
             uint32_t                          numMappings         // [IN] Number of rich mappings
             ) = 0;
 
+    // Report async debug information to EE.
+    // The arrays are expected to be allocated with allocateArray
+    // and ownership is transferred to the EE with this call.
+    virtual void reportAsyncDebugInfo(
+            ICorDebugInfo::AsyncInfo*             asyncInfo,         // [IN] Async method information
+            ICorDebugInfo::AsyncSuspensionPoint*  suspensionPoints,  // [IN] Array of async suspension points, indexed by state number
+            ICorDebugInfo::AsyncContinuationVarInfo* vars,           // [IN] Array of async continuation variable info
+            uint32_t                              numVars            // [IN] Number of entries in the async vars array
+            ) = 0;
+
     // Report back some metadata about the compilation to the EE -- for
     // example, metrics about the compilation.
     virtual void reportMetadata(

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -453,6 +453,12 @@ void reportRichMappings(
           ICorDebugInfo::RichOffsetMapping* mappings,
           uint32_t numMappings) override;
 
+void reportAsyncDebugInfo(
+          ICorDebugInfo::AsyncInfo* asyncInfo,
+          ICorDebugInfo::AsyncSuspensionPoint* suspensionPoints,
+          ICorDebugInfo::AsyncContinuationVarInfo* vars,
+          uint32_t numVars) override;
+
 void reportMetadata(
           const char* key,
           const void* value,

src/coreclr/inc/jiteeversionguid.h

@@ -37,11 +37,11 @@
 
 #include <minipal/guid.h>
 
-constexpr GUID JITEEVersionIdentifier = { /* 68e93e9d-dd28-49ca-9ebc-a01a54532bb3 */
-    0x68e93e9d,
-    0xdd28,
-    0x49ca,
-    {0x9e, 0xbc, 0xa0, 0x1a, 0x54, 0x53, 0x2b, 0xb3}
+constexpr GUID JITEEVersionIdentifier = { /* 590a21bb-2a2e-4b80-82dc-0bf1fd92a301 */
+    0x590a21bb,
+    0x2a2e,
+    0x4b80,
+    {0x82, 0xdc, 0x0b, 0xf1, 0xfd, 0x92, 0xa3, 0x01}
   };
 
 #endif // JIT_EE_VERSIONING_GUID_H

src/coreclr/inc/readytorun.h

@@ -19,10 +19,10 @@
 //  src/coreclr/nativeaot/Runtime/inc/ModuleHeaders.h
 // If you update this, ensure you run `git grep MINIMUM_READYTORUN_MAJOR_VERSION`
 // and handle pending work.
-#define READYTORUN_MAJOR_VERSION 16
+#define READYTORUN_MAJOR_VERSION 17
 #define READYTORUN_MINOR_VERSION 0x0000
 
-#define MINIMUM_READYTORUN_MAJOR_VERSION 16
+#define MINIMUM_READYTORUN_MAJOR_VERSION 17
 
 // R2R Version 2.1 adds the InliningInfo section
 // R2R Version 2.2 adds the ProfileDataInfo section
@@ -47,6 +47,7 @@
 // R2R Version 14 changed x86 code generation to use funclets
 // R2R Version 15 removes double to int/uint helper calls
 // R2R Version 16 replaces the compression format for debug boundaries with a new format that is smaller and more efficient to parse
+// R2R Version 17 adds support for producing "fat" debug information (that e.g. can include async debug info)
 
 struct READYTORUN_CORE_HEADER
 {

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -112,6 +112,7 @@ DEF_CLR_API(setBoundaries)
 DEF_CLR_API(getVars)
 DEF_CLR_API(setVars)
 DEF_CLR_API(reportRichMappings)
+DEF_CLR_API(reportAsyncDebugInfo)
 DEF_CLR_API(reportMetadata)
 DEF_CLR_API(allocateArray)
 DEF_CLR_API(freeArray)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -1067,6 +1067,17 @@ void WrapICorJitInfo::reportRichMappings(
     API_LEAVE(reportRichMappings);
 }
 
+void WrapICorJitInfo::reportAsyncDebugInfo(
+          ICorDebugInfo::AsyncInfo* asyncInfo,
+          ICorDebugInfo::AsyncSuspensionPoint* suspensionPoints,
+          ICorDebugInfo::AsyncContinuationVarInfo* vars,
+          uint32_t numVars)
+{
+    API_ENTER(reportAsyncDebugInfo);
+    wrapHnd->reportAsyncDebugInfo(asyncInfo, suspensionPoints, vars, numVars);
+    API_LEAVE(reportAsyncDebugInfo);
+}
+
 void WrapICorJitInfo::reportMetadata(
           const char* key,
           const void* value,