Move coreclr EH second pass to native code (#119863)

* [WIP] Move coreclr EH second pass to native code

There were some GC holes discovered caused by the fact that GC can be
triggered during 2nd pass of EH in-between calls to finally handlers and
catch handler. After considering options, moving the 2nd pass to native
code seems the most reasonable solution.

* Several fixes

* Reflect PR feedback
* Implement rethrow
* Implement new way of collided unwind detection now that the
  CallCatchFunclet is not called via pinvoke
* Remove forced reporting of EH code from stack frame iterator, as we
  now cannot have that code on the stack during 2nd pass

* Fix arm64 build and remove now useless stuff from stackwalk

* Fix build break

* Fix offsets, exception interception and MUSL build break

* Alternative change with minimalistic managed code differences

* Fix 32 bit offsets

* Fix arm64 issue

* Update src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs

* Add/fix some contracts

* Fix another arm64 issue - need to use adjusted PC

* Change the GC prevention to single frame only

* Fix one new contract issue

* Update GC forbid locations

This is done to ensure that no GC is allowed between the scanned stack
range is extended and a funclet for the current frame is called.

* Fix/add comment based on review

---------

Co-authored-by: Jan Kotas <[email protected]>

Author: janvorli

src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs

@@ -68,17 +68,17 @@ class AsmOffsets
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x132;
 #elif TARGET_X86
     public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
-    public const int SIZEOF__StackFrameIterator = 0x3d4;
+    public const int SIZEOF__StackFrameIterator = 0x3d0;
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x3c2;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3d0;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3cc;
 #else // TARGET_64BIT
     public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
 #if FEATURE_INTERPRETER
-    public const int SIZEOF__StackFrameIterator = 0xdc;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xd8;
+    public const int SIZEOF__StackFrameIterator = 0xd8;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xd4;
 #else
-    public const int SIZEOF__StackFrameIterator = 0xcc;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xc8;
+    public const int SIZEOF__StackFrameIterator = 0xc8;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xc4;
 #endif
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xba;
 #endif // TARGET_64BIT
@@ -139,17 +139,17 @@ class AsmOffsets
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x12a;
 #elif TARGET_X86
     public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
-    public const int SIZEOF__StackFrameIterator = 0x3cc;
+    public const int SIZEOF__StackFrameIterator = 0x3c8;
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x3ba;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3c8;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x3c4;
 #else // TARGET_64BIT
     public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
 #if FEATURE_INTERPRETER
-    public const int SIZEOF__StackFrameIterator = 0xd4;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xd0;
+    public const int SIZEOF__StackFrameIterator = 0xd0;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xcc;
 #else
-    public const int SIZEOF__StackFrameIterator = 0xc4;
-    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xc0;
+    public const int SIZEOF__StackFrameIterator = 0xc0;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0xbc;
 #endif
     public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0xb2;
 #endif // TARGET_64BIT
@@ -217,6 +217,18 @@ class AsmOffsets
     public const int OFFSETOF__ExInfo__m_idxCurClause = 0xbc;
     public const int OFFSETOF__ExInfo__m_frameIter = 0xc0;
     public const int OFFSETOF__ExInfo__m_notifyDebuggerSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator;
+    public const int OFFSETOF__ExInfo__m_pCatchHandler = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x48;
+    public const int OFFSETOF__ExInfo__m_handlingFrameSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x50;
+
+#if TARGET_ARM64
+    public const int OFFSETOF__ExInfo__m_handlingFramePC = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x58;
+#endif
+
+#if TARGET_UNIX
+    public const int OFFSETOF__ExInfo__m_pReversePInvokePropagationCallback = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x30;
+    public const int OFFSETOF__ExInfo__m_pReversePInvokePropagationContext = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x38;
+#endif
+
 #else // TARGET_64BIT
     public const int SIZEOF__EHEnum = 0x10;
     public const int OFFSETOF__StackFrameIterator__m_pRegDisplay = 0x14;
@@ -228,6 +240,14 @@ class AsmOffsets
     public const int OFFSETOF__ExInfo__m_idxCurClause = 0x68;
     public const int OFFSETOF__ExInfo__m_frameIter = 0x6c;
     public const int OFFSETOF__ExInfo__m_notifyDebuggerSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator;
+    public const int OFFSETOF__ExInfo__m_pCatchHandler = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x2c;
+    public const int OFFSETOF__ExInfo__m_handlingFrameSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x30;
+
+#if TARGET_UNIX
+    public const int OFFSETOF__ExInfo__m_pReversePInvokePropagationCallback = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x38;
+    public const int OFFSETOF__ExInfo__m_pReversePInvokePropagationContext = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator + 0x3c;
+#endif
+
 #endif // TARGET_64BIT
 
 #if __cplusplus
@@ -268,8 +288,13 @@ class AsmOffsets
     static_assert(offsetof(ExInfo, m_idxCurClause) == OFFSETOF__ExInfo__m_idxCurClause);
     static_assert(offsetof(ExInfo, m_frameIter) == OFFSETOF__ExInfo__m_frameIter);
     static_assert(offsetof(ExInfo, m_notifyDebuggerSP) == OFFSETOF__ExInfo__m_notifyDebuggerSP);
+    static_assert(offsetof(ExInfo, m_pCatchHandler) == OFFSETOF__ExInfo__m_pCatchHandler);
+    static_assert(offsetof(ExInfo, m_handlingFrameSP) == OFFSETOF__ExInfo__m_handlingFrameSP);
+#if TARGET_ARM64
+    static_assert(offsetof(ExInfo, m_handlingFramePC) == OFFSETOF__ExInfo__m_handlingFramePC);
 #endif
 
+#endif
 }
 #if __cplusplus
 ;

