implement ISOSDacInterface.GetAssemblyList

Author: Max Charlamb

Diff for: src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -249,8 +249,17 @@ CDAC_TYPE_INDETERMINATE(Assembly)
 #ifdef FEATURE_COLLECTIBLE_TYPES
 CDAC_TYPE_FIELD(Assembly, /*uint8*/, IsCollectible, cdac_data<Assembly>::IsCollectible)
 #endif
+CDAC_TYPE_FIELD(Assembly, /*pointer*/, Module, cdac_data<Assembly>::Module)
+CDAC_TYPE_FIELD(Assembly, /*pointer*/, Error, cdac_data<Assembly>::Error)
+CDAC_TYPE_FIELD(Assembly, /*uint32*/, NotifyFlags, cdac_data<Assembly>::NotifyFlags)
+CDAC_TYPE_FIELD(Assembly, /*uint32*/, Level, cdac_data<Assembly>::Level)
 CDAC_TYPE_END(Assembly)
 
+CDAC_TYPE_BEGIN(LoaderAllocator)
+CDAC_TYPE_INDETERMINATE(LoaderAllocator)
+CDAC_TYPE_FIELD(LoaderAllocator, /*uint32*/, ReferenceCount, cdac_data<LoaderAllocator>::ReferenceCount)
+CDAC_TYPE_END(LoaderAllocator)
+
 CDAC_TYPE_BEGIN(PEAssembly)
 CDAC_TYPE_INDETERMINATE(PEAssembly)
 CDAC_TYPE_FIELD(PEAssembly, /*pointer*/, PEImage, cdac_data<PEAssembly>::PEImage)
@@ -293,9 +302,9 @@ 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_FIELD(ArrayListBlock, /*pointer*/, Next, cdac_data<ArrayListBase>::Next)
+CDAC_TYPE_FIELD(ArrayListBlock, /*uint32*/, Size, cdac_data<ArrayListBase>::Size)
+CDAC_TYPE_FIELD(ArrayListBlock, /*pointer*/, ArrayStart, cdac_data<ArrayListBase>::ArrayStart)
 CDAC_TYPE_END(ArrayListBlock)
 
 // RuntimeTypeSystem
@@ -832,6 +841,7 @@ CDAC_GLOBAL_STRING(Architecture, riscv64)
 CDAC_GLOBAL_STRING(RID, RID_STRING)
 
 CDAC_GLOBAL_POINTER(AppDomain, &AppDomain::m_pTheAppDomain)
+CDAC_GLOBAL_POINTER(SystemDomain, &SystemDomain::m_pSystemDomain)
 CDAC_GLOBAL_POINTER(ThreadStore, &ThreadStore::s_pThreadStore)
 CDAC_GLOBAL_POINTER(FinalizerThread, &::g_pFinalizerThread)
 CDAC_GLOBAL_POINTER(GCThread, &::g_pSuspensionThread)

Diff for: src/coreclr/inc/arraylist.h

@@ -9,6 +9,9 @@
 #include <contract.h>
 #include <stddef.h> // offsetof
 
+// Forward Declarations
+template<typename T> struct cdac_data;
+
 //
 // ArrayList is a simple class which is used to contain a growable
 // list of pointers, stored in chunks.  Modification is by appending
@@ -53,7 +56,6 @@ class ArrayListBase
                 (*PTR_DWORD(addr + offsetof(ArrayListBlock, m_blockSize)) * sizeof(void*));
         }
 #endif
-        friend struct ::cdac_data<ArrayListBlock>;
     };
     typedef SPTR(ArrayListBlock) PTR_ArrayListBlock;
 
@@ -264,25 +266,21 @@ class ArrayListBase
         return BlockIterator((ArrayListBlock *) &m_firstBlock, m_count);
     }
 
-    friend struct ::cdac_data<ArrayListBase>;
-    friend struct ::cdac_data<ArrayListBlock>;
+    friend struct cdac_data<ArrayListBase>;
 };
 
 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
 {
 public:

Diff for: src/coreclr/vm/appdomain.hpp

@@ -964,6 +964,8 @@ class AppDomain final
         {
             return m_array.Iterate();
         }
+
+        friend struct cdac_data<AppDomain>;
     };  // class DomainAssemblyList
 
     // Conceptually a list of code:Assembly structures, protected by lock code:GetAssemblyListLock
