[cDAC] implement GetRuntimeNameByAddress

docs/design/datacontracts/ExecutionManager.md

@@ -52,6 +52,10 @@ struct CodeBlockHandle
     // Get the exception clause info for the code block
     List<ExceptionClauseInfo> GetExceptionClauses(CodeBlockHandle codeInfoHandle);
 
+    // Classify a code address as a known stub kind (precode, jump stub, VSD stub, etc.)
+    // or as managed code. Returns CodeBlockUnknown if the address is not recognized.
+    StubKind GetStubKind(TargetCodePointer jittedCodeAddress);
+
     // Extension Methods (implemented in terms of other APIs)
     // Returns true if the code block is a funclet (exception handler, filter, or finally)
     bool IsFunclet(CodeBlockHandle codeInfoHandle);
@@ -143,6 +147,8 @@ Data descriptors used:
 | `RangeSection` | `Flags` | Flags for the range section |
 | `RangeSection` | `HeapList` | Pointer to the heap list |
 | `RangeSection` | `R2RModule` | ReadyToRun module |
+| `RangeSection` | `RangeList` | Pointer to the `CodeRangeMapRangeList` associated with this range section |
+| `CodeRangeMapRangeList` | `RangeListType` | Integer identifying the stub code block kind for this range list |
 | `CodeHeapListNode` | `Next` | Next node |
 | `CodeHeapListNode` | `StartAddress` | Start address of the used portion of the code heap |
 | `CodeHeapListNode` | `EndAddress` | End address of the used portion of the code heap |
@@ -219,6 +225,11 @@ Global variables used:
 | `GCInfoVersion` | uint32 | JITted code GCInfo version |
 | `FeatureOnStackReplacement` | uint8 | 1 if FEATURE_ON_STACK_REPLACEMENT is enabled, 0 otherwise |
 | `FeaturePortableEntrypoints` | uint8 | 1 if FEATURE_PORTABLE_ENTRYPOINTS is enabled, 0 otherwise |
+| `ThePreStub` | TargetPointer | Address of the pre-stub entry point (only present when `FeaturePortableEntrypoints` is disabled) |
+| `GenericPInvokeCalliHelper` | TargetPointer | Address of the generic PInvoke CALLI helper stub |
+| `VarargPInvokeStub` | TargetPointer | Address of the vararg PInvoke stub |
+| `VarargPInvokeStub_RetBuffArg` | TargetPointer | Address of the vararg PInvoke stub with return buffer argument (not present on x86, ARM64, LoongArch64, RISC-V) |
+| `TailCallJitHelper` | TargetPointer | Address of the JIT tail call helper (only present on x86 Windows) |
 | `ObjectMethodTable` | TargetPointer | Pointer to the `System.Object` MethodTable, used for catch-all handler detection |
 
 Contract constants used:
@@ -501,6 +512,36 @@ After obtaining the clause array bounds, the common iteration logic classifies e
 
 `IsFilterFunclet` first checks `IsFunclet`. If the code block is a funclet, it retrieves the EH clauses for the method and checks whether any filter clause's handler offset matches the funclet's relative offset. If a match is found, the funclet is a filter funclet.
 
+### Stub Kind Classification
+
+`GetStubKind` classifies a code address as a known stub type or managed code. It first checks the address against well-known global stub pointers (`ThePreStub`, `VarargPInvokeStub`, `VarargPInvokeStub_RetBuffArg`, `GenericPInvokeCalliHelper`, `TailCallJitHelper`). If the address matches one of these, it returns the corresponding `StubKind` immediately.
+
+If no global match is found, the method looks up the address in the `RangeSectionMap`. If a `RangeSection` is found, the JIT manager for that section classifies the code:
+
+- **EEJitManager**: If the range section is a range list, reads the `CodeRangeMapRangeList.RangeListType` to determine the stub code block kind. Otherwise, it uses the nibble map to find the method code start, reads the code header indirect pointer, and checks whether it is a stub code block (value ≤ `StubCodeBlockLast`). If so, the value identifies the specific stub kind.
+- **ReadyToRunJitManager**: Checks whether the address falls within a delay-load method call thunk region.
+
+```csharp
+StubKind GetStubKind(TargetCodePointer jittedCodeAddress)
+{
+    TargetPointer address = CodePointerUtils.AddressFromCodePointer(jittedCodeAddress);
+
+    // Check well-known global stubs
+    if (address == ThePreStub) return StubKind.PreStub;
+    if (address == VarargPInvokeStub || address == VarargPInvokeStub_RetBuffArg
+        || address == GenericPInvokeCalliHelper)
+        return StubKind.InteropDispatchStub;
+    if (address == TailCallJitHelper) return StubKind.TailCallStub;
+
+    // Look up in range section map
+    RangeSection range = FindRangeSection(jittedCodeAddress);
+    if (range == null) return StubKind.CodeBlockUnknown;
+
+    JitManager jitManager = GetJitManager(range);
+    return jitManager.GetStubCodeBlockKind(range, jittedCodeAddress);
+}
+```
+
 ### EE JIT Manager and Code Heap Info
 
 ```csharp

docs/design/datacontracts/PrecodeStubs.md

@@ -7,6 +7,11 @@ This contract provides support for examining [precode](../coreclr/botr/method-de
 ```csharp
     // Gets a pointer to the MethodDesc for a given stub entrypoint
     TargetPointer GetMethodDescFromStubAddress(TargetCodePointer entryPoint);
