[interp] Report async-suspension locals to the debugger via GetAsyncLocals

When a managed async method is suspended at an await, the right-side debugger asks the runtime for the live values of the user's locals and arguments at that suspension point so they can be displayed on the call stack. The JIT path supplies this through ICorJitInfo::reportAsyncDebugInfo, which the runtime stores in the standard DebugInfoStore and DacDbiInterfaceImpl::GetAsyncLocals reads back on the right side. The interpreter compiler never participated in this pipeline, so ICorDebugAsyncFrame::GetArgument and GetLocalVariableEx returned CORDBG_E_IL_VAR_NOT_AVAILABLE for every IL variable on every interpreted async frame.

This adds a small parallel pipeline for the interpreter. InterpAsyncSuspendData now carries a per-suspension-point table of {ilVarNum, dataOffset} entries, populated from EmitAsyncSuspensionPoint as it lays out which IL vars are kept live across the suspension. On the DAC side, GetAsyncLocals detects an interpreter method via pMethodDesc->GetInterpreterCode(), treats the incoming state as a byte offset from InterpByteCodeStart (the existing interpreter encoding for INTOP_HANDLE_CONTINUATION_RESUME), decodes the bytecode at startIp + state, expects INTOP_HANDLE_CONTINUATION_RESUME, and surfaces the matching InterpAsyncSuspendData::asyncDebugVars table. The JIT DebugInfoStore path is unchanged.

This fixes the following interpreter debugger test failures:
- Async.AsyncSimple
- Async.AsyncBreakpoint
- Async.AsyncBreakpointJmc
- Async.AsyncGeneric
- Async.AsyncRecursive
- Async.AsyncSharedGeneric
- Async.AsyncV2CallingAsyncV1Iterator
- Async.AsyncGenericStepInto

Three sibling tests (Async.AsyncStepIntoThunk, Async.AsyncStepIntoSync, Async.AsyncGenericStepIntoThunk) still fail. They need interp-aware async-thunk-skip support in DebuggerStepper / InterpreterStepHelper::SetupStep, which is independent of the async debug info plumbing addressed here.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: kotlarmilos

src/coreclr/debug/daccess/dacdbiimpl.cpp

@@ -23,6 +23,10 @@
 
 #include "dacdbiimpl.h"
 
+#ifdef FEATURE_INTERPRETER
+#include <interpretershared.h>
+#endif // FEATURE_INTERPRETER
+
 #ifdef FEATURE_COMINTEROP
 #include "runtimecallablewrapper.h"
 #include "comcallablewrapper.h"
