[clr-interp] Add User Breakpoint Support for Interpreter Debugging

src/coreclr/debug/daccess/request.cpp

@@ -1287,6 +1287,11 @@ HRESULT ClrDataAccess::GetTieredVersions(
                 nativeCodeAddrs[count].OptimizationTier = DacpTieredVersionData::OptimizationTier_Optimized;
             }
 
+            if ((int)(*iter).GetOptimizationTier() == NativeCodeVersion::OptimizationTierInterpreted)
+            {
+                nativeCodeAddrs[count].OptimizationTier = DacpTieredVersionData::OptimizationTier_Interpreted;
+            }
+
             ++count;
 
             if (count >= cNativeCodeAddrs)

src/coreclr/debug/ee/CMakeLists.txt

@@ -11,6 +11,7 @@ set(CORDBEE_SOURCES_DAC_AND_WKS
   debugger.cpp
   debuggermessagebox.cpp
   debuggermodule.cpp
+  executioncontrol.cpp
   functioninfo.cpp
 )
 
@@ -20,6 +21,7 @@ set(CORDBEE_HEADERS_DAC_AND_WKS
   datatest.h
   debugger.h
   debugger.inl
+  executioncontrol.h
 )
 
 set(CORDBEE_SOURCES_WKS

src/coreclr/debug/ee/controller.cpp

@@ -1502,6 +1502,13 @@ bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch)
             return true;
         }
 
+#ifdef FEATURE_INTERPRETER
+        EECodeInfo codeInfo((PCODE)patch->address);
+        IJitManager* pJitManager = codeInfo.GetJitManager();
+        if (pJitManager != NULL && pJitManager == ExecutionManager::GetInterpreterJitManager())
+            return pJitManager->GetExecutionControl()->ApplyPatch(patch);
+#endif // FEATURE_INTERPRETER
+
 #if _DEBUG
         VerifyExecutableAddress((BYTE*)patch->address);
 #endif
@@ -1615,6 +1622,13 @@ bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch)
             return true;
         }
 
+#ifdef FEATURE_INTERPRETER
+        EECodeInfo codeInfo((PCODE)patch->address);
+        IJitManager* pJitManager = codeInfo.GetJitManager();
+        if (pJitManager != NULL && pJitManager == ExecutionManager::GetInterpreterJitManager())
+            return pJitManager->GetExecutionControl()->UnapplyPatch(patch);
+#endif // FEATURE_INTERPRETER
+
         LPVOID baseAddress = (LPVOID)(patch->address);
 
 #if !defined(HOST_OSX) || !defined(HOST_ARM64)