+
+    // Enumerates candidate precode entry points near a given code address.
+    // This is used to resolve a code address that falls within a
+    // precode stub back to its entry point.
+    IEnumerable<TargetCodePointer> GetCandidateEntryPoints(TargetCodePointer address);
 ```
 
 ## Version 1, 2, and 3
@@ -295,4 +300,17 @@ After the initial precode type is determined, for stub precodes a refined precod
 
         return precode.GetMethodDesc(_target, MachineDescriptor);
     }
+
+    IEnumerable<TargetCodePointer> IPrecodeStubs.GetCandidateEntryPoints(TargetCodePointer address)
+    {
+        TargetPointer instrPointer = CodePointerReadableInstrPointer(address);
+        ulong aligned = instrPointer.Value & ~(ulong)(PointerSize - 1);
+        uint count = StubPrecodeSize / PointerSize;
+
+        for (uint i = 0; i < count; i++)
+        {
+            TargetPointer candidateAddr = new TargetPointer(aligned - (i * PointerSize));
+            yield return CodePointerFromAddress(candidateAddr);
+        }
+    }
 ```

src/coreclr/debug/daccess/daccess.cpp

@@ -5327,7 +5327,7 @@ static int FormatCLRStubName(
 
     // Compute the address as a string safely.
     WCHAR addrString[Max64BitHexString + 1];
-    FormatInteger(addrString, ARRAY_SIZE(addrString), "%p", stubAddr);
+    FormatInteger(addrString, ARRAY_SIZE(addrString), sizeof(void*) == 8 ? "%016llX" : "%08X", stubAddr);
     size_t addStringLen = u16_strlen(addrString);
 
     // Compute maximum length, include the null terminator.

src/coreclr/inc/gfunc_list.h

@@ -12,6 +12,14 @@
 
 DEFINE_DACGFN(DACNotifyCompilationFinished)
 DEFINE_DACGFN(ThePreStub)
+DEFINE_DACGFN(GenericPInvokeCalliHelper)
+DEFINE_DACGFN(VarargPInvokeStub)
+#if !defined(TARGET_X86) && !defined(TARGET_ARM64) && !defined(TARGET_LOONGARCH64) && !defined(TARGET_RISCV64)
+DEFINE_DACGFN(VarargPInvokeStub_RetBuffArg)
+#endif
+#if defined(TARGET_X86) && !defined(UNIX_X86_ABI)
+DEFINE_DACGFN(JIT_TailCall)
+#endif
 
 DEFINE_DACGFN(ThePreStubPatchLabel)
 #ifdef FEATURE_COMINTEROP

src/coreclr/vm/cgensys.h

@@ -56,6 +56,13 @@ extern "C" void STDCALL GenericPInvokeCalliHelper(void);
 
 extern "C" PCODE STDCALL ExternalMethodFixupWorker(TransitionBlock * pTransitionBlock, TADDR pIndirection, DWORD sectionIndex, Module * pModule);
 
+// cDAC-visible TADDR wrappers for function entrypoints.
+inline const TADDR g_cdacGenericPInvokeCalliHelper = (TADDR)(void*)GenericPInvokeCalliHelper;
+inline const TADDR g_cdacVarargPInvokeStub = (TADDR)(void*)VarargPInvokeStub;
+#if !defined(TARGET_X86) && !defined(TARGET_ARM64) && !defined(TARGET_LOONGARCH64) && !defined(TARGET_RISCV64)
+inline const TADDR g_cdacVarargPInvokeStub_RetBuffArg = (TADDR)(void*)VarargPInvokeStub_RetBuffArg;
+#endif
+
 extern "C" void STDCALL VirtualMethodFixupStub(void);
 extern "C" void STDCALL VirtualMethodFixupPatchLabel(void);
 

src/coreclr/vm/class.h

@@ -1955,6 +1955,9 @@ inline BOOL EEClass::IsInt128OrHasInt128Fields()
 VOID InitPreStubManager();
 
 EXTERN_C void STDCALL ThePreStub();
+#ifndef FEATURE_PORTABLE_ENTRYPOINTS
+inline const TADDR g_cdacThePreStub = (TADDR)(void*)ThePreStub;
+#endif // !FEATURE_PORTABLE_ENTRYPOINTS
 
 inline PCODE GetPreStubEntryPoint()
 {

src/coreclr/vm/codeman.h

@@ -793,6 +793,7 @@ template<> struct cdac_data<RangeSection>
     static constexpr size_t Flags = offsetof(RangeSection, _flags);
     static constexpr size_t HeapList = offsetof(RangeSection, _pHeapList);
     static constexpr size_t R2RModule = offsetof(RangeSection, _pR2RModule);
+    static constexpr size_t RangeList = offsetof(RangeSection, _pRangeList);
 };
 
 enum class RangeSectionLockState

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -805,8 +805,14 @@ CDAC_TYPE_FIELD(RangeSection, T_POINTER, JitManager, cdac_data<RangeSection>::Ji
 CDAC_TYPE_FIELD(RangeSection, T_INT32, Flags, cdac_data<RangeSection>::Flags)
 CDAC_TYPE_FIELD(RangeSection, T_POINTER, HeapList, cdac_data<RangeSection>::HeapList)
 CDAC_TYPE_FIELD(RangeSection, T_POINTER, R2RModule, cdac_data<RangeSection>::R2RModule)
+CDAC_TYPE_FIELD(RangeSection, T_POINTER, RangeList, cdac_data<RangeSection>::RangeList)
 CDAC_TYPE_END(RangeSection)
 
+CDAC_TYPE_BEGIN(CodeRangeMapRangeList)
+CDAC_TYPE_INDETERMINATE(CodeRangeMapRangeList)
+CDAC_TYPE_FIELD(CodeRangeMapRangeList, T_INT32, RangeListType, cdac_data<CodeRangeMapRangeList>::RangeListType)
+CDAC_TYPE_END(CodeRangeMapRangeList)
+
 CDAC_TYPE_BEGIN(EEJitManager)
 CDAC_TYPE_INDETERMINATE(EEJitManager)
 CDAC_TYPE_FIELD(EEJitManager, T_BOOL, StoreRichDebugInfo, cdac_data<EEJitManager>::StoreRichDebugInfo)
@@ -1412,6 +1418,17 @@ CDAC_GLOBAL(ArrayBaseSize, T_UINT32, ARRAYBASE_BASESIZE)
 CDAC_GLOBAL(SyncBlockValueToObjectOffset, T_UINT16, OBJHEADER_SIZE - cdac_data<ObjHeader>::SyncBlockValue)
 CDAC_GLOBAL(StubCodeBlockLast, T_UINT8, STUB_CODE_BLOCK_LAST)
 CDAC_GLOBAL(DefaultADID, T_UINT32, DefaultADID)
+#ifndef FEATURE_PORTABLE_ENTRYPOINTS
+CDAC_GLOBAL_POINTER(ThePreStub, &g_cdacThePreStub)
+#endif // !FEATURE_PORTABLE_ENTRYPOINTS
+CDAC_GLOBAL_POINTER(GenericPInvokeCalliHelper, &g_cdacGenericPInvokeCalliHelper)
+CDAC_GLOBAL_POINTER(VarargPInvokeStub, &g_cdacVarargPInvokeStub)
+#if !defined(TARGET_X86) && !defined(TARGET_ARM64) && !defined(TARGET_LOONGARCH64) && !defined(TARGET_RISCV64)
+CDAC_GLOBAL_POINTER(VarargPInvokeStub_RetBuffArg, &g_cdacVarargPInvokeStub_RetBuffArg)
+#endif
+#if defined(TARGET_X86) && !defined(UNIX_X86_ABI)
+CDAC_GLOBAL_POINTER(TailCallJitHelper, &g_cdacTailCallJitHelper)
+#endif // TARGET_X86 && !UNIX_X86_ABI
 #ifndef TARGET_UNIX
 CDAC_GLOBAL(SizeOfGenericModeBlock, T_UINT32, sizeof(GenericModeBlock))
 #endif

src/coreclr/vm/jitinterface.h

@@ -273,6 +273,10 @@ extern "C"
 #endif // !defined(TARGET_ARM64) && !defined(TARGET_LOONGARCH64) && !defined(TARGET_RISCV64)
 };
 
+#if defined(TARGET_X86) && !defined(UNIX_X86_ABI)
+inline const TADDR g_cdacTailCallJitHelper = (TADDR)(void*)JIT_TailCall;
+#endif // TARGET_X86 && !UNIX_X86_ABI
+
 /*********************************************************************/
 /*********************************************************************/
 

src/coreclr/vm/loaderallocator.hpp

@@ -182,6 +182,13 @@ class CodeRangeMapRangeList : public RangeList
     SArray<TADDR> _starts;
     void* _id;
     bool _collectible;
+    friend struct ::cdac_data<CodeRangeMapRangeList>;
+};
+
+template<>
+struct cdac_data<CodeRangeMapRangeList>
+{
+    static constexpr size_t RangeListType = offsetof(CodeRangeMapRangeList, _rangeListType);
 };
 
 // Iterator over Assemblies in the same ALC

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IExecutionManager.cs

