Adding GetAppDomainData cDAC API

docs/design/datacontracts/Loader.md

@@ -87,7 +87,6 @@ bool IsAssemblyLoaded(ModuleHandle handle);
 | `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 |
@@ -133,6 +132,7 @@ bool IsAssemblyLoaded(ModuleHandle handle);
 | Global Name | Type | Purpose |
 | --- | --- | --- |
 | `AppDomain` | TargetPointer | Pointer to the global AppDomain |
+| `SystemDomain` | TargetPointer | Pointer to the global SystemDomain |
 
 
 ### Contract Constants:

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -968,7 +968,6 @@ CDAC_GLOBAL(ObjectHeaderSize, uint64, OBJHEADER_SIZE)
 CDAC_GLOBAL(SyncBlockValueToObjectOffset, uint16, OBJHEADER_SIZE - cdac_data<ObjHeader>::SyncBlockValue)
 CDAC_GLOBAL(StubCodeBlockLast, uint8, STUB_CODE_BLOCK_LAST)
 CDAC_GLOBAL(DefaultADID, uint32, DefaultADID)
-CDAC_GLOBAL(StageOpen, uint32, DacpAppDomainDataStage::STAGE_OPEN)
 CDAC_GLOBAL_POINTER(ArrayBoundsZero, cdac_data<ArrayBase>::ArrayBoundsZero)
 CDAC_GLOBAL_POINTER(ExceptionMethodTable, &::g_pExceptionClass)
 CDAC_GLOBAL_POINTER(FreeObjectMethodTable, &::g_pFreeObjectMethodTable)

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

@@ -61,6 +61,7 @@ public enum AssemblyIterationFlags
     ExcludeCollectible = 0x00000040, // Exclude all collectible assemblies
     IncludeCollected = 0x00000080, // Include all collectible assemblies that have been collected
 }
+
 public record struct ModuleLookupTables(
     TargetPointer FieldDefToDesc,
     TargetPointer ManifestModuleReferences,

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

@@ -54,7 +54,6 @@ public static class Globals
         public const string ExecutionManagerCodeRangeMapAddress = nameof(ExecutionManagerCodeRangeMapAddress);
         public const string StubCodeBlockLast = nameof(StubCodeBlockLast);
         public const string DefaultADID = nameof(DefaultADID);
-        public const string StageOpen = nameof(StageOpen);
         public const string PlatformMetadata = nameof(PlatformMetadata);
         public const string ProfilerControlBlock = nameof(ProfilerControlBlock);
 

src/native/managed/cdac/mscordaccore_universal/Legacy/ISOSDacInterface.cs

@@ -36,7 +36,7 @@ internal struct DacpAppDomainData
     public ClrDataAddress DomainLocalBlock;
     public ClrDataAddress pDomainLocalModules;
     // The creation sequence number of this app domain (starting from 1)
-    public int dwId;
+    public uint dwId;
     public int AssemblyCount;
     public int FailedAssemblyCount;
     public uint appDomainStage;
@@ -125,6 +125,23 @@ internal enum DacpObjectType
     OBJ_OTHER
 };
 
+internal enum DacpAppDomainDataStage
+{
+    STAGE_CREATING,
+    STAGE_READYFORMANAGEDCODE,
+    STAGE_ACTIVE,
+    STAGE_OPEN,
+    STAGE_UNLOAD_REQUESTED,
+    STAGE_EXITING,
+    STAGE_EXITED,
+    STAGE_FINALIZING,
+    STAGE_FINALIZED,
+    STAGE_HANDLETABLE_NOACCESS,
+    STAGE_CLEARED,
+    STAGE_COLLECTED,
+    STAGE_CLOSED
+};
+
 internal struct DacpObjectData
 {
     public ClrDataAddress MethodTable;
@@ -218,7 +235,7 @@ internal unsafe partial interface ISOSDacInterface
     [PreserveSig]
     int GetAppDomainList(uint count, [In, Out, MarshalUsing(CountElementName = nameof(count))] ClrDataAddress[] values, uint* pNeeded);
     [PreserveSig]
-    int GetAppDomainData(ClrDataAddress addr, /*struct DacpAppDomainData*/ void* data);
+    int GetAppDomainData(ClrDataAddress addr, DacpAppDomainData* data);
     [PreserveSig]
     int GetAppDomainName(ClrDataAddress addr, uint count, char* name, uint* pNeeded);
     [PreserveSig]

src/native/managed/cdac/mscordaccore_universal/Legacy/SOSDacImpl.cs

@@ -110,10 +110,9 @@ int ISOSDacInterface.GetAppDomainConfigFile(ClrDataAddress appDomain, int count,
 
         return hr;
     }
-    int ISOSDacInterface.GetAppDomainData(ClrDataAddress addr, void* data)
+    int ISOSDacInterface.GetAppDomainData(ClrDataAddress addr, DacpAppDomainData* data)
     {
         int hr = HResults.S_OK;
-        DacpAppDomainData* dataPtr = (DacpAppDomainData*)data;
         try
         {
             if (addr == 0)
@@ -122,21 +121,20 @@ int ISOSDacInterface.GetAppDomainData(ClrDataAddress addr, void* data)
             }
             else
             {
-                NativeMemory.Clear(dataPtr, (nuint)sizeof(DacpAppDomainData));
-                dataPtr->AppDomainPtr = addr;
-                uint StageOpen = _target.ReadGlobal<uint>(Constants.Globals.StageOpen);
+                NativeMemory.Clear(data, (nuint)sizeof(DacpAppDomainData));
+                data->AppDomainPtr = addr;
                 TargetPointer systemDomainPointer = _target.ReadGlobalPointer(Constants.Globals.SystemDomain);
                 ClrDataAddress systemDomain = _target.ReadPointer(systemDomainPointer).ToClrDataAddress(_target);
                 Contracts.ILoader loader = _target.Contracts.Loader;
                 TargetPointer globalLoaderAllocator = loader.GetGlobalLoaderAllocator();
-                dataPtr->pHighFrequencyHeap = loader.GetHighFrequencyHeap(globalLoaderAllocator).ToClrDataAddress(_target);
-                dataPtr->pLowFrequencyHeap = loader.GetLowFrequencyHeap(globalLoaderAllocator).ToClrDataAddress(_target);
-                dataPtr->pStubHeap = loader.GetStubHeap(globalLoaderAllocator).ToClrDataAddress(_target);
-                dataPtr->appDomainStage = StageOpen;
+                data->pHighFrequencyHeap = loader.GetHighFrequencyHeap(globalLoaderAllocator).ToClrDataAddress(_target);
+                data->pLowFrequencyHeap = loader.GetLowFrequencyHeap(globalLoaderAllocator).ToClrDataAddress(_target);
+                data->pStubHeap = loader.GetStubHeap(globalLoaderAllocator).ToClrDataAddress(_target);
+                data->appDomainStage = (uint)DacpAppDomainDataStage.STAGE_OPEN;
                 if (addr != systemDomain)
                 {
                     TargetPointer pAppDomain = addr.ToTargetPointer(_target);
-                    dataPtr->dwId = (int)_target.ReadGlobal<uint>(Constants.Globals.DefaultADID);
+                    data->dwId = _target.ReadGlobal<uint>(Constants.Globals.DefaultADID);
 
                     List<Contracts.ModuleHandle> modules = loader.GetModuleHandles(
                         pAppDomain,
@@ -149,14 +147,14 @@ int ISOSDacInterface.GetAppDomainData(ClrDataAddress addr, void* data)
                         Contracts.ModuleHandle module = modules[i];
                         if (loader.IsAssemblyLoaded(module))
                         {
-                            dataPtr->AssemblyCount++;
+                            data->AssemblyCount++;
                         }
                     }
 
                     List<Contracts.ModuleHandle> failedModules = loader.GetModuleHandles(
                         pAppDomain,
                         AssemblyIterationFlags.IncludeFailedToLoad).ToList();
-                    dataPtr->FailedAssemblyCount = failedModules.Count;
+                    data->FailedAssemblyCount = failedModules.Count;
                 }
             }
         }
@@ -172,16 +170,16 @@ int ISOSDacInterface.GetAppDomainData(ClrDataAddress addr, void* data)
             Debug.Assert(hrLocal == hr, $"cDAC: {hr:x}, DAC: {hrLocal:x}");
             if (hr == HResults.S_OK)
             {
-                Debug.Assert(dataPtr->AppDomainPtr == dataLocal.AppDomainPtr);
-                Debug.Assert(dataPtr->pHighFrequencyHeap == dataLocal.pHighFrequencyHeap);
-                Debug.Assert(dataPtr->pLowFrequencyHeap == dataLocal.pLowFrequencyHeap);
-                Debug.Assert(dataPtr->pStubHeap == dataLocal.pStubHeap);
-                Debug.Assert(dataPtr->DomainLocalBlock == dataLocal.DomainLocalBlock);
-                Debug.Assert(dataPtr->pDomainLocalModules == dataLocal.pDomainLocalModules);
-                Debug.Assert(dataPtr->dwId == dataLocal.dwId);
-                Debug.Assert(dataPtr->appDomainStage == dataLocal.appDomainStage);
-                Debug.Assert(dataPtr->AssemblyCount == dataLocal.AssemblyCount);
-                Debug.Assert(dataPtr->FailedAssemblyCount == dataLocal.FailedAssemblyCount);
+                Debug.Assert(data->AppDomainPtr == dataLocal.AppDomainPtr);
+                Debug.Assert(data->pHighFrequencyHeap == dataLocal.pHighFrequencyHeap);
+                Debug.Assert(data->pLowFrequencyHeap == dataLocal.pLowFrequencyHeap);
+                Debug.Assert(data->pStubHeap == dataLocal.pStubHeap);
+                Debug.Assert(data->DomainLocalBlock == dataLocal.DomainLocalBlock);
+                Debug.Assert(data->pDomainLocalModules == dataLocal.pDomainLocalModules);
+                Debug.Assert(data->dwId == dataLocal.dwId);
+                Debug.Assert(data->appDomainStage == dataLocal.appDomainStage);
+                Debug.Assert(data->AssemblyCount == dataLocal.AssemblyCount);
+                Debug.Assert(data->FailedAssemblyCount == dataLocal.FailedAssemblyCount);
             }
         }
 #endif