[cdac] Basic ISOSDacInterface::GetMethodDescData

docs/design/datacontracts/CodeVersions.md

@@ -0,0 +1,149 @@
+# Contract CodeVersions
+
+This contract encapsulates support for [code versioning](../features/code-versioning.md) in the runtime.
+
+## APIs of contract
+
+```csharp
+internal struct NativeCodeVersionHandle
+{
+    // no public constructors
+    internal readonly TargetPointer MethodDescAddress;
+    internal readonly TargetPointer CodeVersionNodeAddress;
+    internal NativeCodeVersionHandle(TargetPointer methodDescAddress, TargetPointer codeVersionNodeAddress)
+    {
+        if (methodDescAddress != TargetPointer.Null && codeVersionNodeAddress != TargetPointer.Null)
+        {
+            throw new ArgumentException("Only one of methodDescAddress and codeVersionNodeAddress can be non-null");
+        }
+        MethodDescAddress = methodDescAddress;
+        CodeVersionNodeAddress = codeVersionNodeAddress;
+    }
+
+    internal static NativeCodeVersionHandle Invalid => new(TargetPointer.Null, TargetPointer.Null);
+    public bool Valid => MethodDescAddress != TargetPointer.Null || CodeVersionNodeAddress != TargetPointer.Null;
+}
+```
+
+```csharp
+    // Return a handle to the version of the native code that includes the given instruction pointer
+    public virtual NativeCodeVersionHandle GetSpecificNativeCodeVersion(TargetCodePointer ip) => throw new NotImplementedException();
+    // Return a handle to the active version of the native code for a given method descriptor
+    public virtual NativeCodeVersionHandle GetActiveNativeCodeVersion(TargetPointer methodDesc) => throw new NotImplementedException();
+
+    // returns true if the given method descriptor supports multiple code versions
+    public virtual bool CodeVersionManagerSupportsMethod(TargetPointer methodDesc) => throw new NotImplementedException();
+
+    // Return the instruction pointer corresponding to the start of the given native code version
+    public virtual TargetCodePointer GetNativeCode(NativeCodeVersionHandle codeVersionHandle) => throw new NotImplementedException();
+```
+
+## Version 1
+
+Data descriptors used:
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| MethodDescVersioningState | ? | ? |
+| NativeCodeVersionNode | ? | ? |
+| ILCodeVersioningState | ? | ? |
+
+
+Global variables used:
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+
+Contracts used:
+| Contract Name |
+| --- |
+| ExecutionManager |
+| Loader |
+| RuntimeTypeSystem |
+
+### Finding the start of a specific native code version
+
+```csharp
+    NativeCodeVersionHandle GetSpecificNativeCodeVersion(TargetCodePointer ip)
+    {
+        Contracts.IExecutionManager executionManager = _target.Contracts.ExecutionManager;
+        EECodeInfoHandle? info = executionManager.GetEECodeInfoHandle(ip);
+        if (!info.HasValue)
+        {
+            return NativeCodeVersionHandle.Invalid;
+        }
+        TargetPointer methodDescAddress = executionManager.GetMethodDesc(info.Value);
+        if (methodDescAddress == TargetPointer.Null)
+        {
+            return NativeCodeVersionHandle.Invalid;
+        }
+        IRuntimeTypeSystem rts = _target.Contracts.RuntimeTypeSystem;
+        MethodDescHandle md = rts.GetMethodDescHandle(methodDescAddress);
+        if (!rts.IsVersionable(md))
+        {
+            return new NativeCodeVersionHandle(methodDescAddress, codeVersionNodeAddress: TargetPointer.Null);
+        }
+        else
+        {
+            TargetCodePointer startAddress = executionManager.GetStartAddress(info.Value);
+            return GetSpecificNativeCodeVersion(md, startAddress);
+        }
+    }
+
+    private NativeCodeVersionHandle GetSpecificNativeCodeVersion(MethodDescHandle md, TargetCodePointer startAddress)
+    {
+        TargetPointer methodDescVersioningStateAddress = target.Contracts.RuntimeTypeSystem.GetMethodDescVersioningState(md);
+        if (methodDescVersioningStateAddress == TargetPointer.Null)
+        {
+            return NativeCodeVersionHandle.Invalid;
+        }
+        Data.MethodDescVersioningState methodDescVersioningStateData = _target.ProcessedData.GetOrAdd<Data.MethodDescVersioningState>(methodDescVersioningStateAddress);
+        // CodeVersionManager::GetNativeCodeVersion(PTR_MethodDesc, PCODE startAddress)
+        return FindFirstCodeVersion(methodDescVersioningStateData, (codeVersion) =>
+        {
+            return codeVersion.MethodDesc == md.Address && codeVersion.NativeCode == startAddress;
+        });
+    }
+
+    private NativeCodeVersionHandle FindFirstCodeVersion(Data.MethodDescVersioningState versioningState, Func<Data.NativeCodeVersionNode, bool> predicate)
+    {
+        // NativeCodeVersion::Next, heavily inlined
+        TargetPointer currentAddress = versioningState.NativeCodeVersionNode;
+        while (currentAddress != TargetPointer.Null)
+        {
+            Data.NativeCodeVersionNode current = _target.ProcessedData.GetOrAdd<Data.NativeCodeVersionNode>(currentAddress);
+            if (predicate(current))
+            {
+                return new NativeCodeVersionHandle(methodDescAddress: TargetPointer.Null, currentAddress);
+            }
+            currentAddress = current.Next;
+        }
+        return NativeCodeVersionHandle.Invalid;
+    }
+```
+
+### Finding the active native code version of a method descriptor
+
+```csharp
+    NativeCodeVersionHandle ICodeVersions.GetActiveNativeCodeVersion(TargetPointer methodDesc)
+    {
+        // CodeVersionManager::GetActiveILCodeVersion
+        // then ILCodeVersion::GetActiveNativeCodeVersion
+        IRuntimeTypeSystem rts = _target.Contracts.RuntimeTypeSystem;
+        MethodDescHandle md = rts.GetMethodDescHandle(methodDesc);
+        TargetPointer mtAddr = rts.GetMethodTable(md);
+        TypeHandle typeHandle = rts.GetTypeHandle(mtAddr);
+        TargetPointer module = rts.GetModule(typeHandle);
+        uint methodDefToken = rts.GetMethodToken(md);
+        ILCodeVersionHandle methodDefActiveVersion = FindActiveILCodeVersion(module, methodDefToken);
+        if (!methodDefActiveVersion.IsValid)
+        {
+            return NativeCodeVersionHandle.Invalid;
+        }
+        return FindActiveNativeCodeVersion(methodDefActiveVersion, methodDesc);
+    }
+```
+
+**FIXME**
+
+### Determining whether a method descriptor supports code versioning
+
+**TODO**

