[cDAC] Remove references to FEATURE_EH_FUNCLETS (#116743)

max-charlamb · web-flow · commit 0bd4424eef37 · 2025-06-19T19:41:22.000-07:00
* remove references to feature eh funclets in cDAC managed code
* remove FeatureEHFunclets data descriptor
diff --git a/src/coreclr/debug/runtimeinfo/datadescriptor.h b/src/coreclr/debug/runtimeinfo/datadescriptor.h
@@ -870,11 +870,6 @@ CDAC_GLOBAL_POINTER(GCThread, &::g_pSuspensionThread)
 #undef FRAME_TYPE_NAME
 
 CDAC_GLOBAL(MethodDescTokenRemainderBitCount, uint8, METHOD_TOKEN_REMAINDER_BIT_COUNT)
-#if FEATURE_EH_FUNCLETS
-CDAC_GLOBAL(FeatureEHFunclets, uint8, 1)
-#else
-CDAC_GLOBAL(FeatureEHFunclets, uint8, 0)
-#endif
 #if FEATURE_COMINTEROP
 CDAC_GLOBAL(FeatureCOMInterop, uint8, 1)
 #else
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Constants.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Constants.cs
@@ -15,7 +15,6 @@ public static class Globals
         public const string GCThread = nameof(GCThread);
 
         public const string FeatureCOMInterop = nameof(FeatureCOMInterop);
-        public const string FeatureEHFunclets = nameof(FeatureEHFunclets);
 
         public const string ObjectToMethodTableUnmask = nameof(ObjectToMethodTableUnmask);
         public const string SOSBreakingChangeVersion = nameof(SOSBreakingChangeVersion);
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/ExecutionManager/ExecutionManagerCore.EEJitManager.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/ExecutionManager/ExecutionManagerCore.EEJitManager.cs
@@ -46,7 +46,6 @@ public override bool GetMethodInfo(RangeSection rangeSection, TargetCodePointer
 
         public override TargetPointer GetUnwindInfo(RangeSection rangeSection, TargetCodePointer jittedCodeAddress)
         {
-            // TODO: This only works with funclets enabled. See runtime definition of RealCodeHeader for more info.
             if (rangeSection.IsRangeList)
                 return TargetPointer.Null;
             if (rangeSection.Data == null)
@@ -60,16 +59,7 @@ public override TargetPointer GetUnwindInfo(RangeSection rangeSection, TargetCod
             if (!GetRealCodeHeader(rangeSection, codeStart, out Data.RealCodeHeader? realCodeHeader))
                 return TargetPointer.Null;
 
-            if (realCodeHeader.NumUnwindInfos is not uint numUnwindInfos)
-            {
-                throw new InvalidOperationException("Unable to get NumUnwindInfos");
-            }
-            if (realCodeHeader.UnwindInfos is not TargetPointer unwindInfos)
-            {
-                throw new InvalidOperationException("Unable to get NumUnwindInfos");
-            }
-
-            if (numUnwindInfos == 0)
+            if (realCodeHeader.NumUnwindInfos == 0)
             {
                 return TargetPointer.Null;
             }
@@ -79,10 +69,10 @@ public override TargetPointer GetUnwindInfo(RangeSection rangeSection, TargetCod
             TargetPointer imageBase = rangeSection.Data.RangeBegin;
             TargetPointer relativeAddr = addr - imageBase;
 
-            if (!_runtimeFunctions.TryGetRuntimeFunctionIndexForAddress(unwindInfos, numUnwindInfos, relativeAddr, out uint index))
+            if (!_runtimeFunctions.TryGetRuntimeFunctionIndexForAddress(realCodeHeader.UnwindInfos, realCodeHeader.NumUnwindInfos, relativeAddr, out uint index))
                 return TargetPointer.Null;
 
-            return _runtimeFunctions.GetRuntimeFunctionAddress(unwindInfos, index);
+            return _runtimeFunctions.GetRuntimeFunctionAddress(realCodeHeader.UnwindInfos, index);
         }
 
         public override void GetGCInfo(RangeSection rangeSection, TargetCodePointer jittedCodeAddress, out TargetPointer gcInfo, out uint gcVersion)
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/AMD64FrameHandler.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/AMD64FrameHandler.cs
@@ -13,11 +13,7 @@ internal class AMD64FrameHandler(Target target, ContextHolder<AMD64Context> cont
 
     void IPlatformFrameHandler.HandleFaultingExceptionFrame(FaultingExceptionFrame frame)
     {
-        if (frame.TargetContext is not TargetPointer targetContext)
-        {
-            throw new InvalidOperationException("Unexpected null context pointer on FaultingExceptionFrame");
-        }
-        _holder.ReadFromAddress(_target, targetContext);
+        _holder.ReadFromAddress(_target, frame.TargetContext);
 
         // Clear the CONTEXT_XSTATE, since the AMD64Context contains just plain CONTEXT structure
         // that does not support holding any extended state.
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/ARM64FrameHandler.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/ARM64FrameHandler.cs
@@ -15,11 +15,7 @@ internal class ARM64FrameHandler(Target target, ContextHolder<ARM64Context> cont
 
     void IPlatformFrameHandler.HandleFaultingExceptionFrame(FaultingExceptionFrame frame)
     {
-        if (frame.TargetContext is not TargetPointer targetContext)
-        {
-            throw new InvalidOperationException("Unexpected null context pointer on FaultingExceptionFrame");
-        }
-        _holder.ReadFromAddress(_target, targetContext);
+        _holder.ReadFromAddress(_target, frame.TargetContext);
 
         // Clear the CONTEXT_XSTATE, since the ARM64Context contains just plain CONTEXT structure
         // that does not support holding any extended state.
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/X86FrameHandler.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/X86FrameHandler.cs
@@ -14,11 +14,7 @@ internal class X86FrameHandler(Target target, ContextHolder<X86Context> contextH
 
     public void HandleFaultingExceptionFrame(FaultingExceptionFrame frame)
     {
-        if (frame.TargetContext is not TargetPointer targetContext)
-        {
-            throw new InvalidOperationException("Unexpected null context pointer on FaultingExceptionFrame");
-        }
-        _context.ReadFromAddress(_target, targetContext);
+        _context.ReadFromAddress(_target, frame.TargetContext);
 
         // Clear the CONTEXT_XSTATE, since the X86Context contains just plain CONTEXT structure
         // that does not support holding any extended state.
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Thread_1.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Thread_1.cs
@@ -46,10 +46,7 @@ ThreadData IThread.GetThreadData(TargetPointer threadPointer)
     {
         Data.Thread thread = _target.ProcessedData.GetOrAdd<Data.Thread>(threadPointer);
 
-        // Exception tracker is a pointer when EH funclets are enabled
-        TargetPointer address = _target.ReadGlobal<byte>(Constants.Globals.FeatureEHFunclets) != 0
-            ? _target.ReadPointer(thread.ExceptionTracker)
-            : thread.ExceptionTracker;
+        TargetPointer address = _target.ReadPointer(thread.ExceptionTracker);
         TargetPointer firstNestedException = TargetPointer.Null;
         if (address != TargetPointer.Null)
         {
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FaultingExceptionFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/FaultingExceptionFrame.cs
@@ -11,15 +11,10 @@ static FaultingExceptionFrame IData<FaultingExceptionFrame>.Create(Target target
     public FaultingExceptionFrame(Target target, TargetPointer address)
     {
         Target.TypeInfo type = target.GetTypeInfo(DataType.FaultingExceptionFrame);
-
-        // TargetContextPtr only exists when FEATURE_EH_FUNCLETS is defined
-        if (type.Fields.ContainsKey(nameof(TargetContext)))
-        {
-            TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;
-        }
+        TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;
         Address = address;
     }
 
     public TargetPointer Address { get; }
-    public TargetPointer? TargetContext { get; }
+    public TargetPointer TargetContext { get; }
 }
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Frames/SoftwareExceptionFrame.cs
@@ -10,8 +10,6 @@ static SoftwareExceptionFrame IData<SoftwareExceptionFrame>.Create(Target target
 
     public SoftwareExceptionFrame(Target target, TargetPointer address)
     {
-        // TypeInfo will only exist if FEATURE_EH_FUNCLETS is enabled.
-        // If it doesn't exist, then this type of frame is not present in target.
         Target.TypeInfo type = target.GetTypeInfo(DataType.SoftwareExceptionFrame);
         Address = address;
         TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/RealCodeHeader.cs
@@ -13,18 +13,12 @@ public RealCodeHeader(Target target, TargetPointer address)
         Target.TypeInfo type = target.GetTypeInfo(DataType.RealCodeHeader);
         MethodDesc = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodDesc)].Offset);
         GCInfo = target.ReadPointer(address + (ulong)type.Fields[nameof(GCInfo)].Offset);
-
-        // Only available if FEATURE_EH_FUNCLETS is enabled.
-        if (type.Fields.ContainsKey(nameof(NumUnwindInfos)))
-            NumUnwindInfos = target.Read<uint>(address + (ulong)type.Fields[nameof(NumUnwindInfos)].Offset);
-
-        // Only available if FEATURE_EH_FUNCLETS is enabled.
-        if (type.Fields.ContainsKey(nameof(UnwindInfos)))
-            UnwindInfos = address + (ulong)type.Fields[nameof(UnwindInfos)].Offset;
+        NumUnwindInfos = target.Read<uint>(address + (ulong)type.Fields[nameof(NumUnwindInfos)].Offset);
+        UnwindInfos = address + (ulong)type.Fields[nameof(UnwindInfos)].Offset;
     }
 
     public TargetPointer MethodDesc { get; init; }
     public TargetPointer GCInfo { get; init; }
-    public uint? NumUnwindInfos { get; init; }
-    public TargetPointer? UnwindInfos { get; init; }
+    public uint NumUnwindInfos { get; init; }
+    public TargetPointer UnwindInfos { get; init; }
 }
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs
@@ -31,7 +31,7 @@ public Thread(Target target, TargetPointer address)
             target.ReadPointer(address + (ulong)type.Fields[nameof(LastThrownObject)].Offset));
         LinkNext = target.ReadPointer(address + (ulong)type.Fields[nameof(LinkNext)].Offset);
 
-        // Address of the exception tracker - how it should be read depends on EH funclets feature global value
+        // Address of the exception tracker
         ExceptionTracker = address + (ulong)type.Fields[nameof(ExceptionTracker)].Offset;
     }
 
diff --git a/src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.ExecutionManager.cs b/src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.ExecutionManager.cs
@@ -17,7 +17,7 @@ internal class ExecutionManager
     {
         public const ulong ExecutionManagerCodeRangeMapAddress = 0x000a_fff0;
 
-        const int RealCodeHeaderSize = 0x10; // must be big enough for the offsets of RealCodeHeader size in ExecutionManagerTestTarget, below
+        const int RealCodeHeaderSize = 0x20; // must be big enough for the offsets of RealCodeHeader size in ExecutionManagerTestTarget, below
 
         public struct AllocationRange
         {
@@ -233,6 +233,8 @@ public static RangeSectionMapTestBuilder CreateRangeSection(MockTarget.Architect
             [
                 new(nameof(Data.RealCodeHeader.MethodDesc), DataType.pointer),
                 new(nameof(Data.RealCodeHeader.GCInfo), DataType.pointer),
+                new(nameof(Data.RealCodeHeader.NumUnwindInfos), DataType.uint32),
+                new(nameof(Data.RealCodeHeader.UnwindInfos), DataType.pointer),
             ]
         };
 
@@ -292,13 +294,10 @@ internal ExecutionManager(int version, MockMemorySpace.Builder builder, Allocati
                 .Concat(_rfBuilder.Types)
                 .ToDictionary();
 
-            // Tests are currently always set to use funclets
-            bool useFunclets = true;
             Globals =
             [
                 (nameof(Constants.Globals.ExecutionManagerCodeRangeMapAddress), ExecutionManagerCodeRangeMapAddress),
                 (nameof(Constants.Globals.StubCodeBlockLast), 0x0Fu),
-                (nameof(Constants.Globals.FeatureEHFunclets), useFunclets ? 1u : 0u),
             ];
             Globals = Globals
                 .Concat(MockDescriptors.HashMap.GetGlobals(Builder.TargetTestHelpers))
@@ -430,6 +429,11 @@ public TargetCodePointer AddJittedMethod(JittedCodeRange jittedCodeRange, uint c
             var tyInfo = Types[DataType.RealCodeHeader];
             Builder.TargetTestHelpers.WritePointer(chf.Slice(tyInfo.Fields[nameof(Data.RealCodeHeader.MethodDesc)].Offset, Builder.TargetTestHelpers.PointerSize), methodDescAddress);
 
+            // fields are not used in the test, but we still need to write them
+            Builder.TargetTestHelpers.WritePointer(chf.Slice(tyInfo.Fields[nameof(Data.RealCodeHeader.GCInfo)].Offset, Builder.TargetTestHelpers.PointerSize), TargetPointer.Null);
+            Builder.TargetTestHelpers.Write(chf.Slice(tyInfo.Fields[nameof(Data.RealCodeHeader.NumUnwindInfos)].Offset, sizeof(uint)), 0u);
+            Builder.TargetTestHelpers.WritePointer(chf.Slice(tyInfo.Fields[nameof(Data.RealCodeHeader.UnwindInfos)].Offset, Builder.TargetTestHelpers.PointerSize), TargetPointer.Null);
+
             return codeStart;
         }
 
diff --git a/src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.Thread.cs b/src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.Thread.cs
@@ -10,7 +10,6 @@ internal partial class MockDescriptors
 {
     public class Thread
     {
-        const bool UseFunclets = false;
         private const ulong DefaultAllocationRangeStart = 0x0003_0000;
         private const ulong DefaultAllocationRangeEnd = 0x0004_0000;
 
@@ -68,7 +67,6 @@ public Thread(MockMemorySpace.Builder builder, (ulong Start, ulong End) allocati
                 (nameof(Constants.Globals.ThreadStore), threadStoreGlobal.Address),
                 (nameof(Constants.Globals.FinalizerThread), finalizerThreadGlobal.Address),
                 (nameof(Constants.Globals.GCThread), gcThreadGlobal.Address),
-                (nameof(Constants.Globals.FeatureEHFunclets), UseFunclets ? 1 : 0),
             ];
         }
 
@@ -108,28 +106,24 @@ internal void SetThreadCounts(int threadCount, int unstartedCount, int backgroun
         internal TargetPointer AddThread(uint id, TargetNUInt osId)
         {
             TargetTestHelpers helpers = Builder.TargetTestHelpers;
-            Target.TypeInfo typeInfo = Types[DataType.Thread];
-            if (UseFunclets)
-                throw new NotImplementedException("todo for funclets: allocate the ExceptionInfo separately");
-            ulong allocSize = typeInfo.Size.Value + (UseFunclets ? 0 : Types[DataType.ExceptionInfo].Size.Value);
-            MockMemorySpace.HeapFragment thread = _allocator.Allocate(allocSize, UseFunclets ? "Thread" : "Thread and ExceptionInfo");
+            Target.TypeInfo threadType = Types[DataType.Thread];
+            Target.TypeInfo exceptionInfoType = Types[DataType.ExceptionInfo];
+            MockMemorySpace.HeapFragment exceptionInfo = _allocator.Allocate(exceptionInfoType.Size.Value, "ExceptionInfo");
+            MockMemorySpace.HeapFragment thread = _allocator.Allocate(threadType.Size.Value, "Thread");
             Span<byte> data = thread.Data.AsSpan();
             helpers.Write(
-                data.Slice(typeInfo.Fields[nameof(Data.Thread.Id)].Offset),
+                data.Slice(threadType.Fields[nameof(Data.Thread.Id)].Offset),
                 id);
             helpers.WriteNUInt(
-                data.Slice(typeInfo.Fields[nameof(Data.Thread.OSId)].Offset),
+                data.Slice(threadType.Fields[nameof(Data.Thread.OSId)].Offset),
                 osId);
-            Builder.AddHeapFragment(thread);
-
-            // Add exception info for the thread
-            // TODO: [cdac] Handle when UseFunclets is true - see NotImplementedException thrown above
-            TargetPointer exceptionInfoAddress = thread.Address + Types[DataType.ExceptionInfo].Size.Value;
             helpers.WritePointer(
-                data.Slice(typeInfo.Fields[nameof(Data.Thread.ExceptionTracker)].Offset),
-                exceptionInfoAddress);
+                data.Slice(threadType.Fields[nameof(Data.Thread.ExceptionTracker)].Offset),
+                exceptionInfo.Address);
+            Builder.AddHeapFragment(thread);
+            Builder.AddHeapFragment(exceptionInfo);
 
-            ulong threadLinkOffset = (ulong)typeInfo.Fields[nameof(Data.Thread.LinkNext)].Offset;
+            ulong threadLinkOffset = (ulong)threadType.Fields[nameof(Data.Thread.LinkNext)].Offset;
             if (_previousThread != TargetPointer.Null)
             {
                 // Set the next link for the previously added thread to the newly added one

Original file line number	Diff line number	Diff line change
`@@ -46,10 +46,7 @@ ThreadData IThread.GetThreadData(TargetPointer threadPointer)`
`46`	`46`	`{`
`47`	`47`	`Data.Thread thread = _target.ProcessedData.GetOrAdd<Data.Thread>(threadPointer);`
`48`	`48`
`49`		`- // Exception tracker is a pointer when EH funclets are enabled`
`50`		`- TargetPointer address = _target.ReadGlobal<byte>(Constants.Globals.FeatureEHFunclets) != 0`
`51`		`- ? _target.ReadPointer(thread.ExceptionTracker)`
`52`		`- : thread.ExceptionTracker;`
	`49`	`+ TargetPointer address = _target.ReadPointer(thread.ExceptionTracker);`
`53`	`50`	`TargetPointer firstNestedException = TargetPointer.Null;`
`54`	`51`	`if (address != TargetPointer.Null)`
`55`	`52`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,10 @@ static FaultingExceptionFrame IData<FaultingExceptionFrame>.Create(Target target`
`11`	`11`	`public FaultingExceptionFrame(Target target, TargetPointer address)`
`12`	`12`	`{`
`13`	`13`	`Target.TypeInfo type = target.GetTypeInfo(DataType.FaultingExceptionFrame);`
`14`		`-`
`15`		`- // TargetContextPtr only exists when FEATURE_EH_FUNCLETS is defined`
`16`		`- if (type.Fields.ContainsKey(nameof(TargetContext)))`
`17`		`- {`
`18`		`- TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;`
`19`		`- }`
	`14`	`+ TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;`
`20`	`15`	`Address = address;`
`21`	`16`	`}`
`22`	`17`
`23`	`18`	`public TargetPointer Address { get; }`
`24`		`- public TargetPointer? TargetContext { get; }`
	`19`	`+ public TargetPointer TargetContext { get; }`
`25`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,6 @@ static SoftwareExceptionFrame IData<SoftwareExceptionFrame>.Create(Target target`
`10`	`10`
`11`	`11`	`public SoftwareExceptionFrame(Target target, TargetPointer address)`
`12`	`12`	`{`
`13`		`- // TypeInfo will only exist if FEATURE_EH_FUNCLETS is enabled.`
`14`		`- // If it doesn't exist, then this type of frame is not present in target.`
`15`	`13`	`Target.TypeInfo type = target.GetTypeInfo(DataType.SoftwareExceptionFrame);`
`16`	`14`	`Address = address;`
`17`	`15`	`TargetContext = address + (ulong)type.Fields[nameof(TargetContext)].Offset;`