[cdac] GetMethodDescData for jitted methods

docs/design/datacontracts/Loader.md

@@ -40,6 +40,7 @@ TargetPointer GetThunkHeap(ModuleHandle handle);
 TargetPointer GetILBase(ModuleHandle handle);
 ModuleLookupTables GetLookupTables(ModuleHandle handle);
 TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out TargetNUInt flags);
+bool IsCollectible(ModuleHandle handle);
 ```
 
 ## Version 1
@@ -64,6 +65,7 @@ Data descriptors used:
 | `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
+| `Assembly` | `IsCollectible` | Flag indicating if this is module may be collected
 
 ``` csharp
 ModuleHandle GetModuleHandle(TargetPointer modulePointer)
@@ -151,3 +153,12 @@ TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out Tar
     return TargetPointer.Null;
 }
 ```
+
+```csharp
+bool ILoader.IsCollectible(ModuleHandle handle)
+{
+    TargetPointer assembly = _target.ReadPointer(handle.Address + /*Module::Assembly*/);
+    byte isCollectible = _target.Read<byte>(assembly + /* Assembly::IsCollectible*/);
+    return isCollectible != 0;
+}
+```

docs/design/datacontracts/ReJIT.md

@@ -0,0 +1,43 @@
+# 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
+// see src/coreclr/inc/corprof.idl
+[Flags]
+private enum COR_PRF_MONITOR
+{
+    COR_PRF_ENABLE_REJIT = 0x00040000,
+}
+
+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 */;
+    return profEnabledReJIT || clrConfigEnabledReJIT;
+}
+```

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -148,6 +148,15 @@ partial interface IRuntimeTypeSystem : IContract
     // 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);
 

src/coreclr/debug/runtimeinfo/contracts.jsonc

@@ -18,6 +18,7 @@
   "Object": 1,
   "PlatformMetadata": 1,
   "PrecodeStubs": 1,
+  "ReJIT": 1,
   "RuntimeTypeSystem": 1,
   "Thread": 1
 }

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -244,10 +244,17 @@ CDAC_TYPE_FIELD(ModuleLookupMap, /*uint32*/, Count, offsetof(LookupMapBase, dwCo
 CDAC_TYPE_FIELD(ModuleLookupMap, /*nuint*/, SupportedFlagsMask, offsetof(LookupMapBase, supportedFlags))
 CDAC_TYPE_END(ModuleLookupMap)
 
+CDAC_TYPE_BEGIN(Assembly)
+CDAC_TYPE_INDETERMINATE(Assembly)
+#ifdef FEATURE_COLLECTIBLE_TYPES
+CDAC_TYPE_FIELD(Assembly, /*uint8*/, IsCollectible, cdac_data<Assembly>::IsCollectible)
+#endif
+CDAC_TYPE_END(Assembly)
+
 // RuntimeTypeSystem
 
 CDAC_TYPE_BEGIN(MethodTable)
-CDAC_TYPE_INDETERMINATE(MethodTable)
+CDAC_TYPE_SIZE(sizeof(MethodTable))
 CDAC_TYPE_FIELD(MethodTable, /*uint32*/, MTFlags, cdac_data<MethodTable>::MTFlags)
 CDAC_TYPE_FIELD(MethodTable, /*uint32*/, BaseSize, cdac_data<MethodTable>::BaseSize)
 CDAC_TYPE_FIELD(MethodTable, /*uint32*/, MTFlags2, cdac_data<MethodTable>::MTFlags2)
@@ -257,8 +264,14 @@ CDAC_TYPE_FIELD(MethodTable, /*pointer*/, ParentMethodTable, cdac_data<MethodTab
 CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumInterfaces, cdac_data<MethodTable>::NumInterfaces)
 CDAC_TYPE_FIELD(MethodTable, /*uint16*/, NumVirtuals, cdac_data<MethodTable>::NumVirtuals)
 CDAC_TYPE_FIELD(MethodTable, /*pointer*/, PerInstInfo, cdac_data<MethodTable>::PerInstInfo)
+CDAC_TYPE_FIELD(MethodTable, /*pointer*/, AuxiliaryData, cdac_data<MethodTable>::AuxiliaryData)
 CDAC_TYPE_END(MethodTable)
 
+CDAC_TYPE_BEGIN(MethodTableAuxiliaryData)
+CDAC_TYPE_INDETERMINATE(MethodTableAuxiliaryData)
+CDAC_TYPE_FIELD(MethodTableAuxiliaryData, /*pointer*/, LoaderModule, offsetof(MethodTableAuxiliaryData, m_pLoaderModule))
+CDAC_TYPE_END(MethodTableAuxiliaryData)
+
 CDAC_TYPE_BEGIN(EEClass)
 CDAC_TYPE_INDETERMINATE(EEClass)
 CDAC_TYPE_FIELD(EEClass, /*pointer*/, MethodTable, cdac_data<EEClass>::MethodTable)
@@ -309,11 +322,13 @@ CDAC_TYPE_FIELD(DynamicMetadata, /*inline byte array*/, Data, cdac_data<DynamicM
 CDAC_TYPE_END(DynamicMetadata)
 
 CDAC_TYPE_BEGIN(MethodDesc)
-CDAC_TYPE_INDETERMINATE(MethodDesc)
+CDAC_TYPE_SIZE(sizeof(MethodDesc))
 CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, ChunkIndex, cdac_data<MethodDesc>::ChunkIndex)
 CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Slot, cdac_data<MethodDesc>::Slot)
 CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags, cdac_data<MethodDesc>::Flags)
 CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags3AndTokenRemainder, cdac_data<MethodDesc>::Flags3AndTokenRemainder)
+CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, EntryPointFlags, cdac_data<MethodDesc>::EntryPointFlags)
+CDAC_TYPE_FIELD(MethodDesc, /*pointer*/, CodeData, cdac_data<MethodDesc>::CodeData)
 CDAC_TYPE_END(MethodDesc)
 
 CDAC_TYPE_BEGIN(MethodDescChunk)
@@ -348,6 +363,12 @@ CDAC_TYPE_BEGIN(CodePointer)
 CDAC_TYPE_SIZE(sizeof(PCODE))
 CDAC_TYPE_END(CodePointer)
 
+CDAC_TYPE_BEGIN(MethodDescCodeData)
+CDAC_TYPE_INDETERMINATE(MethodDescCodeData)
+CDAC_TYPE_FIELD(MethodDescCodeData, /*CodePointer*/, TemporaryEntryPoint, offsetof(MethodDescCodeData,TemporaryEntryPoint))
+CDAC_TYPE_FIELD(MethodDescCodeData, /*pointer*/, VersioningState, offsetof(MethodDescCodeData,VersioningState))
+CDAC_TYPE_END(MethodDescCodeData)
+
 CDAC_TYPE_BEGIN(MethodDescVersioningState)
 CDAC_TYPE_INDETERMINATE(MethodDescVersioningState)
 CDAC_TYPE_FIELD(MethodDescVersioningState, /*pointer*/, NativeCodeVersionNode, cdac_data<MethodDescVersioningState>::NativeCodeVersionNode)
@@ -441,6 +462,11 @@ CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, Next, cdac_data<NativeCodeVe
 CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, MethodDesc, cdac_data<NativeCodeVersionNode>::MethodDesc)
 CDAC_TYPE_FIELD(NativeCodeVersionNode, /*pointer*/, NativeCode, cdac_data<NativeCodeVersionNode>::NativeCode)
 CDAC_TYPE_END(NativeCodeVersionNode)
+
+CDAC_TYPE_BEGIN(ProfControlBlock)
+CDAC_TYPE_FIELD(ProfControlBlock, /*uint64*/, GlobalEventMask, offsetof(ProfControlBlock, globalEventMask))
+CDAC_TYPE_END(ProfControlBlock)
+
 CDAC_TYPES_END()
 
 CDAC_GLOBALS_BEGIN()
@@ -482,6 +508,7 @@ CDAC_GLOBAL_POINTER(MiniMetaDataBuffAddress, &::g_MiniMetaDataBuffAddress)
 CDAC_GLOBAL_POINTER(MiniMetaDataBuffMaxSize, &::g_MiniMetaDataBuffMaxSize)
 CDAC_GLOBAL_POINTER(ExecutionManagerCodeRangeMapAddress, cdac_data<ExecutionManager>::CodeRangeMapAddress)
 CDAC_GLOBAL_POINTER(PlatformMetadata, &::g_cdacPlatformMetadata)
+CDAC_GLOBAL_POINTER(ProfilerControlBlock, &::g_profControlBlock)
 CDAC_GLOBALS_END()
 
 #undef CDAC_BASELINE

src/coreclr/vm/assembly.cpp

@@ -129,7 +129,7 @@ Assembly::Assembly(PEAssembly* pPEAssembly, LoaderAllocator *pLoaderAllocator)
 #endif
     , m_pLoaderAllocator{pLoaderAllocator}
 #ifdef FEATURE_COLLECTIBLE_TYPES
-    , m_isCollectible{pLoaderAllocator->IsCollectible() != FALSE}
+    , m_isCollectible{static_cast<BYTE>(pLoaderAllocator->IsCollectible() != FALSE ? 1 : 0)}
 #endif
     , m_isDynamic(false)
     , m_isLoading{true}

src/coreclr/vm/assembly.hpp

@@ -516,7 +516,7 @@ class Assembly
 
     PTR_LoaderAllocator   m_pLoaderAllocator;
 #ifdef FEATURE_COLLECTIBLE_TYPES
-    bool                  m_isCollectible;
+    BYTE                  m_isCollectible;
 #endif // FEATURE_COLLECTIBLE_TYPES
     bool                  m_isDynamic;
 
@@ -536,6 +536,16 @@ class Assembly
     LOADERHANDLE          m_hExposedObject;
 
     DomainAssembly*             m_NextAssemblyInSameALC;
+
+    friend struct ::cdac_data<Assembly>;
+};
+
+template<>
+struct cdac_data<Assembly>
+{
+#ifdef FEATURE_COLLECTIBLE_TYPES
+    static constexpr size_t IsCollectible = offsetof(Assembly, m_isCollectible);
+#endif
 };
 
 #ifndef DACCESS_COMPILE

src/coreclr/vm/method.hpp

@@ -1914,6 +1914,8 @@ template<> struct cdac_data<MethodDesc>
     static constexpr size_t Slot = offsetof(MethodDesc, m_wSlotNumber);
     static constexpr size_t Flags = offsetof(MethodDesc, m_wFlags);
     static constexpr size_t Flags3AndTokenRemainder = offsetof(MethodDesc, m_wFlags3AndTokenRemainder);
+    static constexpr size_t EntryPointFlags = offsetof(MethodDesc, m_bFlags4);
+    static constexpr size_t CodeData = offsetof(MethodDesc, m_codeData);
 };
 
 #ifndef DACCESS_COMPILE

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/ContractRegistry.cs

@@ -55,4 +55,8 @@ internal abstract class ContractRegistry
     /// Gets an instance of the PrecodeStubs contract for the target.
     /// </summary>
     public abstract IPrecodeStubs PrecodeStubs { get; }
+    /// <summary>
+    /// Gets an instance of the ReJIT contract for the target.
+    /// </summary>
+    public abstract IReJIT ReJIT { get;  }
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/ILoader.cs

@@ -49,6 +49,7 @@ internal interface ILoader : IContract
     public virtual ModuleLookupTables GetLookupTables(ModuleHandle handle) => throw new NotImplementedException();
 
     public virtual TargetPointer GetModuleLookupMapElement(TargetPointer table, uint token, out TargetNUInt flags) => throw new NotImplementedException();
+    public virtual bool IsCollectible(ModuleHandle handle) => throw new NotImplementedException();
 }
 
 internal readonly struct Loader : ILoader

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IReJIT.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Diagnostics.DataContractReader.Contracts;
+
+internal interface IReJIT : IContract
+{
+    static string IContract.Name { get; } = nameof(ReJIT);
+    bool IsEnabled() => throw new NotImplementedException();
+}
+
+internal readonly struct ReJIT : IReJIT
+{
+
+}

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IRuntimeTypeSystem.cs

@@ -160,6 +160,11 @@ internal interface IRuntimeTypeSystem : IContract
 
     public virtual TargetCodePointer GetNativeCode(MethodDescHandle methodDesc) => throw new NotImplementedException();
 
+    public virtual ushort GetSlotNumber(MethodDescHandle methodDesc) => throw new NotImplementedException();
+
+    public virtual bool HasNativeCodeSlot(MethodDescHandle methodDesc) => throw new NotImplementedException();
+
+    public virtual TargetPointer GetAddressOfNativeCodeSlot(MethodDescHandle methodDesc) => throw new NotImplementedException();
     #endregion MethodDesc inspection APIs
 }
 

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/DataType.cs

@@ -30,6 +30,7 @@ public enum DataType
     RuntimeThreadLocals,
     Module,
     ModuleLookupMap,
+    Assembly,
     MethodTable,
     EEClass,
     ArrayClass,
@@ -44,6 +45,7 @@ public enum DataType
     String,
     MethodDesc,
     MethodDescChunk,
+    MethodDescCodeData,
     PlatformMetadata,
     PrecodeMachineDescriptor,
     StubPrecodeData,
@@ -63,4 +65,5 @@ public enum DataType
     MethodDescVersioningState,
     ILCodeVersioningState,
     NativeCodeVersionNode,
+    ProfControlBlock,
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Constants.cs

@@ -42,5 +42,6 @@ internal static class Globals
         internal const string ExecutionManagerCodeRangeMapAddress = nameof(ExecutionManagerCodeRangeMapAddress);
         internal const string StubCodeBlockLast = nameof(StubCodeBlockLast);
         internal const string PlatformMetadata = nameof(PlatformMetadata);
+        internal const string ProfilerControlBlock = nameof(ProfilerControlBlock);
     }
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/CodeVersions_1.cs

@@ -132,6 +132,14 @@ internal enum MethodDescVersioningStateFlags : byte
 
     private NativeCodeVersionHandle GetSpecificNativeCodeVersion(IRuntimeTypeSystem rts, MethodDescHandle md, TargetCodePointer startAddress)
     {
+        // initial stage of NativeCodeVersionIterator::Next() with a null m_ilCodeFilter
+        TargetCodePointer firstNativeCode = rts.GetNativeCode(md);
+        if (firstNativeCode == startAddress)
+        {
+            NativeCodeVersionHandle first = new NativeCodeVersionHandle(md.Address, TargetPointer.Null);
+            return first;
+        }
+        // ImplicitCodeVersion stage of NativeCodeVersionIterator::Next()
         TargetPointer methodDescVersioningStateAddress = rts.GetMethodDescVersioningState(md);
         if (methodDescVersioningStateAddress == TargetPointer.Null)
         {

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/ExecutionManager_1.EEJitManager.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
@@ -42,7 +41,7 @@ public override bool GetMethodInfo(RangeSection rangeSection, TargetCodePointer
             }
             TargetPointer codeHeaderAddress = Target.ReadPointer(codeHeaderIndirect);
             Data.RealCodeHeader realCodeHeader = Target.ProcessedData.GetOrAdd<Data.RealCodeHeader>(codeHeaderAddress);
-            info = new CodeBlock(jittedCodeAddress, codeHeaderOffset, relativeOffset, realCodeHeader, rangeSection.Data!.JitManager);
+            info = new CodeBlock(start.Value, codeHeaderOffset, relativeOffset, realCodeHeader, rangeSection.Data!.JitManager);
             return true;
         }
 

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Loader_1.cs

@@ -111,4 +111,12 @@ TargetPointer ILoader.GetModuleLookupMapElement(TargetPointer table, uint token,
         } while (table != TargetPointer.Null);
         return TargetPointer.Null;
     }
+
+    bool ILoader.IsCollectible(ModuleHandle handle)
+    {
+        Data.Module module = _target.ProcessedData.GetOrAdd<Data.Module>(handle.Address);
+        TargetPointer assembly = module.Assembly;
+        Data.Assembly la = _target.ProcessedData.GetOrAdd<Data.Assembly>(assembly);
+        return la.IsCollectible != 0;
+    }
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/PrecodeStubs_1.cs

@@ -64,7 +64,7 @@ internal override TargetPointer GetMethodDesc(Target target, Data.PrecodeMachine
         }
     }
 
-    internal sealed class ThisPtrRetBufPrecode : ValidPrecode // FIXME: is this a StubPrecode?
+    internal sealed class ThisPtrRetBufPrecode : ValidPrecode
     {
         internal ThisPtrRetBufPrecode(TargetPointer instrPointer) : base(instrPointer, KnownPrecodeType.ThisPtrRetBuf) { }
 

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/ReJITFactory.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Diagnostics.DataContractReader.Contracts;
+
+internal sealed class ReJITFactory : IContractFactory<IReJIT>
+{
+    IReJIT IContractFactory<IReJIT>.CreateContract(Target target, int version)
+    {
+        TargetPointer profControlBlockAddress = target.ReadGlobalPointer(Constants.Globals.ProfilerControlBlock);
+        Data.ProfControlBlock profControlBlock = target.ProcessedData.GetOrAdd<Data.ProfControlBlock>(profControlBlockAddress);
+        return version switch
+        {
+            1 => new ReJIT_1(target, profControlBlock),
+            _ => default(ReJIT),
+        };
+    }
+}