src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs

@@ -20,16 +20,6 @@ internal static partial class InternalCalls
         [return: MarshalAs(UnmanagedType.U1)]
         internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted);
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ResumeAtInterceptionLocation")]
-        internal static unsafe partial void ResumeAtInterceptionLocation(void* pvRegDisplay);
-
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallCatchFunclet")]
-        internal static unsafe partial IntPtr RhpCallCatchFunclet(
-            ObjectHandleOnStack exceptionObj, byte* pHandlerIP, void* pvRegDisplay, EH.ExInfo* exInfo);
-
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallFinallyFunclet")]
-        internal static unsafe partial void RhpCallFinallyFunclet(byte* pHandlerIP, void* pvRegDisplay, EH.ExInfo* exInfo);
-
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallFilterFunclet")]
         [return: MarshalAs(UnmanagedType.U1)]
         internal static unsafe partial bool RhpCallFilterFunclet(

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs

@@ -549,6 +549,30 @@ internal object ThrownException
 
             [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_notifyDebuggerSP)]
             internal volatile UIntPtr _notifyDebuggerSP;
+#if !NATIVEAOT
+            [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_pCatchHandler)]
+            internal volatile byte* _pCatchHandler;
+
+            [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_handlingFrameSP)]
+            internal volatile UIntPtr _handlingFrameSP;
+
+#if TARGET_ARM64
+            // On ARM64, two frames can have the same SP, when a leaf function
+            // doesn't use any stack. So to distinguish between the caller frame
+            // and the leaf one, we also need to know the PC of the handling frame.
+            [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_handlingFramePC)]
+            internal volatile byte* _handlingFramePC;
+#endif
+
+#if TARGET_UNIX
+            [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_pReversePInvokePropagationCallback)]
+            internal volatile IntPtr _pReversePInvokePropagationCallback;
+
+            [FieldOffset(AsmOffsets.OFFSETOF__ExInfo__m_pReversePInvokePropagationContext)]
+            internal volatile IntPtr _pReversePInvokePropagationContext;
+#endif // TARGET_UNIX
+
+#endif // !NATIVEAOT
         }
 
         //
@@ -630,7 +654,9 @@ public static void RhThrowHwEx(uint exceptionCode, ref ExInfo exInfo)
 
             exInfo.Init(exceptionToThrow!, instructionFault);
             DispatchEx(ref exInfo._frameIter, ref exInfo);
+#if NATIVEAOT
             FallbackFailFast(RhFailFastReason.InternalError, null);
+#endif
         }
 
         private const uint MaxTryRegionIdx = 0xFFFFFFFFu;
@@ -663,68 +689,11 @@ public static void RhThrowEx(object exceptionObj, ref ExInfo exInfo)
 
             exInfo.Init(exceptionObj);
             DispatchEx(ref exInfo._frameIter, ref exInfo);
+#if NATIVEAOT
             FallbackFailFast(RhFailFastReason.InternalError, null);
+#endif
         }
 