@@ -7771,6 +7775,50 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAsyncLocals(VMPTR_MethodDesc v
         {
             return hr;
         }
+
+#ifdef FEATURE_INTERPRETER
+        PTR_InterpByteCodeStart pByteCodeStart = pMethodDesc->GetInterpreterCode();
+        if (pByteCodeStart != NULL)
+        {
+            PTR_InterpMethod pInterpMethod = pByteCodeStart->Method;
+            if (pInterpMethod != NULL)
+            {
+                // ip address of the suspension RESUME opcode = startIp_addr + state.
+                TADDR ipAddr = dac_cast<TADDR>(pByteCodeStart) + state;
+                TADDR bytecodeStart = dac_cast<TADDR>(pByteCodeStart) + sizeof(InterpByteCodeStart);
+                TADDR bytecodeEnd = bytecodeStart + (TADDR)pInterpMethod->codeSize * sizeof(int32_t);
+                if (ipAddr >= bytecodeStart && (ipAddr + 2 * sizeof(int32_t)) <= bytecodeEnd)
+                {
+                    DPTR(int32_t) pIp = dac_cast<DPTR(int32_t)>(ipAddr);
+                    int32_t opcode = pIp[0];
+                    if (opcode == INTOP_HANDLE_CONTINUATION_RESUME)
+                    {
+                        int32_t dataItemIndex = pIp[1];
+                        // pDataItems is an array of void*, where the entry is the InterpAsyncSuspendData*.
+                        DPTR(TADDR) pDataItems = dac_cast<DPTR(TADDR)>(dac_cast<TADDR>(pInterpMethod->pDataItems));
+                        TADDR suspendDataAddr = (pDataItems != NULL) ? pDataItems[dataItemIndex] : 0;
+                        if (suspendDataAddr != 0)
+                        {
+                            DPTR(InterpAsyncSuspendData) pSuspendData = dac_cast<DPTR(InterpAsyncSuspendData)>(suspendDataAddr);
+                            int32_t numVars = pSuspendData->numAsyncDebugVars;
+                            DPTR(InterpAsyncDebugVar) pVars = dac_cast<DPTR(InterpAsyncDebugVar)>(dac_cast<TADDR>(pSuspendData->asyncDebugVars));
+                            if (numVars > 0 && pVars != NULL)
+                            {
+                                pAsyncLocals->Alloc(numVars);
+                                for (int32_t i = 0; i < numVars; i++)
+                                {
+                                    (*pAsyncLocals)[i].offset = pVars[i].dataOffset;
+                                    (*pAsyncLocals)[i].ilVarNum = pVars[i].ilVarNum;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return hr;
+        }
+#endif // FEATURE_INTERPRETER
+
         TADDR nativeCodeStartAddr;
         if (codeAddr != (TADDR)NULL)
         {

src/coreclr/interpreter/compiler.cpp

@@ -1909,6 +1909,17 @@ void InterpCompiler::PrepareInterpMethod()
         count++; // Include the terminator entry
         m_methodDataBuilder.AllocateIntervalMap(count);
     }
+
+    // Reserve IntervalMaps space for the per-suspension async debug-var array.
+    for (int32_t i = 0; i < m_asyncSuspendDataItems.GetSize(); i++)
+    {
+        InterpAsyncSuspendData* sd = m_asyncSuspendDataItems.Get(i);
+        if (sd->numAsyncDebugVars > 0)
+        {
+            m_methodDataBuilder.AllocateInSection(InterpMethodDataSection::IntervalMaps,
+                sd->numAsyncDebugVars * (uint32_t)sizeof(InterpAsyncDebugVar));
+        }
+    }
 }
 
 int32_t* InterpCompiler::GetCode(int32_t *pCodeSize)
@@ -2028,6 +2039,23 @@ InterpMethod* InterpCompiler::FinalizeMethodData(void* baseAddressRW, void* base
             dstDataRW->zeroedLocalsIntervals = dstMapRX;
             currentIntervalMapOffset += mapSize;
         }
+
+        // Copy async debug-var array into IntervalMaps section and fix up pointer
+        if (srcData->numAsyncDebugVars > 0 && srcData->asyncDebugVars != nullptr)
+        {
+            uint32_t dbgSize = (uint32_t)srcData->numAsyncDebugVars * (uint32_t)sizeof(InterpAsyncDebugVar);
+            assert(currentIntervalMapOffset + dbgSize <= intervalMapsSectionEnd);
+
+            InterpAsyncDebugVar* dstDbgRW = (InterpAsyncDebugVar*)(rwBase + currentIntervalMapOffset);
+            InterpAsyncDebugVar* dstDbgRX = (InterpAsyncDebugVar*)(rxBase + currentIntervalMapOffset);
+            memcpy(dstDbgRW, srcData->asyncDebugVars, dbgSize);
+            dstDataRW->asyncDebugVars = dstDbgRX;
+            currentIntervalMapOffset += dbgSize;
+        }
+        else
+        {
+            dstDataRW->asyncDebugVars = nullptr;
+        }
 
         currentAsyncOffset += sizeof(InterpAsyncSuspendData);
     }
@@ -5783,6 +5811,7 @@ void InterpCompiler::EmitSuspend(const CORINFO_CALL_INFO &callInfo, Continuation
 
     TArray<int32_t, MemPoolAllocator> liveVars(GetMemPoolAllocator(IMK_AsyncSuspend));
     TArray<int32_t, MemPoolAllocator> varsToZero(GetMemPoolAllocator(IMK_AsyncSuspend));
+    TArray<InterpAsyncDebugVar, MemPoolAllocator> debugVars(GetMemPoolAllocator(IMK_AsyncSuspend));
 
     // Step 2: Handle live stack vars (excluding return value)
     int32_t stackDepth = (int32_t)(m_pStackPointer - m_pStackBase);
@@ -5935,6 +5964,14 @@ void InterpCompiler::EmitSuspend(const CORINFO_CALL_INFO &callInfo, Continuation
 
         INTERP_DUMP("Allocate var %d at data offset %d (size %d) (offsetFromStartOfReturnValue = %d)\n", var, currentOffset, size, currentOffset - returnValueDataStartOffset);
 
+        if (var >= 0 && var < m_numILVars && var != returnValueVar)
+        {
+            InterpAsyncDebugVar dbgVar;
+            dbgVar.ilVarNum = (uint32_t)var;
+            dbgVar.dataOffset = (uint32_t)(currentOffset + OFFSETOF__CORINFO_Continuation__data);
+            debugVars.Add(dbgVar);
+        }
+
         if (interpType == InterpTypeO)
         {
             // Mark as GC reference
@@ -6015,6 +6052,18 @@ void InterpCompiler::EmitSuspend(const CORINFO_CALL_INFO &callInfo, Continuation
     suspendData->resumeInfo.DiagnosticIP = (size_t)NULL;
     suspendData->methodStartIP = 0; // This is filled in by logic later in emission once we know the final address of the method
     suspendData->continuationArgOffset = m_pVars[m_continuationArgIndex].offset;
+
+    suspendData->numAsyncDebugVars = debugVars.GetSize();
+    if (suspendData->numAsyncDebugVars > 0)
+    {
+        size_t dbgBytes = suspendData->numAsyncDebugVars * sizeof(InterpAsyncDebugVar);
+        suspendData->asyncDebugVars = (InterpAsyncDebugVar*)AllocMethodData(dbgBytes);
+        memcpy(suspendData->asyncDebugVars, debugVars.GetUnderlyingArray(), dbgBytes);
+    }
+    else
+    {
+        suspendData->asyncDebugVars = NULL;
+    }
     suspendData->asyncMethodReturnType = NULL;
     switch (m_methodInfo->args.retType)
     {

src/coreclr/interpreter/inc/interpretershared.h

@@ -199,6 +199,12 @@ struct InterpIntervalMapEntry
     uint32_t countBytes = 0; // If count is 0 then this is the end marker.
 };
 
+struct InterpAsyncDebugVar
+{
+    uint32_t ilVarNum;
+    uint32_t dataOffset;
+};
+
 struct InterpAsyncSuspendData
 {
     CORINFO_AsyncResumeInfo resumeInfo;
@@ -218,6 +224,9 @@ struct InterpAsyncSuspendData
     COMPILER_SHARED_TYPE(CORINFO_METHOD_HANDLE, DPTR(MethodDesc), captureSyncContextMethod);
     COMPILER_SHARED_TYPE(CORINFO_METHOD_HANDLE, DPTR(MethodDesc), restoreExecutionContextMethod);
     COMPILER_SHARED_TYPE(CORINFO_METHOD_HANDLE, DPTR(MethodDesc), restoreContextsOnSuspensionMethod);
+
+    int32_t numAsyncDebugVars;
+    InterpAsyncDebugVar* asyncDebugVars;
 };
 
 #endif