[cDAC] Set first-arg register to InterpreterFrame in per-arch InlinedCallFrame handlers

Mirror the per-architecture native InlinedCallFrame::UpdateRegDisplay_Impl
logic in the corresponding cDAC frame handlers:

- AMD64FrameHandler.HandleInlinedCallFrame: sets Rcx (Windows) or Rdi
  (Unix SysV) to the InterpreterFrame address when the next Frame is an
  InterpreterFrame, matching src/coreclr/vm/amd64/cgenamd64.cpp:212-218.
- ARM64FrameHandler.HandleInlinedCallFrame: sets X0 to the InterpreterFrame
  address when the next Frame is an InterpreterFrame, matching
  src/coreclr/vm/arm64/stubs.cpp:408-414.

ARM, x86, LoongArch64, and RISCV64 native InlinedCallFrame::UpdateRegDisplay_Impl
do NOT perform this update, so the corresponding cDAC handlers (or BaseFrameHandler
inheritance) do not either.

Two protected helpers are added to BaseFrameHandler so each handler can
inspect the chain itself without changing the IPlatformFrameHandler
interface:

- GetNextFrame(currentFrameAddress): returns the next Data.Frame in the
  chain or null if the chain ends (handles the FRAME_TOP all-ones
  terminator).
- IsInterpreterFrame(frame): compares the frame.Identifier against the
  runtime's InterpreterFrameIdentifier global.

Without this update, cDAC reports the thread's literal saved Rcx for frames
between an InlinedCallFrame and its successor InterpreterFrame, while the
legacy DAC reports the InterpreterFrame address. This trips
Debug.Assert(contextStruct.Equals(localContextStruct)) in
ClrDataStackWalk.GetContext during !ClrStack on a thread captured during a
P/Invoke from interpreted code.

Verified locally against the SOS.InterpreterStackTest.Heap.dmp captured in
CI: !ClrStack and !PrintException both succeed with the cDAC parity check
enabled, walking through [InlinedCallFrame], JIT IL stub frames,
[InterpreterFrame: ...], and the interpreted method frames in correct
order. All 2081 cDAC unit tests continue to pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Max Charlamb

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/AMD64FrameHandler.cs

@@ -40,4 +40,26 @@ public override void HandleFaultingExceptionFrame(FaultingExceptionFrame frame)
         // that does not support holding any extended state.
         _holder.Context.ContextFlags &= ~(uint)(ContextFlagsValues.CONTEXT_XSTATE & ContextFlagsValues.CONTEXT_AREA_MASK);
     }
+
+    public override void HandleInlinedCallFrame(InlinedCallFrame inlinedCallFrame)
+    {
+        base.HandleInlinedCallFrame(inlinedCallFrame);
+
+        // Mirror native InlinedCallFrame::UpdateRegDisplay_Impl in
+        // src/coreclr/vm/amd64/cgenamd64.cpp:212-218: when the next Frame is
+        // an InterpreterFrame, the first-argument register (Rcx on Win64,
+        // Rdi on SysV/Unix AMD64) holds a pointer to that InterpreterFrame.
+        Data.Frame? next = GetNextFrame(inlinedCallFrame.Address);
+        if (next is not null && IsInterpreterFrame(next))
+        {
+            if (_target.Contracts.RuntimeInfo.GetTargetOperatingSystem() == RuntimeInfoOperatingSystem.Windows)
+            {
+                _holder.Context.Rcx = next.Address.Value;
+            }
+            else
+            {
+                _holder.Context.Rdi = next.Address.Value;
+            }
+        }
+    }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/ARM64FrameHandler.cs

@@ -37,4 +37,19 @@ public override void HandleFaultingExceptionFrame(FaultingExceptionFrame frame)
         // that does not support holding any extended state.
         _holder.Context.ContextFlags &= ~(uint)(ContextFlagsValues.CONTEXT_XSTATE & ContextFlagsValues.CONTEXT_AREA_MASK);
     }
+
+    public override void HandleInlinedCallFrame(InlinedCallFrame inlinedCallFrame)
+    {
+        base.HandleInlinedCallFrame(inlinedCallFrame);
+
+        // Mirror native InlinedCallFrame::UpdateRegDisplay_Impl in
+        // src/coreclr/vm/arm64/stubs.cpp:408-414: when the next Frame is an
+        // InterpreterFrame, the first-argument register (X0) holds a pointer
+        // to that InterpreterFrame.
+        Data.Frame? next = GetNextFrame(inlinedCallFrame.Address);
+        if (next is not null && IsInterpreterFrame(next))
+        {
+            _holder.Context.X0 = next.Address.Value;
+        }
+    }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/FrameHandling/BaseFrameHandler.cs

@@ -107,4 +107,34 @@ protected void UpdateCalleeSavedRegistersFromOtherContext(IPlatformAgnosticConte
             }
         }
     }
+
+    /// <summary>
+    /// Returns the next <see cref="Data.Frame"/> in the Frame chain after
+    /// the frame at <paramref name="currentFrameAddress"/>, or <c>null</c>
+    /// when the chain ends (the runtime stores <c>FRAME_TOP</c>, an all-ones
+    /// pointer, as the terminator).
+    /// </summary>
+    protected Data.Frame? GetNextFrame(TargetPointer currentFrameAddress)
+    {
+        Data.Frame current = _target.ProcessedData.GetOrAdd<Data.Frame>(currentFrameAddress);
+        if (current.Next == TargetPointer.Null)
+            return null;
+        ulong terminator = _target.PointerSize == 8 ? ulong.MaxValue : uint.MaxValue;
+        if (current.Next.Value == terminator)
+            return null;
+        return _target.ProcessedData.GetOrAdd<Data.Frame>(current.Next);
+    }
+
+    /// <summary>
+    /// Returns true when <paramref name="frame"/>'s identifier matches the
+    /// runtime's <c>InterpreterFrameIdentifier</c> global.
+    /// </summary>
+    protected bool IsInterpreterFrame(Data.Frame frame)
+    {
+        if (_target.TryReadGlobalPointer(nameof(StackWalkHelpers.FrameType.InterpreterFrame) + "Identifier", out TargetPointer? id))
+        {
+            return frame.Identifier == id;
+        }
+        return false;
+    }
 }