@@ -2595,10 +2609,16 @@ bool DebuggerController::MatchPatch(Thread *thread,
 {
     LOG((LF_CORDB, LL_INFO100000, "DC::MP: EIP:0x%p\n", GetIP(context)));
 
-    // Caller should have already matched our addresses.
-    if (patch->address != dac_cast<PTR_CORDB_ADDRESS_TYPE>(GetIP(context)))
+    // For interpreter patches, we can't compare against the context IP because:
+    // - patch->address is the bytecode address
+    // - GetIP(context) is the native C++ address inside the interpreter loop
+    if (patch->kind != PATCH_KIND_NATIVE_INTERPRETER)
     {
-        return false;
+        // Caller should have already matched our addresses.
+        if (patch->address != dac_cast<PTR_CORDB_ADDRESS_TYPE>(GetIP(context)))
+        {
+            return false;
+        }
     }
 
     // <BUGNUM>RAID 67173 -</BUGNUM> we'll make sure that intermediate patches have NULL
@@ -3063,6 +3083,7 @@ DPOSS_ACTION DebuggerController::DispatchPatchOrSingleStep(Thread *thread, CONTE
     CrstHolderWithState lockController(&g_criticalSection);
 
     TADDR originalAddress = 0;
+    bool isInterpreterBreakpoint = false;
 
 #ifdef FEATURE_METADATA_UPDATER
     DebuggerControllerPatch *dcpEnCOriginal = NULL;
@@ -3113,6 +3134,17 @@ DPOSS_ACTION DebuggerController::DispatchPatchOrSingleStep(Thread *thread, CONTE
 
     LOG((LF_CORDB|LF_ENC, LL_EVERYTHING, "DC::DPOSS ScanForTriggers called and returned.\n"));
 
+    // Check if we're debugging with the interpreter by checking the JIT manager for this address
+#ifdef FEATURE_INTERPRETER
+    {
+        IJitManager* pJitManager = ExecutionManager::FindJitMan((PCODE)address);
+        if (pJitManager != NULL && pJitManager == ExecutionManager::GetInterpreterJitManager())
+        {
+            isInterpreterBreakpoint = true;
+            LOG((LF_CORDB, LL_EVERYTHING, "DC::DPOSS Interpreter breakpoint detected at %p\n", address));
+        }
+    }
+#endif // FEATURE_INTERPRETER
 
     // If we setip, then that will change the address in the context.
     // Remeber the old address so that we can compare it to the context's ip and see if it changed.
@@ -3140,7 +3172,7 @@ DPOSS_ACTION DebuggerController::DispatchPatchOrSingleStep(Thread *thread, CONTE
         SENDIPCEVENT_BEGIN(g_pDebugger, thread);
 
         // Now that we've resumed from blocking, check if somebody did a SetIp on us.
-        bool fIpChanged = (originalAddress != GetIP(context));
+        bool fIpChanged = isInterpreterBreakpoint ? false : (originalAddress != GetIP(context));
 
         // Send the events outside of the controller lock
         bool anyEventsSent = false;
@@ -3217,7 +3249,7 @@ DPOSS_ACTION DebuggerController::DispatchPatchOrSingleStep(Thread *thread, CONTE
     }
 #endif
 
-    ActivatePatchSkip(thread, dac_cast<PTR_CBYTE>(GetIP(pCtx)), FALSE
+    ActivatePatchSkip(thread, isInterpreterBreakpoint ? dac_cast<PTR_CBYTE>((CORDB_ADDRESS_TYPE*)originalAddress) : dac_cast<PTR_CBYTE>(GetIP(pCtx)), FALSE
 #ifdef OUT_OF_PROCESS_SETTHREADCONTEXT
     , pDebuggerSteppingInfo
 #endif
@@ -4565,6 +4597,14 @@ bool DebuggerController::DispatchNativeException(EXCEPTION_RECORD *pException,
         switch (dwCode)
         {
         case EXCEPTION_BREAKPOINT:
+            // Check if this is an interpreter breakpoint by examining if we have the special exception information
+            // Interpreter breakpoints provide: [0] = bytecode, [1] = pFrame, [2] = stack
+            if (pException->NumberParameters >= 3 && pException->ExceptionInformation[1] != 0)
+            {
+                // Store the bytecode pointer for patch lookup
+                ip = (CORDB_ADDRESS_TYPE*)pException->ExceptionInformation[0];
+            }
+
             // EIP should be properly set up at this point.
             result = DebuggerController::DispatchPatchOrSingleStep(pCurThread,
                                                        pContext,

src/coreclr/debug/ee/controller.h

@@ -17,6 +17,7 @@
 #if !defined(DACCESS_COMPILE)
 
 #include "frameinfo.h"
+#include "executioncontrol.h"
 
 /* ------------------------------------------------------------------------- *
  * Forward declarations
@@ -363,7 +364,7 @@ typedef DebuggerFunctionKey1 UNALIGNED DebuggerFunctionKey;
 //
 // NativeUnmanaged: A patch applied to any kind of native code.
 
-enum DebuggerPatchKind { PATCH_KIND_IL_PRIMARY, PATCH_KIND_IL_REPLICA, PATCH_KIND_NATIVE_MANAGED, PATCH_KIND_NATIVE_UNMANAGED };
+enum DebuggerPatchKind { PATCH_KIND_IL_PRIMARY, PATCH_KIND_IL_REPLICA, PATCH_KIND_NATIVE_MANAGED, PATCH_KIND_NATIVE_UNMANAGED, PATCH_KIND_NATIVE_INTERPRETER };
 
 // struct DebuggerControllerPatch:  An entry in the patch (hash) table,
 // this should contain all the info that's needed over the course of a
@@ -462,6 +463,7 @@ struct DebuggerControllerPatch
     BOOL IsILPrimaryPatch();
     BOOL IsILReplicaPatch();
     DebuggerPatchKind  GetKind();
+    void SetKind(DebuggerPatchKind newKind);
 
     // A patch has DJI if it was created with it or if it has been mapped to a
     // function that has been jitted while JIT tracking was on.  It does not

src/coreclr/debug/ee/controller.inl

@@ -28,6 +28,11 @@ inline DebuggerPatchKind DebuggerControllerPatch::GetKind()
     return kind;
 }
 
+inline void DebuggerControllerPatch::SetKind(DebuggerPatchKind newKind)
+{
+    kind = newKind;
+}
+
 inline BOOL DebuggerControllerPatch::IsILPrimaryPatch()
 {
     LIMITED_METHOD_CONTRACT;
@@ -47,7 +52,7 @@ inline BOOL DebuggerControllerPatch::IsManagedPatch()
 
 inline BOOL DebuggerControllerPatch::IsNativePatch()
 {
-    return (kind == PATCH_KIND_NATIVE_MANAGED || kind == PATCH_KIND_NATIVE_UNMANAGED || (IsILReplicaPatch() && !offsetIsIL));
+    return (kind == PATCH_KIND_NATIVE_MANAGED || kind == PATCH_KIND_NATIVE_UNMANAGED || kind == PATCH_KIND_NATIVE_INTERPRETER ||(IsILReplicaPatch() && !offsetIsIL));
 }
 
 inline BOOL DebuggerControllerPatch::IsEnCRemapPatch()

src/coreclr/debug/ee/debugger.h

@@ -1358,6 +1358,23 @@ class CodeRegionInfo
             (size_t *) &m_sizeOfColdCode);
     }
 
+    // Initialize for interpreter code - no hot/cold split, just bytecode
+    void InitializeForInterpreter(PCODE bytecodeAddr, SIZE_T bytecodeSize)
+    {
+        CONTRACTL
+        {
+            NOTHROW;
+            GC_NOTRIGGER;
+            SUPPORTS_DAC;
+        }
+        CONTRACTL_END;
+
+        m_addrOfHotCode = bytecodeAddr;
+        m_addrOfColdCode = (PCODE)NULL;  // No cold code for interpreter
+        m_sizeOfHotCode = bytecodeSize;
+        m_sizeOfColdCode = 0;
+    }
+
     // Converts an offset within a method to a code address
     PCODE OffsetToAddress(SIZE_T offset)
     {

src/coreclr/debug/ee/executioncontrol.cpp

@@ -0,0 +1,73 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//*****************************************************************************
+// File: executioncontrol.cpp
+//
+// Implementation of execution control for interpreter breakpoints.
+// WIP
+//
+//*****************************************************************************
+
+#include "stdafx.h"
+#include "executioncontrol.h"
+#include "controller.h"
+#include "../../vm/codeman.h"
+
+#ifdef FEATURE_INTERPRETER
+#include "../../interpreter/intops.h"
+#endif
+
+#if !defined(DACCESS_COMPILE)
+#ifdef FEATURE_INTERPRETER
+
+//=============================================================================
+// InterpreterExecutionControl - Interpreter bytecode breakpoints
+//=============================================================================
+
+InterpreterExecutionControl InterpreterExecutionControl::s_instance;
+
+InterpreterExecutionControl* InterpreterExecutionControl::GetInstance()
+{
+    return &s_instance;
+}
+
+bool InterpreterExecutionControl::ApplyPatch(DebuggerControllerPatch* patch)
+{
+    _ASSERTE(patch != NULL);
+    _ASSERTE(!patch->IsActivated());
+    _ASSERTE(patch->IsBound());
+
+    LOG((LF_CORDB, LL_INFO10000, "InterpreterEC::ApplyPatch %p at bytecode addr %p\n",
+        patch, patch->address));
+
+    patch->SetKind(PATCH_KIND_NATIVE_INTERPRETER);
+    patch->opcode = *(int32_t*)patch->address;;
+    *(uint32_t*)patch->address = INTOP_BREAKPOINT;
+
+    LOG((LF_CORDB, LL_EVERYTHING, "InterpreterEC::ApplyPatch Breakpoint inserted at %p, saved opcode %x\n",
+        patch->address, patch->opcode));
+
+    return true;
+}
+
+bool InterpreterExecutionControl::UnapplyPatch(DebuggerControllerPatch* patch)
+{
+    _ASSERTE(patch != NULL);
+    _ASSERTE(patch->address != NULL);
+    _ASSERTE(patch->IsActivated());
+
+    LOG((LF_CORDB, LL_INFO1000, "InterpreterEC::UnapplyPatch %p at bytecode addr %p, replacing with original opcode 0x%x\n",
+        patch, patch->address, patch->opcode));
+
+    // Restore the original opcode
+    *(uint32_t*)patch->address = patch->opcode;
+    InitializePRD(&(patch->opcode));
+
+    LOG((LF_CORDB, LL_EVERYTHING, "InterpreterEC::UnapplyPatch Restored opcode at %p\n",
+        patch->address));
+
+    return true;
+}
+
+#endif // FEATURE_INTERPRETER
+#endif // !DACCESS_COMPILE

src/coreclr/debug/ee/executioncontrol.h

@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//*****************************************************************************
+// File: executioncontrol.h
+//
+// Abstraction for breakpoint and single-step operations across different
+// code execution strategies (JIT, interpreter, R2R).
+// TODO: WIP - currently only supports interpreter breakpoint handling.
+//
+//*****************************************************************************
+
+#ifndef EXECUTIONCONTROL_H_
+#define EXECUTIONCONTROL_H_
+
+struct DebuggerControllerPatch;
+
+#ifdef FEATURE_INTERPRETER
+
+
+class IExecutionControl
+{
+public:
+    virtual ~IExecutionControl() = default;
+
+    virtual bool ApplyPatch(DebuggerControllerPatch* patch) = 0;
+    virtual bool UnapplyPatch(DebuggerControllerPatch* patch) = 0;
+};
+
+typedef DPTR(IExecutionControl) PTR_IExecutionControl;
+
+// Interpreter execution control using bytecode patching
+class InterpreterExecutionControl : public IExecutionControl
+{
+public:
+    static InterpreterExecutionControl* GetInstance();
+
+    // Apply a breakpoint patch
+    virtual bool ApplyPatch(DebuggerControllerPatch* patch) override;
+
+    // Remove a breakpoint patch and restore original instruction
+    virtual bool UnapplyPatch(DebuggerControllerPatch* patch) override;
+
+private:
+    InterpreterExecutionControl() = default;
+    static InterpreterExecutionControl s_instance;
+};
+
+#endif // FEATURE_INTERPRETER
+#endif // EXECUTIONCONTROL_H_

src/coreclr/debug/ee/frameinfo.cpp

@@ -1715,6 +1715,13 @@ StackWalkAction DebuggerWalkStackProc(CrawlFrame *pCF, void *data)
             {
                 use = false;
             }
+#ifdef FEATURE_INTERPRETER
+            // Avoid treating interpreter frame as a managed frame
+            else if (frame->GetFrameIdentifier() == FrameIdentifier::InterpreterFrame)
+            {
+                use = false;
+            }
+#endif // FEATURE_INTERPRETER
             else
             {
                 d->info.managed = true;

src/coreclr/debug/ee/functioninfo.cpp

@@ -1253,9 +1253,28 @@ void DebuggerJitInfo::Init(TADDR newAddress)
     this->m_addrOfCode = (ULONG_PTR)PTR_TO_CORDB_ADDRESS((BYTE*) newAddress);
     this->m_jitComplete = true;
 
-    this->m_codeRegionInfo.InitializeFromStartAddress(PINSTRToPCODE((TADDR)this->m_addrOfCode));
-    this->m_sizeOfCode =  this->m_codeRegionInfo.getSizeOfTotalCode();
+    if (this->m_nativeCodeVersion.GetOptimizationTier() != NativeCodeVersion::OptimizationTierInterpreted)
+    {
+        this->m_codeRegionInfo.InitializeFromStartAddress(PINSTRToPCODE((TADDR)this->m_addrOfCode));
+    }
+    else
+    {
+        // For interpreter code, initialize code region info with IL bytecode info
+        // We only have "hot" code (the bytecode), no cold regions or funclets
+        MethodDesc* pMD = this->m_nativeCodeVersion.GetMethodDesc();
+        COR_ILMETHOD* pILHeader = pMD->GetILHeader();
+        SIZE_T ilCodeSize = 0;
 
+        if (pILHeader != NULL)
+        {
+            COR_ILMETHOD_DECODER decoder(pILHeader);
+            ilCodeSize = decoder.GetCodeSize();
+        }
+
+        this->m_codeRegionInfo.InitializeForInterpreter(PINSTRToPCODE((TADDR)this->m_addrOfCode), ilCodeSize);
+    }
+
+    this->m_sizeOfCode =  this->m_codeRegionInfo.getSizeOfTotalCode();
     this->m_encVersion = this->m_methodInfo->GetCurrentEnCVersion();
 
 #if defined(FEATURE_EH_FUNCLETS)

src/coreclr/inc/dacprivate.h

@@ -615,6 +615,7 @@ struct MSLAYOUT DacpTieredVersionData
         OptimizationTier_OptimizedTier1OSR,
         OptimizationTier_QuickJittedInstrumented,
         OptimizationTier_OptimizedTier1Instrumented,
+        OptimizationTier_Interpreted
     };
 
     CLRDATA_ADDRESS NativeCodeAddr;