docs/design/datacontracts/ExecutionManager.md

@@ -0,0 +1,57 @@
+# Contract ExecutionManager
+
+This contract
+
+
+## APIs of contract
+
+```csharp
+internal struct EECodeInfoHandle
+{
+    // no public constructor
+    public readonly TargetPointer Address;
+    internal EECodeInfoHandle(TargetPointer address) => Address = address;
+}
+```
+
+```csharp
+    // Collect execution engine info for a code block that includes the given instruction pointer.
+    // Return a handle for the information, or null if an owning code block cannot be found.
+    EECodeInfoHandle? GetEECodeInfoHandle(TargetCodePointer ip);
+    // Get the method descriptor corresponding to the given code block
+    TargetPointer GetMethodDesc(EECodeInfoHandle codeInfoHandle) => throw new NotImplementedException();
+    // Get the instruction pointer address of the start of the code block
+    TargetCodePointer GetStartAddress(EECodeInfoHandle codeInfoHandle) => throw new NotImplementedException();
+```
+
+## Version 1
+
+Data descriptors used:
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| RangeSectionMap | TopLevelData | pointer to the outermost RangeSection |
+| RangeSectionFragment| ? | ? |
+| RangeSection | ? | ? |
+| RealCodeHeader | ? | ? |
+| HeapList | ? | ? |
+
+
+
+Global variables used:
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+| ExecutionManagerCodeRangeMapAddress | TargetPointer | Pointer to the global RangeSectionMap
+| StubCodeBlockLast | uint8 | Maximum sentinel code header value indentifying a stub code block
+
+Contracts used:
+| Contract Name |
+| --- |
+
+```csharp
+```
+
+**TODO** Methods
+
+### NibbleMap
+
+**TODO**

