Just running tests with new EH enabled on all platforms

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -210,6 +210,11 @@
     <Compile Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\ControlledExecution.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\DependentHandle.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)..\nativeaot\Runtime.Base\src\System\Runtime\ExceptionHandling.cs" Condition="('$(Platform)' != 'x86' or '$(TargetsWindows)' != 'true')"/>
+    <Compile Include="$(MSBuildThisFileDirectory)..\nativeaot\Runtime.Base\src\System\Runtime\ExceptionIDs.cs" Condition="('$(Platform)' != 'x86' or '$(TargetsWindows)' != 'true')"/>
+    <Compile Include="$(MSBuildThisFileDirectory)..\nativeaot\Runtime.Base\src\System\Runtime\StackFrameIterator.cs" Condition="('$(Platform)' != 'x86' or '$(TargetsWindows)' != 'true')"/>
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\AsmOffsets.cs" Condition="('$(Platform)' != 'x86' or '$(TargetsWindows)' != 'true')"/>
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\InternalCalls.cs" Condition="('$(Platform)' != 'x86' or '$(TargetsWindows)' != 'true')"/>
     <Compile Include="$(BclSourcesRoot)\System\Runtime\GCSettings.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\JitInfo.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumerable.cs" />

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

@@ -0,0 +1,213 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// NOTE: This file is included also during native runtime compilation by the C++ compiler for verification purposes.
+// The static asserts at the end are compiled only when this file is included in native build by c++ compiler. They
+// provide compile time verification that all the sizes and offsets match between the managed and native code.
+
+#if !__cplusplus
+internal static
+#endif
+class AsmOffsets
+{
+
+    // Offsets / sizes that are different in Release / Debug builds
+#if DEBUG
+    // Debug build offsets
+#if TARGET_AMD64
+#if TARGET_UNIX
+    public const int SIZEOF__REGDISPLAY = 0x1a90;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x1a78;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x1a80;
+#else // TARGET_UNIX
+    public const int SIZEOF__REGDISPLAY = 0xbf0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0xbd8;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0xbe0;
+#endif // TARGET_UNIX
+#elif TARGET_ARM64
+    public const int SIZEOF__REGDISPLAY = 0x940;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x898;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x8a0;
+#elif TARGET_ARM
+    public const int SIZEOF__REGDISPLAY = 0x410;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x3ec;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x3f0;
+#elif TARGET_X86
+    public const int SIZEOF__REGDISPLAY = 0x5fc;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x5f0;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x5f4;
+#elif TARGET_RISCV64
+    public const int SIZEOF__REGDISPLAY = 0x6C0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x628;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x630;
+#elif TARGET_LOONGARCH64
+    public const int SIZEOF__REGDISPLAY = 0x6C0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x628;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x630;
+#endif
+
+#if TARGET_64BIT
+    public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x8;
+    public const int SIZEOF__StackFrameIterator = 0x370;
+    public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x352;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x368;
+#else // TARGET_64BIT
+    public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
+    public const int SIZEOF__StackFrameIterator = 0x2d8;
+    public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x2c2;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x2d0;
+#endif // TARGET_64BIT
+
+#else // DEBUG
+    // Release build offsets
+#if TARGET_AMD64
+#if TARGET_UNIX
+    public const int SIZEOF__REGDISPLAY = 0x1a80;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x1a70;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x1a78;
+#else // TARGET_UNIX
+    public const int SIZEOF__REGDISPLAY = 0xbe0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0xbd0;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0xbd8;
+#endif // TARGET_UNIX
+#elif TARGET_ARM64
+    public const int SIZEOF__REGDISPLAY = 0x930;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x890;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x898;
+#elif TARGET_ARM
+    public const int SIZEOF__REGDISPLAY = 0x408;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x3e8;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x3ec;
+#elif TARGET_X86
+    public const int SIZEOF__REGDISPLAY = 0x5f8;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x5ec;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x5f0;
+#elif TARGET_RISCV64
+    public const int SIZEOF__REGDISPLAY = 0x6B0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x620;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x628;
+#elif TARGET_LOONGARCH64
+    public const int SIZEOF__REGDISPLAY = 0x6B0;
+    public const int OFFSETOF__REGDISPLAY__SP = 0x620;
+    public const int OFFSETOF__REGDISPLAY__ControlPC = 0x628;
+#endif
+
+#if TARGET_64BIT
+    public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x8;
+    public const int SIZEOF__StackFrameIterator = 0x370;
+    public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x34a;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x360;
+#else // TARGET_64BIT
+    public const int OFFSETOF__REGDISPLAY__m_pCurrentContext = 0x4;
+    public const int SIZEOF__StackFrameIterator = 0x2d0;
+    public const int OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions = 0x2ba;
+    public const int OFFSETOF__StackFrameIterator__m_AdjustedControlPC = 0x2c8;
+#endif // TARGET_64BIT
+
+#endif // DEBUG
+
+#if TARGET_AMD64
+#if TARGET_UNIX
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0xc20;
+#else // TARGET_UNIX
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x4d0;
+#endif // TARGET_UNIx
+#elif TARGET_ARM64
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x390;
+#elif TARGET_ARM
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x1a0;
+#elif TARGET_X86
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x2cc;
+#elif TARGET_RISCV64
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x220;
+#elif TARGET_LOONGARCH64
+    public const int SIZEOF__PAL_LIMITED_CONTEXT = 0x220;
+#endif
+
+#if TARGET_AMD64
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0xf8;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0xa0;
+#elif TARGET_ARM64
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0x108;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0xf0;
+#elif TARGET_ARM
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0x40;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0x30;
+#elif TARGET_X86
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0xb8;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0xb4;
+#elif TARGET_RISCV64
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0x108;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0x48;
+#elif TARGET_LOONGARCH64
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__IP = 0x108;
+    public const int OFFSETOF__PAL_LIMITED_CONTEXT__FP = 0x48;
+#endif
+
+    // Offsets / sizes that are different in 64 / 32 bit mode
+
+#if TARGET_64BIT
+    public const int SIZEOF__EHEnum = 0x20;
+    public const int OFFSETOF__StackFrameIterator__m_pRegDisplay = 0x228;
+    public const int OFFSETOF__ExInfo__m_pPrevExInfo = 0;
+    public const int OFFSETOF__ExInfo__m_pExContext = 8;
+    public const int OFFSETOF__ExInfo__m_exception = 0x10;
+    public const int OFFSETOF__ExInfo__m_kind = 0x18;
+    public const int OFFSETOF__ExInfo__m_passNumber = 0x19;
+    public const int OFFSETOF__ExInfo__m_idxCurClause = 0x1c;
+    public const int OFFSETOF__ExInfo__m_frameIter = 0x20;
+    public const int OFFSETOF__ExInfo__m_notifyDebuggerSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator;
+#else // TARGET_64BIT
+    public const int SIZEOF__EHEnum = 0x10;
+    public const int OFFSETOF__StackFrameIterator__m_pRegDisplay = 0x218;
+    public const int OFFSETOF__ExInfo__m_pPrevExInfo = 0;
+    public const int OFFSETOF__ExInfo__m_pExContext = 4;
+    public const int OFFSETOF__ExInfo__m_exception = 8;
+    public const int OFFSETOF__ExInfo__m_kind = 0xC;
+    public const int OFFSETOF__ExInfo__m_passNumber = 0xD;
+    public const int OFFSETOF__ExInfo__m_idxCurClause = 0x10;
+    public const int OFFSETOF__ExInfo__m_frameIter = 0x18;
+    public const int OFFSETOF__ExInfo__m_notifyDebuggerSP = OFFSETOF__ExInfo__m_frameIter + SIZEOF__StackFrameIterator;
+#endif // TARGET_64BIT
+
+#if __cplusplus
+    static_assert_no_msg(sizeof(CONTEXT) == AsmOffsets::SIZEOF__PAL_LIMITED_CONTEXT);
+#if TARGET_AMD64
+    static_assert_no_msg(offsetof(CONTEXT, Rip) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__IP);
+    static_assert_no_msg(offsetof(CONTEXT, Rbp) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__FP);
+#elif TARGET_ARM64
+    static_assert_no_msg(offsetof(CONTEXT, Pc) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__IP);
+    static_assert_no_msg(offsetof(CONTEXT, Fp) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__FP);
+#elif TARGET_ARM
+    static_assert_no_msg(offsetof(CONTEXT, Pc) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__IP);
+    static_assert_no_msg(offsetof(CONTEXT, R11) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__FP);
+#elif TARGET_X86
+    static_assert_no_msg(offsetof(CONTEXT, Eip) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__IP);
+    static_assert_no_msg(offsetof(CONTEXT, Ebp) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__FP);
+#elif TARGET_RISCV64
+    static_assert_no_msg(offsetof(CONTEXT, Pc) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__IP);
+    static_assert_no_msg(offsetof(CONTEXT, Fp) == AsmOffsets::OFFSETOF__PAL_LIMITED_CONTEXT__FP);
+#endif
+    static_assert_no_msg(sizeof(REGDISPLAY) == AsmOffsets::SIZEOF__REGDISPLAY);
+    static_assert_no_msg(offsetof(REGDISPLAY, SP) == AsmOffsets::OFFSETOF__REGDISPLAY__SP);
+    static_assert_no_msg(offsetof(REGDISPLAY, ControlPC) == AsmOffsets::OFFSETOF__REGDISPLAY__ControlPC);
+    static_assert_no_msg(offsetof(REGDISPLAY, pCurrentContext) == AsmOffsets::OFFSETOF__REGDISPLAY__m_pCurrentContext);
+    static_assert_no_msg(sizeof(StackFrameIterator) == AsmOffsets::SIZEOF__StackFrameIterator);
+    static_assert_no_msg(offsetof(StackFrameIterator, m_crawl) + offsetof(CrawlFrame, pRD) == OFFSETOF__StackFrameIterator__m_pRegDisplay);
+    static_assert_no_msg(offsetof(StackFrameIterator, m_isRuntimeWrappedExceptions) == OFFSETOF__StackFrameIterator__m_isRuntimeWrappedExceptions);
+    static_assert_no_msg(offsetof(StackFrameIterator, m_AdjustedControlPC) == OFFSETOF__StackFrameIterator__m_AdjustedControlPC);
+    static_assert_no_msg(sizeof(ExtendedEHClauseEnumerator) == AsmOffsets::SIZEOF__EHEnum);
+    static_assert_no_msg(offsetof(ExInfo, m_pPrevExInfo) == OFFSETOF__ExInfo__m_pPrevExInfo);
+    static_assert_no_msg(offsetof(ExInfo, m_pExContext) == OFFSETOF__ExInfo__m_pExContext);
+    static_assert_no_msg(offsetof(ExInfo, m_exception) == OFFSETOF__ExInfo__m_exception);
+    static_assert_no_msg(offsetof(ExInfo, m_kind) == OFFSETOF__ExInfo__m_kind);
+    static_assert_no_msg(offsetof(ExInfo, m_passNumber) == OFFSETOF__ExInfo__m_passNumber);
+    static_assert_no_msg(offsetof(ExInfo, m_idxCurClause) == OFFSETOF__ExInfo__m_idxCurClause);
+    static_assert_no_msg(offsetof(ExInfo, m_frameIter) == OFFSETOF__ExInfo__m_frameIter);
+    static_assert_no_msg(offsetof(ExInfo, m_notifyDebuggerSP) == OFFSETOF__ExInfo__m_notifyDebuggerSP);
+#endif    
+
+}
+#if __cplusplus
+;
+#endif

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

