[cDAC] Implement DacDbi APIs ParseContinuation and GetAsyncLocals

[rcj1]

• Add cDAC API to read continuation
• Add cDAC API to read async debug info
• Implement the DacDbi APIs using those

Note to CCR: DO NOT mention breaking changes of cDAC APIs or DacDbi interface!!!!

[Copilot]

Pull request overview

This PR extends the cDAC (DataContractReader) stack to expose continuation-object data and async debug-info data, then wires those into the legacy DacDbi surface by implementing ParseContinuation and replacing the old “return a list” async-locals API with a callback-based enumeration API.

Changes:

• Add new cDAC Object contract support for reading ContinuationObject + AsyncResumeInfo and expose GetContinuationInfo.
• Add DebugInfo contract support for decoding the AsyncInfo chunk into suspension points + captured locals.
• Update the DacDbi interface and implementations to use ParseContinuation and EnumerateAsyncLocals (callback-based), and update the RS consumer to accumulate results.

Show a summary per file

File	Description
src/native/managed/cdac/tests/ObjectTests.cs	Adds unit tests for IObject.GetContinuationInfo behavior (resume info present/absent).
src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.Object.cs	Adds mock layouts + builders for ContinuationObject and AsyncResumeInfo test objects.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs	Introduces AsyncLocalData and switches from GetAsyncLocals to callback-based EnumerateAsyncLocals.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs	Implements ParseContinuation and EnumerateAsyncLocals using cDAC contracts, with DEBUG cross-checking vs legacy DAC.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/DataType.cs	Adds AsyncResumeInfo data type.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/ContinuationObject.cs	Defines cDAC data descriptor-backed reader for ContinuationObject.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/AsyncResumeInfo.cs	Defines cDAC data descriptor-backed reader for AsyncResumeInfo (DiagnosticIP).
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Object_1.cs	Implements GetContinuationInfo in the Object contract.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/DebugInfo/DebugInfoHelpers.cs	Adds decoding for async suspension points + locals from the AsyncInfo chunk.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/DebugInfo/DebugInfo_2.cs	Exposes IDebugInfo.GetAsyncSuspensionPoints by decoding the AsyncInfo chunk.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IObject.cs	Adds ContinuationInfo + GetContinuationInfo to the Object contract surface.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IDebugInfo.cs	Adds public async suspension/local data structures and GetAsyncSuspensionPoints.
src/coreclr/vm/object.h	Adds cdac_data<ContinuationObject> offsets for descriptor generation.
src/coreclr/vm/datadescriptor/datadescriptor.inc	Adds descriptors for ContinuationObject fields and new AsyncResumeInfo type (DiagnosticIP).
src/coreclr/inc/dacdbi.idl	Updates COM IDL to replace GetAsyncLocals with EnumerateAsyncLocals callback form.
src/coreclr/debug/inc/dacdbiinterface.h	Updates the native interface contract docs and signature for EnumerateAsyncLocals.
src/coreclr/debug/di/rsthread.cpp	Updates RS to call EnumerateAsyncLocals and accumulate results into a quick array list.
src/coreclr/debug/di/rspriv.h	Switches CordbAsyncFrame async locals storage to CQuickArrayList<AsyncLocalData>.
src/coreclr/debug/daccess/dacdbiimpl.h	Renames GetAsyncLocals to EnumerateAsyncLocals in the DAC implementation declaration.
src/coreclr/debug/daccess/dacdbiimpl.cpp	Implements callback-based EnumerateAsyncLocals in the DAC implementation.
docs/design/datacontracts/Object.md	Documents the new GetContinuationInfo contract API and involved descriptors.
docs/design/datacontracts/DebugInfo.md	Documents async suspension point APIs and the AsyncInfo encoding format.

Copilot's findings

Comments suppressed due to low confidence (2)

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs:4154

