[WIP] [Draft] runtime-async Exception.ToString()

docs/design/coreclr/botr/readytorun-format.md

@@ -858,6 +858,7 @@ enum ReadyToRunHelper
     READYTORUN_HELPER_FailFast                  = 0x24,
     READYTORUN_HELPER_ThrowNullRef              = 0x25,
     READYTORUN_HELPER_ThrowDivZero              = 0x26,
+    READYTORUN_HELPER_ThrowExact                = 0x27,
 
     // Write barriers
     READYTORUN_HELPER_WriteBarrier              = 0x30,

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

@@ -87,6 +87,11 @@ internal enum ContinuationFlags
         ContinueOnCapturedTaskScheduler = 64,
     }
 
+    internal enum RhEHFrameType
+    {
+        RH_EH_RUNTIME_ASYNC_FRAME = 4,
+    }
+
     // Keep in sync with CORINFO_AsyncResumeInfo in corinfo.h
     internal unsafe struct ResumeInfo
     {
@@ -226,6 +231,14 @@ public void CaptureContexts()
 
         [ThreadStatic]
         private static RuntimeAsyncAwaitState t_runtimeAsyncAwaitState;
+#if !NATIVEAOT
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AsyncHelpers_AddContinuationToExInternal")]
+        private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex);
+
+        internal static unsafe void AddContinuationToExInternal(void* diagnosticIP, Exception e)
+            => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e));
+#endif
 
         private static unsafe Continuation AllocContinuation(Continuation prevContinuation, MethodTable* contMT)
         {
@@ -434,6 +447,7 @@ internal void HandleSuspended()
                 }
             }
 