@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+//
+// This is where we group together all the internal calls.
+//
+
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.ExceptionServices
+{
+    internal static partial class InternalCalls
+    {
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiInit")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.Bool)] bool instructionFault);
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiNext")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke);
+
+#pragma warning disable CS8500
+        [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.Bool)]
+        internal static unsafe partial bool RhpCallFilterFunclet(
+            ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay);
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppendExceptionStackFrame")]
+        internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo);
+#pragma warning restore CS8500
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumInitFromStackFrameIterator")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool RhpEHEnumInitFromStackFrameIterator(ref StackFrameIterator pFrameIter, byte** pMethodStartAddress, void* pEHEnum);
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumNext")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause);
+    }
+}

src/coreclr/clr.featuredefines.props

@@ -40,6 +40,10 @@
         <FeatureObjCMarshal>true</FeatureObjCMarshal>
     </PropertyGroup>
 
+    <PropertyGroup Condition="!('$(TargetsWindows)' == 'true' AND '$(Platform)' == 'x86')">
+        <FeatureEHFunclets>true</FeatureEHFunclets>
+    </PropertyGroup>
+
     <PropertyGroup>
         <DefineConstants Condition="'$(FeatureArrayStubAsIL)' == 'true'">$(DefineConstants);FEATURE_ARRAYSTUB_AS_IL</DefineConstants>
         <DefineConstants Condition="'$(FeatureMulticastStubAsIL)' == 'true'">$(DefineConstants);FEATURE_MULTICASTSTUB_AS_IL</DefineConstants>
