[cdac] Begin adding MethodDesc APIs to the RuntimeTypeSystem contract

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -4,10 +4,11 @@ This contract is for exploring the properties of the runtime types of values on
 
 ## APIs of contract
 
+### TypeHandle
+
 A `TypeHandle` is the runtime representation of the type information about a value which is represented as a TypeHandle.
 Given a `TargetPointer` address, the `RuntimeTypeSystem` contract provides a `TypeHandle` for querying the details of the `TypeHandle`.
 
-
 ``` csharp
 struct TypeHandle
 {
@@ -28,6 +29,8 @@ internal enum CorElementType
 A `TypeHandle` is the runtime representation of the type information about a value.  This can be constructed from the address of a `TypeHandle` or a `MethodTable`.
 
 ``` csharp
+partial interface IRuntimeTypeSystem : IContract
+{
     #region TypeHandle inspection APIs
     public virtual TypeHandle GetTypeHandle(TargetPointer targetPointer);
 
@@ -73,10 +76,37 @@ A `TypeHandle` is the runtime representation of the type information about a val
     public virtual bool IsFunctionPointer(TypeHandle typeHandle, out ReadOnlySpan<TypeHandle> retAndArgTypes, out byte callConv);
 
     #endregion TypeHandle inspection APIs
+}
+```
+
+### MethodDesc
+
+A `MethodDesc` is the runtime representationn of a managed method (either from IL, from reflection emit, or generated by the runtime).
+
+```csharp
+struct MethodDescHandle
+{
+    // no public properties or constructors
+
+    internal TargetPointer Address { get; }
+}
+```
+
+```csharp
+partial interface IRuntimeTypeSystem : IContract
+{
+    #region MethodDesc inspection APIs
+    public virtual MethodDescHandle GetMethodDescHandle (TargetPointer methodDescPointer);
+
+    public virtual TargetPointer GetMethodTable (MethodDescHandle methodDesc);
+    #endregion MethodDesc inspection APIs
+}
 ```
 
 ## Version 1
 
+### TypeHandle
+
 The `MethodTable` inspection APIs are implemented in terms of the following flags on the runtime `MethodTable` structure:
 
 ``` csharp
