cDAC: Add GetGCDescSeries contract API and continuation pretty-printing (#127419)

## Summary

Implements continuation pretty-printing in the cDAC, mirroring
`AsyncContinuationsManager::PrintContinuationName` from
`asynccontinuations.h`, and adds a new `GetGCDescSeries` API to the
`RuntimeTypeSystem` contract.

Fixes the WebApp3 test failure seen in recent runtime-diagnostics legs
such as this:
https://dev.azure.com/dnceng-public/public/_build/results?buildId=1395576

The `GetGCDescSeries` API accepts an optional `numComponents` parameter
(defaulting to `0` for non-array types) and handles both regular
(positive `NumSeries`) and value-class repeating (negative `NumSeries`)
GCDesc layouts. For value-class GCDesc, the outer loop iterates
`numComponents` times — callers must pass the actual element count to
enumerate pointer runs across array elements.

> [!NOTE]
> This PR was created with the assistance of GitHub Copilot
(AI-generated content).

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: rcj1 <77995559+rcj1@users.noreply.github.com>
Co-authored-by: rcj1 <rachel.jarvi@gmail.com>
Co-authored-by: Noah Falk <noahfalk@users.noreply.github.com>

Author: 3 people

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -58,6 +58,11 @@ partial interface IRuntimeTypeSystem : IContract
     public virtual bool RequiresAlign8(TypeHandle typeHandle);
     // True if the MethodTable represents a continuation type used by the async continuation feature
     public virtual bool IsContinuation(TypeHandle typeHandle);
+    // Returns the GC pointer runs for the method table as (offset, size) pairs. Each
+    // run starts Offset bytes from the object pointer (`this`), where offset 0
+    // is the method table pointer, and includes Size bytes of contiguous pointers
+    // For handles representing value types the object is assumed to be stored in the boxed layout.
+    public virtual IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0);
     public virtual bool IsDynamicStatics(TypeHandle typeHandle);
     public virtual ushort GetNumInterfaces(TypeHandle typeHandle);
 