@@ -46,6 +46,26 @@ public interface ICodeHeapInfo
 {
 }
 
+public enum StubKind : uint
+{
+    CodeBlockUnknown = 0,
+    CodeBlockJumpStub = 1,
+    CodeBlockDynamicHelper = 3,
+    CodeBlockPrecode = 4,
+    CodeBlockVSDDispatchStub = 5,
+    CodeBlockVSDResolveStub = 6,
+    CodeBlockVSDLookupStub = 7,
+    CodeBlockVSDVTableStub = 8,
+    CodeBlockCallCounting = 9,
+    CodeBlockStubLinkStub = 10,
+    CodeBlockMethodCallThunk = 11,
+    CodeBlockNoCode = 12,
+    CodeBlockManaged = 13,
+    PreStub = 14,
+    InteropDispatchStub = 15,
+    TailCallStub = 16,
+}
+
 public sealed class LoaderCodeHeapInfo : ICodeHeapInfo
 {
     public TargetPointer HeapAddress { get; }
@@ -101,6 +121,7 @@ public interface IExecutionManager : IContract
     List<ExceptionClauseInfo> GetExceptionClauses(CodeBlockHandle codeInfoHandle) => throw new NotImplementedException();
     JitManagerInfo GetEEJitManagerInfo() => throw new NotImplementedException();
     IEnumerable<ICodeHeapInfo> GetCodeHeapInfos() => throw new NotImplementedException();
+    StubKind GetStubKind(TargetCodePointer jittedCodeAddress) => throw new NotImplementedException();
 }
 
 public readonly struct ExecutionManager : IExecutionManager

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IPrecodeStubs.cs