@@ -1621,6 +1623,7 @@ template<>
 struct cdac_data<AppDomain>
 {
     static constexpr size_t RootAssembly = offsetof(AppDomain, m_pRootAssembly);
+    static constexpr size_t DomainAssemblyList = offsetof(AppDomain, m_Assemblies) + offsetof(AppDomain::DomainAssemblyList, m_array);
 };
 
 typedef DPTR(class SystemDomain) PTR_SystemDomain;
@@ -1913,9 +1916,10 @@ class SystemDomain final
 
     InlineSString<100>  m_SystemDirectory;
 
+public:
     // Global domain that every one uses
     SPTR_DECL(SystemDomain, m_pSystemDomain);
-
+private:
     LoaderAllocator * m_pDelayedUnloadListOfLoaderAllocators;
 
 #ifndef DACCESS_COMPILE

Diff for: src/coreclr/vm/assembly.hpp

@@ -546,6 +546,10 @@ struct cdac_data<Assembly>
 #ifdef FEATURE_COLLECTIBLE_TYPES
     static constexpr size_t IsCollectible = offsetof(Assembly, m_isCollectible);
 #endif
+    static constexpr size_t Module = offsetof(Assembly, m_pModule);
+    static constexpr size_t Error = offsetof(Assembly, m_pError);
+    static constexpr size_t NotifyFlags = offsetof(Assembly, m_notifyFlags);
+    static constexpr size_t Level = offsetof(Assembly, m_level);
 };
 
 #ifndef DACCESS_COMPILE

Diff for: src/coreclr/vm/loaderallocator.hpp

@@ -47,15 +47,15 @@ class CodeRangeMapRangeList : public RangeList
     VPTR_VTABLE_CLASS(CodeRangeMapRangeList, RangeList)
 
 #if defined(DACCESS_COMPILE) || !defined(TARGET_WINDOWS)
-    CodeRangeMapRangeList() : 
+    CodeRangeMapRangeList() :
         _RangeListRWLock(COOPERATIVE_OR_PREEMPTIVE, LOCK_TYPE_DEFAULT),
         _rangeListType(STUB_CODE_BLOCK_UNKNOWN),
         _id(NULL),
         _collectible(true)
     {}
 #endif
 
-    CodeRangeMapRangeList(StubCodeBlockKind rangeListType, bool collectible) : 
+    CodeRangeMapRangeList(StubCodeBlockKind rangeListType, bool collectible) :
         _RangeListRWLock(COOPERATIVE_OR_PREEMPTIVE, LOCK_TYPE_DEFAULT),
         _rangeListType(rangeListType),
         _id(NULL),
@@ -85,15 +85,15 @@ class CodeRangeMapRangeList : public RangeList
 
         _ASSERTE(id == _id || _id == NULL);
         _id = id;
-        // Grow the array first, so that a failure cannot break the 
+        // Grow the array first, so that a failure cannot break the
 
         RangeSection::RangeSectionFlags flags = RangeSection::RANGE_SECTION_RANGELIST;
         if (_collectible)
         {
             _starts.Preallocate(_starts.GetCount() + 1);
             flags = (RangeSection::RangeSectionFlags)(flags | RangeSection::RANGE_SECTION_COLLECTIBLE);
         }
-        
+
         ExecutionManager::AddCodeRange(start, end, ExecutionManager::GetEEJitManager(), flags, this);
 
         if (_collectible)
@@ -168,7 +168,7 @@ class CodeRangeMapRangeList : public RangeList
             return FALSE;
         if ((pRS->_flags & RangeSection::RANGE_SECTION_RANGELIST) == 0)
             return FALSE;
-        
+
         return (pRS->_pRangeList == this);
     }
 
@@ -262,7 +262,7 @@ class SegmentedHandleIndexStack
 public:
 
     ~SegmentedHandleIndexStack();
-    
+
     // Push the value to the stack. If the push cannot be done due to OOM, return false;
     inline bool Push(DWORD value);
 
@@ -877,8 +877,16 @@ class LoaderAllocator
     virtual void UnregisterDependentHandleToNativeObjectFromCleanup(LADependentHandleToNativeObject *dependentHandle) {};
     virtual void CleanupDependentHandlesToNativeObjects() {};
 #endif