+            [StackTraceHidden]
             private unsafe void DispatchContinuations()
             {
                 ExecutionAndSyncBlockStore contexts = default;
@@ -467,7 +481,7 @@ private unsafe void DispatchContinuations()
                     }
                     catch (Exception ex)
                     {
-                        Continuation? handlerContinuation = UnwindToPossibleHandler(asyncDispatcherInfo.NextContinuation);
+                        Continuation? handlerContinuation = UnwindToPossibleHandler(asyncDispatcherInfo.NextContinuation, ex);
                         if (handlerContinuation == null)
                         {
                             // Tail of AsyncTaskMethodBuilderT.SetException
@@ -518,10 +532,34 @@ private unsafe void DispatchContinuations()
 
             private ref byte GetResultStorage() => ref Unsafe.As<T?, byte>(ref m_result);
 
-            private static Continuation? UnwindToPossibleHandler(Continuation? continuation)
+            private static unsafe Continuation? UnwindToPossibleHandler(Continuation? continuation, Exception ex)
             {
                 while (true)
                 {
+                    if (continuation != null && continuation.ResumeInfo != null && continuation.ResumeInfo->DiagnosticIP != null)
+#if !NATIVEAOT
+                        AddContinuationToExInternal(continuation.ResumeInfo->DiagnosticIP, ex);
+#else
+        {
+                    IntPtr ip = (IntPtr)continuation.ResumeInfo->DiagnosticIP;
+                    int flags = (int)RhEHFrameType.RH_EH_RUNTIME_ASYNC_FRAME;
+                    IntPtr pAppendStackFrame = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromCodeAddress(ip,
+                        ClassLibFunctionId.AppendExceptionStackFrame);
+
+                    if (pAppendStackFrame != IntPtr.Zero)
+                    {
+                        try
+                        {
+                            ((delegate*<object, IntPtr, int, void>)pAppendStackFrame)(ex, ip, flags);
+                        }
+                        catch
+                        {
+                            // disallow all exceptions leaking out of callbacks
+                        }
+                    }
+        }
+
+#endif
                     if (continuation == null || (continuation.Flags & ContinuationFlags.HasException) != 0)
                         return continuation;
 
@@ -767,12 +805,14 @@ private static void CaptureContinuationContext(ref object continuationContext, r
             flags |= ContinuationFlags.ContinueOnThreadPool;
         }
 
+        [StackTraceHidden]
         internal static T CompletedTaskResult<T>(Task<T> task)
         {
             TaskAwaiter.ValidateEnd(task);
             return task.ResultOnSuccess;
         }
 
+        [StackTraceHidden]
         internal static void CompletedTask(Task task)
         {
             TaskAwaiter.ValidateEnd(task);

src/coreclr/inc/readytorun.h

@@ -336,6 +336,7 @@ enum ReadyToRunHelper
     READYTORUN_HELPER_FailFast                  = 0x24,
     READYTORUN_HELPER_ThrowNullRef              = 0x25,
     READYTORUN_HELPER_ThrowDivZero              = 0x26,
+    READYTORUN_HELPER_ThrowExact                = 0x27,
 
     // Write barriers
     READYTORUN_HELPER_WriteBarrier              = 0x30,

src/coreclr/nativeaot/Runtime/StackFrameIterator.cpp

@@ -44,6 +44,7 @@ EXTERN_C CODE_LOCATION RhpCallFilterFunclet2;
 EXTERN_C CODE_LOCATION RhpThrowEx2;
 EXTERN_C CODE_LOCATION RhpThrowHwEx2;
 EXTERN_C CODE_LOCATION RhpRethrow2;
+EXTERN_C CODE_LOCATION RhpThrowExact2;
 #endif // !defined(FEATURE_PORTABLE_HELPERS)
 
 // Addresses of functions in the DAC won't match their runtime counterparts so we
@@ -2241,7 +2242,8 @@ StackFrameIterator::ReturnAddressCategory StackFrameIterator::CategorizeUnadjust
 
     if (EQUALS_RETURN_ADDRESS(returnAddress, RhpThrowEx2) ||
         EQUALS_RETURN_ADDRESS(returnAddress, RhpThrowHwEx2) ||
-        EQUALS_RETURN_ADDRESS(returnAddress, RhpRethrow2))
+        EQUALS_RETURN_ADDRESS(returnAddress, RhpRethrow2) ||
+        EQUALS_RETURN_ADDRESS(returnAddress, RhpThrowExact2))
     {
         return InThrowSiteThunk;
     }

src/coreclr/nativeaot/Runtime/amd64/ExceptionHandling.S

@@ -78,6 +78,24 @@ ALTERNATE_ENTRY RhpThrowHwEx2
 NESTED_END RhpThrowHwEx, _TEXT
 
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RhpThrowExact
+//
+// SUMMARY:  Similar to RhpThrowEx, except that it sets the rethrow flag
+//
+// INPUT:  RDI:  exception object
+//
+// OUTPUT:
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+NESTED_ENTRY RhpThrowExact, _TEXT, NoHandler
+
+        mov     r8d, 4                  // r8d = ExKind.RethrowFlag
+        jmp     LOCAL_LABEL(RhpThrowExImpl)
+
+NESTED_END RhpThrowExact, _TEXT
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // RhpThrowEx
@@ -89,6 +107,10 @@ NESTED_END RhpThrowHwEx, _TEXT
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov     r8d, 1                  // r8d = ExKind.Throw
+
+LOCAL_LABEL(RhpThrowExImpl):
+
         STACKSIZEOF_ExInfo      = ((SIZEOF__ExInfo + 15) & (~ 15))
         rsp_offsetof_Context    = STACKSIZEOF_ExInfo
 
@@ -136,7 +158,7 @@ NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
         mov     [rsi + OFFSETOF__ExInfo__m_exception], rdx          // init the exception object to null
         mov     byte ptr [rsi + OFFSETOF__ExInfo__m_passNumber], 1  // init to the first pass
         mov     dword ptr [rsi + OFFSETOF__ExInfo__m_idxCurClause], 0xFFFFFFFF
-        mov     byte ptr [rsi + OFFSETOF__ExInfo__m_kind], 1        // ExKind.Throw
+        mov     byte ptr [rsi + OFFSETOF__ExInfo__m_kind], r8b      // ExKind (from r8b)
 
         // link the ExInfo into the thread's ExInfo chain
         mov     rdx, [rax + OFFSETOF__Thread__m_pExInfoStackHead]
@@ -152,6 +174,7 @@ NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
         call    EXTERNAL_C_FUNC(RhThrowEx)
 
 ALTERNATE_ENTRY RhpThrowEx2
+ALTERNATE_ENTRY RhpThrowExact2
 
         // no return
         int 3

src/coreclr/nativeaot/Runtime/amd64/ExceptionHandling.asm

@@ -105,6 +105,24 @@ ALTERNATE_ENTRY RhpThrowHwEx2
 
 NESTED_END RhpThrowHwEx, _TEXT
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; RhpThrowExact
+;;
+;; SUMMARY:  Similar to RhpThrowEx, except that it sets the rethrow flag
+;;
+;; INPUT:  RCX:  exception object
+;;
+;; OUTPUT:
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+NESTED_ENTRY RhpThrowExact, _TEXT
+
+        mov     r9d, 4                  ;; r9d = ExKind.RethrowFlag
+        jmp     RhpThrowExImpl
+
+NESTED_END RhpThrowExact, _TEXT
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; RhpThrowEx
@@ -116,6 +134,10 @@ NESTED_END RhpThrowHwEx, _TEXT
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 NESTED_ENTRY RhpThrowEx, _TEXT
 
+        mov     r9d, 1                  ;; r9d = ExKind.Throw
+
+ALTERNATE_ENTRY RhpThrowExImpl
+
         SIZEOF_XmmSaves equ SIZEOF__PAL_LIMITED_CONTEXT - OFFSETOF__PAL_LIMITED_CONTEXT__Xmm6
         STACKSIZEOF_ExInfo equ ((SIZEOF__ExInfo + 15) AND (NOT 15))
 
@@ -172,7 +194,7 @@ NESTED_ENTRY RhpThrowEx, _TEXT
         ;; address could have been hijacked when we were in that C# code and we must remove the hijack and
         ;; reflect the correct return address in our exception context record.  The other throw helpers don't
         ;; need this because they cannot be tail-called from C#.
-        INLINE_THREAD_UNHIJACK  rax, r9, rdx        ;; trashes R9, RDX
+        INLINE_THREAD_UNHIJACK  rax, r10, rdx       ;; trashes R10, RDX (use r10 instead of r9 to preserve ExKind)
         mov                     rdx, [rbx]          ;; rdx <- return address
         mov                     [rsp + rsp_offsetof_Context + OFFSETOF__PAL_LIMITED_CONTEXT__IP], rdx   ;; set 'faulting' IP after unhijack
 
@@ -181,7 +203,7 @@ NESTED_ENTRY RhpThrowEx, _TEXT
         mov     [rdx + OFFSETOF__ExInfo__m_exception], r8           ;; init the exception object to null
         mov     byte ptr [rdx + OFFSETOF__ExInfo__m_passNumber], 1  ;; init to the first pass
         mov     dword ptr [rdx + OFFSETOF__ExInfo__m_idxCurClause], 0FFFFFFFFh
-        mov     byte ptr [rdx + OFFSETOF__ExInfo__m_kind], 1        ;; ExKind.Throw
+        mov     byte ptr [rdx + OFFSETOF__ExInfo__m_kind], r9b      ;; ExKind (from r9b)
 
         ;; link the ExInfo into the thread's ExInfo chain
         mov     r8, [rax + OFFSETOF__Thread__m_pExInfoStackHead]
@@ -197,6 +219,7 @@ NESTED_ENTRY RhpThrowEx, _TEXT
         call    RhThrowEx
 
 ALTERNATE_ENTRY RhpThrowEx2
+ALTERNATE_ENTRY RhpThrowExact2
 
         ;; no return
         int 3

src/coreclr/nativeaot/Runtime/arm/ExceptionHandling.S

@@ -79,6 +79,24 @@ GLOBAL_LABEL RhpThrowHwEx2
 NESTED_END RhpThrowHwEx
 
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RhpThrowExact
+//
+// SUMMARY:  Similar to RhpThrowEx, except that it sets the rethrow flag
+//
+// INPUT:  R0:  exception object
+//
+// OUTPUT:
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+NESTED_ENTRY RhpThrowExact, _TEXT, NoHandler
+
+        mov         r5, #4                                          // r5 = ExKind.RethrowFlag
+        b           LOCAL_LABEL(RhpThrowExImpl)
+
+NESTED_END RhpThrowExact, _TEXT
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // RhpThrowEx
@@ -90,6 +108,10 @@ NESTED_END RhpThrowHwEx
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov         r5, #1                                          // r5 = ExKind.Throw
+
+LOCAL_LABEL(RhpThrowExImpl):
+
         // Setup a PAL_LIMITED_CONTEXT on the stack {
         PROLOG_VPUSH {d8-d15}
         PROLOG_PUSH "{r0,lr}"        	// Reserve space for SP and store LR
@@ -158,9 +180,9 @@ LOCAL_LABEL(NotHiJacked):
         str         r3, [r1, #OFFSETOF__ExInfo__m_exception] 	      // init the exception object to null
         mov         r3, #1
         strb        r3, [r1, #OFFSETOF__ExInfo__m_passNumber]       // init to the first pass
-        strb        r3, [r1, #OFFSETOF__ExInfo__m_kind]
+        strb        r5, [r1, #OFFSETOF__ExInfo__m_kind]             // ExKind (from r5)
         mov         r3, #0xFFFFFFFF
-        str         r3, [r1, #OFFSETOF__ExInfo__m_idxCurClause]     // ExKind.Throw
+        str         r3, [r1, #OFFSETOF__ExInfo__m_idxCurClause]
 
         // link the ExInfo into the thread's ExInfo chain
         ldr         r3, [r0, #OFFSETOF__Thread__m_pExInfoStackHead]
@@ -177,6 +199,7 @@ LOCAL_LABEL(NotHiJacked):
         bl          C_FUNC(RhThrowEx)
 
 GLOBAL_LABEL RhpThrowEx2
+GLOBAL_LABEL RhpThrowExact2
 
         // no return
         EMIT_BREAKPOINT

src/coreclr/nativeaot/Runtime/arm64/ExceptionHandling.S

@@ -252,6 +252,23 @@
 
     NESTED_END RhpThrowHwEx, _TEXT
 
+//
+// RhpThrowExact
+//
+// SUMMARY:  Similar to RhpThrowEx, except that it sets the rethrow flag
+//
+// INPUT:  X0:  exception object
+//
+// OUTPUT:
+//
+
+    NESTED_ENTRY RhpThrowExact, _TEXT, NoHandler
+
+        mov         w4, #4                                          // w4 = ExKind.RethrowFlag
+        b           LOCAL_LABEL(RhpThrowExImpl)
+
+    NESTED_END RhpThrowExact, _TEXT
+
 //
 // RhpThrowEx
 //
@@ -262,6 +279,10 @@
 
     NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov         w4, #1                                          // w4 = ExKind.Throw
+
+LOCAL_LABEL(RhpThrowExImpl):
+
         ALLOC_THROW_FRAME SOFTWARE_EXCEPTION
 
         GetThreadX2
@@ -316,8 +337,7 @@ LOCAL_LABEL(NotHijacked):
         strb        w3, [x1, #OFFSETOF__ExInfo__m_passNumber]       // pExInfo->m_passNumber = 1
         mov         w3, #0xFFFFFFFF
         str         w3, [x1, #OFFSETOF__ExInfo__m_idxCurClause]     // pExInfo->m_idxCurClause = MaxTryRegionIdx
-        mov         w3, #1
-        strb        w3, [x1, #OFFSETOF__ExInfo__m_kind]             // pExInfo->m_kind = ExKind.Throw
+        strb        w4, [x1, #OFFSETOF__ExInfo__m_kind]             // pExInfo->m_kind = ExKind (from w4)
 
         // link the ExInfo into the thread's ExInfo chain
         ldr         x3, [x2, #OFFSETOF__Thread__m_pExInfoStackHead]
@@ -333,12 +353,12 @@ LOCAL_LABEL(NotHijacked):
         bl          C_FUNC(RhThrowEx)
 
     ALTERNATE_ENTRY RhpThrowEx2
+    ALTERNATE_ENTRY RhpThrowExact2
 
         // no return
         EMIT_BREAKPOINT
     NESTED_END RhpThrowEx, _TEXT
 
-
 //
 // void FASTCALL RhpRethrow()
 //