wip

Author: Max Charlamb

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -282,8 +282,22 @@ CDAC_TYPE_END(ProbeExtensionResult)
 CDAC_TYPE_BEGIN(AppDomain)
 CDAC_TYPE_INDETERMINATE(AppDomain)
 CDAC_TYPE_FIELD(AppDomain, /*pointer*/, RootAssembly, cdac_data<AppDomain>::RootAssembly)
+CDAC_TYPE_FIELD(AppDomain, /*DomainAssemblyList*/, DomainAssemblyList, cdac_data<AppDomain>::DomainAssemblyList)
 CDAC_TYPE_END(AppDomain)
 
+CDAC_TYPE_BEGIN(ArrayListBase)
+CDAC_TYPE_INDETERMINATE(ArrayListBase)
+CDAC_TYPE_FIELD(ArrayListBase, /*uint32*/, Count, cdac_data<ArrayListBase>::Count)
+CDAC_TYPE_FIELD(ArrayListBase, /*pointer*/, FirstBlock, cdac_data<ArrayListBase>::FirstBlock)
+CDAC_TYPE_END(ArrayListBase)
+
+CDAC_TYPE_BEGIN(ArrayListBlock)
+CDAC_TYPE_INDETERMINATE(ArrayListBlock)
+CDAC_TYPE_FIELD(ArrayListBlock, /*pointer*/, Next, cdac_data<ArrayListBlock>::Next)
+CDAC_TYPE_FIELD(ArrayListBlock, /*uint32*/, Size, cdac_data<ArrayListBlock>::Size)
+CDAC_TYPE_FIELD(ArrayListBlock, /*pointer*/, ArrayStart, cdac_data<ArrayListBlock>::ArrayStart)
+CDAC_TYPE_END(ArrayListBlock)
+
 // RuntimeTypeSystem
 
 CDAC_TYPE_BEGIN(MethodTable)

src/coreclr/inc/arraylist.h

@@ -53,6 +53,7 @@ class ArrayListBase
                 (*PTR_DWORD(addr + offsetof(ArrayListBlock, m_blockSize)) * sizeof(void*));
         }
 #endif
+        friend struct ::cdac_data<ArrayListBlock>;
     };
     typedef SPTR(ArrayListBlock) PTR_ArrayListBlock;
 
@@ -263,6 +264,23 @@ class ArrayListBase
         return BlockIterator((ArrayListBlock *) &m_firstBlock, m_count);
     }
 
+    friend struct ::cdac_data<ArrayListBase>;
+    friend struct ::cdac_data<ArrayListBlock>;
+};
+
+template<>
+struct cdac_data<ArrayListBase>
+{
+    static constexpr size_t Count = offsetof(ArrayListBase, m_count);
+    static constexpr size_t FirstBlock = offsetof(ArrayListBase, m_firstBlock);
+};
+
+template<>
+struct cdac_data<ArrayListBase::ArrayListBlock>
+{
+    static constexpr size_t Next = offsetof(ArrayListBase::ArrayListBlock, m_next);
+    static constexpr size_t Size = offsetof(ArrayListBase::ArrayListBlock, m_blockSize);
+    static constexpr size_t ArrayStart = offsetof(ArrayListBase::ArrayListBlock, m_array);
 };
 
 class ArrayList : public ArrayListBase

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

@@ -38,6 +38,7 @@ public interface ILoader : IContract
 
     ModuleHandle GetModuleHandle(TargetPointer modulePointer) => throw new NotImplementedException();
 
+    List<TargetPointer> GetAssemblies(TargetPointer appDomain) => throw new NotImplementedException();
     TargetPointer GetRootAssembly() => throw new NotImplementedException();
     TargetPointer GetAssembly(ModuleHandle handle) => throw new NotImplementedException();
     TargetPointer GetPEAssembly(ModuleHandle handle) => throw new NotImplementedException();

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

@@ -96,6 +96,9 @@ public enum DataType
     MethodImpl,
     NativeCodeSlot,
     GCCoverageInfo,
+    ArrayListBase,
+    ArrayListBlock,
+
     TransitionBlock,
     DebuggerEval,
     CalleeSavedRegisters,

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ArrayListBase.cs

@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.using System;
+
+using System.Collections.Generic;
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+internal sealed class ArrayListBase : IData<ArrayListBase>
+{
+    static ArrayListBase IData<ArrayListBase>.Create(Target target, TargetPointer address) => new ArrayListBase(target, address);
+    public ArrayListBase(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.ArrayListBase);
+
+        Count = target.Read<uint>(address + (ulong)type.Fields[nameof(Count)].Offset);
+        FirstBlock = address + (ulong)type.Fields[nameof(FirstBlock)].Offset;
+
+        TargetPointer next = FirstBlock;
+        while (next != TargetPointer.Null)
+        {
+            ArrayListBlock block = target.ProcessedData.GetOrAdd<ArrayListBlock>(next);
+            Blocks.Add(block);
+            next = block.Next;
+        }
+    }
+
+    public uint Count { get; init; }
+    public TargetPointer FirstBlock { get; init; }
+
+    public List<ArrayListBlock> Blocks { get; init; } = [];
+    public List<TargetPointer> Elements { get; init; } = [];
+
+    internal sealed class ArrayListBlock : IData<ArrayListBlock>
+    {
+        static ArrayListBlock IData<ArrayListBlock>.Create(Target target, TargetPointer address) => new ArrayListBlock(target, address);
+        public ArrayListBlock(Target target, TargetPointer address)
+        {
+            Target.TypeInfo type = target.GetTypeInfo(DataType.ArrayListBlock);
+
+            Next = target.ReadPointer(address + (ulong)type.Fields[nameof(Next)].Offset);
+            Size = target.Read<uint>(address + (ulong)type.Fields[nameof(Size)].Offset);
+            ArrayStart = address + (ulong)type.Fields[nameof(ArrayStart)].Offset;
+
+            for (ulong i = 0; i < Size; i++)
+            {
+                Elements.Add(target.ReadPointer(ArrayStart + (i * (ulong)target.PointerSize)));
+            }
+        }
+
+        public TargetPointer Next { get; init; }
+        public uint Size { get; init; }
+        public TargetPointer ArrayStart { get; init; }
+
+        public List<TargetPointer> Elements { get; init; } = [];
+    }
+}