@@ -59,6 +63,7 @@
         <DefineConstants Condition="'$(FeatureBasicFreeze)' == 'true'">$(DefineConstants);FEATURE_BASICFREEZE</DefineConstants>
         <DefineConstants Condition="'$(FeaturePortableShuffleThunks)' == 'true'">$(DefineConstants);FEATURE_PORTABLE_SHUFFLE_THUNKS</DefineConstants>
         <DefineConstants Condition="'$(FeatureICastable)' == 'true'">$(DefineConstants);FEATURE_ICASTABLE</DefineConstants>
+        <DefineConstants Condition="'$(FeatureEHFunclets)' == 'true'">$(DefineConstants);FEATURE_EH_FUNCLETS</DefineConstants>
 
         <DefineConstants Condition="'$(ProfilingSupportedBuild)' == 'true'">$(DefineConstants);PROFILING_SUPPORTED</DefineConstants>
         <DefineConstants Condition="'$(FeatureProfAttach)' == 'true'">$(DefineConstants);FEATURE_PROFAPI_ATTACH_DETACH</DefineConstants>

src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp

@@ -261,6 +261,22 @@ BOOL DacDbiInterfaceImpl::UnwindStackWalkFrame(StackWalkHandle pSFIHandle)
                 // Just continue onto the next managed stack frame.
                 continue;
             }
