adds DAC like entrypoint, Platform descriptor WIP

Author: Max Charlamb

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader/ContractDescriptorTarget.cs

@@ -44,25 +44,22 @@ private readonly struct Configuration
 
     public delegate int ReadFromTargetDelegate(ulong address, Span<byte> bufferToFill);
     public delegate int GetTargetThreadContextDelegate(uint threadId, uint contextFlags, uint contextSize, Span<byte> bufferToFill);
-    public delegate int GetTargetPlatformDelegate(out int platform);
 
     /// <summary>
     /// Create a new target instance from a contract descriptor embedded in the target memory.
     /// </summary>
     /// <param name="contractDescriptor">The offset of the contract descriptor in the target memory</param>
     /// <param name="readFromTarget">A callback to read memory blocks at a given address from the target</param>
     /// <param name="getThreadContext">A callback to fetch a thread's context</param>
-    /// <param name="getTargetPlatform">A callback to fetch the target's platform</param>
     /// <param name="target">The target object.</param>
     /// <returns>If a target instance could be created, <c>true</c>; otherwise, <c>false</c>.</returns>
     public static bool TryCreate(
         ulong contractDescriptor,
         ReadFromTargetDelegate readFromTarget,
         GetTargetThreadContextDelegate getThreadContext,
-        GetTargetPlatformDelegate getTargetPlatform,
-        out ContractDescriptorTarget? target)
+        [NotNullWhen(true)] out ContractDescriptorTarget? target)
     {
-        Reader reader = new Reader(readFromTarget, getThreadContext, getTargetPlatform);
+        Reader reader = new Reader(readFromTarget, getThreadContext);
         if (TryReadContractDescriptor(
             contractDescriptor,
             reader,
@@ -94,15 +91,14 @@ public static ContractDescriptorTarget Create(
         TargetPointer[] globalPointerValues,
         ReadFromTargetDelegate readFromTarget,
         GetTargetThreadContextDelegate getThreadContext,
-        GetTargetPlatformDelegate getTargetPlatform,
         bool isLittleEndian,
         int pointerSize)
     {
         return new ContractDescriptorTarget(
             new Configuration { IsLittleEndian = isLittleEndian, PointerSize = pointerSize },
             contractDescriptor,
             globalPointerValues,
-            new Reader(readFromTarget, getThreadContext, getTargetPlatform));
+            new Reader(readFromTarget, getThreadContext));
     }
 
     private ContractDescriptorTarget(Configuration config, ContractDescriptorParser.ContractDescriptor descriptor, TargetPointer[] pointerData, Reader reader)
@@ -267,8 +263,7 @@ public override CorDebugPlatform Platform
     {
         get
         {
-            _reader.GetTargetPlatform(out int platform);
-            return (CorDebugPlatform)platform;
+            return CorDebugPlatform.CORDB_PLATFORM_WINDOWS_AMD64;
         }
     }
 
@@ -594,8 +589,7 @@ public void Clear()
 
     private readonly struct Reader(
         ReadFromTargetDelegate readFromTarget,
-        GetTargetThreadContextDelegate getThreadContext,
-        GetTargetPlatformDelegate getTargetPlatform)
+        GetTargetThreadContextDelegate getThreadContext)
     {
         public int ReadFromTarget(ulong address, Span<byte> buffer)
         {
@@ -605,11 +599,6 @@ public int ReadFromTarget(ulong address, Span<byte> buffer)
         public int ReadFromTarget(ulong address, byte* buffer, uint bytesToRead)
             => readFromTarget(address, new Span<byte>(buffer, checked((int)bytesToRead)));
 
-        public int GetTargetPlatform(out int platform)
-        {
-            return getTargetPlatform(out platform);
-        }
-
         public int GetThreadContext(uint threadId, uint contextFlags, uint contextSize, Span<byte> buffer)
         {
             return getThreadContext(threadId, contextFlags, contextSize, buffer);

src/native/managed/cdacreader/src/Entrypoints.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
+using Microsoft.Diagnostics.DataContractReader.Legacy;
 
 namespace Microsoft.Diagnostics.DataContractReader;
 
@@ -37,13 +38,6 @@ private static unsafe int Init(
                     return readThreadContext(threadId, contextFlags, contextSize, bufferPtr, readContext);
                 }
             },
-            (out int platform) =>
-            {
-                fixed (int* platformPtr = &platform)
-                {
-                    return getPlatform(platformPtr, readContext);
-                }
-            },
             out ContractDescriptorTarget? target))
             return -1;
 
@@ -83,4 +77,56 @@ private static unsafe int CreateSosInterface(IntPtr handle, IntPtr legacyImplPtr
         *obj = ptr;
         return 0;
     }
+
+    [UnmanagedCallersOnly(EntryPoint = "CLRDataCreateInstance")]
+    private static unsafe int CLRDataCreateInstance(Guid* pIID, IntPtr /*ICLRDataTarget*/ pLegacyTarget, void** iface)
+    {
+        if (pLegacyTarget == IntPtr.Zero || iface == null)
+            return HResults.E_INVALIDARG;
+
+        *iface = null;
+
+        ComWrappers cw = new StrategyBasedComWrappers();
+        object obj = cw.GetOrCreateObjectForComInstance(pLegacyTarget, CreateObjectFlags.None);
+        ICLRDataTarget dataTarget = obj as ICLRDataTarget ?? throw new ArgumentException($"pLegacyTarget does not implement ${nameof(ICLRDataTarget)}", nameof(pLegacyTarget));
+        ICLRContractLocator contractLocator = obj as ICLRContractLocator ?? throw new ArgumentException($"pLegacyTarget does not implement ${nameof(ICLRContractLocator)}", nameof(pLegacyTarget));
+
+        ulong contractAddress;
+        if (contractLocator.GetContractDescriptor(&contractAddress) != 0)
+        {
+            throw new InvalidOperationException("Unable to retrieve contract address from ICLRContractLocator");
+        }
+
+        if (!ContractDescriptorTarget.TryCreate(
+            contractAddress,
+            (address, buffer) =>
+            {
+                fixed (byte* bufferPtr = buffer)
+                {
+                    uint bytesRead;
+                    return dataTarget.ReadVirtual(address, bufferPtr, (uint)buffer.Length, &bytesRead);
+                }
+            },
+            (threadId, contextFlags, contextSize, bufferToFill) =>
+            {
+                fixed (byte* bufferPtr = bufferToFill)
+                {
+                    return dataTarget.GetThreadContext(threadId, contextFlags, contextSize, bufferPtr);
+                }
+            },
+            out ContractDescriptorTarget? target))
+        {
+            return -1;
+        }
+
+        Legacy.SOSDacImpl impl = new(target, null);
+        nint ccw = cw.GetOrCreateComInterfaceForObject(impl, CreateComInterfaceFlags.None);
+        Marshal.QueryInterface(ccw, *pIID, out nint ptrToIface);
+        *iface = (void*)ptrToIface;
+
+        // Decrement reference count on ccw because QI increments it
+        Marshal.Release(ccw);
+
+        return 0;
+    }
 }

