[cDAC] Implement IXCLRDataModule APIs SOS uses to read line numbers (#114491)

* Implement cDAC support for the following IXCLRDataModule APIs: GetFlags, StartEnumExtents, EnumExtents, EndEnumExtents, and Request(DACDATAMODULEPRIV_REQUEST_GET_MODULEDATA…)

Author: max-charlamb

docs/design/datacontracts/Loader.md

@@ -31,7 +31,12 @@ record struct ModuleLookupTables(
 
 ``` csharp
 ModuleHandle GetModuleHandle(TargetPointer module);
+TargetPointer GetRootAssembly();
 TargetPointer GetAssembly(ModuleHandle handle);
+TargetPointer GetPEAssembly(ModuleHandle handle);
+bool TryGetLoadedImageContents(ModuleHandle handle, out TargetPointer baseAddress, out uint size, out uint imageFlags);
+bool TryGetSymbolStream(ModuleHandle handle, out TargetPointer buffer, out uint size);
+bool IsProbeExtensionResultValid(ModuleHandle handle);
 ModuleFlags GetFlags(ModuleHandle handle);
 string GetPath(ModuleHandle handle);
 string GetFileName(ModuleHandle handle);
@@ -49,12 +54,14 @@ Data descriptors used:
 | Data Descriptor Name | Field | Meaning |
 | --- | --- | --- |
 | `Module` | `Assembly` | Assembly of the Module |
+| `Module` | `PEAssembly` | PEAssembly of the Module |
 | `Module` | `Base` | Pointer to start of PE file in memory |
 | `Module` | `Flags` | Assembly of the Module |
 | `Module` | `LoaderAllocator` | LoaderAllocator of the Module |
 | `Module` | `ThunkHeap` | Pointer to the thunk heap |
 | `Module` | `Path` | Path of the Module (UTF-16, null-terminated) |
 | `Module` | `FileName` | File name of the Module (UTF-16, null-terminated) |
+| `Module` | `GrowableSymbolStream` | Pointer to the in memory symbol stream |
 | `Module` | `FieldDefToDescMap` | Mapping table |
 | `Module` | `ManifestModuleReferencesMap` | Mapping table |
 | `Module` | `MemberRefToDescMap` | Mapping table |
@@ -64,18 +71,92 @@ Data descriptors used:
 | `ModuleLookupMap` | `TableData` | Start of the mapping table's data |
 | `ModuleLookupMap` | `SupportedFlagsMask` | Mask for flag bits on lookup map entries |
 | `ModuleLookupMap` | `Count` | Number of TargetPointer sized entries in this section of the map |
-| `ModuleLookupMap` | `Next` | Pointer to next ModuleLookupMap segment for this map
-| `Assembly` | `IsCollectible` | Flag indicating if this is module may be collected
+| `ModuleLookupMap` | `Next` | Pointer to next ModuleLookupMap segment for this map |
+| `Assembly` | `IsCollectible` | Flag indicating if this is module may be collected |
+| `PEAssembly` | `PEImage` | Pointer to the PEAssembly's PEImage |
+| `PEImage` | `LoadedImageLayout` | Pointer to the PEImage's loaded PEImageLayout |
+| `PEImage` | `ProbeExtensionResult` | PEImage's ProbeExtensionResult |
+| `ProbeExtensionResult` | `Type` | Type of ProbeExtensionResult |
+| `PEImageLayout` | `Base` | Base address of the image layout |
+| `PEImageLayout` | `Size` | Size of the image layout |
+| `PEImageLayout` | `Flags` | Flags associated with the PEImageLayout |
+| `CGrowableSymbolStream` | `Buffer` | Pointer to the raw symbol stream buffer start |
+| `CGrowableSymbolStream` | `Size` | Size of the raw symbol stream buffer |
+| `AppDomain` | `RootAssembly` | Pointer to the root assembly |
+
+Global variables used:
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+| `AppDomain` | TargetPointer | Pointer to the global AppDomain |
+
 
 ``` csharp
 ModuleHandle GetModuleHandle(TargetPointer modulePointer)
 {
     return new ModuleHandle(modulePointer);
 }
 
+TargetPointer GetRootAssembly()
+{
+    TargetPointer appDomainPointer = _target.ReadGlobalPointer(Constants.Globals.AppDomain);
+    AppDomain appDomain = // read AppDomain object starting at appDomainPointer
+    return appDomain.RootAssembly;
+}
+
 TargetPointer GetAssembly(ModuleHandle handle)
 {
-    return target.ReadPointer(handle.Address + /* Module::Assrembly offset */);
+    return target.ReadPointer(handle.Address + /* Module::Assembly offset */);
+}
+
+TargetPointer GetPEAssembly(ModuleHandle handle)
+{
+    return target.ReadPointer(handle.Address + /* Module::PEAssembly offset */);
+}
+
+bool TryGetLoadedImageContents(ModuleHandle handle, out TargetPointer baseAddress, out uint size, out uint imageFlags)
+{
+    baseAddress = TargetPointer.Null;
+    size = 0;
+    imageFlags = 0;
+
+    TargetPointer peAssembly = target.ReadPointer(handle.Address + /* Module::PEAssembly offset */);
+    if (peAssembly == 0) return false; // no loaded PEAssembly
+
+    TargetPointer peImage = target.ReadPointer(peAssembly + /* PEAssembly::PEImage offset */);
+    if(peImage == 0) return false; // no loaded PEImage
+
+    TargetPointer peImageLayout = target.ReadPointer(peImage + /* PEImage::LoadedImageLayout offset */);
+
+    baseAddress = target.ReadPointer(peImageLayout + /* PEImageLayout::Base offset */);
+    size = target.Read<uint>(peImageLayout + /* PEImageLayout::Size offset */);
+    imageFlags = target.Read<uint>(peImageLayout + /* PEImageLayout::Flags offset */);
+    return true;
+}
+
+bool TryGetSymbolStream(ModuleHandle handle, out TargetPointer buffer, out uint size)
+{
+    buffer = TargetPointer.Null;
+    size = 0;
+
+    TargetPointer growableSymbolStream = target.ReadPointer(handle.Address + /* Module::GrowableSymbolStream offset */);
+    if (growableSymbolStream == 0) return false; // no GrowableSymbolStream found
+
+    buffer = target.ReadPointer(growableSymbolStream + /* CGrowableSymbolStream::Buffer offset */);
+    size = target.Read<uint>(growableSymbolStream + /* CGrowableSymbolStream::Size offset */);
+    return true;
+}
+
+bool IsProbeExtensionResultValid(ModuleHandle handle)
+{
+    TargetPointer peAssembly = target.ReadPointer(handle.Address + /* Module::PEAssembly offset */);
+    if (peAssembly == 0) return false; // no loaded PEAssembly
+
+    TargetPointer peImage = target.ReadPointer(peAssembly + /* PEAssembly::PEImage offset */);
+    if(peImage == 0) return false; // no loaded PEImage
+
+    TargetPointer probeExtensionResult = target.ReadPointer(peImage + /* PEImage::ProbeExtensionResult offset */);
+    int type = target.Read<int>(probeExtensionResult + /* ProbeExtensionResult::Type offset */);
+    return type != 0; // 0 is the invalid type. See assemblyprobeextension.h for details
 }
 
 ModuleFlags GetFlags(ModuleHandle handle)

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -218,13 +218,15 @@ CDAC_TYPE_END(SyncTableEntry)
 CDAC_TYPE_BEGIN(Module)
 CDAC_TYPE_INDETERMINATE(Module)
 CDAC_TYPE_FIELD(Module, /*pointer*/, Assembly, cdac_data<Module>::Assembly)
+CDAC_TYPE_FIELD(Module, /*pointer*/, PEAssembly, cdac_data<Module>::PEAssembly)
 CDAC_TYPE_FIELD(Module, /*pointer*/, Base, cdac_data<Module>::Base)
 CDAC_TYPE_FIELD(Module, /*uint32*/, Flags, cdac_data<Module>::Flags)
 CDAC_TYPE_FIELD(Module, /*pointer*/, LoaderAllocator, cdac_data<Module>::LoaderAllocator)
 CDAC_TYPE_FIELD(Module, /*pointer*/, DynamicMetadata, cdac_data<Module>::DynamicMetadata)
 CDAC_TYPE_FIELD(Module, /*pointer*/, Path, cdac_data<Module>::Path)
 CDAC_TYPE_FIELD(Module, /*pointer*/, FileName, cdac_data<Module>::FileName)
 CDAC_TYPE_FIELD(Module, /*pointer*/, ReadyToRunInfo, cdac_data<Module>::ReadyToRunInfo)
+CDAC_TYPE_FIELD(Module, /*pointer*/, GrowableSymbolStream, cdac_data<Module>::GrowableSymbolStream)
 
 CDAC_TYPE_FIELD(Module, /*pointer*/, FieldDefToDescMap, cdac_data<Module>::FieldDefToDescMap)
 CDAC_TYPE_FIELD(Module, /*pointer*/, ManifestModuleReferencesMap, cdac_data<Module>::ManifestModuleReferencesMap)
@@ -249,6 +251,39 @@ CDAC_TYPE_FIELD(Assembly, /*uint8*/, IsCollectible, cdac_data<Assembly>::IsColle
 #endif
 CDAC_TYPE_END(Assembly)
 
+CDAC_TYPE_BEGIN(PEAssembly)
+CDAC_TYPE_INDETERMINATE(PEAssembly)
+CDAC_TYPE_FIELD(PEAssembly, /*pointer*/, PEImage, cdac_data<PEAssembly>::PEImage)
+CDAC_TYPE_END(PEAssembly)
+
+CDAC_TYPE_BEGIN(PEImage)
+CDAC_TYPE_INDETERMINATE(PEImage)
+CDAC_TYPE_FIELD(PEImage, /*pointer*/, LoadedImageLayout, cdac_data<PEImage>::LoadedImageLayout)
+CDAC_TYPE_FIELD(PEImage, /*ProbeExtensionResult*/, ProbeExtensionResult, cdac_data<PEImage>::ProbeExtensionResult)
+CDAC_TYPE_END(PEImage)
+
+CDAC_TYPE_BEGIN(PEImageLayout)
+CDAC_TYPE_FIELD(PEImageLayout, /*pointer*/, Base, cdac_data<PEImageLayout>::Base)
+CDAC_TYPE_FIELD(PEImageLayout, /*uint32*/, Size, cdac_data<PEImageLayout>::Size)
+CDAC_TYPE_FIELD(PEImageLayout, /*uint32*/, Flags, cdac_data<PEImageLayout>::Flags)
+CDAC_TYPE_END(PEImageLayout)
+
+CDAC_TYPE_BEGIN(CGrowableSymbolStream)
+CDAC_TYPE_INDETERMINATE(CGrowableSymbolStream)
+CDAC_TYPE_FIELD(CGrowableSymbolStream, /*pointer*/, Buffer, cdac_data<CGrowableStream>::Buffer)
+CDAC_TYPE_FIELD(CGrowableSymbolStream, /*uint32*/, Size, cdac_data<CGrowableStream>::Size)
+CDAC_TYPE_END(CGrowableSymbolStream)
+
+CDAC_TYPE_BEGIN(ProbeExtensionResult)
+CDAC_TYPE_INDETERMINATE(ProbeExtensionResult)
+CDAC_TYPE_FIELD(ProbeExtensionResult, /*int32*/, Type, offsetof(ProbeExtensionResult, Type))
+CDAC_TYPE_END(ProbeExtensionResult)
+
+CDAC_TYPE_BEGIN(AppDomain)
+CDAC_TYPE_INDETERMINATE(AppDomain)
+CDAC_TYPE_FIELD(AppDomain, /*pointer*/, RootAssembly, cdac_data<AppDomain>::RootAssembly)
+CDAC_TYPE_END(AppDomain)
+
 // RuntimeTypeSystem
 
 CDAC_TYPE_BEGIN(MethodTable)

src/coreclr/inc/assemblyprobeextension.h

@@ -10,7 +10,7 @@
 class ProbeExtensionResult
 {
 public:
-    enum class Type
+    enum class Type : int32_t
     {
         Invalid,
         Bundle,

src/coreclr/inc/pedecoder.h

@@ -52,6 +52,8 @@ typedef DPTR(IMAGE_COR20_HEADER)    PTR_IMAGE_COR20_HEADER;
 
 class Module;
 
+template<typename T> struct cdac_data;
+
 // --------------------------------------------------------------------------------
 // RVA definition
 // --------------------------------------------------------------------------------
@@ -405,6 +407,9 @@ class PEDecoder
     PTR_IMAGE_NT_HEADERS   m_pNTHeaders;
     PTR_IMAGE_COR20_HEADER m_pCorHeader;
     PTR_READYTORUN_HEADER  m_pReadyToRunHeader;
+
+    // to allow inherited classes to access, friend to all specializations of cdac_data
+    template<typename U> friend struct ::cdac_data;
 };
 
 //

src/coreclr/inc/stgpool.h

@@ -49,6 +49,8 @@ class StgStringPool;
 class StgBlobPool;
 class StgCodePool;
 
+template<typename T> struct cdac_data;
+
 //  Perform binary search on index table.
 //
 class RIDBinarySearch : public CBinarySearch<UINT32>
@@ -1500,6 +1502,15 @@ class CGrowableStream : public IStream
          IStream ** ppstm);
 
 #endif // DACCESS_COMPILE
+
+    friend struct cdac_data<CGrowableStream>;
 }; // class CGrowableStream
 
+template<>
+struct cdac_data<CGrowableStream>
+{
+    static constexpr size_t Buffer = offsetof(CGrowableStream, m_swBuffer);
+    static constexpr size_t Size = offsetof(CGrowableStream, m_dwBufferSize);
+};
+
 #endif // __StgPool_h__

src/coreclr/vm/appdomain.hpp

@@ -1613,8 +1613,16 @@ class AppDomain final
     TieredCompilationManager m_tieredCompilationManager;
 
 #endif
+
+    friend struct cdac_data<AppDomain>;
 };  // class AppDomain
 
+template<>
+struct cdac_data<AppDomain>
+{
+    static constexpr size_t RootAssembly = offsetof(AppDomain, m_pRootAssembly);
+};
+
 typedef DPTR(class SystemDomain) PTR_SystemDomain;
 
 class SystemDomain final

src/coreclr/vm/ceeload.h

@@ -1669,13 +1669,15 @@ template<>
 struct cdac_data<Module>
 {
     static constexpr size_t Assembly = offsetof(Module, m_pAssembly);
+    static constexpr size_t PEAssembly = offsetof(Module, m_pPEAssembly);
     static constexpr size_t Base = offsetof(Module, m_baseAddress);
     static constexpr size_t Flags = offsetof(Module, m_dwTransientFlags);
     static constexpr size_t LoaderAllocator = offsetof(Module, m_loaderAllocator);
     static constexpr size_t DynamicMetadata = offsetof(Module, m_pDynamicMetadata);
     static constexpr size_t Path = offsetof(Module, m_path);
     static constexpr size_t FileName = offsetof(Module, m_fileName);
     static constexpr size_t ReadyToRunInfo = offsetof(Module, m_pReadyToRunInfo);
+    static constexpr size_t GrowableSymbolStream = offsetof(Module, m_pIStreamSym);
 
     // Lookup map pointers
     static constexpr size_t FieldDefToDescMap = offsetof(Module, m_FieldDefToDescMap);

src/coreclr/vm/peassembly.h

@@ -434,8 +434,16 @@ class PEAssembly final
     // assembly that created the dynamic assembly. If the creator assembly is dynamic itself, then its fallback
     // load context would be propagated to the assembly being dynamically generated.
     PTR_AssemblyBinder m_pFallbackBinder;
+
+    friend struct cdac_data<PEAssembly>;
 };  // class PEAssembly
 
+template<>
+struct cdac_data<PEAssembly>
+{
+    static constexpr size_t PEImage = offsetof(PEAssembly, m_PEImage);
+};
+
 typedef ReleaseHolder<PEAssembly> PEAssemblyHolder;
 
 #endif  // PEASSEMBLY_H_

src/coreclr/vm/peimage.h

@@ -19,6 +19,7 @@
 #include "sstring.h"
 #include "holder.h"
 #include <assemblyprobeextension.h>
+#include "cdacdata.h"
 
 class SimpleRWLock;
 // --------------------------------------------------------------------------------
@@ -316,6 +317,16 @@ class PEImage final
     SimpleRWLock *m_pLayoutLock;
     PTR_PEImageLayout m_pLayouts[IMAGE_COUNT];
     IMDInternalImport* m_pMDImport;
+
+    friend struct cdac_data<PEImage>;
+};
+
+template<>
+struct cdac_data<PEImage>
+{
+    // The loaded PEImageLayout is m_pLayouts[IMAGE_LOADED]
+    static constexpr size_t LoadedImageLayout = offsetof(PEImage, m_pLayouts) + sizeof(PTR_PEImageLayout);
+    static constexpr size_t ProbeExtensionResult = offsetof(PEImage, m_probeExtensionResult);
 };
 
 FORCEINLINE void PEImageRelease(PEImage *i)