docs/design/datacontracts/Loader.md

@@ -38,6 +38,9 @@ TargetPointer GetLoaderAllocator(ModuleHandle handle);
 TargetPointer GetThunkHeap(ModuleHandle handle);
 TargetPointer GetILBase(ModuleHandle handle);
 ModuleLookupTables GetLookupTables(ModuleHandle handle);
+TargetPointer GetModuleLookupMapElement(TargetPointer table, uint rid, out TargetNUInt flags);
+bool IsCollectibleLoaderAllocator(ModuleHandle handle);
+
 ```
 
 ## Version 1
@@ -58,6 +61,10 @@ Data descriptors used:
 | `Module` | `TypeDefToMethodTableMap` | Mapping table |
 | `Module` | `TypeRefToMethodTableMap` | Mapping table |
 | `ModuleLookupMap` | `TableData` | Start of the mapping table's data |
+| `ModuleLookupMap` | `SupportedFlagsMask` | Mask for flag bits on lookup map entries |
+| `ModuleLookupMap` | `Count` | Number of TargetPointer sized entries in this section of the map |
+| `ModuleLookupMap` | `Next` | Pointer to next ModuleLookupMap segment for this map
+| `LoaderAllocator` | `IsCollectible` | Flag indicating if this is loader allocator may be collected
 
 ``` csharp
 ModuleHandle GetModuleHandle(TargetPointer modulePointer)
@@ -110,3 +117,5 @@ ModuleLookupTables GetLookupTables(ModuleHandle handle)
         Module::MethodDefToILCodeVersioningState */));
 }
 ```
+
+**TODO* pseudocode for IsCollectibleLoaderAllocator  and LookupTableMap element lookup

docs/design/datacontracts/ReJIT.md

@@ -0,0 +1,37 @@
+# Contract ReJIT
+
+This contract encapsulates support for [ReJIT](../features/code-versioning.md) in the runtime.
+
+## APIs of contract
+
+```csharp
+bool IsEnabled();
+```
+
+## Version 1
+
+Data descriptors used:
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| ProfControlBlock | GlobalEventMask | an `ICorProfiler` `COR_PRF_MONITOR` value |
+
+Global variables used:
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+|ProfilerControlBlock | TargetPointer | pointer to the `ProfControlBlock` |
+
+Contracts used:
+| Contract Name |
+| --- |
+
+```csharp
+bool IsEnabled()
+{
+    TargetPointer address = target.ReadGlobalPointer("ProfilerControlBlock");
+    ulong globalEventMask = target.Read<ulong>(address + /* ProfControlBlock::GlobalEventMask offset*/);
+    bool profEnabledReJIT = (GlobalEventMask & (ulong)COR_PRF_MONITOR.COR_PRF_ENABLE_REJIT) != 0;
+    bool clrConfigEnabledReJit = /* host process does not have environment variable DOTNET_ProfAPI_ReJitOnAttach set to 0 */;
+    // See https://github.com/dotnet/runtime/issues/106148
+    return profEnabledReJIT || clrConfigEnabledReJIT;
+}
+```

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -138,6 +138,28 @@ partial interface IRuntimeTypeSystem : IContract
     // Return true if a MethodDesc represents an IL Stub dynamically generated by the runtime
     // A IL Stub method is also a StoredSigMethodDesc, and a NoMetadataMethod
     public virtual bool IsILStub(MethodDescHandle methodDesc);
+
+    // Return true if a MethodDesc is in a collectible module
+    public virtual bool IsCollectibleMethod(MethodDescHandle methodDesc);
+
+    // Return true if a MethodDesc supports mulitiple code versions
+    public virtual bool IsVersionable(MethodDescHandle methodDesc);
+
+    // Return a pointer to the IL versioning state of the MethodDesc
+    public virtual TargetPointer GetMethodDescVersioningState(MethodDescHandle methodDesc);
+
+    // Return the MethodTable slot number of the MethodDesc
+    public virtual ushort GetSlotNumber(MethodDescHandle methodDesc);
+
+    // Return true if the MethodDesc has space associated with it for storing a pointer to a code block
+    public virtual bool HasNativeCodeSlot(MethodDescHandle methodDesc);
+
+    // Return the address of the space that stores a pointer to a code block associated with the MethodDesc
+    public virtual TargetPointer GetAddressOfNativeCodeSlot(MethodDescHandle methodDesc);
+
+    // Get an instruction pointer that can be called to cause the MethodDesc to be executed
+    public virtual TargetCodePointer GetNativeCode(MethodDescHandle methodDesc);
+
 }
 ```
 
