Resuming after catch via native exception

This commit moves the resuming after catch to using native exception
handling instead of fragile context capturing, which was not correct
anyways.

It also adds handling of exceptions comming out of native runtime
methods called from the interpreter.

Author: janvorli

src/coreclr/inc/eetwain.h

@@ -307,7 +307,7 @@ virtual void            LeaveCatch(GCInfoToken gcInfoToken,
                                    PCONTEXT pCtx)=0;
 #else // FEATURE_EH_FUNCLETS
 virtual DWORD_PTR CallFunclet(OBJECTREF throwable, void* pHandler, REGDISPLAY *pRD, ExInfo *pExInfo, bool isFilter) = 0;
-virtual void PrepareForResumeAfterCatch(CONTEXT *pContext) = 0;
+virtual void ResumeAfterCatch(CONTEXT *pContext, size_t targetSSP, bool fIntercepted) = 0;
 #if defined(HOST_AMD64) && defined(HOST_WINDOWS)
 virtual void UpdateSSP(PREGDISPLAY pRD) = 0;
 #endif // HOST_AMD64 && HOST_WINDOWS
@@ -557,10 +557,7 @@ virtual void LeaveCatch(GCInfoToken gcInfoToken,
                          PCONTEXT pCtx);
 #else // FEATURE_EH_FUNCLETS
 virtual DWORD_PTR CallFunclet(OBJECTREF throwable, void* pHandler, REGDISPLAY *pRD, ExInfo *pExInfo, bool isFilter);
-virtual void PrepareForResumeAfterCatch(CONTEXT *pContext)
-{
-    // Nothing to do for non-interpreter code manager.
-}
+virtual void ResumeAfterCatch(CONTEXT *pContext, size_t targetSSP, bool fIntercepted);
 
 #if defined(HOST_AMD64) && defined(HOST_WINDOWS)
 virtual void UpdateSSP(PREGDISPLAY pRD);
@@ -774,7 +771,7 @@ virtual void LeaveCatch(GCInfoToken gcInfoToken,
 }
 #else // FEATURE_EH_FUNCLETS
 virtual DWORD_PTR CallFunclet(OBJECTREF throwable, void* pHandler, REGDISPLAY *pRD, ExInfo *pExInfo, bool isFilter);
-virtual void PrepareForResumeAfterCatch(CONTEXT *pContext);
+virtual void ResumeAfterCatch(CONTEXT *pContext, size_t targetSSP, bool fIntercepted);
 #if defined(HOST_AMD64) && defined(HOST_WINDOWS)
 virtual void UpdateSSP(PREGDISPLAY pRD);
 #endif // HOST_AMD64 && HOST_WINDOWS

src/coreclr/vm/eetwain.cpp

@@ -22,6 +22,7 @@
 #endif // FEATURE_INTERPRETER
 
 #include "exinfo.h"
+#include "excep.h"
 
 #ifdef TARGET_X86
 
@@ -2075,21 +2076,68 @@ DWORD_PTR EECodeManager::CallFunclet(OBJECTREF throwable, void* pHandler, REGDIS
     return dwResult;
 }
 
+void EECodeManager::ResumeAfterCatch(CONTEXT *pContext, size_t targetSSP, bool fIntercepted)
+{
+    Thread *pThread = GetThread();
+    DWORD_PTR dwResumePC = GetIP(pContext);
+    UINT_PTR uAbortAddr = 0;
+    if (!fIntercepted)
+    {
+        CopyOSContext(pThread->m_OSContext, pContext);
+        uAbortAddr = (UINT_PTR)COMPlusCheckForAbort(dwResumePC);
+    }
+
+    if (uAbortAddr)
+    {
+        STRESS_LOG2(LF_EH, LL_INFO10, "Thread abort in progress, resuming under control: IP=%p, SP=%p\n", dwResumePC, GetSP(pContext));
+
+        // The dwResumePC is passed to the THROW_CONTROL_FOR_THREAD_FUNCTION ASM helper so that
+        // it can establish it as its return address and native stack unwinding can work properly.
+#ifdef TARGET_AMD64
+#ifdef TARGET_UNIX
+        pContext->Rdi = dwResumePC;
+#else
+        pContext->Rcx = dwResumePC;
+#endif
+#elif defined(TARGET_ARM) || defined(TARGET_ARM64)
+        // On ARM & ARM64, we save off the original PC in Lr. This is the same as done
+        // in HandleManagedFault for H/W generated exceptions.
+        pContext->Lr = dwResumePC;
+#elif defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
+        pContext->Ra = dwResumePC;
+#endif
+
+        SetIP(pContext, uAbortAddr);
+    }
+    else
+    {
+        STRESS_LOG2(LF_EH, LL_INFO100, "Resuming after exception at IP=%p, SP=%p\n", GetIP(pContext), GetSP(pContext));
+    }
+
+    ClrRestoreNonvolatileContext(pContext, targetSSP);
+}
+
 #if defined(HOST_AMD64) && defined(HOST_WINDOWS)
