[cdac] start of RuntimeTypeSystem contract; implement GetMethodTableData SOS method

src/coreclr/debug/daccess/dacimpl.h

@@ -1231,6 +1231,7 @@ class ClrDataAccess
 
     HRESULT GetThreadDataImpl(CLRDATA_ADDRESS threadAddr, struct DacpThreadData *threadData);
     HRESULT GetThreadStoreDataImpl(struct DacpThreadStoreData *data);
+    HRESULT GetMethodTableDataImpl(CLRDATA_ADDRESS mt, struct DacpMethodTableData *data);
 
     BOOL IsExceptionFromManagedCode(EXCEPTION_RECORD * pExceptionRecord);
 #ifndef TARGET_UNIX

src/coreclr/debug/daccess/request.cpp

@@ -161,10 +161,14 @@ BOOL DacValidateMethodTable(PTR_MethodTable pMT, BOOL &bIsFree)
             // In rare cases, we've seen the standard check above pass when it shouldn't.
             // Insert additional/ad-hoc tests below.
 
+            // FIXME(cdac): ak - this check is trivially true - GetCl() runs in the DAC and synthesizes a token with a mdtTypeDef table
+            // so the check is always true.
+#if 0
             // Metadata token should look valid for a class
             mdTypeDef td = pMT->GetCl();
             if (td != mdTokenNil && TypeFromToken(td) != mdtTypeDef)
                 goto BadMethodTable;
+#endif
 
             // BaseSize should always be greater than 0 for valid objects (unless it's an interface)
             // For strings, baseSize is not ptr-aligned
@@ -1765,12 +1769,55 @@ ClrDataAccess::GetMethodTableData(CLRDATA_ADDRESS mt, struct DacpMethodTableData
         return E_INVALIDARG;
 
     SOSDacEnter();
+    if (m_cdacSos != NULL)
+    {
+        // Try the cDAC first - it will return E_NOTIMPL if it doesn't support this method yet. Fall back to the DAC.
+        hr = m_cdacSos->GetMethodTableData(mt, MTData);
+        if (FAILED(hr))
+        {
+            hr = GetMethodTableDataImpl(mt, MTData);
+        }
+#ifdef _DEBUG
+        else
+        {
+            // Assert that the data is the same as what we get from the DAC.
+            DacpMethodTableData mtDataLocal;
+            HRESULT hrLocal = GetMethodTableDataImpl(mt, &mtDataLocal);
+            _ASSERTE(hr == hrLocal);
+            _ASSERTE(MTData->BaseSize == mtDataLocal.BaseSize);
+            _ASSERTE(MTData->ComponentSize == mtDataLocal.ComponentSize);
+            _ASSERTE(MTData->bIsFree == mtDataLocal.bIsFree);
+            _ASSERTE(MTData->Module == mtDataLocal.Module);
+            _ASSERTE(MTData->Class == mtDataLocal.Class);
+            _ASSERTE(MTData->ParentMethodTable == mtDataLocal.ParentMethodTable);
+            _ASSERTE(MTData->wNumInterfaces == mtDataLocal.wNumInterfaces);
+            _ASSERTE(MTData->wNumMethods == mtDataLocal.wNumMethods);
+            _ASSERTE(MTData->wNumVtableSlots == mtDataLocal.wNumVtableSlots);
+            _ASSERTE(MTData->wNumVirtuals == mtDataLocal.wNumVirtuals);
+            _ASSERTE(MTData->cl == mtDataLocal.cl);
+            _ASSERTE(MTData->dwAttrClass = mtDataLocal.dwAttrClass);
+            _ASSERTE(MTData->bContainsPointers == mtDataLocal.bContainsPointers);
+            _ASSERTE(MTData->bIsShared == mtDataLocal.bIsShared);
+            _ASSERTE(MTData->bIsDynamic == mtDataLocal.bIsDynamic);
+        }
+#endif
+    }
+    else
+    {
+        hr = GetMethodTableDataImpl (mt, MTData);
+    }
+    SOSDacLeave();
+    return hr;
+}
 
+HRESULT
+ClrDataAccess::GetMethodTableDataImpl(CLRDATA_ADDRESS mt, struct DacpMethodTableData *MTData)
+{
     PTR_MethodTable pMT = PTR_MethodTable(TO_TADDR(mt));
     BOOL bIsFree = FALSE;
     if (!DacValidateMethodTable(pMT, bIsFree))
     {
-        hr = E_INVALIDARG;
+        return E_INVALIDARG;
     }
     else
     {
@@ -1797,8 +1844,7 @@ ClrDataAccess::GetMethodTableData(CLRDATA_ADDRESS mt, struct DacpMethodTableData
         }
     }
 
-    SOSDacLeave();
-    return hr;
+    return S_OK;
 }
 
 HRESULT