-#if !NATIVEAOT
-        public static void RhUnwindAndIntercept(ref ExInfo exInfo, UIntPtr interceptStackFrameSP)
-        {
-            exInfo._passNumber = 2;
-            exInfo._idxCurClause = MaxTryRegionIdx;
-            uint startIdx = MaxTryRegionIdx;
-            bool unwoundReversePInvoke = false;
-            bool isExceptionIntercepted = false;
-            bool isValid = exInfo._frameIter.Init(exInfo._pExContext, (exInfo._kind & ExKind.InstructionFaultFlag) != 0, &isExceptionIntercepted);
-            for (; isValid && !isExceptionIntercepted && ((byte*)exInfo._frameIter.SP <= (byte*)interceptStackFrameSP); isValid = exInfo._frameIter.Next(&startIdx, &unwoundReversePInvoke, &isExceptionIntercepted))
-            {
-                Debug.Assert(isValid, "Unwind and intercept failed unexpectedly");
-                DebugScanCallFrame(exInfo._passNumber, exInfo._frameIter.ControlPC, exInfo._frameIter.SP);
-
-                if (unwoundReversePInvoke)
-                {
-                    // Found the native frame that called the reverse P/invoke.
-                    // It is not possible to run managed second pass handlers on a native frame.
-                    break;
-                }
-
-                if (exInfo._frameIter.SP == interceptStackFrameSP)
-                {
-                    break;
-                }
-
-                InvokeSecondPass(ref exInfo, startIdx);
-                if (isExceptionIntercepted)
-                {
-                    Debug.Assert(false);
-                    break;
-                }
-            }
-
-            // ------------------------------------------------
-            //
-            // Call the interception code
-            //
-            // ------------------------------------------------
-            if (unwoundReversePInvoke)
-            {
-                object exceptionObj = exInfo.ThrownException;
-                fixed (EH.ExInfo* pExInfo = &exInfo)
-                {
-                    InternalCalls.RhpCallCatchFunclet(
-                        ObjectHandleOnStack.Create(ref exceptionObj), null, exInfo._frameIter.RegisterSet, pExInfo);
-                }
-            }
-            else
-            {
-                InternalCalls.ResumeAtInterceptionLocation(exInfo._frameIter.RegisterSet);
-            }
-
-            Debug.Fail("unreachable");
-            FallbackFailFast(RhFailFastReason.InternalError, null);
-        }
-#endif // !NATIVEAOT
-
-
 #if NATIVEAOT
         [RuntimeExport("RhRethrow")]
 #endif
@@ -750,7 +719,9 @@ public static void RhRethrow(ref ExInfo activeExInfo, ref ExInfo exInfo)
 
             exInfo.Init(rethrownException, ref activeExInfo);
             DispatchEx(ref exInfo._frameIter, ref exInfo);
+#if NATIVEAOT
             FallbackFailFast(RhFailFastReason.InternalError, null);
+#endif
         }
 
         [StackTraceHidden]
