[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 GetNativeCodeVersionForIP(TargetCodePointer ip);
+    // Return a handle to the active version of the native code for a given method descriptor
+    public virtual NativeCodeVersionHandle GetActiveNativeCodeVersion(TargetPointer methodDesc);
+
+    // returns true if the given method descriptor supports multiple code versions
+    public virtual bool CodeVersionManagerSupportsMethod(TargetPointer methodDesc);
+
+    // Return the instruction pointer corresponding to the start of the given native code version
+    public virtual TargetCodePointer GetNativeCode(NativeCodeVersionHandle codeVersionHandle);
+```
+
+## 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 GetNativeCodeVersionForIP(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