Use an unwinder to get register contexts of frames other than zeroth under Windows

[aleksandr.urakov]

Summary

The current version of TargetThreadWindows::CreateRegisterContextForFrame function always returns the register context of the zeroth frame. This patch uses an unwinder to get register contexts of frames other than zeroth.

[aleksandr.urakov]

This can be tested after applying D49018 patch.

[aleksandr.urakov]

Excuse me, I have forgot to add lldb-commits as a subscriber, so I'll repeat initial message.

The current version of TargetThreadWindows::CreateRegisterContextForFrame function always returns the register context of the zeroth frame. This patch uses an unwinder to get register contexts of frames other than zeroth.

[stella.stamenova]

I'm actually in the middle of cleaning up the change attached to this bug: https://bugs.llvm.org/show_bug.cgi?id=37495 which is equivalent functionally but follows the pattern for the other targets. Let me run some tests and I'll submit it for review. It should fix your issue.

[amccarth]

source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp

52

This bit seems redundant given that CreateRegisterContextForFrameIndex now checks the special case of 0. It's not a big deal, but I could see someone getting confused while debugging things wondering by CreateRegisterContextForFrameIndex is sometimes called for frame 0 and sometimes not.

[aleksandr.urakov]

Thank you!

Yes, D49111 is more like other targets, so I think it will be a better choice. So I will abandon the current revision.

source/Plugins/Process/Windows/Common/TargetThreadWindows.h

public:
   bool CalculateStopInfo() override;
   Unwind *GetUnwinder() override;
 
   Status DoResume();
 
   HostThread GetHostThread() const { return m_host_thread; }
 
 private:
-  lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);
+  lldb::RegisterContextSP CreateRegisterContextForZerothFrame();
 
   HostThread m_host_thread;
 };
-}
+} // namespace lldb_private
 
 #endif

source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThreadBase.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 
+#include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "ProcessWindows.h"
 #include "ProcessWindowsLog.h"
 #include "TargetThreadWindows.h"
-#include "Plugins/Process/Utility/UnwindLLDB.h"
 
 #if defined(_WIN64)
 #include "x64/RegisterContextWindows_x64.h"
 #else
 #include "x86/RegisterContextWindows_x86.h"
 #endif
 
 using namespace lldb;

 }
 
 void TargetThreadWindows::WillResume(lldb::StateType resume_state) {}
 
 void TargetThreadWindows::DidStop() {}
 
 RegisterContextSP TargetThreadWindows::GetRegisterContext() {
   if (!m_reg_context_sp)
-    m_reg_context_sp = CreateRegisterContextForFrameIndex(0);
+    m_reg_context_sp = CreateRegisterContextForZerothFrame();
 
   return m_reg_context_sp;
 }
 
 RegisterContextSP
 TargetThreadWindows::CreateRegisterContextForFrame(StackFrame *frame) {
-  return CreateRegisterContextForFrameIndex(frame->GetConcreteFrameIndex());
+  uint32_t concrete_frame_idx = 0;
+  if (frame)
+    concrete_frame_idx = frame->GetConcreteFrameIndex();
+  if (concrete_frame_idx == 0)
+    return CreateRegisterContextForZerothFrame();
+
+  Unwind *unwinder = GetUnwinder();
+  if (unwinder)
+    return unwinder->CreateRegisterContextForFrame(frame);
+
+  return RegisterContextSP();
 }
 
-RegisterContextSP
-TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx) {
+RegisterContextSP TargetThreadWindows::CreateRegisterContextForZerothFrame() {
   if (!m_reg_context_sp) {
     ArchSpec arch = HostInfo::GetArchitecture();
     switch (arch.GetMachine()) {
     case llvm::Triple::x86:
 #if defined(_WIN64)
 // FIXME: This is a Wow64 process, create a RegisterContextWindows_Wow64
 #else
-      m_reg_context_sp.reset(new RegisterContextWindows_x86(*this, idx));
+      m_reg_context_sp.reset(new RegisterContextWindows_x86(*this, 0));
 #endif
       break;
     case llvm::Triple::x86_64:
 #if defined(_WIN64)
-      m_reg_context_sp.reset(new RegisterContextWindows_x64(*this, idx));
+      m_reg_context_sp.reset(new RegisterContextWindows_x64(*this, 0));
 #else
 // LLDB is 32-bit, but the target process is 64-bit.  We probably can't debug
 // this.
 #endif
     default:
       break;
     }
   }
if (resume_state == eStateStepping) {
     flags_value |= 0x100; // Set the trap flag on the CPU
     GetRegisterContext()->WriteRegisterFromUnsigned(flags_index, flags_value);
   }
 
   if (resume_state == eStateStepping || resume_state == eStateRunning) {
     DWORD previous_suspend_count = 0;
     HANDLE thread_handle = m_host_thread.GetNativeThread().GetSystemHandle();
     do {
-      // ResumeThread returns -1 on error, or the thread's *previous* suspend count on success.
-      // This means that the return value is 1 when the thread was restarted.
-      // Note that DWORD is an unsigned int, so we need to explicitly compare with -1.
+      // ResumeThread returns -1 on error, or the thread's *previous* suspend
+      // count on success. This means that the return value is 1 when the thread
+      // was restarted. Note that DWORD is an unsigned int, so we need to
+      // explicitly compare with -1.
       previous_suspend_count = ::ResumeThread(thread_handle);
 
       if (previous_suspend_count == (DWORD)-1)
         return Status(::GetLastError(), eErrorTypeWin32);
 
     } while (previous_suspend_count > 1);
   }
 
   return Status();
 }