Adding GetReJITInformation cDAC API (#119111)

* Adding GetRejitInformation cDAC API

* Restructuring SHash

---------

Co-authored-by: Max Charlamb <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: Jan Kotas <[email protected]>

Author: 4 people

docs/design/datacontracts/CodeVersions.md

@@ -45,6 +45,9 @@ public virtual TargetCodePointer GetNativeCode(NativeCodeVersionHandle codeVersi
 
 // Gets the GCStressCodeCopy pointer if available, otherwise returns TargetPointer.Null
 public virtual TargetPointer GetGCStressCodeCopy(NativeCodeVersionHandle codeVersionHandle);
+
+// Gets the IL address given a code version
+public virtual TargetPointer GetIL(ILCodeVersionHandle ilCodeVersionHandle);
 ```
 ### Extension Methods
 ```csharp
@@ -74,6 +77,8 @@ Data descriptors used:
 | ILCodeVersioningState | ActiveVersionMethodDef | if the active version is synthetic or unknown, the MethodDef token for the method |
 | ILCodeVersionNode | VersionId | Version ID of the node |
 | ILCodeVersionNode | Next | Pointer to the next `ILCodeVersionNode`|
+| ILCodeVersionNode | RejitState | ReJIT state of the node |
+| ILCodeVersionNode | ILAddress | Address of IL corresponding to `ILCodeVersionNode`|
 | GCCoverageInfo | SavedCode | Pointer to the GCCover saved code copy, if supported |
 
 The flag indicates that the default version of the code for a method desc is active:
@@ -111,6 +116,60 @@ Contracts used:
 | Loader |
 | RuntimeTypeSystem |
 
+Implementation of CodeVersionHandles
+
+```csharp
+private readonly struct ILCodeVersionHandle
+{
+    public readonly TargetPointer Module;
+    public readonly uint MethodDefinition;
+    public readonly TargetPointer ILCodeVersionNode;
+    private ILCodeVersionHandle(TargetPointer module, uint methodDef, TargetPointer ilCodeVersionNodeAddress)
+    {
+        Module = module;
+        MethodDefinition = methodDef;
+        ILCodeVersionNode = ilCodeVersionNodeAddress;
+    }
+
+    // for more information on Explicit/Synthetic code versions see docs/design/features/code-versioning.md
+    public static ILCodeVersionHandle CreateExplicit(TargetPointer ilCodeVersionNodeAddress) =>
+        // create handle from node address
+    public static ILCodeVersionHandle CreateSynthetic(TargetPointer module, uint methodDef) =>
+        // create handle from module and methodDef
+
+    public static ILCodeVersionHandle Invalid { get; } = // everything is null
+
+    public bool IsValid => // either module or node addr is non nulls
+
+    public bool IsExplicit => ILCodeVersionNode != TargetPointer.Null;
+}
+```
+
+```csharp
+private readonly struct NativeCodeVersionHandle
+{
+    public readonly TargetPointer MethodDescAddress;
+    public readonly TargetPointer CodeVersionNodeAddress;
+    private NativeCodeVersionHandle(TargetPointer methodDescAddress, TargetPointer codeVersionNodeAddress)
+    {
+        MethodDescAddress = methodDescAddress;
+        CodeVersionNodeAddress = codeVersionNodeAddress;
+    }
+
+    // for more information on Explicit/Synthetic code versions see docs/design/features/code-versioning.md
+    public static NativeCodeVersionHandle CreateExplicit(TargetPointer codeVersionNodeAddress) =>
+        // create handle from node address
+    public static NativeCodeVersionHandle CreateSynthetic(TargetPointer methodDescAddress) =>
+        // create handle from method desc
+
+    public static NativeCodeVersionHandle Invalid { get; } = // all is null
+
+    public bool Valid => // either method desc or node address is non null
+
+    public bool IsExplicit => CodeVersionNodeAddress != TargetPointer.Null;
+}
+```
+
 ### Finding active ILCodeVersion for a method
 ```csharp
 public virtual ILCodeVersionHandle GetActiveILCodeVersion(TargetPointer methodDesc);
@@ -295,3 +354,29 @@ public virtual TargetPointer GetGCStressCodeCopy(NativeCodeVersionHandle codeVer
 
 1. If `codeVersionHandle` is synthetic, use the `IRuntimeTypeSystem` to find the GCStressCodeCopy.
 2. If `codeVersionHandle` is explicit, read the `NativeCodeVersionNode` for the `GCCoverageInfo` pointer. This value only exists in some builds. If the value doesn't exist or is a nullptr, return `TargetPointer.Null`. Otherwise return the `SavedCode` pointer from the `GCCoverageInfo` struct.
+
+### Finding IL address for method
+```csharp
+TargetPointer ICodeVersions.GetIL(ILCodeVersionHandle ilCodeVersionHandle, TargetPointer methodDescPtr)
+{
+    TargetPointer ilAddress = default;
+    if (ilCodeVersionHandle.IsExplicit)
+    {
+        ilAddress = target.ReadPointer(ilCodeVersionHandle.ILCodeVersionNode + /* ILCodeVersionNode::ILAddress offset */)
+    }
+
+    // For the default code version we always fetch the globally stored default IL for a method
+    // See src/coreclr/vm/codeversion.cpp for more detailed implementation comments.
+
+    if (ilAddress == TargetPointer.Null)
+    {
+        // Synthetic ILCodeVersion, get the IL from the module and method def
+
+        ILoader loader = _target.Contracts.Loader;
+        ModuleHandle moduleHandle = loader.GetModuleHandleFromModulePtr(ilCodeVersionHandle.Module);
+        ilAddress = loader.GetILHeader(moduleHandle, ilCodeVersionHandle.MethodDefinition);
+    }
+
+    return ilAddress;
+}
+```

docs/design/datacontracts/Loader.md

@@ -106,6 +106,7 @@ TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer);
 | `Module` | `MethodDefToDescMap` | Mapping table |
 | `Module` | `TypeDefToMethodTableMap` | Mapping table |
 | `Module` | `TypeRefToMethodTableMap` | Mapping table |
+| `Module` | `DynamicILBlobTable` | pointer to the table of dynamic IL |
 | `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 |
@@ -149,6 +150,12 @@ TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer);
 | `InstMethodHashTable` | `Count` | Count of elements in the hash table |
 | `InstMethodHashTable` | `VolatileEntryValue` | The data stored in the hash table entry |
 | `InstMethodHashTable` | `VolatileEntryNextEntry` | Next pointer in the hash table entry |
+| `DynamicILBlobTable` | `Table` | Pointer to IL blob table |
+| `DynamicILBlobTable` | `TableSize` | Number of entries in table |
+| `DynamicILBlobTable` | `EntrySize` | Size of each table entry |
+| `DynamicILBlobTable` | `EntryMethodToken` | Offset of each entry method token from entry address |
+| `DynamicILBlobTable` | `EntryIL` | Offset of each entry IL from entry address |
+
 
 
 ### Global variables used:
@@ -164,6 +171,12 @@ TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer);
 | `ASSEMBLY_LEVEL_LOADED` | uint | The value of Assembly Level required for an Assembly to be considered loaded. In the runtime, this is `FILE_LOAD_DELIVER_EVENTS` | `0x4` |
 | `ASSEMBLY_NOTIFYFLAGS_PROFILER_NOTIFIED` | uint | Flag in Assembly NotifyFlags indicating the Assembly will notify profilers. | `0x1` |
 
