Fix sos clrstack unwinding for the special HelperMethodFrame.

Add and implement new ICorDebugDataTarget4 unwind interface using lldb stack unwinder ABIs. The implementation
does a linear search of the native frames for the stack pointer provided. It doesn't happen often so the
performance is fine.

Stub out the DBI's ICorDebugDataTarget4 (in ShimDataTarget::VirtualUnwind) for now. Since PAL_VirtualUnwindOutOfProc
is disabled it makes sense to just return E_NOTIMPL.

Fix bpmd command so it doesn't stop in lldb when it isn't a CLRN exception (continues).

Author: Mike McLaughlin

src/ToolBox/SOS/Strike/datatarget.cpp

@@ -196,8 +196,14 @@ DataTarget::Request(
 }
 
 HRESULT STDMETHODCALLTYPE 
-DataTarget::GetPid(
-    /* [out] */ DWORD *pdwProcessId)
+DataTarget::VirtualUnwind(
+    /* [in] */ DWORD threadId,
+    /* [in] */ ULONG32 contextSize,
+    /* [in, out, size_is(contextSize)] */ PBYTE context)
 {
-    return g_ExtSystem->GetCurrentProcessId(pdwProcessId);
+    if (g_ExtClient == NULL)
+    {
+        return E_UNEXPECTED;
+    }
+    return g_ExtClient->VirtualUnwind(threadId, contextSize, context);
 }

src/ToolBox/SOS/Strike/datatarget.h

@@ -85,6 +85,8 @@ class DataTarget : public ICLRDataTarget, ICorDebugDataTarget4
 
     // ICorDebugDataTarget4
 
-    virtual HRESULT STDMETHODCALLTYPE GetPid(
-        /* [out] */ DWORD *pdwProcessId);
+    virtual HRESULT STDMETHODCALLTYPE VirtualUnwind(
+        /* [in] */ DWORD threadId,
+        /* [in] */ ULONG32 contextSize,
+        /* [in, out, size_is(contextSize)] */ PBYTE context);
 };

src/ToolBox/SOS/Strike/strike.cpp

@@ -6892,8 +6892,13 @@ HRESULT HandleCLRNotificationEvent()
 
     if (!CheckCLRNotificationEvent(&dle))
     {
+#ifndef FEATURE_PAL
         ExtOut("Expecting first chance CLRN exception\n");
         return E_FAIL;
+#else
+        g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, "process continue", 0);
+        return S_OK;
+#endif
     }
 
     // Notification only needs to live for the lifetime of the call below, so it's a non-static

src/ToolBox/SOS/lldbplugin/debugclient.cpp

@@ -7,7 +7,6 @@
 #include <cstdlib>
 #include "sosplugin.h"
 #include <string.h>
-#include <dbgtargetcontext.h>
 #include <string>
 
 ULONG g_currentThreadIndex = -1;
