comments

Author: max-charlamb

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

@@ -146,6 +146,30 @@ public ref byte GetResultStorageOrNull()
         }
     }
 
+    [StructLayout(LayoutKind.Explicit)]
+    internal unsafe ref struct AsyncDispatcherInfo
+    {
+        // Dispatcher info for next dispatcher present on stack, or
+        // null if none.
+        [FieldOffset(0)]
+        public AsyncDispatcherInfo* Next;
+
+        // Next continuation the dispatcher will process.
+#if TARGET_64BIT
+        [FieldOffset(8)]
+#else
+        [FieldOffset(4)]
+#endif
+        public Continuation? NextContinuation;
+
+        // Information about current task dispatching, to be used for async
+        // stackwalking.
+        [ThreadStatic]
+        internal static unsafe AsyncDispatcherInfo* t_current; // Debugger depends on the exact name of this field.
+    }
+
+
+
     public static partial class AsyncHelpers
     {
 #if FEATURE_INTERPRETER
@@ -417,19 +441,19 @@ private unsafe void DispatchContinuations()
                 ExecutionAndSyncBlockStore contexts = default;
                 contexts.Push();
 
-                DispatcherInfo dispatcherInfo;
-                dispatcherInfo.Next = t_dispatcherInfo;
-                dispatcherInfo.NextContinuation = MoveContinuationState();
-                t_dispatcherInfo = &dispatcherInfo;
+                AsyncDispatcherInfo asyncDispatcherInfo;
+                asyncDispatcherInfo.Next = AsyncDispatcherInfo.t_current;
+                asyncDispatcherInfo.NextContinuation = MoveContinuationState();
+                AsyncDispatcherInfo.t_current = &asyncDispatcherInfo;
 
                 while (true)
                 {
-                    Debug.Assert(dispatcherInfo.NextContinuation != null);
+                    Debug.Assert(asyncDispatcherInfo.NextContinuation != null);
                     try
                     {
-                        Continuation curContinuation = dispatcherInfo.NextContinuation;
+                        Continuation curContinuation = asyncDispatcherInfo.NextContinuation;
                         Continuation? nextContinuation = curContinuation.Next;
-                        dispatcherInfo.NextContinuation = nextContinuation;
+                        asyncDispatcherInfo.NextContinuation = nextContinuation;
 
                         ref byte resultLoc = ref nextContinuation != null ? ref nextContinuation.GetResultStorageOrNull() : ref GetResultStorage();
                         Continuation? newContinuation = curContinuation.ResumeInfo->Resume(curContinuation, ref resultLoc);
@@ -439,13 +463,13 @@ private unsafe void DispatchContinuations()
                             newContinuation.Next = nextContinuation;
                             HandleSuspended();
                             contexts.Pop();
-                            t_dispatcherInfo = dispatcherInfo.Next;
+                            AsyncDispatcherInfo.t_current = asyncDispatcherInfo.Next;
                             return;
                         }
                     }
                     catch (Exception ex)
                     {
-                        Continuation? handlerContinuation = UnwindToPossibleHandler(dispatcherInfo.NextContinuation);
+                        Continuation? handlerContinuation = UnwindToPossibleHandler(asyncDispatcherInfo.NextContinuation);
                         if (handlerContinuation == null)
                         {
                             // Tail of AsyncTaskMethodBuilderT.SetException
@@ -455,7 +479,7 @@ private unsafe void DispatchContinuations()
 
                             contexts.Pop();
 
-                            t_dispatcherInfo = dispatcherInfo.Next;
+                            AsyncDispatcherInfo.t_current = asyncDispatcherInfo.Next;
 
                             if (!successfullySet)
                             {
@@ -466,16 +490,16 @@ private unsafe void DispatchContinuations()
                         }
 
                         handlerContinuation.SetException(ex);
-                        dispatcherInfo.NextContinuation = handlerContinuation;
+                        asyncDispatcherInfo.NextContinuation = handlerContinuation;
                     }
 
-                    if (dispatcherInfo.NextContinuation == null)
+                    if (asyncDispatcherInfo.NextContinuation == null)
                     {
                         bool successfullySet = TrySetResult(m_result);
 
                         contexts.Pop();
 
-                        t_dispatcherInfo = dispatcherInfo.Next;
+                        AsyncDispatcherInfo.t_current = asyncDispatcherInfo.Next;
 
                         if (!successfullySet)
                         {
@@ -485,10 +509,10 @@ private unsafe void DispatchContinuations()
                         return;
                     }
 
-                    if (QueueContinuationFollowUpActionIfNecessary(dispatcherInfo.NextContinuation))
+                    if (QueueContinuationFollowUpActionIfNecessary(asyncDispatcherInfo.NextContinuation))
                     {
                         contexts.Pop();
-                        t_dispatcherInfo = dispatcherInfo.Next;
+                        AsyncDispatcherInfo.t_current = asyncDispatcherInfo.Next;
                         return;
                     }
                 }
@@ -583,28 +607,6 @@ private bool QueueContinuationFollowUpActionIfNecessary(Continuation continuatio
             };
         }
 
-        [StructLayout(LayoutKind.Explicit)]
-        internal unsafe ref struct DispatcherInfo
-        {
-            // Dispatcher info for next dispatcher present on stack, or
-            // null if none.
-            [FieldOffset(0)]
-            public DispatcherInfo* Next;
-
-            // Next continuation the dispatcher will process.
-#if TARGET_64BIT
-            [FieldOffset(8)]
-#else
-            [FieldOffset(4)]
-#endif
-            public Continuation? NextContinuation;
-        }
-
-        // Information about current task dispatching, to be used for async
-        // stackwalking.
-        [ThreadStatic]
-        internal static unsafe DispatcherInfo* t_dispatcherInfo;
-
         // Change return type to RuntimeAsyncTask<T?> -- no benefit since this is used for Task returning thunks only
 #pragma warning disable CA1859
         // When a Task-returning thunk gets a continuation result