• EnumerateAsyncLocals compares state by casting to int. For values >= 0x8000_0000 this becomes negative, the (int)state < suspensionPoints.Count check passes, and the subsequent index uses a negative value, causing an exception (and an unintended HRESULT) instead of the intended "out of range => S_OK with no callbacks" behavior. The native DAC implementation treats state as an unsigned index (state >= NumSuspensionPoints).

        try
        {
            if (vmObject == 0)
            {

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs:4077

• ParseContinuation doesn't initialize the output pointers on the success path until after reading target state. If an exception is thrown after the null checks (e.g., invalid address / read failure), the method returns a failing HRESULT but leaves the out values uninitialized. Other methods in this file zero-init outputs early (e.g., GetAssemblyFromModule) to avoid callers observing garbage.

#if DEBUG
        if (_legacy is not null)
        {
            ulong resultLocal;
            int hrLocal = _legacy.GetNativeCodeVersionNode(vmMethod, codeStartAddress, &resultLocal);

• Files reviewed: 22/22 changed files
• Comments generated: 1

[github-actions]

Note

This review was generated by Copilot.

🤖 Copilot Code Review — PR #129147

Holistic Assessment

Motivation: The PR implements two cDAC contract APIs (ParseContinuation on the Object contract and GetAsyncSuspensionPoints on DebugInfo) and wires them into the DacDbi ParseContinuation and EnumerateAsyncLocals methods. This fills a clear gap in the async debugging diagnostics path.

Approach: The approach follows established cDAC patterns — data descriptors in datadescriptor.inc, IData<T> types, contract implementations, DacDbi callback-based enumeration, and validation via #if DEBUG comparisons against legacy DAC. The GetAsyncLocals → EnumerateAsyncLocals rename to a callback pattern is consistent with other DacDbi APIs (e.g., EnumerateTypeHandleParams, field enumeration).

Summary: ⚠️ Needs Human Review. The code is well-structured and follows established patterns. I have one low-confidence concern about the signed-to-unsigned cast in DoAsyncInfo and would like a human reviewer to confirm the encoding semantics. Otherwise the implementation looks solid.

---

Detailed Findings

✅ Correctness — cDAC encoding/decoding matches native runtime

The DoAsyncInfo decoding in DebugInfoHelpers.cs matches the native CompressAsyncDebugInfo / RestoreAsyncDebugInfo encoder/decoder:

• ReadUInt() for NumSuspensionPoints and total var count ↔ WriteEncodedU32
• ReadInt() for signed delta ↔ DoEncodedDeltaU32NonMonotonic (which reads ReadEncodedI32)
• ReadUInt() + MAX_ILNUM for var number ↔ DoEncodedAdjustedU32(var->VarNumber, MAX_ILNUM) (which does ReadEncodedU32 + dwAdjust)
• ReadUInt() for offset ↔ DoEncodedU32

The MAX_ILNUM constant (unchecked((uint)-5)) is consistent with the native ICorDebugInfo::MAX_ILNUM.

✅ Object contract — GetContinuationInfo correctly reads continuation data

The Object_1.GetContinuationInfo implementation properly reads Next, ResumeInfo, and State from the ContinuationObject, and conditionally reads DiagnosticIP from AsyncResumeInfo when ResumeInfo is non-null. This matches the field layout in object.h and the native ParseContinuation implementation.

✅ DacDbi interface change — callback pattern is well-implemented

The rename from GetAsyncLocals (which allocated a DacDbiArrayList) to EnumerateAsyncLocals (callback-based) follows the established CallbackAccumulator<T> pattern already used by other DacDbi enumeration APIs. The consumer side in rsthread.cpp correctly uses CallbackAccumulator<AsyncLocalData> with error propagation via acc.hrError.

✅ Data descriptors — properly defined

datadescriptor.inc correctly adds ContinuationObject fields (Next, ResumeInfo, State) using cdac_data<ContinuationObject> offsets, and AsyncResumeInfo::DiagnosticIP using offsetof(CORINFO_AsyncResumeInfo, DiagnosticIP). The CDAC_TYPE_INDETERMINATE for AsyncResumeInfo is appropriate since its size isn't needed.

✅ Debug validation — thorough cross-validation in DacDbiImpl.cs

Both ParseContinuation and EnumerateAsyncLocals in DacDbiImpl.cs include #if DEBUG validation blocks that compare cDAC results against legacy DAC results field-by-field, which will catch any discrepancy during development.

✅ Unit tests — good coverage for Object contract

Three test cases (WithResumeInfo, NullResumeInfo, NullDiagnosticIP) in ObjectTests.cs cover the key scenarios for GetContinuationInfo. The mock data structures properly model the ContinuationObject and AsyncResumeInfo layouts.

⚠️ Potential concern — signed delta cast to uint in DoAsyncInfo

In DebugInfoHelpers.DoAsyncInfo (line 222-223):

lastOffset += reader.ReadInt();
nativeOffsets[i] = (uint)lastOffset;

lastOffset is long, which handles the signed accumulation correctly. However, casting to uint could silently truncate if the accumulated offset ever goes negative (which the native side stores as a uint32_t). The native decoder does: dw = static_cast<uint32_t>(static_cast<int32_t>(dwLast) + dwDelta) — which means it operates in int32_t space and wraps to uint32_t. The cDAC code operates in long space and truncates to uint. These should produce identical results for valid data, but the semantics differ slightly for malformed input. This is likely fine in practice.

💡 Observation — No unit test for GetAsyncSuspensionPoints

There is no unit test for the DebugInfo_2.GetAsyncSuspensionPoints() / DoAsyncInfo decoding path. The Object contract has tests, but the DebugInfo decoding is only tested indirectly via dump tests. A targeted unit test with known nibble-encoded data would provide stronger coverage for the new decoder. This is non-blocking — the existing dump test infrastructure (AsyncContinuationDumpTests) and the #if DEBUG cross-validation provide reasonable confidence.

✅ Documentation — clear and accurate

The additions to DebugInfo.md and Object.md clearly document the new API types, encoding format, and pseudocode. The encoding documentation matches the native implementation faithfully.

Generated by Code Review for issue #129147 · ● 21.3M · ◷