Skip to content

Commit ec2da71

Browse files
Copilotrcj1
Copilot
and
rcj1
authored
Bring in PR #127419 implementation files
Agent-Logs-Url: https://github.com/dotnet/runtime/sessions/e9402571-fdfe-4171-b9e1-eec00046cb3e Co-authored-by: rcj1 <77995559+rcj1@users.noreply.github.com>
1 parent 8f854af commit ec2da71

8 files changed

Lines changed: 725 additions & 13 deletions

File tree

‎docs/design/datacontracts/RuntimeTypeSystem.md‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,11 @@ partial interface IRuntimeTypeSystem : IContract
5858
public virtual bool RequiresAlign8(TypeHandle typeHandle);
5959
// True if the MethodTable represents a continuation type used by the async continuation feature
6060
public virtual bool IsContinuation(TypeHandle typeHandle);
61+
// Returns the GC pointer runs for the method table as (offset, size) pairs. Each
62+
// run starts Offset bytes from the object pointer (`this`), where offset 0
63+
// is the method table pointer, and includes Size bytes of contiguous pointers
64+
// For handles representing value types the object is assumed to be stored in the boxed layout.
65+
public virtual IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0);
6166
public virtual bool IsDynamicStatics(TypeHandle typeHandle);
6267
public virtual ushort GetNumInterfaces(TypeHandle typeHandle);
6368

@@ -554,6 +559,63 @@ Contracts used:
554559