src/coreclr/debug/runtimeinfo/contractpointerdata.cpp

@@ -7,10 +7,11 @@
 #include <stdint.h>
 
 #include "threads.h"
+#include "vars.hpp"
 
 extern "C"
 {
-  
+
 // without an extern declaration, clang does not emit this global into the object file
 extern const uintptr_t contractDescriptorPointerData[];
 

src/coreclr/debug/runtimeinfo/contracts.jsonc

@@ -9,6 +9,7 @@
 // cdac-build-tool can take multiple "-c contract_file" arguments
 // so to conditionally include contracts, put additional contracts in a separate file
 {
+  "Metadata": 1,
   "Thread": 1,
   "SOSBreakingChangeVersion": 1 // example contract: "runtime exports an SOS breaking change version global"
 }

src/coreclr/debug/runtimeinfo/datadescriptor.cpp

@@ -9,6 +9,7 @@
 #include "static_assert.h"
 
 #include <sospriv.h>
+#include "methodtable.h"
 #include "threads.h"
 
 // begin blob definition

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -126,6 +126,34 @@ CDAC_TYPE_BEGIN(GCHandle)
 CDAC_TYPE_SIZE(sizeof(OBJECTHANDLE))
 CDAC_TYPE_END(GCHandle)
 
+// Metadata
+
+CDAC_TYPE_BEGIN(MethodTable)
+CDAC_TYPE_INDETERMINATE(MethodTable)
+CDAC_TYPE_FIELD(MethodTable, /*uint32*/, DwFlags, cdac_offsets<MethodTable>::m_dwFlags)
+CDAC_TYPE_FIELD(MethodTable, /*uint32*/, BaseSize, cdac_offsets<MethodTable>::m_BaseSize)
+CDAC_TYPE_FIELD(MethodTable, /*uint32*/, DwFlags2, cdac_offsets<MethodTable>::m_dwFlags2)
+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()
@@ -138,6 +166,7 @@ CDAC_GLOBAL(FeatureEHFunclets, uint8, 1)
 CDAC_GLOBAL(FeatureEHFunclets, uint8, 0)
 #endif
 CDAC_GLOBAL(SOSBreakingChangeVersion, uint8, SOS_BREAKING_CHANGE_VERSION)
+CDAC_GLOBAL_POINTER(FreeObjectMethodTable, &::g_pFreeObjectMethodTable)
 CDAC_GLOBALS_END()
 
 #undef CDAC_BASELINE

src/coreclr/vm/cdacoffsets.h

@@ -8,8 +8,8 @@
 //
 // If the offset of some field F in class C must be provided to cDAC, but the field is private, the
 // class C should declare cdac_offsets<T> as a friend:
-// 
-//     friend template<typename T> struct cdac_offsets;
+//
+//     template<typename T> friend struct ::cdac_offsets;
 //
 // and provide a specialization cdac_offsets<C> with a constexpr size_t member providing the offset:
 //

src/coreclr/vm/class.h

@@ -1798,6 +1798,15 @@ class EEClass // DO NOT CREATE A NEW EEClass USING NEW!
     }
 #endif // !DACCESS_COMPILE
 
+    template<typename T> friend struct ::cdac_offsets;
+};
+
+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);
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/methodtable.h

@@ -582,7 +582,7 @@ struct DynamicStaticsInfo
                 // If it has, then we don't need to do anything
                 return false;
             }
-            
+
             oldValFromInterlockedOp = InterlockedCompareExchangeT(pAddr, newVal | oldVal, oldVal);
         } while(oldValFromInterlockedOp != oldVal);
         return true;
@@ -3858,8 +3858,23 @@ public :
     BOOL Validate ();
 
     static void GetStaticsOffsets(StaticsOffsetType staticsOffsetType, bool fGenericsStatics, uint32_t *dwGCOffset, uint32_t *dwNonGCOffset);
+
+    template<typename T> friend struct ::cdac_offsets;
 };  // class MethodTable
 
+template<> struct ::cdac_offsets<MethodTable>
+{
+    static constexpr size_t m_dwFlags = offsetof(MethodTable, m_dwFlags);
+    static constexpr size_t m_BaseSize = offsetof(MethodTable, m_BaseSize);
+    static constexpr size_t m_dwFlags2 = offsetof(MethodTable, m_dwFlags2);
+    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
 static_assert_no_msg(sizeof(MethodTable) == SIZEOF__MethodTable_);
 #endif

src/native/managed/cdacreader/src/Constants.cs

@@ -13,5 +13,7 @@ internal static class Globals
         internal const string GCThread = nameof(GCThread);
 
         internal const string SOSBreakingChangeVersion = nameof(SOSBreakingChangeVersion);
+
+        internal const string FreeObjectMethodTable = nameof(FreeObjectMethodTable);
     }
 }