@@ -2,13 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
 public interface IPrecodeStubs : IContract
 {
     static string IContract.Name { get; } = nameof(PrecodeStubs);
     TargetPointer GetMethodDescFromStubAddress(TargetCodePointer entryPoint) => throw new NotImplementedException();
+    IEnumerable<TargetCodePointer> GetCandidateEntryPoints(TargetCodePointer address) => throw new NotImplementedException();
 }
 
 public readonly struct PrecodeStubs : IPrecodeStubs

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

@@ -168,6 +168,7 @@ public enum DataType
     ComInterfaceEntry,
     InternalComInterfaceDispatch,
     AuxiliarySymbolInfo,
+    CodeRangeMapRangeList,
 
     /* GC Data Types */
 

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

@@ -82,6 +82,11 @@ public static class Globals
         public const string ExecutionManagerCodeRangeMapAddress = nameof(ExecutionManagerCodeRangeMapAddress);
         public const string EEJitManagerAddress = nameof(EEJitManagerAddress);
         public const string StubCodeBlockLast = nameof(StubCodeBlockLast);
+        public const string ThePreStub = nameof(ThePreStub);
+        public const string VarargPInvokeStub = nameof(VarargPInvokeStub);
+        public const string VarargPInvokeStub_RetBuffArg = nameof(VarargPInvokeStub_RetBuffArg);
+        public const string GenericPInvokeCalliHelper = nameof(GenericPInvokeCalliHelper);
+        public const string TailCallJitHelper = nameof(TailCallJitHelper);
         public const string DefaultADID = nameof(DefaultADID);
         public const string StaticsPointerMask = nameof(StaticsPointerMask);
         public const string PtrArrayOffsetToDataArray = nameof(PtrArrayOffsetToDataArray);