checkpoint GetMethodTableData implemented

dotnet · lambdageek · Jul 8, 2024 · May 16, 2024 · May 17, 2024 · May 23, 2024
commit 7be5c6079c795a028b0458502eedbf1fc5b6ff95
diff --git a/src/coreclr/debug/runtimeinfo/datadescriptor.h b/src/coreclr/debug/runtimeinfo/datadescriptor.h
@@ -136,13 +136,24 @@ CDAC_TYPE_FIELD(MethodTable, /*uint32*/, DwFlags2, cdac_offsets<MethodTable>::m_
 CDAC_TYPE_FIELD(MethodTable, /*nuint*/, EEClassOrCanonMT, cdac_offsets<MethodTable>::m_pEEClassOrCanonMT)
 CDAC_TYPE_FIELD(MethodTable, /*pointer*/, Module, cdac_offsets<MethodTable>::m_pModule)
 CDAC_TYPE_FIELD(MethodTable, /*pointer*/, AuxiliaryData, cdac_offsets<MethodTable>::m_pAuxiliaryData)
+CDAC_TYPE_FIELD(MethodTable, /*pointer*/, ParentMethodTable, cdac_offsets<MethodTable>::m_pParentMethodTable)
+CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumInterfaces, cdac_offsets<MethodTable>::m_wNumInterfaces)
+CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumVirtuals, cdac_offsets<MethodTable>::m_wNumVirtuals)
 CDAC_TYPE_END(MethodTable)
 
 CDAC_TYPE_BEGIN(EEClass)
 CDAC_TYPE_INDETERMINATE(EEClass)
 CDAC_TYPE_FIELD(EEClass, /*pointer*/, MethodTable, cdac_offsets<EEClass>::m_pMethodTable)
+CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumMethods, cdac_offsets<EEClass>::m_NumMethods)
+CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumNonVirtualSlots, cdac_offsets<EEClass>::m_NumNonVirtualSlots)
+CDAC_TYPE_FIELD(EEClass, /*uint32*/, DwAttrClass, cdac_offsets<EEClass>::m_dwAttrClass)
 CDAC_TYPE_END(EEClass)
 
+CDAC_TYPE_BEGIN(MethodTableAuxiliaryData)
+CDAC_TYPE_INDETERMINATE(MethodTableAuxiliaryData)
+CDAC_TYPE_FIELD(MethodTableAuxiliaryData, /*uint32*/, DwFlags, offsetof(MethodTableAuxiliaryData, m_dwFlags))
+CDAC_TYPE_END(MethodTableAuxiliaryData)
+
 CDAC_TYPES_END()
 
 CDAC_GLOBALS_BEGIN()

diff --git a/src/coreclr/vm/class.h b/src/coreclr/vm/class.h
@@ -1823,6 +1823,9 @@ class EEClass // DO NOT CREATE A NEW EEClass USING NEW!
 template<> struct ::cdac_offsets<EEClass>
 {
     static constexpr size_t m_pMethodTable = offsetof(EEClass, m_pMethodTable);
+    static constexpr size_t m_NumMethods = offsetof(EEClass, m_NumMethods);
+    static constexpr size_t m_NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
+    static constexpr size_t m_dwAttrClass = offsetof(EEClass, m_dwAttrClass);
 };
 
 // --------------------------------------------------------------------------------------------

diff --git a/src/coreclr/vm/methodtable.h b/src/coreclr/vm/methodtable.h
@@ -3671,6 +3671,9 @@ template<> struct ::cdac_offsets<MethodTable>
     static constexpr size_t m_pEEClassOrCanonMT = offsetof(MethodTable, m_pEEClass);
     static constexpr size_t m_pModule = offsetof(MethodTable, m_pModule);
     static constexpr size_t m_pAuxiliaryData = offsetof(MethodTable, m_pAuxiliaryData);
+    static constexpr size_t m_pParentMethodTable = offsetof(MethodTable, m_pParentMethodTable)
+    static constexpr size_t m_wNumInterfaces = offsetof(MethodTable, m_wNumInterfaces)
+    static constexpr size_t m_wNumVirtuals = offsetof(MethodTable, m_wNumVirtuals)
 };
 
 #ifndef CROSSBITNESS_COMPILE