555560
public bool RequiresAlign8(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[typeHandle.Address].Flags.RequiresAlign8;
556561

562+
public bool IsContinuation(TypeHandle typeHandle) => typeHandle.IsMethodTable()
563+
&& ContinuationMethodTablePointer != TargetPointer.Null
564+
&& _methodTables[typeHandle.Address].ParentMethodTable == ContinuationMethodTablePointer;
565+
566+
IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0)
567+
{
568+
// Returns empty if not a method table or has no GC pointers.
569+
// Compute objectSize: baseSize + numComponents * componentSize.
570+
// For non-array types, numComponents == 0 so objectSize == baseSize.
571+
572+
// Read NumSeries from (mtAddress - pointerSize), sign-extended to native width.
573+
// NumSeries == 0 → empty.
574+
575+
// NumSeries > 0: Regular series.
576+
// Used for normal objects and reference-type arrays (e.g. object[]).
577+
// Memory layout (each slot is pointer-sized, growing away from MT):
578+
//
579+
// MT - (2*N+1)*ptrSize : series[N-1].seriessize
580+
// MT - (2*N) *ptrSize : series[N-1].startoffset
581+
// ...
582+
// MT - 3*ptrSize : series[0].seriessize
583+
// MT - 2*ptrSize : series[0].startoffset
584+
// MT - 1*ptrSize : NumSeries (positive)
585+
// MT : MethodTable
586+
//
587+
// The raw seriessize is stored with baseSize subtracted.
588+
// Add objectSize back to get the true run length:
589+
// trueRunLength = rawSeriesSize + objectSize
590+
// For non-arrays objectSize == baseSize, recovering the actual run.
591+
// For arrays objectSize > baseSize, extending the single series across all elements.
592+
593+
// NumSeries < 0: Value-class (repeating) series.
594+
// Used for arrays of value types containing GC references.
595+
// |NumSeries| val_serie_items describe pointer runs within one array element.
596+
// Memory layout:
597+
//
598+
// MT - (N+2)*ptrSize : val_serie[N-1]
599+
// ...
600+
// MT - 3*ptrSize : val_serie[0]
601+
// MT - 2*ptrSize : startoffset
602+
// MT - 1*ptrSize : NumSeries (-N)
603+
// MT : MethodTable
604+
//
605+
// Each val_serie_item is { HALF_SIZE_T nptrs; HALF_SIZE_T skip; } packed into one pointer-width.
606+
// HALF_SIZE_T is uint16 on 32-bit, uint32 on 64-bit.
607+
// Read nptrs and skip as separate typed reads for endianness safety.
608+
// runBytes = nptrs * pointerSize; advance currentOffset by runBytes + skip after each item.
609+
//
610+
// The val_serie_items describe the GC pointer layout of a single array element.
611+
// An outer loop repeats the pattern across all elements in the array:
612+
// currentOffset = startoffset
613+
// while currentOffset <= objectSize - pointerSize:
614+
// for each val_serie_item:
615+
// yield (currentOffset, nptrs * pointerSize)
616+
// currentOffset += nptrs * pointerSize + skip
617+
}
618+
557619
public bool IsDynamicStatics(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsDynamicStatics;
558620

559621
public ushort GetNumInterfaces(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : _methodTables[TypeHandle.Address].NumInterfaces;

‎src/coreclr/vm/datadescriptor/datadescriptor.inc‎

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,9 @@ CDAC_TYPE_FIELD(Thread, T_POINTER, CachedStackBase, cdac_data<Thread>::CachedSta
4545
CDAC_TYPE_FIELD(Thread, T_POINTER, CachedStackLimit, cdac_data<Thread>::CachedStackLimit)
4646
CDAC_TYPE_FIELD(Thread, T_POINTER, ExceptionTracker, cdac_data<Thread>::ExceptionTracker)
4747
CDAC_TYPE_FIELD(Thread, T_POINTER, DebuggerFilterContext, cdac_data<Thread>::DebuggerFilterContext)
48+
#ifdef PROFILING_SUPPORTED
49+
CDAC_TYPE_FIELD(Thread, T_POINTER, ProfilerFilterContext, cdac_data<Thread>::ProfilerFilterContext)
50+
#endif // PROFILING_SUPPORTED
4851
CDAC_TYPE_FIELD(Thread, TYPE(ObjectHandle), ExposedObject, cdac_data<Thread>::ExposedObject)
4952
CDAC_TYPE_FIELD(Thread, TYPE(ObjectHandle), LastThrownObject, cdac_data<Thread>::LastThrownObject)
5053
CDAC_TYPE_FIELD(Thread, T_UINT32, LastThrownObjectIsUnhandled, cdac_data<Thread>::LastThrownObjectIsUnhandled)
@@ -152,13 +155,6 @@ CDAC_TYPE_BEGIN(ObjectHandle)
152155
CDAC_TYPE_SIZE(sizeof(OBJECTHANDLE))
153156
CDAC_TYPE_END(ObjectHandle)
154157

155-
CDAC_TYPE_BEGIN(JITNotification)
156-
CDAC_TYPE_SIZE(sizeof(::JITNotification))
157-
CDAC_TYPE_FIELD(JITNotification, T_UINT16, State, offsetof(::JITNotification, state))
158-
CDAC_TYPE_FIELD(JITNotification, T_NUINT, ClrModule, offsetof(::JITNotification, clrModule))
159-
CDAC_TYPE_FIELD(JITNotification, T_UINT32, MethodToken, offsetof(::JITNotification, methodToken))
160-
CDAC_TYPE_END(JITNotification)
161-
162158
// Object
163159

164160
CDAC_TYPE_BEGIN(Object)
@@ -177,6 +173,10 @@ CDAC_TYPE_FIELD(String, T_POINTER, m_FirstChar, cdac_data<StringObject>::m_First
177173
CDAC_TYPE_FIELD(String, T_UINT32, m_StringLength, cdac_data<StringObject>::m_StringLength)
178174
CDAC_TYPE_END(String)
179175

176+
CDAC_TYPE_BEGIN(ContinuationObject)
177+
CDAC_TYPE_SIZE(sizeof(ContinuationObject))
178+
CDAC_TYPE_END(ContinuationObject)
179+
180180
CDAC_TYPE_BEGIN(Array)
181181
CDAC_TYPE_SIZE(sizeof(ArrayBase))
182182
CDAC_TYPE_FIELD(Array, T_UINT32, m_NumComponents, cdac_data<ArrayBase>::m_NumComponents)
@@ -986,7 +986,7 @@ CDAC_TYPE_END(FuncEvalFrame)
986986
CDAC_TYPE_BEGIN(DebuggerEval)
987987
CDAC_TYPE_SIZE(sizeof(DebuggerEval))
988988
CDAC_TYPE_FIELD(DebuggerEval, EXTERN_TYPE(Context), TargetContext, offsetof(DebuggerEval, m_context))
989-
CDAC_TYPE_FIELD(DebuggerEval, T_BOOL, EvalUsesHijack, offsetof(DebuggerEval, m_evalUsesHijack))
989+
CDAC_TYPE_FIELD(DebuggerEval, T_BOOL, EvalDuringException, offsetof(DebuggerEval, m_evalDuringException))
990990
CDAC_TYPE_END(DebuggerEval)
991991
#endif // DEBUGGING_SUPPORTED
992992

@@ -1460,8 +1460,6 @@ CDAC_GLOBAL(DispatchThisPtrMask, T_NUINT, InteropLib::ABI::DispatchThisPtrMask)
14601460
CDAC_GLOBAL_POINTER(ComWrappersVtablePtrs, InteropLib::ABI::g_knownQueryInterfaceImplementations)
14611461
#endif // FEATURE_COMWRAPPERS
14621462
CDAC_GLOBAL_POINTER(GcNotificationFlags, &::g_gcNotificationFlags)
1463-
CDAC_GLOBAL_POINTER(JITNotificationTable, &::g_pNotificationTable)
1464-
CDAC_GLOBAL(JITNotificationTableSize, T_UINT32, JIT_NOTIFICATION_TABLE_SIZE)
14651463
CDAC_GLOBAL_POINTER(GlobalAllocContext, &::g_global_alloc_context)
14661464
CDAC_GLOBAL_POINTER(CoreLib, &::g_CoreLib)
14671465
#ifdef TARGET_WINDOWS
@@ -1519,7 +1517,6 @@ CDAC_GLOBAL_CONTRACT(AuxiliarySymbols, c1)
15191517
CDAC_GLOBAL_CONTRACT(BuiltInCOM, c1)
15201518
#endif // FEATURE_COMINTEROP
15211519
CDAC_GLOBAL_CONTRACT(CodeVersions, c1)
1522-
CDAC_GLOBAL_CONTRACT(CodeNotifications, c1)
15231520
#ifdef FEATURE_COMWRAPPERS
15241521
CDAC_GLOBAL_CONTRACT(ComWrappers, c1)
15251522
#endif // FEATURE_COMWRAPPERS

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

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -121,6 +121,12 @@ public interface IRuntimeTypeSystem : IContract
121121
bool RequiresAlign8(TypeHandle typeHandle) => throw new NotImplementedException();
122122
// True if the MethodTable represents a continuation type used by the async continuation feature
123123
bool IsContinuation(TypeHandle typeHandle) => throw new NotImplementedException();
124+
/// <summary>
125+
/// Enumerates GC pointer runs from the CGCDesc stored before the method table.
126+
/// Returns (offset, size) pairs normalized to actual byte lengths.
127+
/// See RuntimeTypeSystem.md for the full GCDesc format documentation.
128+
/// </summary>
129+
IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0) => throw new NotImplementedException();
124130
bool IsDynamicStatics(TypeHandle typeHandle) => throw new NotImplementedException();
125131
ushort GetNumInterfaces(TypeHandle typeHandle) => throw new NotImplementedException();
126132

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,6 @@ public enum DataType
2222
/* VM Data Types */
2323

2424
ObjectHandle,
25-
JITNotification,
2625
CodePointer,
2726
Thread,
2827
ThreadStore,
@@ -78,6 +77,7 @@ public enum DataType
7877
StressMsg,
7978
StressMsgHeader,
8079
Object,
80+
ContinuationObject,
8181
NativeObjectWrapperObject,
8282
ManagedObjectWrapperHolderObject,
8383
ManagedObjectWrapperLayout,

‎src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/RuntimeTypeSystem_1.cs‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -564,6 +564,81 @@ private Data.EEClass GetClassData(TypeHandle typeHandle)
564564
public bool IsContinuation(TypeHandle typeHandle) => typeHandle.IsMethodTable()
565565
&& _continuationMethodTablePointer != TargetPointer.Null
566566
&& _methodTables[typeHandle.Address].ParentMethodTable == _continuationMethodTablePointer;
567+
568+
IEnumerable<(uint Offset, uint Size)> IRuntimeTypeSystem.GetGCDescSeries(TypeHandle typeHandle, uint numComponents)
569+
{
570+
if (!typeHandle.IsMethodTable())
571+
yield break;
572+
573+
if (!ContainsGCPointers(typeHandle))
574+
yield break;
575+
576+
uint baseSize = GetBaseSize(typeHandle);
577+
uint componentSize = GetComponentSize(typeHandle);
578+
uint objectSize = baseSize + numComponents * componentSize;
579+
580+
ulong mtAddress = typeHandle.Address;
581+
ulong pointerSize = (ulong)_target.PointerSize;
582+
583+
// Sign-extend NumSeries from native pointer width.
584+
long numSeries = _target.PointerSize == sizeof(uint)
585+
? (long)(int)_target.ReadPointer(mtAddress - pointerSize).Value
586+
: (long)_target.ReadPointer(mtAddress - pointerSize).Value;
587+
if (numSeries == 0)
588+
yield break;
589+
590+
if (numSeries > 0)
591+
{
592+
// Regular series: iterate from highest (closest to MT) to lowest.
593+
for (ulong i = 0; i < (ulong)numSeries; i++)
594+
{
595+
ulong seriesBase = mtAddress - (3 + 2 * i) * pointerSize;
596+
ulong rawSeriesSize = _target.ReadPointer(seriesBase).Value;
597+
ulong seriesOffset = _target.ReadPointer(seriesBase + pointerSize).Value;
598+
yield return ((uint)seriesOffset, (uint)(rawSeriesSize + objectSize));
599+
}
600+
}
601+
else
602+
{
603+
long absNumSeries = -numSeries;
604+
ulong startOffset = _target.ReadPointer(mtAddress - 2 * pointerSize).Value;
605+
606+
var seriesItems = new (uint Nptrs, uint Skip)[absNumSeries];
607+
for (long i = 0; i < absNumSeries; i++)
608+
{
609+
ulong itemAddress = mtAddress - (3 + (ulong)i) * pointerSize;
610+
611+
// Read val_serie_item fields individually for endianness safety.
612+
uint nptrs, skip;
613+
if (_target.PointerSize == sizeof(uint))
614+
{
615+
nptrs = _target.Read<ushort>(itemAddress);
616+
skip = _target.Read<ushort>(itemAddress + sizeof(ushort));
617+
}
618+
else
619+
{
620+
nptrs = _target.Read<uint>(itemAddress);
621+
skip = _target.Read<uint>(itemAddress + sizeof(uint));
622+
}
623+
624+
seriesItems[i] = (nptrs, skip);
625+
}
626+
627+
ulong currentOffset = startOffset;
628+
for (int i = 0; i < numComponents; i++)
629+
{
630+
for (long j = 0; j < absNumSeries; j++)
631+
{
632+
if (currentOffset > objectSize - pointerSize)
633+
yield break;
634+
uint runBytes = seriesItems[j].Nptrs * (uint)pointerSize;
635+
yield return ((uint)currentOffset, runBytes);
636+
currentOffset += runBytes + seriesItems[j].Skip;
637+
}
638+
}
639+
}
640+
}
641+
567642
public bool IsDynamicStatics(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[typeHandle.Address].Flags.IsDynamicStatics;
568643
public ushort GetNumInterfaces(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? (ushort)0 : _methodTables[typeHandle.Address].NumInterfaces;
569644

‎src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/TypeNameBuilder.cs‎

Lines changed: 55 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
using System.Reflection.Metadata;
77
using System.Reflection.Metadata.Ecma335;
88
using System.Text;
9+
using Microsoft.Diagnostics.DataContractReader;
910
using Microsoft.Diagnostics.DataContractReader.Contracts;
1011

1112
namespace Microsoft.Diagnostics.DataContractReader.Legacy;
@@ -283,7 +284,14 @@ private static void AppendTypeCore(ref TypeNameBuilder tnb, Contracts.TypeHandle
283284
Contracts.ModuleHandle moduleHandle = tnb.Target.Contracts.Loader.GetModuleHandleFromModulePtr(typeSystemContract.GetModule(typeHandle));
284285
if (MetadataTokens.EntityHandle((int)typeDefToken).IsNil)
285286
{
286-
tnb.AddName("(dynamicClass)");
287+
if (typeSystemContract.IsContinuation(typeHandle))
288+
{
289+
AppendContinuationName(ref tnb, typeSystemContract, typeHandle);
290+
}
291+
else
292+
{
293+
tnb.AddName("(dynamicClass)");
294+
}
287295
}
288296
else
289297
{
@@ -480,6 +488,52 @@ private void AddAssemblySpec(string? assemblySpec)
480488
}
481489
}
482490

491+
/// <summary>
492+
/// Builds the synthetic name for a dynamically-created continuation method table, mirroring the
493+
/// native <c>AsyncContinuationsManager::PrintContinuationName</c> in <c>asynccontinuations.h</c>.
494+
/// </summary>
495+
/// <remarks>
496+
/// The name has the form:
497+
/// <c>Continuation_&lt;dataSize&gt;[_&lt;gcOffset&gt;_&lt;gcCount&gt;]*</c>
498+
/// where:
499+
/// <list type="bullet">
500+
/// <item><description>
501+
/// <c>dataSize</c> is the number of bytes of data payload (base size minus the fixed
502+
/// object-header and continuation-header overhead).
503+
/// </description></item>
504+
/// <item><description>
505+
/// Each <c>_gcOffset_gcCount</c> pair describes one GC-pointer run: <c>gcOffset</c> is the
506+
/// offset in bytes from the start of the data payload to the run, and <c>gcCount</c> is the
507+
/// number of pointer-sized GC references in that run.
508+
/// </description></item>
509+
/// </list>
510+
/// Only GC descriptor series whose <c>startoffset</c> is at or above the continuation data
511+
/// payload (i.e., after the fixed <c>CORINFO_Continuation</c> header fields) are included.
512+
/// </remarks>
513+
private static void AppendContinuationName(ref TypeNameBuilder tnb, IRuntimeTypeSystem typeSystemContract, TypeHandle typeHandle)
514+
{
515+
uint baseSize = typeSystemContract.GetBaseSize(typeHandle);
516+
uint continuationDataOffset = tnb.Target.GetTypeInfo(DataType.ContinuationObject).Size!.Value;
517+
uint objHeaderSize = tnb.Target.GetTypeInfo(DataType.ObjectHeader).Size!.Value;
518+
uint dataSize = baseSize - (objHeaderSize + continuationDataOffset);
519+
520+
var name = new StringBuilder("Continuation_");
521+
name.Append(dataSize);
522+
523+
foreach ((uint seriesOffset, uint seriesSize) in typeSystemContract.GetGCDescSeries(typeHandle))
524+
{
525+
if (seriesOffset < continuationDataOffset)
526+
continue;
527+
528+
name.Append('_');
529+
name.Append(seriesOffset - continuationDataOffset);
530+
name.Append('_');
531+
name.Append(seriesSize / (uint)tnb.Target.PointerSize);
532+
}
533+
534+
tnb.AddNameNoEscaping(name);
535+
}
536+
483537
private static void AppendNestedTypeDef(ref TypeNameBuilder tnb, MetadataReader reader, TypeDefinitionHandle typeDefToken, TypeNameFormat format)
484538
{
485539
TypeDefinition typeDef = reader.GetTypeDefinition(typeDefToken);

0 commit comments

Comments
 (0)