Implement cDAC TraverseLoaderHeap via Loader contract

docs/design/datacontracts/GC.md

@@ -97,7 +97,7 @@ public readonly struct GCOomData
     IEnumerable<TargetPointer> GetGCHeaps();
 
     // The following APIs have both a workstation and serer variant.
-    // The workstation variant implitly operates on the global heap.
+    // The workstation variant implicitly operates on the global heap.
     // The server variants allow passing in a heap pointer.
 
     // Gets data about a GC heap
@@ -740,3 +740,4 @@ void IGC.GetGlobalAllocationContext(out TargetPointer allocPtr, out TargetPointe
     allocLimit = target.ReadPointer(globalAllocContextAddress + /* EEAllocContext::GCAllocationContext offset */ + /* GCAllocContext::Limit offset */);
 }
 ```
+

docs/design/datacontracts/Loader.md

@@ -86,6 +86,20 @@ TargetPointer GetStubHeap(TargetPointer loaderAllocatorPointer);
 TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer);
 TargetPointer GetILHeader(ModuleHandle handle, uint token);
 TargetPointer GetDynamicIL(ModuleHandle handle, uint token);
+
+// Loader heap traversal
+readonly struct LoaderHeapBlockData
+{
+    public TargetPointer VirtualAddress { get; init; }
+    public TargetNUInt VirtualSize { get; init; }
+}
+
+// Returns the first block of the loader heap linked list, or TargetPointer.Null if the heap has no blocks
+TargetPointer GetFirstLoaderHeapBlock(TargetPointer loaderHeap);
+// Returns the address and size of virtual memory for the given loader heap block
+LoaderHeapBlockData GetLoaderHeapBlockData(TargetPointer block);
+// Returns the next block in the loader heap linked list, or TargetPointer.Null if there are no more blocks
+TargetPointer GetNextLoaderHeapBlock(TargetPointer block);
 ```
 
 ## Version 1
@@ -159,6 +173,10 @@ TargetPointer GetDynamicIL(ModuleHandle handle, uint token);
 | `DynamicILBlobTable` | `EntrySize` | Size of each table entry |
 | `DynamicILBlobTable` | `EntryMethodToken` | Offset of each entry method token from entry address |
 | `DynamicILBlobTable` | `EntryIL` | Offset of each entry IL from entry address |
+| `LoaderHeap` | `FirstBlock` | Pointer to the first `LoaderHeapBlock` in the linked list |
+| `LoaderHeapBlock` | `Next` | Pointer to the next `LoaderHeapBlock` in the linked list |
+| `LoaderHeapBlock` | `VirtualAddress` | Pointer to the start of the reserved virtual memory |
+| `LoaderHeapBlock` | `VirtualSize` | Size in bytes of the reserved virtual memory region |
 
 
 
