[cDAC] Add simple Debugger DacDbi APIs (#127037)

Copilot · rcj1 · web-flow · commit 38af44d51890 · 2026-04-17T21:50:36.000-07:00
Add `RequestSyncAtEvent`, ` SetSendExceptionsOutsideOfJMC`,
`GetDebuggerControlBlockAddress`
and `EnableGCNotificationEvents` DacDbi cDAC APIs, as well as APIs on
Debugger contract of the same name, and unit tests.

---------

Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
Co-authored-by: rcj1 &lt;rachel.jarvi@gmail.com&gt;
Co-authored-by: rcj1 &lt;77995559+rcj1@users.noreply.github.com&gt;
diff --git a/docs/design/datacontracts/Debugger.md b/docs/design/datacontracts/Debugger.md
@@ -12,6 +12,10 @@ record struct DebuggerData(uint DefinesBitField, uint MDStructuresVersion);
 bool TryGetDebuggerData(out DebuggerData data);
 int GetAttachStateFlags();
 bool MetadataUpdatesApplied();
+void RequestSyncAtEvent();
+void SetSendExceptionsOutsideOfJMC(bool sendExceptionsOutsideOfJMC);
+TargetPointer GetDebuggerControlBlockAddress();
+void EnableGCNotificationEvents(bool fEnable);
 ```
 
 ## Version 1
@@ -31,6 +35,11 @@ The contract additionally depends on these data descriptors
 | `Debugger` | `LeftSideInitialized` | Whether the left-side debugger infrastructure is initialized |
 | `Debugger` | `Defines` | Bitfield of compile-time debugger feature defines |
 | `Debugger` | `MDStructuresVersion` | Version of metadata data structures |
+| `Debugger` | `RCThread` | Pointer to `DebuggerRCThread` |
+| `Debugger` | `RSRequestedSync` | Sync-at-event request flag |
+| `Debugger` | `SendExceptionsOutsideOfJMC` | Exception delivery policy flag |
+| `Debugger` | `GCNotificationEventsEnabled` | Whether GC notification events are enabled |
+| `DebuggerRCThread` | `DCB` | Pointer to `DebuggerIPCControlBlock` |
 
 ```csharp
 bool TryGetDebuggerData(out DebuggerData data)
@@ -65,4 +74,44 @@ bool MetadataUpdatesApplied()
         return target.Read<byte>(addr) != 0;
     return false;
 }