@@ -870,6 +841,21 @@ private static void DispatchEx(scoped ref StackFrameIterator frameIter, ref ExIn
             Debug.Assert(pCatchHandler != null || pReversePInvokePropagationCallback != IntPtr.Zero || unwoundReversePInvoke || isExceptionIntercepted, "We should have a handler if we're starting the second pass");
             Debug.Assert(!isExceptionIntercepted || (pCatchHandler == null), "No catch handler should be returned for intercepted exceptions in the first pass");
 
+#if !NATIVEAOT
+            exInfo._pCatchHandler = pCatchHandler;
+            exInfo._handlingFrameSP = handlingFrameSP;
+#if TARGET_ARM64
+            exInfo._handlingFramePC = prevOriginalPC;
+#endif
+#if TARGET_UNIX
+            exInfo._pReversePInvokePropagationCallback = pReversePInvokePropagationCallback;
+            exInfo._pReversePInvokePropagationContext = pReversePInvokePropagationContext;
+#endif // TARGET_UNIX
+            exInfo._idxCurClause = catchingTryRegionIdx;
+
+            return;
+
+#else // !NATIVEAOT
             // ------------------------------------------------
             //
             // Second pass
@@ -881,9 +867,10 @@ private static void DispatchEx(scoped ref StackFrameIterator frameIter, ref ExIn
             // 'collapse' funclets which gets confused when we walk out of the dispatch code and encounter the
             // 'main body' without first encountering the funclet.  The thunks used to invoke 2nd-pass
             // funclets will always toggle this mode off before invoking them.
-#if NATIVEAOT
+
             InternalCalls.RhpSetThreadDoNotTriggerGC();
-#endif
+
+
             exInfo._passNumber = 2;
             exInfo._idxCurClause = catchingTryRegionIdx;
             startIdx = MaxTryRegionIdx;
@@ -903,10 +890,8 @@ private static void DispatchEx(scoped ref StackFrameIterator frameIter, ref ExIn
 
                 if (unwoundReversePInvoke)
                 {
-#if NATIVEAOT
                     Debug.Assert(pReversePInvokePropagationCallback != IntPtr.Zero, "Unwound to a reverse P/Invoke in the second pass. We should have a propagation handler.");
                     Debug.Assert(frameIter.PreviousTransitionFrame != IntPtr.Zero, "Should have a transition frame for reverse P/Invoke.");
-#endif
                     Debug.Assert(frameIter.SP == handlingFrameSP, "Encountered a different reverse P/Invoke frame in the second pass.");
                     // Found the native frame that called the reverse P/invoke.
                     // It is not possible to run managed second pass handlers on a native frame.
@@ -930,36 +915,26 @@ private static void DispatchEx(scoped ref StackFrameIterator frameIter, ref ExIn
 #if FEATURE_OBJCMARSHAL
             if (pReversePInvokePropagationCallback != IntPtr.Zero)
             {
-#if NATIVEAOT
                 InternalCalls.RhpCallPropagateExceptionCallback(
                     pReversePInvokePropagationContext, pReversePInvokePropagationCallback, frameIter.RegisterSet, ref exInfo, frameIter.PreviousTransitionFrame);
                 // the helper should jump to propagation handler and not return
-#endif
                 Debug.Fail("unreachable");
                 FallbackFailFast(RhFailFastReason.InternalError, null);
             }
 #endif // FEATURE_OBJCMARSHAL
 
-
             // ------------------------------------------------
             //
             // Call the handler and resume execution
             //
             // ------------------------------------------------
             exInfo._idxCurClause = catchingTryRegionIdx;
-#if NATIVEAOT
             InternalCalls.RhpCallCatchFunclet(
                 exceptionObj, pCatchHandler, frameIter.RegisterSet, ref exInfo);
-#else // NATIVEAOT
-            fixed (EH.ExInfo* pExInfo = &exInfo)
-            {
-                InternalCalls.RhpCallCatchFunclet(
-                    ObjectHandleOnStack.Create(ref exceptionObj), pCatchHandler, frameIter.RegisterSet, pExInfo);
-            }
-#endif // NATIVEAOT
             // currently, RhpCallCatchFunclet will resume after the catch
             Debug.Fail("unreachable");
             FallbackFailFast(RhFailFastReason.InternalError, null);
+#endif // !NATIVEAOT
         }
 
         [System.Diagnostics.Conditional("DEBUG")]
@@ -1165,6 +1140,7 @@ private static bool ShouldTypedClauseCatchThisException(object exception, Method
 #endif
         }
 
+#if NATIVEAOT
         private static void InvokeSecondPass(ref ExInfo exInfo, uint idxStart)
         {
             InvokeSecondPass(ref exInfo, idxStart, MaxTryRegionIdx);
@@ -1202,11 +1178,7 @@ private static void InvokeSecondPass(ref ExInfo exInfo, uint idxStart, uint idxL
 
                     // Now, we continue skipping while the try region is identical to the one that invoked the
                     // previous dispatch.
-                    if ((ehClause._tryStartOffset == lastTryStart) && (ehClause._tryEndOffset == lastTryEnd)
-#if !NATIVEAOT
-                        && (ehClause._isSameTry)
-#endif
-                    )
+                    if ((ehClause._tryStartOffset == lastTryStart) && (ehClause._tryEndOffset == lastTryEnd))
                         continue;
 
                     // We are done skipping. This is required to handle empty finally block markers that are used
@@ -1237,19 +1209,11 @@ private static void InvokeSecondPass(ref ExInfo exInfo, uint idxStart, uint idxL
 
                 byte* pFinallyHandler = ehClause._handlerAddress;
                 exInfo._idxCurClause = curIdx;
-#if NATIVEAOT
                 InternalCalls.RhpCallFinallyFunclet(pFinallyHandler, exInfo._frameIter.RegisterSet);
-#else // NATIVEAOT
-                fixed (EH.ExInfo* pExInfo = &exInfo)
-                {
-                    InternalCalls.RhpCallFinallyFunclet(pFinallyHandler, exInfo._frameIter.RegisterSet, pExInfo);
-                }
-#endif // NATIVEAOT
                 exInfo._idxCurClause = MaxTryRegionIdx;
             }
         }
 
-#if NATIVEAOT
 #pragma warning disable IDE0060
         [UnmanagedCallersOnly(EntryPoint = "RhpFailFastForPInvokeExceptionPreemp")]
         public static void RhpFailFastForPInvokeExceptionPreemp(IntPtr PInvokeCallsiteReturnAddr, void* pExceptionRecord, void* pContextRecord)

src/coreclr/vm/corelib.h

@@ -1357,7 +1357,6 @@ DEFINE_CLASS(EH, Runtime, EH)
 DEFINE_METHOD(EH, RH_THROW_EX, RhThrowEx, SM_Obj_RefExInfo_RetVoid)
 DEFINE_METHOD(EH, RH_THROWHW_EX, RhThrowHwEx, SM_UInt_RefExInfo_RetVoid)
 DEFINE_METHOD(EH, RH_RETHROW, RhRethrow, SM_RefExInfo_RefExInfo_RetVoid)
-DEFINE_METHOD(EH, UNWIND_AND_INTERCEPT, RhUnwindAndIntercept, SM_RefExInfo_UIntPtr_RetVoid)
 DEFINE_CLASS(EXCEPTIONSERVICES_INTERNALCALLS, ExceptionServices, InternalCalls)
 DEFINE_CLASS(STACKFRAMEITERATOR, Runtime, StackFrameIterator)
 #endif // FEATURE_EH_FUNCLETS