+Contracts used:
+| Contract Name |
+| --- |
+| EcmaMetadata |
+| SHash |
+
 ### Data Structures
 ```csharp
 // The runtime representation of Module's flag field.
@@ -625,6 +638,42 @@ TargetPointer GetObjectHandle(TargetPointer loaderAllocatorPointer)
     return target.ReadPointer(loaderAllocatorPointer + /* LoaderAllocator::ObjectHandle offset */);
 }
 
+private sealed class DynamicILBlobTraits : ITraits<uint, DynamicILBlobEntry>
+{
+    public uint GetKey(DynamicILBlobEntry entry) => entry.EntryMethodToken;
+    public bool Equals(uint left, uint right) => left == right;
+    public uint Hash(uint key) => key;
+    public bool IsNull(DynamicILBlobEntry entry) => entry.EntryMethodToken == 0;
+    public DynamicILBlobEntry Null() => new DynamicILBlobEntry(0, TargetPointer.Null);
+    public bool IsDeleted(DynamicILBlobEntry entry) => false;
+}
+
+TargetPointer GetILHeader(ModuleHandle handle, uint token)
+{
+    // we need module
+    ILoader loader = this;
+    TargetPointer peAssembly = loader.GetPEAssembly(handle);
+    TargetPointer headerPtr = GetDynamicIL(handle, token);
+    TargetPointer dynamicBlobTablePtr = target.ReadPointer(handle.Address + /* Module::DynamicILBlobTable offset */);
+    Contracts.IThread shashContract = target.Contracts.SHash;
+    DynamicILBlobTraits traits = new();
+    /* To construct an SHash we must pass a DataType enum.
+    We must be able to look up this enum in a dictionary of known types and retrieve a Target.TypeInfo struct.
+    This struct contains a dictionary of fields with keys corresponding to the names of offsets
+    and values corresponding to the offset values. Optionally, it contains a Size field.
+    */
+    SHash<uint, Data.DynamicILBlobEntry> shash = shashContract.CreateSHash<uint, Data.DynamicILBlobEntry>(target, dynamicBlobTablePtr, DataType.DynamicILBlobTable, traits)
+    Data.DynamicILBlobEntry blobEntry = shashContract.LookupSHash(shash, token);
+    if (blobEntry.EntryIL == TargetPointer.Null)
+    {
+        IEcmaMetadata ecmaMetadataContract = _target.Contracts.EcmaMetadata;
+        MetadataReader mdReader = ecmaMetadataContract.GetMetadata(handle)!;
+        MethodDefinition methodDef = mdReader.GetMethodDefinition(MetadataTokens.MethodDefinitionHandle(token));
+        int rva = methodDef.RelativeVirtualAddress;
+        headerPtr = loader.GetILAddr(peAssembly, rva);
+    }
+    return headerPtr;
+}
 ```
 
 ### DacEnumerableHash (EETypeHashTable and InstMethodHashTable)

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -182,6 +182,7 @@ partial interface IRuntimeTypeSystem : IContract
 
     // Gets the GCStressCodeCopy pointer if available, otherwise returns TargetPointer.Null
     public virtual TargetPointer GetGCStressCodeCopy(MethodDescHandle methodDesc);