+
+void RequestSyncAtEvent()
+{
+    if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+        return;
+
+    target.Write<int>(debuggerAddress + /* Debugger::RSRequestedSync offset */, 1);
+}
+
+void SetSendExceptionsOutsideOfJMC(bool sendExceptionsOutsideOfJMC)
+{
+    if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+        return;
+
+    target.Write<int>(
+        debuggerAddress + /* Debugger::SendExceptionsOutsideOfJMC offset */,
+        sendExceptionsOutsideOfJMC ? 1 : 0);
+}
+
+TargetPointer GetDebuggerControlBlockAddress()
+{
+    if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+        return TargetPointer.Null;
+
+    TargetPointer rcThread = target.ReadPointer(debuggerAddress + /* Debugger::RCThread offset */);
+    if (rcThread == TargetPointer.Null)
+        return TargetPointer.Null;
+
+    return target.ReadPointer(rcThread + /* DebuggerRCThread::DCB offset */);
+}
+
+void EnableGCNotificationEvents(bool fEnable)
+{
+    if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+        return;
+
+    target.Write<int>(
+        debuggerAddress + /* Debugger::GCNotificationEventsEnabled offset */,
+        fEnable ? 1 : 0);
+}
 ```
diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h
@@ -46,6 +46,7 @@
 #include "dllimportcallback.h"
 
 #include "canary.h"
+#include "cdacdata.h"
 
 #undef ASSERT
 #define CRASH(x)  _ASSERTE(!(x))
@@ -901,6 +902,7 @@ class DebuggerRCThread
 
 
     friend class Debugger;
+    friend struct ::cdac_data<DebuggerRCThread>;
     Debugger*                       m_debugger;
 
     // IPC_TARGET_* define default targets - if we ever want to do
@@ -2892,6 +2894,7 @@ class Debugger : public DebugInterface
 
     // DacDbiInterfaceImpl needs to be able to write to private fields in the debugger class.
     friend class DacDbiInterfaceImpl;
+    friend struct ::cdac_data<Debugger>;
 
     // Set OOP by RS to request a sync after a debug event.
     // Clear by LS when we sync.
@@ -3884,6 +3887,21 @@ HANDLE OpenWin32EventOrThrow(
 // Include all of the inline stuff now.
 #include "debugger.inl"
 
+template<>
+struct cdac_data<Debugger>
+{
+    static constexpr size_t RCThread = offsetof(Debugger, m_pRCThread);
+    static constexpr size_t RSRequestedSync = offsetof(Debugger, m_RSRequestedSync);
+    static constexpr size_t SendExceptionsOutsideOfJMC = offsetof(Debugger, m_sendExceptionsOutsideOfJMC);
+    static constexpr size_t GCNotificationEventsEnabled = offsetof(Debugger, m_isGarbageCollectionEventsEnabled);
+};
+
+template<>
+struct cdac_data<DebuggerRCThread>
+{
+    static constexpr size_t DCB = offsetof(DebuggerRCThread, m_pDCB);
+};
+
 
 //
 //
diff --git a/src/coreclr/gc/CMakeLists.txt b/src/coreclr/gc/CMakeLists.txt
@@ -41,7 +41,6 @@ endif (CLR_CMAKE_TARGET_ARCH_ARM64 OR CLR_CMAKE_TARGET_ARCH_AMD64)
 
 if (CLR_CMAKE_TARGET_WIN32)
   set(GC_HEADERS
-    env/cdacdata.h
     env/common.h
     env/etmdummy.h
     env/gcenv.base.h
diff --git a/src/coreclr/gc/gc.h b/src/coreclr/gc/gc.h
@@ -30,7 +30,7 @@ Module Name:
 #endif // BUILD_AS_STANDALONE
 #include "gcconfig.h"
 
-#include "cdacdata.h"
+#include "../inc/cdacdata.h"
 
 /*
  * Promotion Function Prototypes
diff --git a/src/coreclr/inc/cdacdata.h b/src/coreclr/inc/cdacdata.h
diff --git a/src/coreclr/inc/patchpointinfo.h b/src/coreclr/inc/patchpointinfo.h
@@ -7,7 +7,7 @@
 
 #include <clrtypes.h>
 
-#include "../vm/cdacdata.h"
+#include "cdacdata.h"
 
 #ifndef _PATCHPOINTINFO_H_
 #define _PATCHPOINTINFO_H_
diff --git a/src/coreclr/inc/shash.h b/src/coreclr/inc/shash.h
@@ -9,7 +9,7 @@
 #include "clrtypes.h"
 #include "check.h"
 #include "iterator.h"
-#include "../vm/cdacdata.h"
+#include "cdacdata.h"
 
 // SHash is a templated closed chaining hash table of pointers.  It provides
 // for multiple entries under the same key, and also for deleting elements.
diff --git a/src/coreclr/interop/inc/interoplibabi.h b/src/coreclr/interop/inc/interoplibabi.h
@@ -6,7 +6,7 @@
 
 #include <stddef.h>
 #include <interoplib.h>
-#include "../../vm/cdacdata.h"
+#include "cdacdata.h"
 
 namespace InteropLib
 {
diff --git a/src/coreclr/vm/CMakeLists.txt b/src/coreclr/vm/CMakeLists.txt
@@ -410,7 +410,6 @@ set(VM_HEADERS_WKS
     cachelinealloc.h
     callhelpers.h
     callconvbuilder.hpp
-    cdacdata.h
     ceemain.h
     clrconfignative.h
     clrex.h
diff --git a/src/coreclr/vm/cdacdata.h b/src/coreclr/vm/cdacdata.h
diff --git a/src/coreclr/vm/datadescriptor/datadescriptor.inc b/src/coreclr/vm/datadescriptor/datadescriptor.inc
@@ -369,7 +369,16 @@ CDAC_TYPE_INDETERMINATE(Debugger)
 CDAC_TYPE_FIELD(Debugger, T_INT32, LeftSideInitialized, offsetof(Debugger, m_fLeftSideInitialized))
 CDAC_TYPE_FIELD(Debugger, T_UINT32, Defines, offsetof(Debugger, m_defines))
 CDAC_TYPE_FIELD(Debugger, T_UINT32, MDStructuresVersion, offsetof(Debugger, m_mdDataStructureVersion))
+CDAC_TYPE_FIELD(Debugger, T_POINTER, RCThread, cdac_data<Debugger>::RCThread)
+CDAC_TYPE_FIELD(Debugger, T_INT32, RSRequestedSync, cdac_data<Debugger>::RSRequestedSync)
+CDAC_TYPE_FIELD(Debugger, T_INT32, SendExceptionsOutsideOfJMC, cdac_data<Debugger>::SendExceptionsOutsideOfJMC)
+CDAC_TYPE_FIELD(Debugger, T_INT32, GCNotificationEventsEnabled, cdac_data<Debugger>::GCNotificationEventsEnabled)
 CDAC_TYPE_END(Debugger)
+
+CDAC_TYPE_BEGIN(DebuggerRCThread)
+CDAC_TYPE_INDETERMINATE(DebuggerRCThread)
+CDAC_TYPE_FIELD(DebuggerRCThread, T_POINTER, DCB, cdac_data<DebuggerRCThread>::DCB)
+CDAC_TYPE_END(DebuggerRCThread)
 #endif // DEBUGGING_SUPPORTED && !TARGET_WASM
 
 CDAC_TYPE_BEGIN(ArrayListBase)
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IDebugger.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IDebugger.cs
@@ -14,6 +14,10 @@ public interface IDebugger : IContract
     bool TryGetDebuggerData(out DebuggerData data) => throw new NotImplementedException();
     int GetAttachStateFlags() => throw new NotImplementedException();
     bool MetadataUpdatesApplied() => throw new NotImplementedException();
+    void RequestSyncAtEvent() => throw new NotImplementedException();
+    void SetSendExceptionsOutsideOfJMC(bool sendExceptionsOutsideOfJMC) => throw new NotImplementedException();
+    TargetPointer GetDebuggerControlBlockAddress() => throw new NotImplementedException();
+    void EnableGCNotificationEvents(bool fEnable) => throw new NotImplementedException();
 }
 
 public readonly struct Debugger : IDebugger
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/DataType.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/DataType.cs
@@ -43,6 +43,7 @@ public enum DataType
     ModuleLookupMap,
     AppDomain,
     Debugger,
+    DebuggerRCThread,
     SystemDomain,
     Assembly,
     LoaderAllocator,
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Debugger_1.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Debugger_1.cs
@@ -12,18 +12,25 @@ internal Debugger_1(Target target)
         _target = target;
     }
 
-    bool IDebugger.TryGetDebuggerData(out DebuggerData data)
+    private bool TryGetDebuggerAddress(out TargetPointer debuggerAddress)
     {
-        data = default;
+        debuggerAddress = TargetPointer.Null;
+
         TargetPointer debuggerPtrPtr = _target.ReadGlobalPointer(Constants.Globals.Debugger);
         if (debuggerPtrPtr == TargetPointer.Null)
             return false;
 
-        TargetPointer debuggerPtr = _target.ReadPointer(debuggerPtrPtr);
-        if (debuggerPtr == TargetPointer.Null)
+        debuggerAddress = _target.ReadPointer(debuggerPtrPtr);
+        return debuggerAddress != TargetPointer.Null;
+    }
+
+    bool IDebugger.TryGetDebuggerData(out DebuggerData data)
+    {
+        data = default;
+        if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
             return false;
 
-        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerPtr);
+        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerAddress);
         if (debugger.LeftSideInitialized == 0)
             return false;
 
@@ -45,4 +52,45 @@ bool IDebugger.MetadataUpdatesApplied()
         }
         return false;
     }
+
+    void IDebugger.RequestSyncAtEvent()
+    {
+        if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+            return;
+
+        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerAddress);
+        debugger.SetField(_target, nameof(Data.Debugger.RSRequestedSync), 1);
+    }
+
+    void IDebugger.SetSendExceptionsOutsideOfJMC(bool sendExceptionsOutsideOfJMC)
+    {
+        if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+            return;
+
+        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerAddress);
+        debugger.SetField(_target, nameof(Data.Debugger.SendExceptionsOutsideOfJMC), sendExceptionsOutsideOfJMC ? 1 : 0);
+    }
+
+    TargetPointer IDebugger.GetDebuggerControlBlockAddress()
+    {
+        if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+            return TargetPointer.Null;
+
+        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerAddress);
+        TargetPointer rcThread = debugger.RCThread;
+        if (rcThread == TargetPointer.Null)
+            return TargetPointer.Null;
+
+        Data.DebuggerRCThread debuggerRcThread = _target.ProcessedData.GetOrAdd<Data.DebuggerRCThread>(rcThread);
+        return debuggerRcThread.DCB;
+    }
+
+    void IDebugger.EnableGCNotificationEvents(bool fEnable)
+    {
+        if (!TryGetDebuggerAddress(out TargetPointer debuggerAddress))
+            return;
+
+        Data.Debugger debugger = _target.ProcessedData.GetOrAdd<Data.Debugger>(debuggerAddress);
+        debugger.SetField(_target, nameof(Data.Debugger.GCNotificationEventsEnabled), fEnable ? 1 : 0);
+    }
 }
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Debugger.cs
@@ -1,23 +1,57 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 namespace Microsoft.Diagnostics.DataContractReader.Data;
 
 internal sealed class Debugger : IData<Debugger>
 {
     static Debugger IData<Debugger>.Create(Target target, TargetPointer address)
         => new Debugger(target, address);
 
+    private readonly TargetPointer _address;
+
     public Debugger(Target target, TargetPointer address)
     {
+        _address = address;
         Target.TypeInfo type = target.GetTypeInfo(DataType.Debugger);
 
         LeftSideInitialized = target.ReadField<int>(address, type, nameof(LeftSideInitialized));
         Defines = target.ReadField<uint>(address, type, nameof(Defines));
         MDStructuresVersion = target.ReadField<uint>(address, type, nameof(MDStructuresVersion));
+        RCThread = target.ReadPointerFieldOrNull(address, type, nameof(RCThread));
+        RSRequestedSync = target.ReadFieldOrDefault<int>(address, type, nameof(RSRequestedSync));
+        SendExceptionsOutsideOfJMC = target.ReadFieldOrDefault<int>(address, type, nameof(SendExceptionsOutsideOfJMC));
+        GCNotificationEventsEnabled = target.ReadFieldOrDefault<int>(address, type, nameof(GCNotificationEventsEnabled));
     }
 
     public int LeftSideInitialized { get; init; }
     public uint Defines { get; init; }
     public uint MDStructuresVersion { get; init; }
+    public TargetPointer RCThread { get; init; }
+    public int RSRequestedSync { get; private set; }
+    public int SendExceptionsOutsideOfJMC { get; private set; }
+    public int GCNotificationEventsEnabled { get; private set; }
+
+    public void SetField(Target target, string fieldName, int value)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.Debugger);
+        ulong addr = _address + (ulong)type.Fields[fieldName].Offset;
+        target.Write<int>(addr, value);
+
+        switch (fieldName)
+        {
+            case nameof(RSRequestedSync):
+                RSRequestedSync = value;
+                break;
+            case nameof(SendExceptionsOutsideOfJMC):
+                SendExceptionsOutsideOfJMC = value;
+                break;
+            case nameof(GCNotificationEventsEnabled):
+                GCNotificationEventsEnabled = value;
+                break;
+            default:
+                throw new ArgumentException($"Field '{fieldName}' is not a writable Debugger field.", nameof(fieldName));
+        }
+    }
 }
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DebuggerRCThread.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/DebuggerRCThread.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+internal sealed class DebuggerRCThread : IData<DebuggerRCThread>
+{
+    static DebuggerRCThread IData<DebuggerRCThread>.Create(Target target, TargetPointer address)
+        => new DebuggerRCThread(target, address);
+
+    public DebuggerRCThread(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.DebuggerRCThread);
+        DCB = target.ReadPointerField(address, type, nameof(DCB));
+    }
+
+    public TargetPointer DCB { get; init; }
+}
diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs
diff --git a/src/native/managed/cdac/tests/DebuggerTests.cs b/src/native/managed/cdac/tests/DebuggerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`#include <stddef.h>`
`8`	`8`	`#include <interoplib.h>`
`9`		`-#include "../../vm/cdacdata.h"`
	`9`	`+#include "cdacdata.h"`
`10`	`10`
`11`	`11`	`namespace InteropLib`
`12`	`12`	`{`