+#ifdef FEATURE_EH_FUNCLETS
+            else if (g_isNewExceptionHandlingEnabled && pIter->GetFrameState() == StackFrameIterator::SFITER_FRAMELESS_METHOD)
+            {
+                // Skip the new exception handling managed code, the debugger clients are not supposed to see them
+                MethodDesc *pMD = pIter->m_crawl.GetFunction();
+                PTR_MethodDesc ptrMD = dac_cast<PTR_MethodDesc>(pMD);
+
+                // EH.DispatchEx, EH.RhThrowEx, EH.RhThrowHwEx
+                if (ptrMD->GetMethodTable() == g_pEHClass)
+                {
+                    continue;
+                }
+
+                fIsAtEndOfStack = FALSE;
+            }
+#endif // FEATURE_EH_FUNCLETS
             else
             {
                 fIsAtEndOfStack = FALSE;
@@ -433,6 +449,20 @@ ULONG32 DacDbiInterfaceImpl::GetCountOfInternalFrames(VMPTR_Thread vmThread)
     ULONG32 uCount = 0;
     while (pFrame != FRAME_TOP)
     {
+#ifdef FEATURE_EH_FUNCLETS
+        if (g_isNewExceptionHandlingEnabled && InlinedCallFrame::FrameHasActiveCall(pFrame))
+        {
+            // Skip new exception handling helpers
+            InlinedCallFrame *pInlinedCallFrame = (InlinedCallFrame *)pFrame;
+            PTR_NDirectMethodDesc pMD = pInlinedCallFrame->m_Datum;
+            TADDR datum = dac_cast<TADDR>(pMD);
+            if ((datum & (TADDR)InlinedCallFrameMarker::Mask) == (TADDR)InlinedCallFrameMarker::ExceptionHandlingHelper)
+            {
+                pFrame = pFrame->Next();
+                continue;
+            }
+        }
+#endif // FEATURE_EH_FUNCLETS
         CorDebugInternalFrameType ift = GetInternalFrameType(pFrame);
         if (ift != STUBFRAME_NONE)
         {
@@ -472,6 +502,20 @@ void DacDbiInterfaceImpl::EnumerateInternalFrames(VMPTR_Thread
 
     while (pFrame != FRAME_TOP)
     {
+#ifdef FEATURE_EH_FUNCLETS
+        if (g_isNewExceptionHandlingEnabled && InlinedCallFrame::FrameHasActiveCall(pFrame))
+        {
+            // Skip new exception handling helpers
+            InlinedCallFrame *pInlinedCallFrame = (InlinedCallFrame *)pFrame;
+            PTR_NDirectMethodDesc pMD = pInlinedCallFrame->m_Datum;
+            TADDR datum = dac_cast<TADDR>(pMD);
+            if ((datum & (TADDR)InlinedCallFrameMarker::Mask) == (TADDR)InlinedCallFrameMarker::ExceptionHandlingHelper)
+            {
+                pFrame = pFrame->Next();
+                continue;
+            }
+        }
+#endif // FEATURE_EH_FUNCLETS
         // check if the internal frame is interesting
         frameData.stubFrame.frameType = GetInternalFrameType(pFrame);
         if (frameData.stubFrame.frameType != STUBFRAME_NONE)

src/coreclr/inc/clrconfigvalues.h

@@ -259,6 +259,8 @@ RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_legacyCorruptedStateExceptionsPolicy, W("le
 CONFIG_DWORD_INFO(INTERNAL_SuppressLostExceptionTypeAssert, W("SuppressLostExceptionTypeAssert"), 0, "")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_UseEntryPointFilter, W("UseEntryPointFilter"), 0, "")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_Corhost_Swallow_Uncaught_Exceptions, W("Corhost_Swallow_Uncaught_Exceptions"), 0, "")
+RETAIL_CONFIG_DWORD_INFO(EXTERNAL_EnableNewExceptionHandling, W("EnableNewExceptionHandling"), 1, "Enable new exception handling.");
+
 
 ///
 /// Garbage collector

src/coreclr/inc/dacvars.h

@@ -113,6 +113,11 @@ DEFINE_DACVAR(DWORD, dac__g_debuggerWordTLSIndex, g_debuggerWordTLSIndex)
 #endif
 DEFINE_DACVAR(DWORD, dac__g_TlsIndex, g_TlsIndex)
 
+#ifdef FEATURE_EH_FUNCLETS
+DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pEHClass, ::g_pEHClass)
+DEFINE_DACVAR(BOOL, dac__g_isNewExceptionHandlingEnabled, ::g_isNewExceptionHandlingEnabled)
+#endif
+
 DEFINE_DACVAR(PTR_SString, SString__s_Empty, SString::s_Empty)
 
 DEFINE_DACVAR(INT32, ArrayBase__s_arrayBoundsZero, ArrayBase::s_arrayBoundsZero)