+
 }
 ```
 

docs/design/datacontracts/SHash.md

@@ -0,0 +1,98 @@
+# Contract SHash
+
+This contract is for creating and using the SHash data structure.
+
+## APIs of contract
+
+```csharp
+public interface ITraits<TKey, TEntry>
+{
+    TKey GetKey(TEntry entry);
+    bool Equals(TKey left, TKey right);
+    uint Hash(TKey key);
+    bool IsNull(TEntry entry);
+    TEntry Null();
+    bool IsDeleted(TEntry entry);
+}
+
+public interface ISHash<TKey, TEntry> where TEntry : IData<TEntry>
+{
+
+}
+```
+
+``` csharp
+TEntry LookupSHash<TKey, TEntry>(ISHash<TKey, TEntry> hashTable, TKey key) where TEntry : IData<TEntry>;
+SHash<TKey, TEntry> CreateSHash<TKey, TEntry>(Target target, TargetPointer address, Target.TypeInfo type, ITraits<TKey, TEntry> traits) where TEntry : IData<TEntry>;
+```
+
+## Version 1
+
+In order to properly populate an SHash, we need to know the size of each element, which varies from instantiation to instantiation of SHash. Therefore, we pass as an argument the DataType ```type``` which contains the particular offsets.
+
+Data descriptors used:
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| `type` | `Table` | Address of the SHash table |
+| `type` | `TableSize` | Number of entries in the table |
+| `type` | `EntrySize` | Size in bytes of each table entry |
+
+``` csharp
+
+private class SHash<TKey, TEntry> : ISHash<TKey, TEntry> where TEntry : IData<TEntry>
+{
+    public TargetPointer Table { get; set; }
+    public uint TableSize { get; set; }
+    public uint EntrySize { get; set; }
+    public List<TEntry>? Entries { get; set; }
+    public ITraits<TKey, TEntry>? Traits { get; set; }
+}
+
+ISHash<TKey, TEntry> ISHash.CreateSHash<TKey, TEntry>(Target target, TargetPointer address, Target.TypeInfo type, ITraits<TKey, TEntry> traits)
+{
+    TargetPointer table = target.ReadPointer(address + /* type::Table offset */);
+    uint tableSize = target.Read<uint>(address + /* type::TableSize offset */);
+    uint entrySize = target.Read<uint>(address + /* type::EntrySize offset */);
+    List<TEntry> entries = [];
+    for (int i = 0; i < tableSize; i++)
+    {
+        TargetPointer entryAddress = table + (ulong)(i * entrySize);
+        TEntry entry = new TEntry(entryAddress);
+        entries.Add(entry);
+    }
+    return new SHash<TKey, TEntry>
+    {
+        Table = table,
+        TableSize = tableSize,
+        EntrySize = entrySize,
+        Traits = traits,
+        Entries = entries
+    };
+}
+TEntry ISHash.LookupSHash<TKey, TEntry>(ISHash<TKey, TEntry> hashTable, TKey key)
+{
+    SHash<TKey, TEntry> shashTable = (SHash<TKey, TEntry>)hashTable;
+    if (shashTable.TableSize == 0)
+        return shashTable.Traits!.Null();
+
+    uint hash = shashTable.Traits!.Hash(key);
+    uint index = hash % shashTable.TableSize;
+    uint increment = 0;
+    while (true)
+    {
+        TEntry current = shashTable.Entries![(int)index];
+        if (shashTable.Traits.IsNull(current))
+            return shashTable.Traits.Null();
+        // we don't support the removal of entries
+        if (!shashTable.Traits.IsDeleted(current) && shashTable.Traits.Equals(key, shashTable.Traits.GetKey(current)))
+            return current;
+
+        if (increment == 0)
+            increment = (hash % (shashTable.TableSize - 1)) + 1;
+
+        index += increment;
+        if (index >= shashTable.TableSize)
+            index -= shashTable.TableSize;
+    }
+}
+```

src/coreclr/inc/shash.h

@@ -9,6 +9,7 @@
 #include "clrtypes.h"
 #include "check.h"
 #include "iterator.h"
+#include "../vm/cdacdata.h"
 
 // SHash is a templated closed chaining hash table of pointers.  It provides
 // for multiple entries under the same key, and also for deleting elements.
@@ -593,6 +594,7 @@ class EMPTY_BASES_DECL SHash : public TRAITS
     count_t       m_tableCount;           // number of elements in table
     count_t       m_tableOccupied;        // number, includes deleted slots
     count_t       m_tableMax;             // maximum occupied count before reallocating
+    friend struct ::cdac_data<SHash<TRAITS>>;
 };  // class SHash
 
 // disables support for DAC marshaling. Useful for defining right-side only SHashes

src/coreclr/vm/ceeload.h

@@ -424,6 +424,16 @@ class DynamicILBlobTraits : public NoRemoveSHashTraits<DefaultSHashTraits<Dynami
 typedef SHash<DynamicILBlobTraits> DynamicILBlobTable;
 typedef DPTR(DynamicILBlobTable) PTR_DynamicILBlobTable;
 
+template<>
+struct cdac_data<DynamicILBlobTable>
+{
+    static constexpr size_t Table = offsetof(DynamicILBlobTable, m_table);
+    static constexpr size_t TableSize = offsetof(DynamicILBlobTable, m_tableSize);
+    static constexpr size_t EntrySize = sizeof(DynamicILBlobEntry);
+    static constexpr size_t EntryMethodToken = offsetof(DynamicILBlobEntry, m_methodToken);
+    static constexpr size_t EntryIL = offsetof(DynamicILBlobEntry, m_il);
+};
+
 #ifdef FEATURE_READYTORUN
 typedef DPTR(class ReadyToRunInfo)      PTR_ReadyToRunInfo;
 #endif
@@ -1705,6 +1715,7 @@ struct cdac_data<Module>
     static constexpr size_t TypeDefToMethodTableMap = offsetof(Module, m_TypeDefToMethodTableMap);
     static constexpr size_t TypeRefToMethodTableMap = offsetof(Module, m_TypeRefToMethodTableMap);
     static constexpr size_t MethodDefToILCodeVersioningStateMap = offsetof(Module, m_ILCodeVersioningStateMap);
+    static constexpr size_t DynamicILBlobTable = offsetof(Module, m_debuggerSpecificData.m_pDynamicILBlobTable);
 };
 
 //

src/coreclr/vm/codeversion.cpp

@@ -917,11 +917,41 @@ PTR_COR_ILMETHOD ILCodeVersion::GetIL() const
     if(pIL == NULL)
     {
         PTR_Module pModule = GetModule();
-        PTR_MethodDesc pMethodDesc = dac_cast<PTR_MethodDesc>(pModule->LookupMethodDef(GetMethodDef()));
-        if (pMethodDesc != NULL && pMethodDesc->MayHaveILHeader())
+        // Always pickup overrides like reflection emit, EnC, etc. irrespective of RVA.
+        // Profilers can attach dynamic IL to methods with zero RVA.
+        mdMethodDef methodDef = GetMethodDef();
+        TADDR pIL = pModule->GetDynamicIL(methodDef);
+        if (pIL == (TADDR)NULL)
         {
-            pIL = dac_cast<PTR_COR_ILMETHOD>(pMethodDesc->GetILHeader());
+            DWORD rva;
+            DWORD dwImplFlags;
+            if (methodDef & 0x00FFFFFF)
+            {
+                if (FAILED(pModule->GetMDImport()->GetMethodImplProps(methodDef, &rva, &dwImplFlags)))
+                {   // Class loader already asked for MethodImpls, so this should always succeed (unless there's a
+                    // bug or a new code path)
+                    _ASSERTE(!"If this ever fires, then this method should return HRESULT");
+                    rva = 0;
+                }
+
+                // RVA points to IL header only when the code type is IL
+                if (!IsMiIL(dwImplFlags))
+                {
+                    rva = 0;
+                }
+            }
+            else
+            {
+                rva = 0;
+            }
+            pIL = pModule->GetIL(rva);
         }
+
+#ifdef DACCESS_COMPILE
+        return (pIL != (TADDR)NULL) ? dac_cast<PTR_COR_ILMETHOD>(DacGetIlMethod(pIL)) : NULL;
+#else // !DACCESS_COMPILE
+        return PTR_COR_ILMETHOD(pIL);
+#endif // !DACCESS_COMPILE
     }
 
     return pIL;

src/coreclr/vm/codeversion.h

@@ -426,6 +426,7 @@ struct cdac_data<ILCodeVersionNode>
     static constexpr size_t VersionId = offsetof(ILCodeVersionNode, m_rejitId);
     static constexpr size_t Next = offsetof(ILCodeVersionNode, m_pNextILVersionNode);
     static constexpr size_t RejitState = offsetof(ILCodeVersionNode, m_rejitState);
+    static constexpr size_t ILAddress = offsetof(ILCodeVersionNode, m_pIL);
 };
 
 class ILCodeVersionCollection

src/coreclr/vm/datadescriptor/contracts.jsonc

@@ -22,7 +22,8 @@
   "ReJIT": 1,
   "RuntimeInfo": 1,
   "RuntimeTypeSystem": 1,
+  "SHash": 1,
   "StackWalk": 1,
   "StressLog": 2,
   "Thread": 1
-}
+}