+
+    friend struct ::cdac_data<LoaderAllocator>;
 };  // class LoaderAllocator
 
+template<>
+struct cdac_data<LoaderAllocator>
+{
+    static constexpr size_t ReferenceCount = offsetof(LoaderAllocator, m_cReferences);
+};
+
 typedef VPTR(LoaderAllocator) PTR_LoaderAllocator;
 
 extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator);

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

@@ -19,6 +19,7 @@ public ModuleHandle(TargetPointer address)
 [Flags]
 public enum ModuleFlags
 {
+    Tenured = 0x00000001,           // Set once we know for sure the Module will not be freed until the appdomain itself exits
     EditAndContinue = 0x00000008,   // Edit and Continue is enabled for this module
     ReflectionEmit = 0x00000040,    // Reflection.Emit was used to create this module
 }
@@ -32,13 +33,34 @@ public record struct ModuleLookupTables(
     TargetPointer TypeRefToMethodTable,
     TargetPointer MethodDefToILCodeVersioningState);
 
+[Flags]
+public enum AssemblyIterationFlags
+{
+    // load status flags
+    IncludeLoaded = 0x00000001, // include assemblies that are already loaded
+                                // (m_level >= code:FILE_LOAD_DELIVER_EVENTS)
+    IncludeLoading = 0x00000002, // include assemblies that are still in the process of loading
+                                 // (all m_level values)
+    IncludeAvailableToProfilers = 0x00000020, // include assemblies available to profilers
+                                              // See comment at code:DomainAssembly::IsAvailableToProfilers
+
+    // Execution / introspection flags
+    IncludeExecution = 0x00000004, // include assemblies that are loaded for execution only
+
+    IncludeFailedToLoad = 0x00000010, // include assemblies that failed to load
+
+    // Collectible assemblies flags
+    ExcludeCollectible = 0x00000040, // Exclude all collectible assemblies
+    IncludeCollected = 0x00000080, // Include all collectible assemblies that have been collected
+}
+
 public interface ILoader : IContract
 {
     static string IContract.Name => nameof(Loader);
 
     ModuleHandle GetModuleHandle(TargetPointer modulePointer) => throw new NotImplementedException();
 
-    List<TargetPointer> GetAssemblies(TargetPointer appDomain) => throw new NotImplementedException();
+    List<ModuleHandle> GetAssemblies(TargetPointer appDomain, AssemblyIterationFlags iterationFlags) => throw new NotImplementedException();
     TargetPointer GetRootAssembly() => throw new NotImplementedException();
     TargetPointer GetAssembly(ModuleHandle handle) => throw new NotImplementedException();
     TargetPointer GetPEAssembly(ModuleHandle handle) => throw new NotImplementedException();
@@ -55,6 +77,7 @@ public interface ILoader : IContract
 
     TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out TargetNUInt flags) => throw new NotImplementedException();
     bool IsCollectible(ModuleHandle handle) => throw new NotImplementedException();
+    bool IsAssemblyLoaded(ModuleHandle handle) => throw new NotImplementedException();
 }
 
 public readonly struct Loader : ILoader

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

@@ -32,6 +32,7 @@ public enum DataType
     ModuleLookupMap,
     AppDomain,
     Assembly,
+    LoaderAllocator,
     PEAssembly,
     PEImage,
     PEImageLayout,

Diff for: src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Constants.cs

@@ -9,6 +9,7 @@ public static class Globals
     {
         // See src/coreclr/debug/runtimeinfo/datadescriptor.h
         public const string AppDomain = nameof(AppDomain);
+        public const string SystemDomain = nameof(SystemDomain);
         public const string ThreadStore = nameof(ThreadStore);
         public const string FinalizerThread = nameof(FinalizerThread);
         public const string GCThread = nameof(GCThread);

Diff for: src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Loader_1.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using Microsoft.Diagnostics.DataContractReader.Data;
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
@@ -23,6 +24,71 @@ ModuleHandle ILoader.GetModuleHandle(TargetPointer modulePointer)
         return new ModuleHandle(modulePointer);
     }
 
