[cDAC] Stack walk support more Frame types (#112997)

Adds cDAC support for runtime Frame types:
* `TransitionFrame` (and subclasses)
* `FuncEvalFrame`
* `ResumableFrame` (and subclasses)
* `FaultingExceptionFrame`
* `HijackFrame`

Author: max-charlamb

docs/design/datacontracts/StackWalk.md

@@ -41,11 +41,25 @@ This contract depends on the following descriptors:
 | `InlinedCallFrame` | `CalleeSavedFP` | FP saved in Frame |
 | `SoftwareExceptionFrame` | `TargetContext` | Context object saved in Frame |
 | `SoftwareExceptionFrame` | `ReturnAddress` | Return address saved in Frame |
+| `FramedMethodFrame` | `TransitionBlockPtr` | Pointer to Frame's TransitionBlock |
+| `TransitionBlock` | `ReturnAddress` | Return address associated with the TransitionBlock |
+| `TransitionBlock` | `CalleeSavedRegisters` | Platform specific CalleeSavedRegisters struct associated with the TransitionBlock |
+| `FuncEvalFrame` | `DebuggerEvalPtr` | Pointer to the Frame's DebuggerEval object |
+| `DebuggerEval` | `TargetContext` | Context saved inside DebuggerEval |
+| `DebuggerEval` | `EvalDuringException` | Flag used in processing FuncEvalFrame |
+| `ResumableFrame` | `TargetContextPtr` | Pointer to the Frame's Target Context |
+| `FaultingExceptionFrame` | `TargetContext` | Frame's Target Context |
+| `HijackFrame` | `ReturnAddress` | Frame's stored instruction pointer |
+| `HijackFrame` | `HijackArgsPtr` | Pointer to the Frame's stored HijackArgs |
+| `HijackArgs` (amd64) | `CalleeSavedRegisters` | CalleeSavedRegisters data structure |
+| `HijackArgs` (amd64 Windows) | `Rsp` | Saved stack pointer |
+| `HijackArgs` (arm64) | For each register `r` saved in HijackArgs, `r` | Register names associated with stored register values |
+| `CalleeSavedRegisters` | For each callee saved register `r`, `r` | Register names associated with stored register values |
 
 Global variables used:
 | Global Name | Type | Purpose |
 | --- | --- | --- |
-| For each FrameType `<frameType>`, `<frameType>##Identifier` | FrameIdentifier enum value | Identifier used to determine concrete type of Frames |
+| For each FrameType `<frameType>`, `<frameType>##Identifier` | `FrameIdentifier` enum value | Identifier used to determine concrete type of Frames |
 
 Contracts used:
 | Contract Name |
@@ -215,6 +229,71 @@ private static void bar()
 }
 ```
 
+### Capital 'F' Frame Handling
+
+Capital 'F' Frame's store context data in a number of different ways. Of the couple dozen Frame types defined in `src/coreclr/vm/frames.h` several do not store any context data or update the context, signified by `NeedsUpdateRegDisplay_Impl() == false`. Of that Frames that do update the context, several share implementations of `UpdateRegDisplay_Impl` through inheritance. This leaves us with 9 distinct mechanisms to update the context that will be detailed below. Each mechanism is referred to using the Frame class that implements the mechanism and may be used by subclasses.
+
+Most of the handlers are implemented in `BaseFrameHandler`. Platform specific components are implemented/overridden in `<arch>FrameHandler`.
+
+#### InlinedCallFrame
+
+InlinedCallFrames store and update only the IP, SP, and FP of a given context. If the stored IP (CallerReturnAddress) is 0 then the InlinedCallFrame does not have an active call and should not update the context.
+
+#### SoftwareExceptionFrame
+
+SoftwareExceptionFrames store a copy of the context struct. The IP, SP, and all ABI specified (platform specific) callee-saved registers are copied from the stored context to the working context.
+
+#### TransitionFrame
+
+TransitionFrames hold a pointer to a `TransitionBlock`. The TransitionBlock holds a return address along with a `CalleeSavedRegisters` struct which has values for all ABI specified callee-saved registers. The SP can be found using the address of the TransitionBlock. Since the TransitionBlock will be the lowest element on the stack, the SP is the address of the TransitionBlock + sizeof(TransitionBlock).
+
+When updating the context from a TransitionFrame, the IP, SP, and all ABI specified callee-saved registers are copied over.
+
+The following Frame types also use this mechanism:
+* FramedMethodFrame
+* CLRToCOMMethodFrame
+* PInvokeCallIFrame
+* PrestubMethodFrame
+* StubDispatchFrame
+* CallCountingHelperFrame
+* ExternalMethodFrame
+* DynamicHelperFrame
+
+#### FuncEvalFrame
+
+FuncEvalFrames hold a pointer to a `DebuggerEval`. The DebuggerEval holds a full context which is completely copied over to the working context when updating.
+
+#### ResumableFrame
+
+ResumableFrames hold a pointer to a context object (Note this is different from SoftwareExceptionFrames which hold the context directly). The entire context object is copied over to the working context when updating.
+
+RedirectedThreadFrames also use this mechanism.
+
+#### FaultingExceptionFrame
+
+FaultingExceptionFrames have two different implementations. One for Windows x86 and another for all other builds (with funclets).
+
+Given the cDAC does not yet support Windows x86, this version is not supported.
+
+The other version stores a context struct. To update the working context, the entire stored context is copied over. In addition the `ContextFlags` are updated to ensure the `CONTEXT_XSTATE` bit is not set given the debug version of the contexts can not store extended state. This bit is architecture specific.
+
+#### HijackFrame
+
+HijackFrames carry a IP (ReturnAddress) and a pointer to `HijackArgs`. All platforms update the IP and use the platform specific HijackArgs to update further registers. The following details currently implemented platforms.
+
+* x64 - On x64, HijackArgs contains a CalleeSavedRegister struct. The saved registers values contained in the struct are copied over to the working context.
+    * Windows - On Windows, HijackArgs also contains the SP value directly which is copied over to the working context.
+    * Non-Windows - On OS's other than Windows, HijackArgs does not contain an SP value. Instead since the HijackArgs struct lives on the stack, the SP is `&hijackArgs + sizeof(HijackArgs)`. This value is also copied over.
+* arm64 - Unlike on x64, on arm64 HijackArgs contains a list of register values instead of the CalleeSavedRegister struct. These values are copied over to the working context. The SP is fetched using the same technique as on x64 non-Windows where `SP = &hijackArgs + sizeof(HijackArgs)` and is copied over to the working context.
+
+#### TailCallFrame
+
+TailCallFrames are only used on Windows x86 which is not yet supported in the cDAC and therefore not implemented.
+
+#### HelperMethodFrame
+
+HelperMethodFrames are on the way to being removed. They are not currently supported in the cDAC.
+
 ### APIs
 
 The majority of the contract's complexity is the stack walking algorithm (detailed above) implemented as part of `CreateStackWalk`.

src/coreclr/debug/runtimeinfo/datadescriptor.cpp

@@ -13,6 +13,8 @@
 #include "methodtable.h"
 #include "threads.h"
 
+#include "../debug/ee/debugger.h"
+
 #ifdef HAVE_GCCOVER
 #include "gccover.h"
 #endif // HAVE_GCCOVER

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -652,6 +652,108 @@ CDAC_TYPE_FIELD(SoftwareExceptionFrame, /*pointer*/, ReturnAddress, cdac_data<So
 CDAC_TYPE_END(SoftwareExceptionFrame)
 #endif // FEATURE_EH_FUNCLETS
 
+CDAC_TYPE_BEGIN(FramedMethodFrame)
+CDAC_TYPE_SIZE(sizeof(FramedMethodFrame))
+CDAC_TYPE_FIELD(FramedMethodFrame, /*pointer*/, TransitionBlockPtr, cdac_data<FramedMethodFrame>::TransitionBlockPtr)
+CDAC_TYPE_END(FramedMethodFrame)
+
+CDAC_TYPE_BEGIN(TransitionBlock)
+CDAC_TYPE_SIZE(sizeof(TransitionBlock))
+CDAC_TYPE_FIELD(TransitionBlock, /*pointer*/, ReturnAddress, offsetof(TransitionBlock, m_ReturnAddress))
+CDAC_TYPE_FIELD(TransitionBlock, /*CalleeSavedRegisters*/, CalleeSavedRegisters, offsetof(TransitionBlock, m_calleeSavedRegisters))
+CDAC_TYPE_END(TransitionBlock)
+
+#ifdef DEBUGGING_SUPPORTED
+CDAC_TYPE_BEGIN(FuncEvalFrame)
+CDAC_TYPE_SIZE(sizeof(FuncEvalFrame))
+CDAC_TYPE_FIELD(FuncEvalFrame, /*pointer*/, DebuggerEvalPtr, cdac_data<FuncEvalFrame>::DebuggerEvalPtr)
+CDAC_TYPE_END(FuncEvalFrame)
+
+CDAC_TYPE_BEGIN(DebuggerEval)
+CDAC_TYPE_SIZE(sizeof(DebuggerEval))
+CDAC_TYPE_FIELD(DebuggerEval, /*T_CONTEXT*/, TargetContext, offsetof(DebuggerEval, m_context))
+CDAC_TYPE_FIELD(DebuggerEval, /*bool*/, EvalDuringException, offsetof(DebuggerEval, m_evalDuringException))
+CDAC_TYPE_END(DebuggerEval)
+#endif // DEBUGGING_SUPPORTED
+
+#ifdef FEATURE_HIJACK
+CDAC_TYPE_BEGIN(ResumableFrame)
+CDAC_TYPE_SIZE(sizeof(ResumableFrame))
+CDAC_TYPE_FIELD(ResumableFrame, /*pointer*/, TargetContextPtr, cdac_data<ResumableFrame>::TargetContextPtr)
+CDAC_TYPE_END(ResumableFrame)
+
+CDAC_TYPE_BEGIN(HijackFrame)
+CDAC_TYPE_SIZE(sizeof(HijackFrame))
+CDAC_TYPE_FIELD(HijackFrame, /*pointer*/, ReturnAddress, cdac_data<HijackFrame>::ReturnAddress)
+CDAC_TYPE_FIELD(HijackFrame, /*pointer*/, HijackArgsPtr, cdac_data<HijackFrame>::HijackArgsPtr)
+CDAC_TYPE_END(HijackFrame)
+
+// HijackArgs struct is different on each platform
+CDAC_TYPE_BEGIN(HijackArgs)
+CDAC_TYPE_SIZE(sizeof(HijackArgs))
+#if defined(TARGET_AMD64)
+
+CDAC_TYPE_FIELD(HijackArgs, /*CalleeSavedRegisters*/, CalleeSavedRegisters, offsetof(HijackArgs, Regs))
+#ifdef TARGET_WINDOWS
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Rsp, offsetof(HijackArgs, Rsp))
+#endif // TARGET_WINDOWS
+
+#elif defined(TARGET_ARM64)
+
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X0, offsetof(HijackArgs, X0))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X1, offsetof(HijackArgs, X1))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X19, offsetof(HijackArgs, X19))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X20, offsetof(HijackArgs, X20))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X21, offsetof(HijackArgs, X21))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X22, offsetof(HijackArgs, X22))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X23, offsetof(HijackArgs, X23))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X24, offsetof(HijackArgs, X24))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X25, offsetof(HijackArgs, X25))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X26, offsetof(HijackArgs, X26))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X27, offsetof(HijackArgs, X27))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, X28, offsetof(HijackArgs, X28))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Fp, offsetof(HijackArgs, X29))
+CDAC_TYPE_FIELD(HijackArgs, /*pointer*/, Lr, offsetof(HijackArgs, Lr))
+
+#endif // Platform switch
+CDAC_TYPE_END(HijackArgs)
+#endif // FEATURE_HIJACK
+
+CDAC_TYPE_BEGIN(FaultingExceptionFrame)
+CDAC_TYPE_SIZE(sizeof(FaultingExceptionFrame))
+#ifdef FEATURE_EH_FUNCLETS
+CDAC_TYPE_FIELD(FaultingExceptionFrame, /*T_CONTEXT*/, TargetContext, cdac_data<FaultingExceptionFrame>::TargetContext)
+#endif // FEATURE_EH_FUNCLETS
+CDAC_TYPE_END(FaultingExceptionFrame)
+
+// CalleeSavedRegisters struct is different on each platform
+CDAC_TYPE_BEGIN(CalleeSavedRegisters)
+CDAC_TYPE_SIZE(sizeof(CalleeSavedRegisters))
+#if defined(TARGET_AMD64)
+
+#define CALLEE_SAVED_REGISTER(regname) \
+    CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, regname, offsetof(CalleeSavedRegisters, regname))
+ENUM_CALLEE_SAVED_REGISTERS()
+#undef CALLEE_SAVED_REGISTER
+
+#elif defined(TARGET_ARM64)
+
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X19, offsetof(CalleeSavedRegisters, x19))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X20, offsetof(CalleeSavedRegisters, x20))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X21, offsetof(CalleeSavedRegisters, x21))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X22, offsetof(CalleeSavedRegisters, x22))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X23, offsetof(CalleeSavedRegisters, x23))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X24, offsetof(CalleeSavedRegisters, x24))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X25, offsetof(CalleeSavedRegisters, x25))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X26, offsetof(CalleeSavedRegisters, x26))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X27, offsetof(CalleeSavedRegisters, x27))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, X28, offsetof(CalleeSavedRegisters, x28))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Fp, offsetof(CalleeSavedRegisters, x29))
+CDAC_TYPE_FIELD(CalleeSavedRegisters, /*nuint*/, Lr, offsetof(CalleeSavedRegisters, x30))
+
+#endif // Platform switch
+CDAC_TYPE_END(CalleeSavedRegisters)
+
 CDAC_TYPES_END()
 
 CDAC_GLOBALS_BEGIN()

src/coreclr/vm/frames.h

@@ -745,6 +745,14 @@ class ResumableFrame : public Frame
 
 protected:
     PTR_CONTEXT m_Regs;
+
+    friend struct cdac_data<ResumableFrame>;
+};
+
+template<>
+struct cdac_data<ResumableFrame>
+{
+    static constexpr size_t TargetContextPtr = offsetof(ResumableFrame, m_Regs);
 };
 
 
@@ -1014,6 +1022,16 @@ class FaultingExceptionFrame : public Frame
     }
 
     void UpdateRegDisplay_Impl(const PREGDISPLAY, bool updateFloats = false);
+
+    friend struct ::cdac_data<FaultingExceptionFrame>;
+};
+
+template<>
+struct cdac_data<FaultingExceptionFrame>
+{
+#ifdef FEATURE_EH_FUNCLETS
+    static constexpr size_t TargetContext = offsetof(FaultingExceptionFrame, m_ctx);
+#endif // FEATURE_EH_FUNCLETS
 };
 
 #ifdef FEATURE_EH_FUNCLETS
@@ -1155,6 +1173,14 @@ class FuncEvalFrame : public Frame
 
         return m_showFrame;
     }
+
+    friend struct cdac_data<FuncEvalFrame>;
+};
+
+template<>
+struct cdac_data<FuncEvalFrame>
+{
+    static constexpr size_t DebuggerEvalPtr = offsetof(FuncEvalFrame, m_pDebuggerEval);
 };
 
 typedef DPTR(FuncEvalFrame) PTR_FuncEvalFrame;
@@ -1672,8 +1698,15 @@ class FramedMethodFrame : public TransitionFrame
 #endif
         return dac_cast<PTR_VOID>(p);
     }
+
+    friend struct cdac_data<FramedMethodFrame>;
 };
 
+template<>
+struct cdac_data<FramedMethodFrame>
+{
+    static constexpr size_t TransitionBlockPtr = offsetof(FramedMethodFrame, m_pTransitionBlock);
+};
 
 #ifdef FEATURE_COMINTEROP
 
@@ -1966,6 +1999,15 @@ class HijackFrame : public Frame
     TADDR               m_ReturnAddress;
     PTR_Thread          m_Thread;
     DPTR(HijackArgs)    m_Args;
+
+    friend struct ::cdac_data<HijackFrame>;
+};
+
+template<>
+struct cdac_data<HijackFrame>
+{
+    static constexpr size_t ReturnAddress = offsetof(HijackFrame, m_ReturnAddress);
+    static constexpr size_t HijackArgsPtr = offsetof(HijackFrame, m_Args);
 };
 
 #endif // FEATURE_HIJACK

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/DataType.cs

@@ -90,8 +90,17 @@ public enum DataType
     MethodImpl,
     NativeCodeSlot,
     GCCoverageInfo,
+    TransitionBlock,
+    DebuggerEval,
+    CalleeSavedRegisters,
+    HijackArgs,
 
     Frame,
     InlinedCallFrame,
     SoftwareExceptionFrame,
+    FramedMethodFrame,
+    FuncEvalFrame,
+    ResumableFrame,
+    FaultingExceptionFrame,
+    HijackFrame,
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/Context/AMD64Context.cs

@@ -25,6 +25,8 @@ public enum ContextFlagsValues : uint
         CONTEXT_ALL = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS,
         CONTEXT_XSTATE = CONTEXT_AMD | 0x40,
         CONTEXT_KERNEL_CET = CONTEXT_AMD | 0x80,
+
+        CONTEXT_AREA_MASK = 0xFFFF,
     }
 
     public readonly uint Size => 0x4d0;

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/Context/ARM64Context.cs

@@ -21,8 +21,11 @@ public enum ContextFlagsValues : uint
         CONTEXT_FLOATING_POINT = CONTEXT_ARM64 | 0x4,
         CONTEXT_DEBUG_REGISTERS = CONTEXT_ARM64 | 0x8,
         CONTEXT_X18 = CONTEXT_ARM64 | 0x10,
+        CONTEXT_XSTATE = CONTEXT_ARM64 | 0x20,
         CONTEXT_FULL = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT,
         CONTEXT_ALL = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_X18,
+
+        CONTEXT_AREA_MASK = 0xFFFF,
     }
 
     public readonly uint Size => 0x390;