diff --git a/src/native/managed/cdacreader/src/Contracts/Metadata.MethodTableFlags.cs b/src/native/managed/cdacreader/src/Contracts/Metadata.MethodTableFlags.cs
@@ -141,7 +141,7 @@ internal interface IMethodTableFlags
 
     private Metadata_1.WFLAGS_HIGH FlagsHigh => (Metadata_1.WFLAGS_HIGH)DwFlags;
     private Metadata_1.WFLAGS_LOW FlagsLow => (Metadata_1.WFLAGS_LOW)DwFlags;
-    private int GetTypeDefRid() => (int)(DwFlags2 >> Metadata_1.Constants.MethodTableDwFlags2TypeDefRidShift);
+    public int GetTypeDefRid() => (int)(DwFlags2 >> Metadata_1.Constants.MethodTableDwFlags2TypeDefRidShift);
 
     public Metadata_1.WFLAGS_LOW GetFlag(Metadata_1.WFLAGS_LOW mask) => throw new NotImplementedException("TODO");
     public Metadata_1.WFLAGS_HIGH GetFlag(Metadata_1.WFLAGS_HIGH mask) => FlagsHigh & mask;
@@ -167,4 +167,8 @@ public bool TestFlagWithMask(Metadata_1.WFLAGS_LOW mask, Metadata_1.WFLAGS_LOW f
         }
     }
     public bool HasInstantiation => !TestFlagWithMask(Metadata_1.WFLAGS_LOW.GenericsMask, Metadata_1.WFLAGS_LOW.GenericsMask_NonGeneric);
+
+    public bool ContainsPointers => GetFlag(Metadata_1.WFLAGS_HIGH.ContainsPointers) != 0;
+
+    public bool IsDynamicStatics => !TestFlagWithMask(Metadata_1.WFLAGS_LOW.StaticsMask, Metadata_1.WFLAGS_LOW.StaticsMask_Dynamic);
 }
diff --git a/src/native/managed/cdacreader/src/Contracts/Metadata.cs b/src/native/managed/cdacreader/src/Contracts/Metadata.cs
@@ -6,6 +6,7 @@
 using MethodTable = Microsoft.Diagnostics.DataContractReader.Contracts.MethodTable_1;
 using UntrustedEEClass = Microsoft.Diagnostics.DataContractReader.Contracts.UntrustedEEClass_1;
 using EEClass = Microsoft.Diagnostics.DataContractReader.Contracts.EEClass_1;
+using System.Diagnostics.SymbolStore;
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
@@ -26,6 +27,12 @@ static IContract IContract.Create(Target target, int version)
     public virtual MethodTable GetMethodTableData(TargetPointer targetPointer) => throw new NotImplementedException();
 
     public virtual TargetPointer GetClass(in MethodTable methodTable) => throw new NotImplementedException();
+
+    public virtual ushort GetNumMethods(in MethodTable methodTable) => throw new NotImplementedException();
+
+    public virtual ushort GetNumVtableSlots(in MethodTable methodTable) => throw new NotImplementedException();
+
+    public virtual ushort GetTypeDefTypeAttributes(in MethodTable methodTable) => throw new NotImplementedException();
 }
 
 internal struct Metadata : IMetadata
@@ -106,6 +113,7 @@ internal MethodTable_1(Data.MethodTable data, bool isFreeObjectMT)
     public uint DwFlags => MethodTableData.DwFlags;
     public uint DwFlags2 => MethodTableData.DwFlags2;
     public uint BaseSize => MethodTableData.BaseSize;
+    public int GetTypeDefRid() => ((IMethodTableFlags)this).GetTypeDefRid();
     public TargetPointer EEClassOrCanonMT => MethodTableData.EEClassOrCanonMT;
     public TargetPointer Module => MethodTableData.Module;
 
@@ -115,6 +123,12 @@ internal MethodTable_1(Data.MethodTable data, bool isFreeObjectMT)
 
     public int GetComponentSize() => ((IMethodTableFlags)this).HasComponentSize ? ((IMethodTableFlags)this).RawGetComponentSize() : 0;
 
+    public TargetPointer ParentMethodTable => MethodTableData.ParentMethodTable;
+    public ushort NumInterfaces => MethodTableData.NumInterfaces;
+    public ushort NumVirtuals => MethodTableData.NumVirtuals;
+
+    public bool ContainsPointers => ((IMethodTableFlags)this).ContainsPointers;
+    public bool IsDynamicStatics => ((IMethodTableFlags)this).IsDynamicStatics;
 }
 
 internal struct EEClass_1