src/coreclr/vm/peimagelayout.h

@@ -72,6 +72,16 @@ class PEImageLayout : public PEDecoder
     Volatile<LONG> m_refCount;
 public:
     PEImage* m_pOwner;
+
+    friend struct cdac_data<PEImageLayout>;
+};
+
+template<>
+struct cdac_data<PEImageLayout>
+{
+    static constexpr size_t Base = offsetof(PEImageLayout, m_base);
+    static constexpr size_t Size = offsetof(PEImageLayout, m_size);
+    static constexpr size_t Flags = offsetof(PEImageLayout, m_flags);
 };
 
 typedef ReleaseHolder<PEImageLayout> PEImageLayoutHolder;

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

@@ -38,7 +38,12 @@ public interface ILoader : IContract
 
     ModuleHandle GetModuleHandle(TargetPointer modulePointer) => throw new NotImplementedException();
 
+    TargetPointer GetRootAssembly() => throw new NotImplementedException();
     TargetPointer GetAssembly(ModuleHandle handle) => throw new NotImplementedException();
+    TargetPointer GetPEAssembly(ModuleHandle handle) => throw new NotImplementedException();
+    bool TryGetLoadedImageContents(ModuleHandle handle, out TargetPointer baseAddress, out uint size, out uint imageFlags) => throw new NotImplementedException();
+    bool TryGetSymbolStream(ModuleHandle handle, out TargetPointer buffer, out uint size) => throw new NotImplementedException();
+    bool IsProbeExtensionResultValid(ModuleHandle handle) => throw new NotImplementedException();
     ModuleFlags GetFlags(ModuleHandle handle) => throw new NotImplementedException();
     string GetPath(ModuleHandle handle) => throw new NotImplementedException();
     string GetFileName(ModuleHandle handle) => throw new NotImplementedException();

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

@@ -30,7 +30,13 @@ public enum DataType
     RuntimeThreadLocals,
     Module,
     ModuleLookupMap,
+    AppDomain,
     Assembly,
+    PEAssembly,
+    PEImage,
+    PEImageLayout,
+    CGrowableSymbolStream,
+    ProbeExtensionResult,
     MethodTable,
     EEClass,
     ArrayClass,