@@ -554,6 +559,61 @@ Contracts used:
 
     public bool RequiresAlign8(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[typeHandle.Address].Flags.RequiresAlign8;
 
+    public bool IsContinuation(TypeHandle typeHandle) => typeHandle.IsMethodTable()
+        && ContinuationMethodTablePointer != TargetPointer.Null
+        && _methodTables[typeHandle.Address].ParentMethodTable == ContinuationMethodTablePointer;
+
+    IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0)
+    {
+        // Returns empty if not a method table or has no GC pointers.
+        // Compute objectSize: baseSize + numComponents * componentSize.
+        // For non-array types, numComponents == 0 so objectSize == baseSize.
+
+        // Read NumSeries from (mtAddress - pointerSize), sign-extended to native width.
+        // NumSeries == 0 → empty.
+
+        // NumSeries > 0: Regular series.
+        // Memory layout (each slot is pointer-sized, growing away from MT):
+        //
+        //   MT - (2*N+1)*ptrSize : series[N-1].seriessize
+        //   MT - (2*N)  *ptrSize : series[N-1].startoffset
+        //   ...
+        //   MT - 3*ptrSize       : series[0].seriessize
+        //   MT - 2*ptrSize       : series[0].startoffset
+        //   MT - 1*ptrSize       : NumSeries (positive)
+        //   MT                   : MethodTable
+        //
+        // The raw seriessize is stored with baseSize subtracted.
+        // Add objectSize back to get the true run length:
+        //   trueRunLength = rawSeriesSize + objectSize
+        // For non-arrays objectSize == baseSize, recovering the actual run.
+        // For arrays objectSize > baseSize, extending the single series across all elements.
+
+        // NumSeries < 0: Value-class (repeating) series.
+        // |NumSeries| val_serie_items describe pointer runs within one array element.
+        // Memory layout:
+        //
+        //   MT - (N+2)*ptrSize : val_serie[N-1]
+        //   ...
+        //   MT - 3*ptrSize     : val_serie[0]
+        //   MT - 2*ptrSize     : startoffset
+        //   MT - 1*ptrSize     : NumSeries (-N)
+        //   MT                 : MethodTable
+        //
+        // Each val_serie_item is { HALF_SIZE_T nptrs; HALF_SIZE_T skip; } packed into one pointer-width.
+        // HALF_SIZE_T is uint16 on 32-bit, uint32 on 64-bit.
+        // Read nptrs and skip as separate typed reads for endianness safety.
+        // runBytes = nptrs * pointerSize; advance currentOffset by runBytes + skip after each item.
+        //
+        // The val_serie_items describe the GC pointer layout of a single array element.
+        // An outer loop repeats the pattern across all elements in the array:
+        //   currentOffset = startoffset
+        //   while currentOffset <= objectSize - pointerSize:
+        //       for each val_serie_item:
+        //           yield (currentOffset, nptrs * pointerSize)
+        //           currentOffset += nptrs * pointerSize + skip
+    }
+
     public bool IsDynamicStatics(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[TypeHandle.Address].Flags.IsDynamicStatics;
 
     public ushort GetNumInterfaces(TypeHandle TypeHandle) => !typeHandle.IsMethodTable() ? 0 : _methodTables[TypeHandle.Address].NumInterfaces;

src/coreclr/vm/datadescriptor/datadescriptor.inc

@@ -177,6 +177,10 @@ CDAC_TYPE_FIELD(String, T_POINTER, m_FirstChar, cdac_data<StringObject>::m_First
 CDAC_TYPE_FIELD(String, T_UINT32, m_StringLength, cdac_data<StringObject>::m_StringLength)
 CDAC_TYPE_END(String)
 
+CDAC_TYPE_BEGIN(ContinuationObject)
+CDAC_TYPE_SIZE(sizeof(ContinuationObject))
+CDAC_TYPE_END(ContinuationObject)
+
 CDAC_TYPE_BEGIN(Array)
 CDAC_TYPE_SIZE(sizeof(ArrayBase))
 CDAC_TYPE_FIELD(Array, T_UINT32, m_NumComponents, cdac_data<ArrayBase>::m_NumComponents)

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

@@ -121,6 +121,12 @@ public interface IRuntimeTypeSystem : IContract
     bool RequiresAlign8(TypeHandle typeHandle) => throw new NotImplementedException();
     // True if the MethodTable represents a continuation type used by the async continuation feature
     bool IsContinuation(TypeHandle typeHandle) => throw new NotImplementedException();
+    /// <summary>
+    /// Enumerates GC pointer runs from the CGCDesc stored before the method table.
+    /// Returns (offset, size) pairs normalized to actual byte lengths.
+    /// See RuntimeTypeSystem.md for the full GCDesc format documentation.
+    /// </summary>
+    IEnumerable<(uint Offset, uint Size)> GetGCDescSeries(TypeHandle typeHandle, uint numComponents = 0) => throw new NotImplementedException();
     bool IsDynamicStatics(TypeHandle typeHandle) => throw new NotImplementedException();
     ushort GetNumInterfaces(TypeHandle typeHandle) => throw new NotImplementedException();
 

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

@@ -78,6 +78,7 @@ public enum DataType
     StressMsg,
     StressMsgHeader,
     Object,
+    ContinuationObject,
     NativeObjectWrapperObject,
     ManagedObjectWrapperHolderObject,
     ManagedObjectWrapperLayout,

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

@@ -564,6 +564,81 @@ private Data.EEClass GetClassData(TypeHandle typeHandle)
     public bool IsContinuation(TypeHandle typeHandle) => typeHandle.IsMethodTable()
         && _continuationMethodTablePointer != TargetPointer.Null
         && _methodTables[typeHandle.Address].ParentMethodTable == _continuationMethodTablePointer;
+
+    IEnumerable<(uint Offset, uint Size)> IRuntimeTypeSystem.GetGCDescSeries(TypeHandle typeHandle, uint numComponents)
+    {
+        if (!typeHandle.IsMethodTable())
+            yield break;
+
+        if (!ContainsGCPointers(typeHandle))
+            yield break;
+
+        uint baseSize = GetBaseSize(typeHandle);
+        uint componentSize = GetComponentSize(typeHandle);
+        uint objectSize = baseSize + numComponents * componentSize;
+
+        ulong mtAddress = typeHandle.Address;
+        ulong pointerSize = (ulong)_target.PointerSize;
+
+        // Sign-extend NumSeries from native pointer width.
+        long numSeries = _target.PointerSize == sizeof(uint)
+            ? (long)(int)_target.ReadPointer(mtAddress - pointerSize).Value
+            : (long)_target.ReadPointer(mtAddress - pointerSize).Value;
+        if (numSeries == 0)
+            yield break;
+
+        if (numSeries > 0)
+        {
+            // Regular series: iterate from highest (closest to MT) to lowest.
+            for (ulong i = 0; i < (ulong)numSeries; i++)
+            {
+                ulong seriesBase = mtAddress - (3 + 2 * i) * pointerSize;
+                ulong rawSeriesSize = _target.ReadPointer(seriesBase).Value;
+                ulong seriesOffset = _target.ReadPointer(seriesBase + pointerSize).Value;
+                yield return ((uint)seriesOffset, (uint)(rawSeriesSize + objectSize));
+            }
+        }
+        else
+        {
+            long absNumSeries = -numSeries;
+            ulong startOffset = _target.ReadPointer(mtAddress - 2 * pointerSize).Value;
+
+            var seriesItems = new (uint Nptrs, uint Skip)[absNumSeries];
+            for (long i = 0; i < absNumSeries; i++)
+            {
+                ulong itemAddress = mtAddress - (3 + (ulong)i) * pointerSize;
+
+                // Read val_serie_item fields individually for endianness safety.
+                uint nptrs, skip;
+                if (_target.PointerSize == sizeof(uint))
+                {
+                    nptrs = _target.Read<ushort>(itemAddress);
+                    skip = _target.Read<ushort>(itemAddress + sizeof(ushort));
+                }
+                else
+                {
+                    nptrs = _target.Read<uint>(itemAddress);
+                    skip = _target.Read<uint>(itemAddress + sizeof(uint));
+                }
+
+                seriesItems[i] = (nptrs, skip);
+            }
+
+            ulong currentOffset = startOffset;
+            for (int i = 0; i < numComponents; i++)
+            {
+                for (long j = 0; j < absNumSeries; j++)
+                {
+                    if (currentOffset > objectSize - pointerSize)
+                        yield break;
+                    uint runBytes = seriesItems[j].Nptrs * (uint)pointerSize;
+                    yield return ((uint)currentOffset, runBytes);
+                    currentOffset += runBytes + seriesItems[j].Skip;
+                }
+            }
+        }
+    }
+
     public bool IsDynamicStatics(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? false : _methodTables[typeHandle.Address].Flags.IsDynamicStatics;
     public ushort GetNumInterfaces(TypeHandle typeHandle) => !typeHandle.IsMethodTable() ? (ushort)0 : _methodTables[typeHandle.Address].NumInterfaces;
 

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

@@ -6,6 +6,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Text;
+using Microsoft.Diagnostics.DataContractReader;
 using Microsoft.Diagnostics.DataContractReader.Contracts;
 
 namespace Microsoft.Diagnostics.DataContractReader.Legacy;
@@ -283,7 +284,14 @@ private static void AppendTypeCore(ref TypeNameBuilder tnb, Contracts.TypeHandle
                 Contracts.ModuleHandle moduleHandle = tnb.Target.Contracts.Loader.GetModuleHandleFromModulePtr(typeSystemContract.GetModule(typeHandle));
                 if (MetadataTokens.EntityHandle((int)typeDefToken).IsNil)
                 {
-                    tnb.AddName("(dynamicClass)");
+                    if (typeSystemContract.IsContinuation(typeHandle))
+                    {
+                        AppendContinuationName(ref tnb, typeSystemContract, typeHandle);
+                    }
+                    else
+                    {
+                        tnb.AddName("(dynamicClass)");
+                    }
                 }
                 else
                 {
@@ -480,6 +488,52 @@ private void AddAssemblySpec(string? assemblySpec)
         }
     }
 
+    /// <summary>
+    /// Builds the synthetic name for a dynamically-created continuation method table, mirroring the
+    /// native <c>AsyncContinuationsManager::PrintContinuationName</c> in <c>asynccontinuations.h</c>.
+    /// </summary>
+    /// <remarks>
+    /// The name has the form:
+    /// <c>Continuation_&lt;dataSize&gt;[_&lt;gcOffset&gt;_&lt;gcCount&gt;]*</c>
+    /// where:
+    /// <list type="bullet">
+    ///   <item><description>
+    ///     <c>dataSize</c> is the number of bytes of data payload (base size minus the fixed
+    ///     object-header and continuation-header overhead).
+    ///   </description></item>
+    ///   <item><description>
+    ///     Each <c>_gcOffset_gcCount</c> pair describes one GC-pointer run: <c>gcOffset</c> is the
+    ///     offset in bytes from the start of the data payload to the run, and <c>gcCount</c> is the
+    ///     number of pointer-sized GC references in that run.
+    ///   </description></item>
+    /// </list>
+    /// Only GC descriptor series whose <c>startoffset</c> is at or above the continuation data
+    /// payload (i.e., after the fixed <c>CORINFO_Continuation</c> header fields) are included.
+    /// </remarks>
+    private static void AppendContinuationName(ref TypeNameBuilder tnb, IRuntimeTypeSystem typeSystemContract, TypeHandle typeHandle)
+    {
+        uint baseSize = typeSystemContract.GetBaseSize(typeHandle);
+        uint continuationDataOffset = tnb.Target.GetTypeInfo(DataType.ContinuationObject).Size!.Value;
+        uint objHeaderSize = tnb.Target.GetTypeInfo(DataType.ObjectHeader).Size!.Value;
+        uint dataSize = baseSize - (objHeaderSize + continuationDataOffset);
+
+        var name = new StringBuilder("Continuation_");
+        name.Append(dataSize);
+
+        foreach ((uint seriesOffset, uint seriesSize) in typeSystemContract.GetGCDescSeries(typeHandle))
+        {
+            if (seriesOffset < continuationDataOffset)
+                continue;
+
+            name.Append('_');
+            name.Append(seriesOffset - continuationDataOffset);
+            name.Append('_');
+            name.Append(seriesSize / (uint)tnb.Target.PointerSize);
+        }
+
+        tnb.AddNameNoEscaping(name);
+    }
+
     private static void AppendNestedTypeDef(ref TypeNameBuilder tnb, MetadataReader reader, TypeDefinitionHandle typeDefToken, TypeNameFormat format)
     {
         TypeDefinition typeDef = reader.GetTypeDefinition(typeDefToken);