+    List<ModuleHandle> ILoader.GetAssemblies(TargetPointer appDomain, AssemblyIterationFlags iterationFlags)
+    {
+        if (appDomain == TargetPointer.Null)
+            throw new ArgumentNullException(nameof(appDomain));
+
+        Data.AppDomain domain = _target.ProcessedData.GetOrAdd<Data.AppDomain>(appDomain);
+        ArrayListBase arrayList = _target.ProcessedData.GetOrAdd<ArrayListBase>(domain.DomainAssemblyList);
+
+        List<ModuleHandle> handles = [];
+        foreach (TargetPointer pAssembly in arrayList.Elements)
+        {
+            TargetPointer assemblyAddr = _target.ReadPointer(pAssembly);
+            Data.Assembly assembly = _target.ProcessedData.GetOrAdd<Data.Assembly>(assemblyAddr);
+
+            // following logic is based on AppDomain::AssemblyIterator::Next_Unlocked in appdomain.cpp
+
+            if (assembly.IsError && !iterationFlags.HasFlag(AssemblyIterationFlags.IncludeFailedToLoad))
+                continue; // skip assemblies with errors
+
+            if ((assembly.NotifyFlags & 0x1 /*PROFILER_NOTIFIED*/) != 0 && !iterationFlags.HasFlag(AssemblyIterationFlags.IncludeAvailableToProfilers))
+            {
+                // The assembly has reached the state at which we would notify profilers,
+                // and we're supposed to include such assemblies in the enumeration. So
+                // don't reject it (i.e., noop here, and don't bother with the rest of
+                // the load status checks). Check for this first, since
+                // IncludeAvailableToProfilers contains some loaded AND loading
+                // assemblies.
+            }
+            else if (assembly.IsLoaded)
+            {
+                if (!iterationFlags.HasFlag(AssemblyIterationFlags.IncludeLoaded))
+                    continue; // skip loaded assemblies
+            }
+            else
+            {
+                if (!iterationFlags.HasFlag(AssemblyIterationFlags.IncludeLoading))
+                    continue; // skip loading assemblies
+            }
+
+            // Next, reject assemblies whose execution status is
+            // not to be included in the enumeration
+
+            if (!iterationFlags.HasFlag(AssemblyIterationFlags.IncludeExecution))
+                continue; // skip assemblies with execution status
+
+            if (assembly.IsCollectible != 0)
+            {
+                if (iterationFlags.HasFlag(AssemblyIterationFlags.ExcludeCollectible))
+                    continue; // skip collectible assemblies
+
+                Module module = _target.ProcessedData.GetOrAdd<Data.Module>(assembly.Module);
+                if (((ModuleFlags)module.Flags).HasFlag(ModuleFlags.Tenured))
+                    continue; // skip tenured modules
+
+                LoaderAllocator loaderAllocator = _target.ProcessedData.GetOrAdd<Data.LoaderAllocator>(module.LoaderAllocator);
+                if (!loaderAllocator.IsAlive && !iterationFlags.HasFlag(AssemblyIterationFlags.IncludeCollected))
+                    continue; // skip collected assemblies
+            }
+
+            handles.Add(new(assembly.Module));
+        }
+
+        return handles;
+    }
+
     TargetPointer ILoader.GetRootAssembly()
     {
         TargetPointer appDomainPointer = _target.ReadGlobalPointer(Constants.Globals.AppDomain);
@@ -192,4 +258,11 @@ bool ILoader.IsCollectible(ModuleHandle handle)
         Data.Assembly la = _target.ProcessedData.GetOrAdd<Data.Assembly>(assembly);
         return la.IsCollectible != 0;
     }
+
+    bool ILoader.IsAssemblyLoaded(ModuleHandle handle)
+    {
+        Data.Module module = _target.ProcessedData.GetOrAdd<Data.Module>(handle.Address);
+        Data.Assembly assembly = _target.ProcessedData.GetOrAdd<Data.Assembly>(module.Assembly);
+        return assembly.IsLoaded;
+    }
 }

Diff for: src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AppDomain.cs

@@ -13,7 +13,9 @@ public AppDomain(Target target, TargetPointer address)
         Target.TypeInfo type = target.GetTypeInfo(DataType.AppDomain);
 
         RootAssembly = target.ReadPointer(address + (ulong)type.Fields[nameof(RootAssembly)].Offset);
+        DomainAssemblyList = address + (ulong)type.Fields[nameof(DomainAssemblyList)].Offset;
     }
 
     public TargetPointer RootAssembly { get; init; }
+    public TargetPointer DomainAssemblyList { get; init; }
 }