-void EECodeManager::UpdateSSP(PREGDISPLAY pRD)
+
+size_t GetSSPForFrameOnCurrentStack(TADDR ip)
 {
     size_t *targetSSP = (size_t *)_rdsspq();
     // The SSP we search is pointing to the return address of the frame represented
-    // by the pRD->ControlPC. So we search for the instruction pointer from
+    // by the passed in IP. So we search for the instruction pointer from
     // the context and return one slot up from there.
     if (targetSSP != NULL)
     {
-        while (*targetSSP++ != pRD->ControlPC)
+        while (*targetSSP++ != ip)
         {
         }
     }
 
-    pRD->SSP = (size_t)targetSSP;
+    return (size_t)targetSSP;
+}
+
+void EECodeManager::UpdateSSP(PREGDISPLAY pRD)
+{
+    pRD->SSP = GetSSPForFrameOnCurrentStack(pRD->ControlPC);
 }
 #endif // HOST_AMD64 && HOST_WINDOWS
 
@@ -2101,13 +2149,64 @@ DWORD_PTR InterpreterCodeManager::CallFunclet(OBJECTREF throwable, void* pHandle
     return 0;
 }
 
-void InterpreterCodeManager::PrepareForResumeAfterCatch(CONTEXT *pContext)
+void InterpreterCodeManager::ResumeAfterCatch(CONTEXT *pContext, size_t targetSSP, bool fIntercepted)
 {
     Thread *pThread = GetThread();
     InterpreterFrame * pInterpreterFrame = (InterpreterFrame*)pThread->GetFrame();
-    pInterpreterFrame->SetResumeContext(GetSP(pContext), GetIP(pContext));
-    pInterpreterFrame->RestoreInterpExecMethodContext(pContext);
+    TADDR resumeSP = GetSP(pContext);
+    TADDR resumeIP = GetIP(pContext);
+
+    ClrCaptureContext(pContext);
+
+    // Unwind to the caller of the Ex.RhThrowEx / Ex.RhThrowHwEx
+    Thread::VirtualUnwindToFirstManagedCallFrame(pContext);
+
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+    targetSSP = GetSSPForFrameOnCurrentStack(GetIP(pContext));
+#endif // HOST_AMD64 && HOST_WINDOWS
+
+    CONTEXT firstNativeContext;
+    size_t firstNativeSSP;
+
+    // Find the native frames chain that contains the resumeSP
+    do
+    {
+        // Skip all managed frames upto a native frame
+        while (ExecutionManager::IsManagedCode(GetIP(pContext)))
+        {
+            Thread::VirtualUnwindCallFrame(pContext);
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+            if (targetSSP != 0)
+            {
+                targetSSP += sizeof(size_t);
+            }
+#endif
+        }
+
+        // Save the first native context after managed frames. This will be the context where we throw the resume after catch exception from.
+        firstNativeContext = *pContext;
+        firstNativeSSP = targetSSP;
+        // Move over all native frames until we move over the resumeSP
+        while ((GetSP(pContext) < resumeSP) && !ExecutionManager::IsManagedCode(GetIP(pContext)))
+        {
+#ifdef TARGET_UNIX
+            PAL_VirtualUnwind(pContext, NULL);
+#else
+            Thread::VirtualUnwindCallFrame(pContext);
+#endif
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+            if (targetSSP != 0)
+            {
+                targetSSP += sizeof(size_t);
+            }
+#endif
+        }
+    }
+    while (GetSP(pContext) < resumeSP);
+
+    ExecuteFunctionBelowContext((PCODE)ThrowResumeAfterCatchException, &firstNativeContext, firstNativeSSP, resumeSP, resumeIP);
 }