@@ -606,6 +628,7 @@ The version 1 `MethodDesc` APIs depend on the `MethodDescAlignment` global and t
 | `MethodDescAlignment` | `MethodDescChunk` trailing data is allocated in multiples of this constant.  The size (in bytes) of each `MethodDesc` (or subclass) instance is a multiple of this constant. |
 | `MethodDescTokenRemainderBitCount` | Number of bits in the token remainder in `MethodDesc` |
 
+**TODO** MethodDesc code pointers additions
 
 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.
@@ -630,6 +653,15 @@ We depend on the following data descriptors:
 | `StoredSigMethodDesc` | `ExtendedFlags` | Flags field for the `StoredSigMethodDesc` |
 | `DynamicMethodDesc` | `MethodName` | Pointer to Null-terminated UTF8 string describing the Method desc |
 
+**TODO** MethodDesc code pointers additions
+
+The contract depends on the following other contracts
+
+| Contract |
+| --- |
+| Loader |
+| ReJIT |
+| CodeVersions |
 
 And the following enumeration definitions
 
@@ -820,4 +852,4 @@ And the various apis are implemented with the following algorithms
         return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsILStub);
     }
 ```
-**TODO(cdac)**
+**TODO(cdac)** additional code pointers methods on MethodDesc

src/coreclr/debug/daccess/request.cpp

@@ -1089,7 +1089,17 @@ HRESULT ClrDataAccess::GetMethodDescData(
             _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
+            _ASSERTE(methodDescData->MethodDescPtr == mdDataLocal.MethodDescPtr);
+            _ASSERTE(methodDescData->MethodTablePtr == mdDataLocal.MethodTablePtr);
+            _ASSERTE(methodDescData->ModulePtr == mdDataLocal.ModulePtr);
+            _ASSERTE(methodDescData->MDToken == mdDataLocal.MDToken);
+            _ASSERTE(methodDescData->GCInfo == mdDataLocal.GCInfo);
+            _ASSERTE(methodDescData->GCStressCodeCopy == mdDataLocal.GCStressCodeCopy);
+            _ASSERTE(methodDescData->managedDynamicMethodObject == mdDataLocal.managedDynamicMethodObject);
+            _ASSERTE(methodDescData->requestedIP == mdDataLocal.requestedIP);
+            // TODO[cdac]: cdacreader always returns 0 currently
+            _ASSERTE(methodDescData->cJittedRejitVersions == 0 || methodDescData->cJittedRejitVersions == mdDataLocal.cJittedRejitVersions);
+            // TODO[cdac]: compare rejitDataCurrent and rejitDataRequested, too
             if (rgRevertedRejitData != NULL)
             {
                 _ASSERTE (cNeededRevertedRejitDataLocal == *pcNeededRevertedRejitData);

src/coreclr/debug/runtimeinfo/.editorconfig

@@ -0,0 +1,2 @@
+[contracts.jsonc]
+indent_size = 2

src/coreclr/debug/runtimeinfo/contracts.jsonc

@@ -9,11 +9,15 @@
 // cdac-build-tool can take multiple "-c contract_file" arguments
 // so to conditionally include contracts, put additional contracts in a separate file
 {
+  "CodeVersions": 1,
   "DacStreams": 1,
   "EcmaMetadata" : 1,
   "Exception": 1,
+  "ExecutionManager": 1,
   "Loader": 1,
   "Object": 1,
+  "PrecodeStubs": 1,
+  "ReJIT": 1,
   "RuntimeTypeSystem": 1,
   "Thread": 1
 }