@@ -523,3 +553,12 @@ The contract additionally depends on these data descriptors
         return true;
     }
 ```
+
+### MethodDesc
+
+The version 1 `MethodDesc` APIs depend on the `MethodDescAlignment` global and the `MethodDesc` and `MethodDescChunk` data descriptors.
+
+In the runtime a `MethodDesc` implicitly belongs to a single `MethodDescChunk` and some common data is shared between method descriptors that belong to the same chunk.  A single method table
+will typically have multiple chunks.  There are subkinds of MethodDescs at runtime of varying sizes (but the sizes must be mutliples of `MethodDescAlignment`) and each chunk contains method descriptors of the same size.
+
+**TODO(cdac)**

src/coreclr/debug/daccess/dacimpl.h

@@ -1241,6 +1241,7 @@ class ClrDataAccess
     HRESULT GetMethodTableForEEClassImpl (CLRDATA_ADDRESS eeClassReallyMT, CLRDATA_ADDRESS *value);
     HRESULT GetMethodTableNameImpl(CLRDATA_ADDRESS mt, unsigned int count, _Inout_updates_z_(count) WCHAR *mtName, unsigned int *pNeeded);
     HRESULT GetObjectExceptionDataImpl(CLRDATA_ADDRESS objAddr, struct DacpExceptionObjectData *data);
+    HRESULT GetMethodDescDataImpl(CLRDATA_ADDRESS methodDesc, CLRDATA_ADDRESS ip, struct DacpMethodDescData *data, ULONG cRevertedRejitVersions, DacpReJitData * rgRevertedRejitData, ULONG * pcNeededRevertedRejitData);
 
     BOOL IsExceptionFromManagedCode(EXCEPTION_RECORD * pExceptionRecord);
 #ifndef TARGET_UNIX

src/coreclr/debug/daccess/request.cpp

@@ -1041,6 +1041,70 @@ HRESULT ClrDataAccess::GetMethodDescData(
     }
 
     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->GetMethodDescData(methodDesc, ip, methodDescData, cRevertedRejitVersions, rgRevertedRejitData, pcNeededRevertedRejitData);
+        if (FAILED(hr))
+        {
+            hr = GetMethodDescDataImpl(methodDesc, ip, methodDescData, cRevertedRejitVersions, rgRevertedRejitData, pcNeededRevertedRejitData);
+        }
+#ifdef _DEBUG
+        else
+        {
+            // Assert that the data is the same as what we get from the DAC.
+            DacpMethodDescData mdDataLocal;
+            DacpReJitData *rgRevertedRejitDataLocal = NULL;
+            if (rgRevertedRejitData != NULL)
+            {
+                rgRevertedRejitDataLocal = new DacpReJitData[cRevertedRejitVersions];
+            }
+            ULONG cNeededRevertedRejitDataLocal = 0;
+            ULONG *pcNeededRevertedRejitDataLocal = NULL;
+            if (pcNeededRevertedRejitData != NULL)
+            {
+                pcNeededRevertedRejitDataLocal = &cNeededRevertedRejitDataLocal;
+            }
+            HRESULT hrLocal = GetMethodDescDataImpl(methodDesc, ip,&mdDataLocal, cRevertedRejitVersions, rgRevertedRejitDataLocal, pcNeededRevertedRejitDataLocal);
+            _ASSERTE(hr == hrLocal);
+            _ASSERTE(methodDescData->bHasNativeCode == mdDataLocal.bHasNativeCode);
+            _ASSERTE(methodDescData->bIsDynamic == mdDataLocal.bIsDynamic);
+            _ASSERTE(methodDescData->wSlotNumber == mdDataLocal.wSlotNumber);
+            _ASSERTE(methodDescData->NativeCodeAddr == mdDataLocal.NativeCodeAddr);
+            _ASSERTE(methodDescData->AddressOfNativeCodeSlot == mdDataLocal.AddressOfNativeCodeSlot);
+            //TODO[cdac]: assert the rest of mdDataLocal contains the same info as methodDescData
+            if (rgRevertedRejitData != NULL)
+            {
+                _ASSERTE (cNeededRevertedRejitDataLocal == *pcNeededRevertedRejitData);
+                for (ULONG i = 0; i < cNeededRevertedRejitDataLocal; i++)
+                {
+                    _ASSERTE(rgRevertedRejitData[i].rejitID == rgRevertedRejitDataLocal[i].rejitID);
+                    _ASSERTE(rgRevertedRejitData[i].NativeCodeAddr == rgRevertedRejitDataLocal[i].NativeCodeAddr);
+                    _ASSERTE(rgRevertedRejitData[i].flags == rgRevertedRejitDataLocal[i].flags);
+                }
+            }
+        }
+#endif
+    }
+    else
+    {
+        hr = GetMethodDescDataImpl(methodDesc, ip, methodDescData, cRevertedRejitVersions, rgRevertedRejitData, pcNeededRevertedRejitData);
+    }
+
+    SOSDacLeave();
+    return hr;
+}
+
+HRESULT ClrDataAccess::GetMethodDescDataImpl(
+    CLRDATA_ADDRESS methodDesc,
+    CLRDATA_ADDRESS ip,
+    struct DacpMethodDescData *methodDescData,
+    ULONG cRevertedRejitVersions,
+    DacpReJitData * rgRevertedRejitData,
+    ULONG * pcNeededRevertedRejitData)
+{
+
+    HRESULT hr = S_OK;
 
     PTR_MethodDesc pMD = PTR_MethodDesc(TO_TADDR(methodDesc));
 
@@ -1236,7 +1300,6 @@ HRESULT ClrDataAccess::GetMethodDescData(
         }
     }
 
-    SOSDacLeave();
     return hr;
 }
 

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -191,7 +191,7 @@ CDAC_TYPE_FIELD(Module, /*pointer*/, TypeDefToMethodTableMap, cdac_offsets<Modul
 CDAC_TYPE_FIELD(Module, /*pointer*/, TypeRefToMethodTableMap, cdac_offsets<Module>::TypeRefToMethodTableMap)
 CDAC_TYPE_END(Module)
 
-// Metadata
+// RuntimeTypeSystem
 
 CDAC_TYPE_BEGIN(MethodTable)
 CDAC_TYPE_INDETERMINATE(MethodTable)
@@ -212,6 +212,7 @@ CDAC_TYPE_FIELD(EEClass, /*pointer*/, MethodTable, cdac_offsets<EEClass>::Method
 CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumMethods, cdac_offsets<EEClass>::NumMethods)
 CDAC_TYPE_FIELD(EEClass, /*uint32*/, CorTypeAttr, cdac_offsets<EEClass>::CorTypeAttr)
 CDAC_TYPE_FIELD(EEClass, /*uint8*/, InternalCorElementType, cdac_offsets<EEClass>::InternalCorElementType)
+CDAC_TYPE_FIELD(EEClass, /*uint16*/, NumNonVirtualSlots, cdac_offsets<EEClass>::NumNonVirtualSlots)
 CDAC_TYPE_END(EEClass)
 
 CDAC_TYPE_BEGIN(ArrayClass)
@@ -252,6 +253,21 @@ CDAC_TYPE_FIELD(DynamicMetadata, /*uint32*/, Size, cdac_offsets<DynamicMetadata>
 CDAC_TYPE_FIELD(DynamicMetadata, /*inline byte array*/, Data, cdac_offsets<DynamicMetadata>::Data)
 CDAC_TYPE_END(DynamicMetadata)
 
+CDAC_TYPE_BEGIN(MethodDesc)
+CDAC_TYPE_INDETERMINATE(MethodDesc)
+CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, ChunkIndex, cdac_offsets<MethodDesc>::ChunkIndex)
+CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, Slot, cdac_offsets<MethodDesc>::Slot)
+CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags, cdac_offsets<MethodDesc>::Flags)
+CDAC_TYPE_END(MethodDesc)
+
+CDAC_TYPE_BEGIN(MethodDescChunk)
+CDAC_TYPE_SIZE(sizeof(MethodDescChunk))
+CDAC_TYPE_FIELD(MethodDescChunk, /*pointer*/, MethodTable, cdac_offsets<MethodDescChunk>::MethodTable)
+CDAC_TYPE_FIELD(MethodDescChunk, /*pointer*/, Next, cdac_offsets<MethodDescChunk>::Next)
+CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Size, cdac_offsets<MethodDescChunk>::Size)
+CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Count, cdac_offsets<MethodDescChunk>::Count)
+CDAC_TYPE_END(MethodDescChunk)
+
 CDAC_TYPES_END()
 
 CDAC_GLOBALS_BEGIN()
@@ -265,6 +281,7 @@ CDAC_GLOBAL(FeatureEHFunclets, uint8, 1)
 CDAC_GLOBAL(FeatureEHFunclets, uint8, 0)
 #endif
 CDAC_GLOBAL(SOSBreakingChangeVersion, uint8, SOS_BREAKING_CHANGE_VERSION)
+CDAC_GLOBAL(MethodDescAlignment, uint64, MethodDesc::ALIGNMENT)
 CDAC_GLOBAL_POINTER(FreeObjectMethodTable, &::g_pFreeObjectMethodTable)
 CDAC_GLOBAL_POINTER(MiniMetaDataBuffAddress, &::g_MiniMetaDataBuffAddress)
 CDAC_GLOBAL_POINTER(MiniMetaDataBuffMaxSize, &::g_MiniMetaDataBuffMaxSize)

src/coreclr/vm/class.h

@@ -1807,6 +1807,7 @@ template<> struct cdac_offsets<EEClass>
     static constexpr size_t MethodTable = offsetof(EEClass, m_pMethodTable);
     static constexpr size_t NumMethods = offsetof(EEClass, m_NumMethods);
     static constexpr size_t CorTypeAttr = offsetof(EEClass, m_dwAttrClass);
+    static constexpr size_t NumNonVirtualSlots = offsetof(EEClass, m_NumNonVirtualSlots);
 };
 
 // --------------------------------------------------------------------------------------------

src/coreclr/vm/method.hpp

@@ -1908,6 +1908,15 @@ class MethodDesc
 public:
     static void Init();
 #endif
+
+    template<typename T> friend struct ::cdac_offsets;
+};
+
+template<> struct cdac_offsets<MethodDesc>
+{
+    static const size_t ChunkIndex = offsetof(MethodDesc, m_chunkIndex);
+    static const size_t Slot = offsetof(MethodDesc, m_wSlotNumber);
+    static const size_t Flags = offsetof(MethodDesc, m_wFlags);
 };
 
 #ifndef DACCESS_COMPILE
@@ -2328,6 +2337,17 @@ class MethodDescChunk
     UINT16               m_flagsAndTokenRange;
 
     // Followed by array of method descs...
+
+    template<typename T> friend struct ::cdac_offsets;
+};
+
+template<>
+struct cdac_offsets<MethodDescChunk>
+{
+    static constexpr size_t MethodTable = offsetof(MethodDescChunk, m_methodTable);
+    static constexpr size_t Next = offsetof(MethodDescChunk, m_next);
+    static constexpr size_t Size = offsetof(MethodDescChunk, m_size);
+    static constexpr size_t Count = offsetof(MethodDescChunk, m_count);
 };
 
 inline int MethodDesc::GetMethodDescChunkIndex() const

src/coreclr/vm/methodtable.h

@@ -621,7 +621,7 @@ struct DynamicStaticsInfo
                 // If it has, then we don't need to do anything
                 return false;
             }
-            
+
             if (isClassInitedByUpdatingStaticPointer)
             {
                 oldValFromInterlockedOp = InterlockedCompareExchangeT(pAddr, newVal, oldVal);

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

@@ -20,5 +20,7 @@ internal static class Globals
 
         internal const string MiniMetaDataBuffAddress = nameof(MiniMetaDataBuffAddress);
         internal const string MiniMetaDataBuffMaxSize = nameof(MiniMetaDataBuffMaxSize);
+
+        internal const string MethodDescAlignment = nameof(MethodDescAlignment);
     }
 }

src/native/managed/cdacreader/src/Contracts/RuntimeTypeSystem.cs

@@ -55,16 +55,27 @@ internal enum CorElementType
     Sentinel = 0x41,
 }
 
+internal readonly struct MethodDescHandle
+{
+    internal MethodDescHandle(TargetPointer address)
+    {
+        Address = address;
+    }
+
+    internal TargetPointer Address { get; }
+}
+
 internal interface IRuntimeTypeSystem : IContract
 {
     static string IContract.Name => nameof(RuntimeTypeSystem);
     static IContract IContract.Create(Target target, int version)
     {
         TargetPointer targetPointer = target.ReadGlobalPointer(Constants.Globals.FreeObjectMethodTable);
         TargetPointer freeObjectMethodTable = target.ReadPointer(targetPointer);
+        ulong methodDescAlignment = target.ReadGlobal<ulong>(Constants.Globals.MethodDescAlignment);
         return version switch
         {
-            1 => new RuntimeTypeSystem_1(target, freeObjectMethodTable),
+            1 => new RuntimeTypeSystem_1(target, freeObjectMethodTable, methodDescAlignment),
             _ => default(RuntimeTypeSystem),
         };
     }
@@ -113,6 +124,11 @@ static IContract IContract.Create(Target target, int version)
     public virtual bool IsFunctionPointer(TypeHandle typeHandle, out ReadOnlySpan<TypeHandle> retAndArgTypes, out byte callConv) => throw new NotImplementedException();
     // Returns null if the TypeHandle is not a class/struct/generic variable
     #endregion TypeHandle inspection APIs
+
+    #region MethodDesc inspection APIs
+    public virtual MethodDescHandle GetMethodDescHandle(TargetPointer targetPointer) => throw new NotImplementedException();
+    public virtual TargetPointer GetMethodTable(MethodDescHandle methodDesc) => throw new NotImplementedException();
+    #endregion MethodDesc inspection APIs
 }
 
 internal struct RuntimeTypeSystem : IRuntimeTypeSystem