@@ -761,3 +779,28 @@ class InstMethodHashTable
     }
 }
 ```
+
+#### GetFirstLoaderHeapBlock, GetLoaderHeapBlockData, GetNextLoaderHeapBlock
+
+`LoaderHeap` instances use `UnlockedLoaderHeapBaseTraversable` as their primary base class. Traversal follows the `m_pFirstBlock` linked list via `LoaderHeapBlock::pNext`.
+
+```csharp
+TargetPointer ILoader.GetFirstLoaderHeapBlock(TargetPointer loaderHeap)
+{
+    return target.ReadPointer(loaderHeap + /* LoaderHeap::FirstBlock offset */);
+}
+
+LoaderHeapBlockData ILoader.GetLoaderHeapBlockData(TargetPointer block)
+{
+    return new LoaderHeapBlockData
+    {
+        VirtualAddress = target.ReadPointer(block + /* LoaderHeapBlock::VirtualAddress offset */),
+        VirtualSize = target.ReadNUInt(block + /* LoaderHeapBlock::VirtualSize offset */),
+    };
+}
+
+TargetPointer ILoader.GetNextLoaderHeapBlock(TargetPointer block)
+{
+    return target.ReadPointer(block + /* LoaderHeapBlock::Next offset */);
+}
+```

src/coreclr/inc/loaderheap.h

@@ -99,6 +99,8 @@ struct TaggedMemAllocPtr
 
 #define VIRTUAL_ALLOC_RESERVE_GRANULARITY (64*1024)    // 0x10000  (64 KB)
 
+template<typename T> struct cdac_data;
+
 typedef DPTR(struct LoaderHeapBlock) PTR_LoaderHeapBlock;
 
 struct LoaderHeapBlock
@@ -143,7 +145,6 @@ struct LoaderHeapBlock
 #endif
 };
 
-
 struct LoaderHeapFreeBlock;
 
 // Collection of methods for helping in debugging heap corruptions

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -250,6 +250,17 @@ CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, StubHeap, cdac_data<LoaderAllocato
 CDAC_TYPE_FIELD(LoaderAllocator, /*pointer*/, ObjectHandle, cdac_data<LoaderAllocator>::ObjectHandle)
 CDAC_TYPE_END(LoaderAllocator)
 
+CDAC_TYPE_BEGIN(LoaderHeap)
+CDAC_TYPE_INDETERMINATE(LoaderHeap)
+CDAC_TYPE_FIELD(LoaderHeap, /*pointer*/, FirstBlock, offsetof(UnlockedLoaderHeapBaseTraversable, m_pFirstBlock))
+CDAC_TYPE_END(LoaderHeap)
+
+CDAC_TYPE_BEGIN(LoaderHeapBlock)
+CDAC_TYPE_FIELD(LoaderHeapBlock, /*pointer*/, Next, offsetof(LoaderHeapBlock, pNext))
+CDAC_TYPE_FIELD(LoaderHeapBlock, /*pointer*/, VirtualAddress, offsetof(LoaderHeapBlock, pVirtualAddress))
+CDAC_TYPE_FIELD(LoaderHeapBlock, /*nuint*/, VirtualSize, offsetof(LoaderHeapBlock, dwVirtualSize))
+CDAC_TYPE_END(LoaderHeapBlock)
+
 CDAC_TYPE_BEGIN(PEAssembly)
 CDAC_TYPE_INDETERMINATE(PEAssembly)
 CDAC_TYPE_FIELD(PEAssembly, /*pointer*/, PEImage, cdac_data<PEAssembly>::PEImage)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/ILoader.cs

@@ -16,6 +16,12 @@ public ModuleHandle(TargetPointer address)
     public TargetPointer Address { get; }
 }
 
+public readonly struct LoaderHeapBlockData
+{
+    public TargetPointer VirtualAddress { get; init; }
+    public TargetNUInt VirtualSize { get; init; }
+}
+
 [Flags]
 public enum ModuleFlags
 {
@@ -94,6 +100,13 @@ public interface ILoader : IContract
     TargetPointer GetILHeader(ModuleHandle handle, uint token) => throw new NotImplementedException();
     TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer) => throw new NotImplementedException();
     TargetPointer GetDynamicIL(ModuleHandle handle, uint token) => throw new NotImplementedException();
+
+    // Returns the first block of the loader heap linked list, or TargetPointer.Null if the heap has no blocks
+    TargetPointer GetFirstLoaderHeapBlock(TargetPointer loaderHeap) => throw new NotImplementedException();
+    // Returns the address and size of virtual memory for the given loader heap block
+    LoaderHeapBlockData GetLoaderHeapBlockData(TargetPointer block) => throw new NotImplementedException();
+    // Returns the next block in the loader heap linked list, or TargetPointer.Null if there are no more blocks
+    TargetPointer GetNextLoaderHeapBlock(TargetPointer block) => throw new NotImplementedException();
 }
 
 public readonly struct Loader : ILoader

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

@@ -41,6 +41,8 @@ public enum DataType
     SystemDomain,
     Assembly,
     LoaderAllocator,
+    LoaderHeap,
+    LoaderHeapBlock,
     PEAssembly,
     AssemblyBinder,
     PEImage,

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Loader_1.cs

@@ -552,4 +552,26 @@ TargetPointer ILoader.GetDynamicIL(ModuleHandle handle, uint token)
         ISHash shashContract = _target.Contracts.SHash;
         return shashContract.LookupSHash(dynamicILBlobTable.HashTable, token).EntryIL;
     }
+
+    TargetPointer ILoader.GetFirstLoaderHeapBlock(TargetPointer loaderHeap)
+    {
+        Data.LoaderHeap heap = _target.ProcessedData.GetOrAdd<Data.LoaderHeap>(loaderHeap);
+        return heap.FirstBlock;
+    }
+
+    LoaderHeapBlockData ILoader.GetLoaderHeapBlockData(TargetPointer block)
+    {
+        Data.LoaderHeapBlock blockData = _target.ProcessedData.GetOrAdd<Data.LoaderHeapBlock>(block);
+        return new LoaderHeapBlockData
+        {
+            VirtualAddress = blockData.VirtualAddress,
+            VirtualSize = blockData.VirtualSize,
+        };
+    }
+
+    TargetPointer ILoader.GetNextLoaderHeapBlock(TargetPointer block)
+    {
+        Data.LoaderHeapBlock blockData = _target.ProcessedData.GetOrAdd<Data.LoaderHeapBlock>(block);
+        return blockData.Next;
+    }
 }

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderHeap.cs

@@ -0,0 +1,19 @@
+// 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 LoaderHeap : IData<LoaderHeap>
+{
+    static LoaderHeap IData<LoaderHeap>.Create(Target target, TargetPointer address)
+        => new LoaderHeap(target, address);
+
+    public LoaderHeap(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.LoaderHeap);
+
+        FirstBlock = target.ReadPointer(address + (ulong)type.Fields[nameof(FirstBlock)].Offset);
+    }
+
+    public TargetPointer FirstBlock { get; init; }
+}

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/LoaderHeapBlock.cs

@@ -0,0 +1,23 @@
+// 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 LoaderHeapBlock : IData<LoaderHeapBlock>
+{
+    static LoaderHeapBlock IData<LoaderHeapBlock>.Create(Target target, TargetPointer address)
+        => new LoaderHeapBlock(target, address);
+
+    public LoaderHeapBlock(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.LoaderHeapBlock);
+
+        Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset);
+        VirtualAddress = target.ReadPointer(address + (ulong)type.Fields[nameof(VirtualAddress)].Offset);
+        VirtualSize = target.ReadNUInt(address + (ulong)type.Fields[nameof(VirtualSize)].Offset);
+    }
+
+    public TargetPointer Next { get; init; }
+    public TargetPointer VirtualAddress { get; init; }
+    public TargetNUInt VirtualSize { get; init; }
+}

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

@@ -4881,8 +4881,87 @@ int ISOSDacInterface12.GetGlobalAllocationContext(ClrDataAddress* allocPtr, ClrD
     #endregion ISOSDacInterface12
 
     #region ISOSDacInterface13
+#if DEBUG
+    [ThreadStatic]
+    private static List<(ulong VirtualAddress, nuint VirtualSize)>? _debugTraverseLoaderHeapBlocks;
+
+    [UnmanagedCallersOnly]
+    private static Interop.BOOL TraverseLoaderHeapDebugCallback(ulong virtualAddress, nuint virtualSize)
+    {
+        List<(ulong VirtualAddress, nuint VirtualSize)>? expected = _debugTraverseLoaderHeapBlocks;
+        if (expected is not null)
+        {
+            bool found = expected.Remove((virtualAddress, virtualSize));
+            Debug.Assert(found, $"Unexpected loader heap block: address={virtualAddress:x}, size={virtualSize:x}");
+        }
+        return Interop.BOOL.TRUE;
+    }
+#endif
+
     int ISOSDacInterface13.TraverseLoaderHeap(ClrDataAddress loaderHeapAddr, /*LoaderHeapKind*/ int kind, /*VISITHEAP*/ delegate* unmanaged<ulong, nuint, Interop.BOOL> pCallback)
-        => _legacyImpl13 is not null ? _legacyImpl13.TraverseLoaderHeap(loaderHeapAddr, kind, pCallback) : HResults.E_NOTIMPL;
+    {
+        // Both LoaderHeapKindNormal (0) and LoaderHeapKindExplicitControl (1) use
+        // the same FirstBlock offset via UnlockedLoaderHeapBaseTraversable.
+        // Unknown kind values return E_NOTIMPL to match the native DAC behavior.
+        const int LoaderHeapKindNormal = 0;
+        const int LoaderHeapKindExplicitControl = 1;
+        if (kind != LoaderHeapKindNormal && kind != LoaderHeapKindExplicitControl)
+            return HResults.E_NOTIMPL;
+
+        int hr = HResults.S_OK;
+        try
+        {
+            if (loaderHeapAddr == 0)
+                throw new ArgumentException();
+            if (pCallback is null)
+                throw new ArgumentException();
+
+            Contracts.ILoader loader = _target.Contracts.Loader;
+            TargetPointer heapAddr = loaderHeapAddr.ToTargetPointer(_target);
+            TargetPointer block = loader.GetFirstLoaderHeapBlock(heapAddr);
+            while (block != TargetPointer.Null)
+            {
+                Contracts.LoaderHeapBlockData blockData = loader.GetLoaderHeapBlockData(block);
+                Interop.BOOL cont = pCallback(blockData.VirtualAddress.Value, (nuint)blockData.VirtualSize.Value);
+                if (cont == Interop.BOOL.FALSE)
+                    break;
+                block = loader.GetNextLoaderHeapBlock(block);
+            }
+        }
+        catch (System.Exception ex)
+        {
+            hr = ex.HResult;
+        }
+#if DEBUG
+        if (_legacyImpl13 is not null)
+        {
+            // Collect expected blocks via a second cDAC traversal (not re-invoking the original callback).
+            List<(ulong VirtualAddress, nuint VirtualSize)> cdacBlocks = [];
+            try
+            {
+                Contracts.ILoader loader = _target.Contracts.Loader;
+                TargetPointer heapAddr = loaderHeapAddr.ToTargetPointer(_target);
+                TargetPointer block = loader.GetFirstLoaderHeapBlock(heapAddr);
+                while (block != TargetPointer.Null)
+                {
+                    Contracts.LoaderHeapBlockData blockData = loader.GetLoaderHeapBlockData(block);
+                    cdacBlocks.Add((blockData.VirtualAddress.Value, (nuint)blockData.VirtualSize.Value));
+                    block = loader.GetNextLoaderHeapBlock(block);
+                }
+            }
+            catch { }
+
+            _debugTraverseLoaderHeapBlocks = cdacBlocks;
+            delegate* unmanaged<ulong, nuint, Interop.BOOL> debugCallbackPtr = &TraverseLoaderHeapDebugCallback;
+            int hrLocal = _legacyImpl13.TraverseLoaderHeap(loaderHeapAddr, kind, debugCallbackPtr);
+            Debug.Assert(hrLocal == hr, $"cDAC: {hr:x}, DAC: {hrLocal:x}");
+            Debug.Assert(_debugTraverseLoaderHeapBlocks!.Count == 0,
+                $"cDAC found {cdacBlocks.Count} blocks but DAC found {cdacBlocks.Count - _debugTraverseLoaderHeapBlocks.Count} matching blocks");
+            _debugTraverseLoaderHeapBlocks = null;
+        }
+#endif
+        return hr;
+    }
     int ISOSDacInterface13.GetDomainLoaderAllocator(ClrDataAddress domainAddress, ClrDataAddress* pLoaderAllocator)
     {
         int hr = HResults.S_OK;