cDAC: Implement ISOSDacInterface::GetRCWData

Co-authored-by: rcj1 <77995559+rcj1@users.noreply.github.com>

Author: Copilot

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/ISOSDacInterface.cs

@@ -394,6 +394,27 @@ public struct DacpCOMInterfacePointerData
     public ClrDataAddress comContext;
 }
 
+// Mirrors struct DacpRCWData in src/coreclr/inc/dacprivate.h.
+// Size must remain 0x58 bytes (enforced by static_assert in the native code).
+public struct DacpRCWData
+{
+    public ClrDataAddress identityPointer;
+    public ClrDataAddress unknownPointer;
+    public ClrDataAddress managedObject;
+    public ClrDataAddress jupiterObject;
+    public ClrDataAddress vtablePtr;
+    public ClrDataAddress creatorThread;
+    public ClrDataAddress ctxCookie;
+    public int refCount;
+    public int interfaceCount;
+    public int isJupiterObject;   // BOOL
+    public int supportsIInspectable; // BOOL
+    public int isAggregated;     // BOOL
+    public int isContained;      // BOOL
+    public int isFreeThreaded;   // BOOL
+    public int isDisconnected;   // BOOL
+}
+
 [GeneratedComInterface]
 [Guid("286CA186-E763-4F61-9760-487D43AE4341")]
 public unsafe partial interface ISOSEnum
@@ -758,7 +779,7 @@ public unsafe partial interface ISOSDacInterface
 
     // COM
     [PreserveSig]
-    int GetRCWData(ClrDataAddress addr, /*struct DacpRCWData */ void* data);
+    int GetRCWData(ClrDataAddress addr, DacpRCWData* data);
     [PreserveSig]
     int GetRCWInterfaces(ClrDataAddress rcw, uint count, [In, Out, MarshalUsing(CountElementName = nameof(count))] DacpCOMInterfacePointerData[]? interfaces, uint* pNeeded);
     [PreserveSig]

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/SOSDacImpl.cs

@@ -3388,8 +3388,66 @@ int ISOSDacInterface.GetPrivateBinPaths(ClrDataAddress appDomain, int count, cha
 
         return hr;
     }
-    int ISOSDacInterface.GetRCWData(ClrDataAddress addr, void* data)
-        => _legacyImpl is not null ? _legacyImpl.GetRCWData(addr, data) : HResults.E_NOTIMPL;
+    int ISOSDacInterface.GetRCWData(ClrDataAddress addr, DacpRCWData* data)
+    {
+        int hr = HResults.S_OK;
+        try
+        {
+            if (addr == 0)
+                throw new ArgumentException();
+            if (data is null)
+                throw new ArgumentException();
+
+            *data = default;
+
+            TargetPointer rcwPtr = addr.ToTargetPointer(_target);
+            IBuiltInCOM builtInCom = _target.Contracts.BuiltInCOM;
+            Contracts.RCWData rcwData = builtInCom.GetRCWData(rcwPtr);
+
+            data->identityPointer = rcwData.IdentityPointer.ToClrDataAddress(_target);
+            data->unknownPointer = rcwData.UnknownPointer.ToClrDataAddress(_target);
+            data->managedObject = rcwData.ManagedObject.ToClrDataAddress(_target);
+            data->vtablePtr = rcwData.VTablePtr.ToClrDataAddress(_target);
+            data->creatorThread = rcwData.CreatorThread.ToClrDataAddress(_target);
+            data->ctxCookie = rcwData.CtxCookie.ToClrDataAddress(_target);
+            data->refCount = (int)rcwData.RefCount;
+            data->interfaceCount = builtInCom.GetRCWInterfaces(rcwPtr).Count();
+            data->isAggregated = rcwData.IsAggregated ? 1 : 0;
+            data->isContained = rcwData.IsContained ? 1 : 0;
+            data->isFreeThreaded = rcwData.IsFreeThreaded ? 1 : 0;
+            data->isDisconnected = rcwData.IsDisconnected ? 1 : 0;
+        }
+        catch (System.Exception ex)
+        {
+            hr = ex.HResult;
+        }
+
+#if DEBUG
+        if (_legacyImpl is not null)
+        {
+            DacpRCWData dataLocal;
+            int hrLocal = _legacyImpl.GetRCWData(addr, &dataLocal);
+            Debug.ValidateHResult(hr, hrLocal);
+            if (hr == HResults.S_OK)
+            {
+                Debug.Assert(data->identityPointer == dataLocal.identityPointer, $"cDAC: {data->identityPointer:x}, DAC: {dataLocal.identityPointer:x}");
+                Debug.Assert(data->unknownPointer == dataLocal.unknownPointer, $"cDAC: {data->unknownPointer:x}, DAC: {dataLocal.unknownPointer:x}");
+                Debug.Assert(data->managedObject == dataLocal.managedObject, $"cDAC: {data->managedObject:x}, DAC: {dataLocal.managedObject:x}");
+                Debug.Assert(data->vtablePtr == dataLocal.vtablePtr, $"cDAC: {data->vtablePtr:x}, DAC: {dataLocal.vtablePtr:x}");
+                Debug.Assert(data->creatorThread == dataLocal.creatorThread, $"cDAC: {data->creatorThread:x}, DAC: {dataLocal.creatorThread:x}");
+                Debug.Assert(data->ctxCookie == dataLocal.ctxCookie, $"cDAC: {data->ctxCookie:x}, DAC: {dataLocal.ctxCookie:x}");
+                Debug.Assert(data->refCount == dataLocal.refCount, $"cDAC: {data->refCount}, DAC: {dataLocal.refCount}");
+                Debug.Assert(data->interfaceCount == dataLocal.interfaceCount, $"cDAC: {data->interfaceCount}, DAC: {dataLocal.interfaceCount}");
+                Debug.Assert(data->isAggregated == dataLocal.isAggregated, $"cDAC: {data->isAggregated}, DAC: {dataLocal.isAggregated}");
+                Debug.Assert(data->isContained == dataLocal.isContained, $"cDAC: {data->isContained}, DAC: {dataLocal.isContained}");
+                Debug.Assert(data->isFreeThreaded == dataLocal.isFreeThreaded, $"cDAC: {data->isFreeThreaded}, DAC: {dataLocal.isFreeThreaded}");
+                Debug.Assert(data->isDisconnected == dataLocal.isDisconnected, $"cDAC: {data->isDisconnected}, DAC: {dataLocal.isDisconnected}");
+            }
+        }
+#endif
+
+        return hr;
+    }
     int ISOSDacInterface.GetRCWInterfaces(ClrDataAddress rcw, uint count, [In, MarshalUsing(CountElementName = nameof(count)), Out] DacpCOMInterfacePointerData[]? interfaces, uint* pNeeded)
     {
         int hr = HResults.S_OK;