@@ -708,8 +707,8 @@ DebugClient::GetModuleDirectory(
 // Internal function
 ULONG64
 DebugClient::GetModuleBase(
-    lldb::SBTarget target,
-    lldb::SBModule module)
+    /* const */ lldb::SBTarget& target,
+    /* const */ lldb::SBModule& module)
 {
     // Find the first section with an valid base address
     int numSections = module.GetNumSections();
@@ -922,6 +921,19 @@ DebugClient::GetThreadContextById(
     dtcontext = (DT_CONTEXT*)context;
     dtcontext->ContextFlags = contextFlags;
 
+    GetContextFromFrame(frame, dtcontext);
+    hr = S_OK;
+
+exit:
+    return hr;
+}
+
+// Internal function
+void
+DebugClient::GetContextFromFrame(
+    /* const */ lldb::SBFrame& frame,
+    DT_CONTEXT *dtcontext)
+{
 #ifdef DBG_TARGET_AMD64
     dtcontext->Rip = frame.GetPC();
     dtcontext->Rsp = frame.GetSP();
@@ -969,29 +981,19 @@ DebugClient::GetThreadContextById(
     dtcontext->R11 = GetRegister(frame, "r11");
     dtcontext->R12 = GetRegister(frame, "r12");
 #endif
-
-    hr = S_OK;
-
-exit:
-    return hr;
 }
 
 // Internal function
 DWORD_PTR 
-DebugClient::GetRegister(lldb::SBFrame frame, const char *name)
+DebugClient::GetRegister(
+    /* const */ lldb::SBFrame& frame,
+    const char *name)
 {
     lldb::SBValue regValue = frame.FindRegister(name);
 
     lldb::SBError error;
     DWORD_PTR result = regValue.GetValueAsUnsigned(error);
 
-#ifdef _DEBUG
-    if (!regValue.IsValid() || error.Fail())
-    {
-        Output(DEBUG_OUTPUT_ERROR, "Invalid register name '%s'\n", name);
-    }
-#endif
-
     return result;
 }
 
@@ -1115,7 +1117,7 @@ DebugClient::GetExpression(
 // Internal function
 DWORD_PTR 
 DebugClient::GetExpression(
-    lldb::SBFrame frame,
+    /* const */ lldb::SBFrame& frame,
     lldb::SBError& error,
     PCSTR exp)
 {
@@ -1130,6 +1132,70 @@ DebugClient::GetExpression(
     return result;
 }
 
+HRESULT 
+DebugClient::VirtualUnwind(
+    DWORD threadID,
+    ULONG32 contextSize,
+    PBYTE context)
+{
+    lldb::SBProcess process;
+    lldb::SBThread thread;
+
+    if (context == NULL || contextSize < sizeof(DT_CONTEXT))
+    {
+        return E_FAIL;
+    }
+
+    process = GetCurrentProcess();
+    if (!process.IsValid())
+    {
+        return E_FAIL;
+    }
+
+    thread = process.GetThreadByID(threadID);
+    if (!thread.IsValid())
+    {
+        return E_FAIL;
+    }
+
+    DT_CONTEXT *dtcontext = (DT_CONTEXT*)context;
+    lldb::SBFrame frameFound;
+
+#ifdef DBG_TARGET_AMD64
+    DWORD64 spToFind = dtcontext->Rsp;
+#elif DBG_TARGET_ARM
+    DWORD spToFind = dtcontext->Sp;
+#endif
+    
+    int numFrames = thread.GetNumFrames();
+    for (int i = 0; i < numFrames; i++)
+    {
+        lldb::SBFrame frame = thread.GetFrameAtIndex(i);
+        if (!frame.IsValid())
+        {
+            break;
+        }
+
+        lldb::addr_t sp = frame.GetSP();
+
+        if (sp == spToFind && (i + 1) < numFrames)
+        {
+            // Get next frame after finding the match
+            frameFound = thread.GetFrameAtIndex(i + 1);
+            break;
+        }
+    }
+
+    if (!frameFound.IsValid())
+    {
+        return E_FAIL;
+    }
+
+    GetContextFromFrame(frameFound, dtcontext);
+
+    return S_OK;
+}
+
 //----------------------------------------------------------------------------
 // Helper functions
 //----------------------------------------------------------------------------

src/ToolBox/SOS/lldbplugin/debugclient.h

@@ -13,9 +13,10 @@ class DebugClient : public IDebugClient
     lldb::SBProcess GetCurrentProcess();
     lldb::SBThread GetCurrentThread();
     lldb::SBFrame GetCurrentFrame();
-    ULONG64 GetModuleBase(lldb::SBTarget target, lldb::SBModule module);
-    DWORD_PTR GetExpression(lldb::SBFrame frame, lldb::SBError& error, PCSTR exp);
-    DWORD_PTR GetRegister(lldb::SBFrame frame, const char *name);
+    ULONG64 GetModuleBase(lldb::SBTarget& target, lldb::SBModule& module);
+    DWORD_PTR GetExpression(lldb::SBFrame& frame, lldb::SBError& error, PCSTR exp);
+    void GetContextFromFrame(lldb::SBFrame& frame, DT_CONTEXT *dtcontext);
+    DWORD_PTR GetRegister(lldb::SBFrame& frame, const char *name);
 
 public:
     DebugClient(lldb::SBDebugger &debugger, lldb::SBCommandReturnObject &returnObject);
@@ -192,4 +193,9 @@ class DebugClient : public IDebugClient
 
     DWORD_PTR GetExpression(
         PCSTR exp);
+
+    HRESULT VirtualUnwind(
+        DWORD threadID,
+        ULONG32 contextSize,
+        PBYTE context);
 };

src/ToolBox/SOS/lldbplugin/inc/dbgeng.h

@@ -457,6 +457,11 @@ class IDebugClient : IDebugControl2, IDebugDataSpaces, IDebugSymbols, IDebugSyst
     // Evaluates a lldb expression into a value.
     virtual DWORD_PTR GetExpression(
         /* [in] */ PCSTR exp) = 0;
+
+    virtual HRESULT VirtualUnwind(
+        /* [in] */ DWORD threadID,
+        /* [in] */ ULONG32 contextSize,
+        /* [in, out, size_is(contextSize)] */ PBYTE context) = 0;
 };
 
 typedef class IDebugClient* PDEBUG_CLIENT;

src/ToolBox/SOS/lldbplugin/sosplugin.h

@@ -7,6 +7,7 @@
 #include "mstypes.h"
 #define DEFINE_EXCEPTION_RECORD
 #include <dbgeng.h>
+#include <dbgtargetcontext.h>
 #include "debugclient.h"
 
 typedef HRESULT (*CommandFunc)(PDEBUG_CLIENT client, const char *args);

src/debug/daccess/dacfn.cpp

@@ -219,19 +219,25 @@ DacWriteAll(TADDR addr, PVOID buffer, ULONG32 size, bool throwEx)
 }
 
 HRESULT 
-DacGetPid(DWORD *pid)
+DacVirtualUnwind(DWORD threadId, CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *contextPointers)
 {
     if (!g_dacImpl)
     {
         DacError(E_UNEXPECTED);
         UNREACHABLE();
     }
 
+    // The DAC code doesn't use these context pointers but zero them out to be safe.
+    if (contextPointers != NULL)
+    {
+        memset(contextPointers, 0, sizeof(KNONVOLATILE_CONTEXT_POINTERS));
+    }
+
     ReleaseHolder<ICorDebugDataTarget4> dt;
     HRESULT hr = g_dacImpl->m_pTarget->QueryInterface(IID_ICorDebugDataTarget4, (void **)&dt);
     if (SUCCEEDED(hr))
     {
-        hr = dt->GetPid(pid);
+        hr = dt->VirtualUnwind(threadId, sizeof(CONTEXT), (BYTE*)context);
     }
 
     return hr;

src/debug/di/shimdatatarget.cpp

@@ -68,22 +68,30 @@ ULONG STDMETHODCALLTYPE ShimDataTarget::Release()
     return ref;
 }
 
-
 //---------------------------------------------------------------------------------------
 //
 // Get the OS Process ID that this DataTarget is for.
 //
 // Return Value: 
 //     The OS PID of the process this data target is representing.
-HRESULT STDMETHODCALLTYPE ShimDataTarget::GetPid(DWORD *pdwProcessId)
+DWORD ShimDataTarget::GetPid()
 {
-    if (pdwProcessId == NULL)  
-    {
-        return E_INVALIDARG;
-    }
+    return m_processId;
+}
 
-    *pdwProcessId = m_processId;
-    return S_OK;
+//---------------------------------------------------------------------------------------
+//
+// Unwind the stack to the next frame.
+//
+// Return Value: 
+//     context and contextPointers filled in with the next frame
+//
+HRESULT STDMETHODCALLTYPE ShimDataTarget::VirtualUnwind(DWORD threadId, ULONG32 contextSize, PBYTE context)
+{
+#ifndef FEATURE_PAL
+    _ASSERTE(!"ShimDataTarget::VirtualUnwind NOT IMPLEMENTED");
+#endif 
+    return E_NOTIMPL;
 }
 
 //---------------------------------------------------------------------------------------

src/debug/di/shimdatatarget.h

@@ -36,6 +36,9 @@ class ShimDataTarget : public ICorDebugMutableDataTarget, ICorDebugDataTarget4
     // is unavailable because it's running
     void SetError(HRESULT hr);
 
+    // Get the OS Process ID that this DataTarget is for.
+    DWORD GetPid();
+
     //
     // IUnknown.
     //
@@ -86,8 +89,8 @@ class ShimDataTarget : public ICorDebugMutableDataTarget, ICorDebugDataTarget4
     // ICorDebugDataTarget4
     //    
 
-    // Get the OS Process ID that this DataTarget is for.
-    virtual HRESULT STDMETHODCALLTYPE GetPid(DWORD *pdwProcessId); 
+    // Unwind to the next stack frame
+    virtual HRESULT STDMETHODCALLTYPE VirtualUnwind(DWORD threadId, ULONG32 contextSize, PBYTE context);
 
 protected:
     // Pid of the target process.