@@ -126,6 +140,10 @@ internal EEClass_1(Data.EEClass eeClassData)
     }
 
     public TargetPointer MethodTable => EEClassData.MethodTable;
+    public ushort NumMethods => EEClassData.NumMethods;
+    public ushort NumNonVirtualSlots => EEClassData.NumNonVirtualSlots;
+
+    public ushort TypeDefTypeAttributes => EEClassData.DwAttrClass;
 }
 
 
@@ -191,7 +209,7 @@ public MethodTable GetMethodTableData(TargetPointer methodTablePointer)
         return new MethodTable(trustedMethodTableData, isFreeObjectMT: false);
     }
 
-    private bool ValidateMethodTablePointer(ref readonly UntrustedMethodTable umt)
+    private bool ValidateMethodTablePointer(in UntrustedMethodTable umt)
     {
         // FIXME: is methodTablePointer properly sign-extended from 32-bit targets?
         // FIXME2: do we need this? Data.MethodTable probably would throw if methodTablePointer is invalid
@@ -201,11 +219,11 @@ private bool ValidateMethodTablePointer(ref readonly UntrustedMethodTable umt)
         //}
         try
         {
-            if (!ValidateWithPossibleAV(in umt))
+            if (!ValidateWithPossibleAV(umt))
             {
                 return false;
             }
-            if (!ValidateMethodTable(in umt))
+            if (!ValidateMethodTable(umt))
             {
                 return false;
             }
@@ -218,7 +236,7 @@ private bool ValidateMethodTablePointer(ref readonly UntrustedMethodTable umt)
         return true;
     }
 
-    private bool ValidateWithPossibleAV(ref readonly UntrustedMethodTable methodTable)
+    private bool ValidateWithPossibleAV(in UntrustedMethodTable methodTable)
     {
         // For non-generic classes, we can rely on comparing
         //    object->methodtable->class->methodtable
@@ -231,7 +249,7 @@ private bool ValidateWithPossibleAV(ref readonly UntrustedMethodTable methodTabl
         //    object->methodtable->class->methodtable->class
         // to
         //    object->methodtable->class
-        TargetPointer eeClassPtr = GetClassWithPossibleAV(in methodTable);
+        TargetPointer eeClassPtr = GetClassWithPossibleAV(methodTable);
         if (eeClassPtr != TargetPointer.Null)
         {
             UntrustedEEClass eeClass = GetUntrustedEEClassData(eeClassPtr);
@@ -250,7 +268,7 @@ private bool ValidateWithPossibleAV(ref readonly UntrustedMethodTable methodTabl
         return false;
     }
 
-    private bool ValidateMethodTable(ref readonly UntrustedMethodTable methodTable)
+    private bool ValidateMethodTable(in UntrustedMethodTable methodTable)
     {
         if (!((IMethodTableFlags)methodTable).IsInterface && !((IMethodTableFlags)methodTable).IsString)
         {
@@ -266,7 +284,7 @@ internal static EEClassOrCanonMTBits GetEEClassOrCanonMTBits(TargetPointer eeCla
     {
         return (EEClassOrCanonMTBits)(eeClassOrCanonMTPtr & (ulong)EEClassOrCanonMTBits.Mask);
     }
-    private TargetPointer GetClassWithPossibleAV(ref readonly UntrustedMethodTable methodTable)
+    private TargetPointer GetClassWithPossibleAV(in UntrustedMethodTable methodTable)
     {
         TargetPointer eeClassOrCanonMT = methodTable.EEClassOrCanonMT;
 
@@ -282,12 +300,12 @@ private TargetPointer GetClassWithPossibleAV(ref readonly UntrustedMethodTable m
         }
     }
 
-    private static TargetPointer GetMethodTableWithPossibleAV(ref readonly UntrustedEEClass eeClass)
+    private static TargetPointer GetMethodTableWithPossibleAV(in UntrustedEEClass eeClass)
     {
         return eeClass.MethodTable;
     }
 
-    internal TargetPointer GetClass(ref readonly MethodTable methodTable)
+    public TargetPointer GetClass(in MethodTable methodTable)
     {
         switch (GetEEClassOrCanonMTBits(methodTable.EEClassOrCanonMT))
         {
@@ -301,4 +319,60 @@ internal TargetPointer GetClass(ref readonly MethodTable methodTable)
                 throw new InvalidOperationException();
         }
     }
+
+    // only called on trusted method tables, so we always trust the resulting EEClass
+    private EEClass GetClassData(in MethodTable methodTable)
+    {
+        TargetPointer clsPtr = GetClass(in methodTable);
+        // Check if we cached it already
+        if (_target.ProcessedData.TryGet(clsPtr, out Data.EEClass? eeClassData))
+        {
+            return new EEClass_1(eeClassData);
+        }
+        eeClassData = _target.ProcessedData.GetOrAdd<Data.EEClass>(clsPtr);
+        return new EEClass_1(eeClassData);
+    }
+
+    public ushort GetNumMethods(in MethodTable methodTable)
+    {
+        EEClass cls = GetClassData(in methodTable);
+        return cls.NumMethods;
+    }
+
+    private ushort GetNumNonVirtualSlots(in MethodTable methodTable)
+    {
+        TargetPointer eeClassOrCanonMT = methodTable.EEClassOrCanonMT;
+        if (GetEEClassOrCanonMTBits(eeClassOrCanonMT) == EEClassOrCanonMTBits.EEClass)
+        {
+            return GetClassData(methodTable).NumNonVirtualSlots;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    public ushort GetNumVtableSlots(in MethodTable methodTable)
+    {
+        return checked((ushort)(methodTable.NumVirtuals + GetNumNonVirtualSlots(methodTable)));
+    }
+
+    public ushort GetTypeDefTypeAttributes(in MethodTable methodTable)
+    {
+        return GetClassData(methodTable).TypeDefTypeAttributes;
+    }
+
+
+    [Flags]
+    internal enum MethodTableAuxiliaryDataFlags : uint
+    {
+        CanCompareBitsOrUseFastGetHashCode = 0x0001,     // Is any field type or sub field type overrode Equals or GetHashCode
+        HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002,  // Whether we have checked the overridden Equals or GetHashCode
+        HasApproxParent = 0x0010,
+        IsNotFullyLoaded = 0x0040,
+        DependenciesLoaded = 0x0080,     // class and all dependencies loaded up to CLASS_LOADED_BUT_NOT_VERIFIED
+        MayHaveOpenInterfaceInInterfaceMap = 0x0100,
+        DebugOnly_ParentMethodTablePointerValid = 0x4000,
+        DebugOnly_HasInjectedInterfaceDuplicates = 0x8000,
+    }
 }
diff --git a/src/native/managed/cdacreader/src/Data/EEClass.cs b/src/native/managed/cdacreader/src/Data/EEClass.cs
@@ -13,8 +13,13 @@ public EEClass(Target target, TargetPointer address)
         Target.TypeInfo type = target.GetTypeInfo(DataType.EEClass);
 
         MethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(MethodTable)].Offset);
+        NumMethods = target.Read<ushort>(address + (ulong)type.Fields[nameof(NumMethods)].Offset);
+        NumNonVirtualSlots = target.Read<ushort>(address + (ulong)type.Fields[nameof(NumNonVirtualSlots)].Offset);
+        DwAttrClass = target.Read<uint>(address + (ulong)type.Fields[nameof(DwAttrClass)].Offset);
     }
 
     public TargetPointer MethodTable { get; init; }
-
+    public ushort NumMethods { get; init; }
+    public ushort NumNonVirtualSlots { get; init; }
+    public uint DwAttrClass { get; init; }
 }
diff --git a/src/native/managed/cdacreader/src/Data/MethodTable.cs b/src/native/managed/cdacreader/src/Data/MethodTable.cs
@@ -12,18 +12,22 @@ public MethodTable(Target target, TargetPointer address)
     {
         Target.TypeInfo type = target.GetTypeInfo(DataType.MethodTable);
 
-        //Id = target.Read<uint>(address + (ulong)type.Fields[nameof(Id)].Offset);
-        //LinkNext = target.ReadPointer(address + (ulong)type.Fields[nameof(LinkNext)].Offset);
         DwFlags = target.Read<uint>(address + (ulong)type.Fields[nameof(DwFlags)].Offset);
         BaseSize = target.Read<uint>(address + (ulong)type.Fields[nameof(BaseSize)].Offset);
         DwFlags2 = target.Read<uint>(address + (ulong)type.Fields[nameof(DwFlags2)].Offset);
         EEClassOrCanonMT = target.ReadPointer(address + (ulong)type.Fields[nameof(EEClassOrCanonMT)].Offset);
-        Module = target.ReadPointer(address + (ulong)type.Fields[(nameof(Module))].Offset);
+        Module = target.ReadPointer(address + (ulong)type.Fields[nameof(Module)].Offset);
+        ParentMethodTable = target.ReadPointer(address + (ulong)type.Fields[nameof(ParentMethodTable)].Offset);
+        NumInterfaces = target.Read<ushort>(address + (ulong)type.Fields[nameof(NumInterfaces)].Offset);
+        NumVirtuals = target.Read<ushort>(address + (ulong)type.Fields[nameof(NumVirtuals)].Offset);
     }
 
     public uint DwFlags { get; init; }
     public uint BaseSize { get; init; }
     public uint DwFlags2 { get; init; }
     public TargetPointer EEClassOrCanonMT { get; init; }
     public TargetPointer Module { get; init; }
+    public TargetPointer ParentMethodTable { get; init; }
+    public ushort NumInterfaces { get; init; }
+    public ushort NumVirtuals { get; init; }
 }
diff --git a/src/native/managed/cdacreader/src/Data/MethodTableAuxiliaryData.cs b/src/native/managed/cdacreader/src/Data/MethodTableAuxiliaryData.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Diagnostics.DataContractReader.Data;
+
+internal sealed class MethodTableAuxiliaryData : IData<MethodTableAuxiliaryData>
+{
+    static MethodTableAuxiliaryData IData<MethodTableAuxiliaryData>.Create(Target target, TargetPointer address) => new MethodTableAuxiliaryData(target, address);
+
+    private MethodTableAuxiliaryData(Target target, TargetPointer address)
+    {
+        Target.TypeInfo type = target.GetTypeInfo(DataType.MethodTableAuxiliaryData);
+
+        DwFlags = target.Read<uint>(address + (ulong)type.Fields[nameof(DwFlags)].Offset);
+
+    }
+
+    public uint DwFlags { get; init; }
+}
diff --git a/src/native/managed/cdacreader/src/DataType.cs b/src/native/managed/cdacreader/src/DataType.cs
@@ -24,4 +24,5 @@ public enum DataType
     ThreadStore,
     MethodTable,
     EEClass,
+    MethodTableAuxiliaryData,
 }
diff --git a/src/native/managed/cdacreader/src/Legacy/SOSDacImpl.cs b/src/native/managed/cdacreader/src/Legacy/SOSDacImpl.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Reflection.Metadata.Ecma335;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
 using Microsoft.Diagnostics.DataContractReader.Data;
@@ -100,21 +101,17 @@ public unsafe int GetMethodTableData(ulong mt, DacpMethodTableData* data)
             if (!methodTable.IsFreeObjectMethodTable)
             {
                 result.module = methodTable.Module;
-                result.@class = contract.GetClass(in methodTable);
-#if false
-                // TODO
-                MTData->ParentMethodTable = HOST_CDADDR(pMT->GetParentMethodTable()); ;
-                MTData->wNumInterfaces = (WORD)pMT->GetNumInterfaces();
-                MTData->wNumMethods = pMT->GetNumMethods();
-                MTData->wNumVtableSlots = pMT->GetNumVtableSlots();
-                MTData->wNumVirtuals = pMT->GetNumVirtuals();
-                MTData->cl = pMT->GetCl();
-                MTData->dwAttrClass = pMT->GetAttrClass();
-                MTData->bContainsPointers = pMT->ContainsPointers();
-                MTData->bIsShared = FALSE;
-                MTData->bIsDynamic = pMT->IsDynamicStatics();
-#endif
-                return HResults.E_NOTIMPL;
+                result.@class = contract.GetClass(methodTable);
+                result.parentMethodTable = methodTable.ParentMethodTable;
+                result.wNumInterfaces = methodTable.NumInterfaces;
+                result.wNumMethods = contract.GetNumMethods(methodTable);
+                result.wNumVtableSlots = contract.GetNumVtableSlots(methodTable);
+                result.wNumVirtuals = methodTable.NumVirtuals;
+                result.cl = (uint)(methodTable.GetTypeDefRid() | ((int)TableIndex.TypeDef << 24));
+                result.dwAttrClass = contract.GetTypeDefTypeAttributes(methodTable);
+                result.bContainsPointers = methodTable.ContainsPointers ? 1 : 0;
+                result.bIsShared = 0;
+                result.bIsDynamic = methodTable.IsDynamicStatics ? 1 : 0;
             }
             return HResults.S_OK;
         }