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

@@ -229,6 +229,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)
         {
 #if NATIVEAOT
@@ -436,6 +444,7 @@ internal void HandleSuspended()
                 }
             }
 
+            [StackTraceHidden]
             private unsafe void DispatchContinuations()
             {
                 ExecutionAndSyncBlockStore contexts = default;
@@ -469,7 +478,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
@@ -520,10 +529,19 @@ 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;
+                        System.Exception.AppendExceptionStackFrame(ex, ip, 0);
+#endif
+                    }
                     if (continuation == null || (continuation.Flags & ContinuationFlags.HasException) != 0)
                         return continuation;
 
@@ -769,12 +787,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

@@ -20,7 +20,7 @@
 // If you update this, ensure you run `git grep MINIMUM_READYTORUN_MAJOR_VERSION`
 // and handle pending work.
 #define READYTORUN_MAJOR_VERSION 18
-#define READYTORUN_MINOR_VERSION 0x0000
+#define READYTORUN_MINOR_VERSION 0x0001
 
 #define MINIMUM_READYTORUN_MAJOR_VERSION 18
 
@@ -337,6 +337,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/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:
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+LEAF_ENTRY RhpThrowExact, _TEXT
+
+        mov     r8d, 4                  // r8d = ExKind.RethrowFlag
+        jmp     RhpThrowExImpl
+
+LEAF_END RhpThrowExact, _TEXT
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // RhpThrowEx
@@ -89,6 +107,10 @@ NESTED_END RhpThrowHwEx, _TEXT
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov     r8d, 1                  // r8d = ExKind.Throw
+
+ALTERNATE_ENTRY 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]

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:
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+LEAF_ENTRY RhpThrowExact, _TEXT
+
+        mov     r9d, 4                  ;; r9d = ExKind.RethrowFlag
+        jmp     RhpThrowExImpl
+
+LEAF_END RhpThrowExact, _TEXT
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; RhpThrowEx
@@ -116,6 +134,10 @@ NESTED_END RhpThrowHwEx, _TEXT
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 NESTED_ENTRY RhpThrowEx, _TEXT
 
+        mov     r9d, 1                  ;; r9d = ExKind.Throw
+
+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
         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]

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:
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+LEAF_ENTRY RhpThrowExact, _TEXT
+
+        mov         r2, #4                                          // r2 = ExKind.RethrowFlag
+        b           RhpThrowExImpl
+
+LEAF_END RhpThrowExact, _TEXT
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // RhpThrowEx
@@ -90,6 +108,10 @@ NESTED_END RhpThrowHwEx
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov         r2, #1                                          // r2 = ExKind.Throw
+
+ALTERNATE_ENTRY RhpThrowExImpl
+
         // Setup a PAL_LIMITED_CONTEXT on the stack {
         PROLOG_VPUSH {d8-d15}
         PROLOG_PUSH "{r0,lr}"        	// Reserve space for SP and store LR
@@ -106,8 +128,6 @@ NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
         // r0 = GetThread()
         INLINE_GETTHREAD
 
-        add         r2, sp, #(rsp_offsetof_Context + SIZEOF__PAL_LIMITED_CONTEXT + 0x8) 	// r2 <- addr of return address
-
         // There is runtime C# code that can tail call to RhpThrowEx using a binder intrinsic. So  the return
         // 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
@@ -158,9 +178,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        r2, [r1, #OFFSETOF__ExInfo__m_kind]             // ExKind (from r2)
         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]

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:
+//
+
+    LEAF_ENTRY RhpThrowExact, _TEXT
+
+        mov         w4, #4                                          // w4 = ExKind.RethrowFlag
+        b           RhpThrowExImpl
+
+    LEAF_END RhpThrowExact, _TEXT
+
 //
 // RhpThrowEx
 //
@@ -262,6 +279,10 @@
 
     NESTED_ENTRY RhpThrowEx, _TEXT, NoHandler
 
+        mov         w4, #1                                          // w4 = ExKind.Throw
+
+ALTERNATE_ENTRY 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]
@@ -338,7 +358,6 @@ LOCAL_LABEL(NotHijacked):
         EMIT_BREAKPOINT
     NESTED_END RhpThrowEx, _TEXT
 
-
 //
 // void FASTCALL RhpRethrow()
 //

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

@@ -250,6 +250,24 @@
 
     NESTED_END RhpThrowHwEx
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; RhpThrowExact
+;;
+;; SUMMARY:  Similar to RhpThrowEx, except that it sets the rethrow flag
+;;
+;; INPUT:  X0:  exception object
+;;
+;; OUTPUT:
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    LEAF_ENTRY RhpThrowExact
+
+        mov         w4, #4                                          ;; w4 = ExKind.RethrowFlag
+        b           RhpThrowExImpl
+
+    LEAF_END RhpThrowExact
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; RhpThrowEx
@@ -261,6 +279,10 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     NESTED_ENTRY RhpThrowEx
 
+        mov         w4, #1                                          ;; w4 = ExKind.Throw
+
+RhpThrowExImpl
+
         ALLOC_THROW_FRAME SOFTWARE_EXCEPTION
 
         ;; x2 = GetThread(), TRASHES x1
@@ -317,8 +339,7 @@ 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]