convert to use IRuntimeInfo to fetch platform

Author: Max Charlamb

src/coreclr/debug/daccess/cdac.cpp

@@ -52,16 +52,6 @@ namespace
 
         return S_OK;
     }
-
-    int GetPlatform(uint32_t* platform, void* context)
-    {
-        ICorDebugDataTarget* target = reinterpret_cast<ICorDebugDataTarget*>(context);
-        HRESULT hr = target->GetPlatform((CorDebugPlatform*)platform);
-        if (FAILED(hr))
-            return hr;
-
-        return S_OK;
-    }
 }
 
 CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown* legacyImpl)
@@ -74,7 +64,7 @@ CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown
     _ASSERTE(init != nullptr);
 
     intptr_t handle;
-    if (init(descriptorAddr, &ReadFromTargetCallback, &ReadThreadContext, &GetPlatform, target, &handle) != 0)
+    if (init(descriptorAddr, &ReadFromTargetCallback, &ReadThreadContext, target, &handle) != 0)
     {
         ::FreeLibrary(cdacLib);
         return {};

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

@@ -18,27 +18,6 @@ namespace Microsoft.Diagnostics.DataContractReader;
 /// </remarks>
 public abstract class Target
 {
-    /// <summary>
-    /// CorDebugPlatform represents the platform of the target.
-    /// </summary>
-    public enum CorDebugPlatform : int
-    {
-        CORDB_PLATFORM_WINDOWS_X86 = 0,
-        CORDB_PLATFORM_WINDOWS_AMD64 = 1,
-        CORDB_PLATFORM_WINDOWS_IA64 = 2,
-        CORDB_PLATFORM_MAC_PPC = 3,
-        CORDB_PLATFORM_MAC_X86 = 4,
-        CORDB_PLATFORM_WINDOWS_ARM = 5,
-        CORDB_PLATFORM_MAC_AMD64 = 6,
-        CORDB_PLATFORM_WINDOWS_ARM64 = 7,
-        CORDB_PLATFORM_POSIX_AMD64 = 8,
-        CORDB_PLATFORM_POSIX_X86 = 9,
-        CORDB_PLATFORM_POSIX_ARM = 10,
-        CORDB_PLATFORM_POSIX_ARM64 = 11,
-        CORDB_PLATFORM_POSIX_LOONGARCH64 = 12,
-        CORDB_PLATFORM_POSIX_RISCV64 = 13,
-    }
-
     /// <summary>
     /// Pointer size of the target
     /// </summary>
@@ -48,11 +27,6 @@ public enum CorDebugPlatform : int
     /// </summary>
     public abstract bool IsLittleEndian { get; }
 
-    /// <summary>
-    /// Platform of the target
-    /// </summary>
-    public abstract CorDebugPlatform Platform { get; }
-
     /// <summary>
     /// Fills a buffer with the context of the given thread
     /// </summary>

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/Context/IPlatformAgnosticContext.cs

@@ -25,17 +25,13 @@ public interface IPlatformAgnosticContext
 
     public static IPlatformAgnosticContext GetContextForPlatform(Target target)
     {
-        switch (target.Platform)
+        IRuntimeInfo runtimeInfo = target.Contracts.RuntimeInfo;
+        return runtimeInfo.GetTargetArchitecture() switch
         {
-            case Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_AMD64:
-            case Target.CorDebugPlatform.CORDB_PLATFORM_POSIX_AMD64:
-            case Target.CorDebugPlatform.CORDB_PLATFORM_MAC_AMD64:
-                return new ContextHolder<AMD64Context>();
-            case Target.CorDebugPlatform.CORDB_PLATFORM_POSIX_ARM64:
-            case Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_ARM64:
-                return new ContextHolder<ARM64Context>();
-            default:
-                throw new InvalidOperationException($"Unsupported platform {target.Platform}");
-        }
+            RuntimeInfoArchitecture.Amd64 => new ContextHolder<AMD64Context>(),
+            RuntimeInfoArchitecture.Arm64 => new ContextHolder<ARM64Context>(),
+            RuntimeInfoArchitecture.Unknown => throw new InvalidOperationException($"Processor architecture is required for creating a platform specific context and is not provided by the target"),
+            _ => throw new InvalidOperationException($"Unsupported architecture {runtimeInfo.GetTargetArchitecture()}"),
+        };
     }
 }

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,
         [NotNullWhen(true)] out ContractDescriptorTarget? target)
     {
-        Reader reader = new Reader(readFromTarget, getThreadContext, getTargetPlatform);
+        Reader reader = new Reader(readFromTarget, getThreadContext);
         if (TryReadContractDescriptor(
             contractDescriptor,
             reader,
@@ -85,7 +82,6 @@ public static bool TryCreate(
     /// <param name="globalPointerValues">The values for any global pointers specified in the contract descriptor.</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="isLittleEndian">Whether the target is little-endian</param>
     /// <param name="pointerSize">The size of a pointer in bytes in the target process.</param>
     /// <returns>The target object.</returns>
@@ -94,15 +90,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)
@@ -263,14 +258,6 @@ private static DataType GetDataType(string type)
 
     public override int PointerSize => _config.PointerSize;
     public override bool IsLittleEndian => _config.IsLittleEndian;
-    public override CorDebugPlatform Platform
-    {
-        get
-        {
-            _reader.GetTargetPlatform(out int platform);
-            return (CorDebugPlatform)platform;
-        }
-    }
 
     public override bool TryGetThreadContext(ulong threadId, uint contextFlags, Span<byte> buffer)
     {
@@ -610,8 +597,7 @@ public void Clear()
 
     private readonly struct Reader(
         ReadFromTargetDelegate readFromTarget,
-        GetTargetThreadContextDelegate getThreadContext,
-        GetTargetPlatformDelegate getTargetPlatform)
+        GetTargetThreadContextDelegate getThreadContext)
     {
         public int ReadFromTarget(ulong address, Span<byte> buffer)
         {
@@ -621,11 +607,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/inc/cdac_reader.h

@@ -13,14 +13,12 @@ extern "C"
 //   descriptor: the address of the descriptor in the target process
 //   read_from_target: a callback that reads memory from the target process
 //   read_thread_context: a callback that reads the context of a thread in the target process
-//   get_platform: a callback that reads the platform of the target process
 //   read_context: a context pointer that will be passed to callbacks
 //   handle: returned opaque the handle to the reader. This should be passed to other functions in this API.
 int cdac_reader_init(
     uint64_t descriptor,
     int(*read_from_target)(uint64_t, uint8_t*, uint32_t, void*),
     int(*read_thread_context)(uint32_t, uint32_t, uint32_t, uint8_t*, void*),
-    int(*get_platform)(uint32_t*, void*),
     void* read_context,
     /*out*/ intptr_t* handle);
 

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

@@ -17,7 +17,6 @@ private static unsafe int Init(
         ulong descriptor,
         delegate* unmanaged<ulong, byte*, uint, void*, int> readFromTarget,
         delegate* unmanaged<uint, uint, uint, byte*, void*, int> readThreadContext,
-        delegate* unmanaged<int*, void*, int> getPlatform,
         void* readContext,
         IntPtr* handle)
     {
@@ -38,13 +37,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;
 
@@ -95,6 +87,7 @@ private static unsafe int CLRDataCreateInstance(Guid* pIID, IntPtr /*ICLRDataTar
 
         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));
 
@@ -121,30 +114,6 @@ private static unsafe int CLRDataCreateInstance(Guid* pIID, IntPtr /*ICLRDataTar
                     return dataTarget.GetThreadContext(threadId, contextFlags, contextSize, bufferPtr);
                 }
             },
-            (out platform) =>
-            {
-                platform = 0;
-                uint machineType;
-                int hr = dataTarget.GetMachineType(&machineType);
-                switch (machineType)
-                {
-                    // ICLRDataTarget can not be used to find OS. For now labeling all platforms as Windows
-                    //
-                    case 0x014c: // IMAGE_FILE_MACHINE_I386
-                        platform = (int)Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_X86;
-                        break;
-                    case 0x8664: // IMAGE_FILE_MACHINE_AMD64
-                        platform = (int)Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_AMD64;
-                        break;
-                    case 0x01c4: // IMAGE_FILE_MACHINE_ARMNT
-                        platform = (int)Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_ARM;
-                        break;
-                    case 0xAA64: // IMAGE_FILE_MACHINE_ARM64
-                        platform = (int)Target.CorDebugPlatform.CORDB_PLATFORM_WINDOWS_ARM64;
-                        break;
-                }
-                return hr;
-            },
             out ContractDescriptorTarget? target))
         {
             return -1;

src/native/managed/cdacreader/tests/TestPlaceholderTarget.cs

@@ -29,7 +29,6 @@ public TestPlaceholderTarget(MockTarget.Architecture arch, ReadFromTargetDelegat
     {
         IsLittleEndian = arch.IsLittleEndian;
         PointerSize = arch.Is64Bit ? 8 : 4;
-        Platform = Target.CorDebugPlatform.CORDB_PLATFORM_MAC_AMD64;
         _contractRegistry = new Mock<ContractRegistry>().Object;
         _dataCache = new DefaultDataCache(this);
         _typeInfoCache = types ?? [];
@@ -44,7 +43,6 @@ internal void SetContracts(ContractRegistry contracts)
 
     public override int PointerSize { get; }
     public override bool IsLittleEndian { get; }
-    public override CorDebugPlatform Platform { get; }
 
     public override bool IsAlignedToPointerSize(TargetPointer pointer)
     {
@@ -93,6 +91,20 @@ public override string ReadUtf16String(ulong address)
     }
 
     public override TargetNUInt ReadNUInt(ulong address) => DefaultReadNUInt(address);
+
+    public override bool TryReadGlobal<T>(string name, [NotNullWhen(true)] out T? value)
+    {
+        value = default;
+        foreach (var global in _globals)
+        {
+            if (global.Name == name)
+            {
+                value = T.CreateChecked(global.Value);
+                return true;
+            }
+        }
+        return false;
+    }
     public override T ReadGlobal<T>(string name)
     {
         foreach (var global in _globals)