+
 #if defined(HOST_AMD64) && defined(HOST_WINDOWS)
 void InterpreterCodeManager::UpdateSSP(PREGDISPLAY pRD)
 {
@@ -2306,7 +2405,7 @@ bool InterpreterCodeManager::UnwindStackFrame(PREGDISPLAY     pRD,
     return true;
 }
 
-void InterpreterCodeManager::EnsureCallerContextIsValid( PREGDISPLAY  pRD, EECodeInfo * pCodeInfo /*= NULL*/, unsigned flags /*= 0*/)
+void InterpreterCodeManager::EnsureCallerContextIsValid(PREGDISPLAY  pRD, EECodeInfo * pCodeInfo /*= NULL*/, unsigned flags /*= 0*/)
 {
     CONTRACTL
     {
@@ -2322,9 +2421,7 @@ void InterpreterCodeManager::EnsureCallerContextIsValid( PREGDISPLAY  pRD, EECod
         *(pRD->pCallerContext) = *(pRD->pCurrentContext);
         TADDR sp = (TADDR)GetRegdisplaySP(pRD);
         VirtualUnwindInterpreterCallFrame(sp, pRD->pCallerContext);
-        // Preserve the context pointers, besides the SP, IP, FP and the first argument register, all the registers are
-        // kept untouched and keep the state it the InterpExecMethod. We use the context pointers to update the registers
-        // before resuming after a catch using the original context.
+        // Preserve the context pointers, they are used by floating point registers unwind starting at the original context.
         memcpy(pRD->pCallerContextPointers, pRD->pCurrentContextPointers, sizeof(KNONVOLATILE_CONTEXT_POINTERS));
 
         pRD->IsCallerContextValid = TRUE;

src/coreclr/vm/excep.cpp

@@ -7307,6 +7307,48 @@ VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFra
     }
 }
 
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+size_t GetSSPForFrameOnCurrentStack(TADDR ip);
+#endif // HOST_AMD64 && HOST_WINDOWS
+
+#ifdef FEATURE_INTERPRETER
+void ThrowResumeAfterCatchException(TADDR resumeSP, TADDR resumeIP)
+{
+    throw ResumeAfterCatchException(resumeSP, resumeIP);
+}
+
+VOID DECLSPEC_NORETURN UnwindAndContinueResumeAfterCatch(TADDR resumeSP, TADDR resumeIP)
+{
+    STATIC_CONTRACT_NOTHROW;
+    STATIC_CONTRACT_GC_TRIGGERS;
+    STATIC_CONTRACT_MODE_ANY;
+
+    CONTEXT context;
+    ClrCaptureContext(&context);
+
+    // Unwind to the caller of the Ex.RhThrowEx / Ex.RhThrowHwEx
+    Thread::VirtualUnwindToFirstManagedCallFrame(&context);
+
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+    size_t targetSSP = GetSSPForFrameOnCurrentStack(GetIP(&context));
+#endif // HOST_AMD64 && HOST_WINDOWS
+
+    // Skip all managed frames upto a native frame
+    while (ExecutionManager::IsManagedCode(GetIP(&context)))
+    {
+        Thread::VirtualUnwindCallFrame(&context);
+#if defined(HOST_AMD64) && defined(HOST_WINDOWS)
+        if (targetSSP != 0)
+        {
+            targetSSP += sizeof(size_t);
+        }
+#endif
+    }
+
+    ExecuteFunctionBelowContext((PCODE)ThrowResumeAfterCatchException, &context, targetSSP, resumeSP, resumeIP);
+}
+#endif // FEATURE_INTERPRETER
+
 thread_local DWORD t_dwCurrentExceptionCode;
 thread_local PEXCEPTION_RECORD t_pCurrentExceptionRecord;
 thread_local PCONTEXT t_pCurrentExceptionContext;

src/coreclr/vm/excep.h

@@ -807,6 +807,10 @@ X86_ONLY(EXCEPTION_REGISTRATION_RECORD* GetNextCOMPlusSEHRecord(EXCEPTION_REGIST
 VOID DECLSPEC_NORETURN ContinueExceptionInterceptionUnwind();
 #endif // FEATURE_EH_FUNCLETS
 
+#ifdef FEATURE_INTERPRETER
+void ThrowResumeAfterCatchException(TADDR resumeSP, TADDR resumeIP);
+#endif // FEATURE_INTERPRETER
+
 #endif // !DACCESS_COMPILE
 
 #endif // __excep_h__