src/native/managed/cdacreader/src/Legacy/ICLRData.cs

@@ -17,3 +17,49 @@ internal unsafe partial interface ICLRDataEnumMemoryRegions
     [PreserveSig]
     int EnumMemoryRegions(/*ICLRDataEnumMemoryRegionsCallback*/ void* callback, uint miniDumpFlags, /*CLRDataEnumMemoryFlags*/ int clrFlags);
 }
+
+[GeneratedComInterface]
+[Guid("3e11ccee-d08b-43e5-af01-32717a64da03")]
+internal unsafe partial interface ICLRDataTarget
+{
+    [PreserveSig]
+    int GetMachineType(uint* machineType);
+
+    [PreserveSig]
+    int GetPointerSize(uint* pointerSize);
+
+    [PreserveSig]
+    int GetImageBase([MarshalAs(UnmanagedType.LPWStr)] string imagePath, ulong* baseAddress);
+
+    [PreserveSig]
+    int ReadVirtual(ulong address, byte* buffer, uint bytesRequested, uint* bytesRead);
+
+    [PreserveSig]
+    int WriteVirtual(ulong address, byte* buffer, uint bytesRequested, uint* bytesWritten);
+
+    [PreserveSig]
+    int GetTLSValue(uint threadID, uint index, ulong* value);
+
+    [PreserveSig]
+    int SetTLSValue(uint threadID, uint index, ulong value);
+
+    [PreserveSig]
+    int GetCurrentThreadID(uint* threadID);
+
+    [PreserveSig]
+    int GetThreadContext(uint threadID, uint contextFlags, uint contextSize, byte* context);
+
+    [PreserveSig]
+    int SetThreadContext(uint threadID, uint contextSize, byte* context);
+
+    [PreserveSig]
+    int Request(uint reqCode, uint inBufferSize, byte* inBuffer, uint outBufferSize, byte* outBuffer);
+}
+
+[GeneratedComInterface]
+[Guid("17d5b8c6-34a9-407f-af4f-a930201d4e02")]
+internal unsafe partial interface ICLRContractLocator
+{
+    [PreserveSig]
+    int GetContractDescriptor(ulong* contractAddress);
+}