[lldb] Make UnwindLLDB a non-plugin

[labath]

Summary

This is the only real unwinder, and things have been this way for quite
a long time. At this point, the class has accumulated so many features
it is unlikely that anyone will want to reimplement the whole thing.

The class is also fairly closely coupled (through UnwindPlans and
FuncUnwinders) with a lot of other lldb components that it is hard to
imagine a different unwinder implementation being substantially
different without reimplementing all of those.

The existing unwinding functionality is nonetheless fairly complex and
there is space for adding more structure to it, but I believe a more
worthwhile effort would be to take the existing UnwindLLDB class and try
to break it down and introduce extension/customization points, instead
of writing a brand new Unwind implementation.

[JDevlieghere]

Jason should make the call but looks good to me

[xiaobai]

Thanks for doing this. LGTM, might want to wait for Jason's approval like Jonas said though.

[jasonmolenda]

Thanks for doing this, lgtm.

lldb/include/lldb/Target/RegisterContextUnwind.h

-//===-- RegisterContextLLDB.h --------------------------------------------*- C++
-//-*-===//
+//===-- RegisterContextUnwind.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLLDB_H
-#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLLDB_H
+#ifndef LLDB_TARGET_REGISTERCONTEXTUNWIND_H
+#define LLDB_TARGET_REGISTERCONTEXTUNWIND_H
 
 #include <vector>
 
-#include "UnwindLLDB.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/RegisterNumber.h"
+#include "lldb/Target/UnwindLLDB.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class UnwindLLDB;
 
-class RegisterContextLLDB : public lldb_private::RegisterContext {
+class RegisterContextUnwind : public lldb_private::RegisterContext {
 public:
-  typedef std::shared_ptr<RegisterContextLLDB> SharedPtr;
+  typedef std::shared_ptr<RegisterContextUnwind> SharedPtr;
 
-  RegisterContextLLDB(lldb_private::Thread &thread, const SharedPtr &next_frame,
+  RegisterContextUnwind(lldb_private::Thread &thread,
+                        const SharedPtr &next_frame,
                         lldb_private::SymbolContext &sym_ctx,
                         uint32_t frame_number,
                         lldb_private::UnwindLLDB &unwind_lldb);
 
-  ~RegisterContextLLDB() override = default;
+  ~RegisterContextUnwind() override = default;
 
   void InvalidateAllRegisters() override;
 
   size_t GetRegisterCount() override;
 
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
bool m_sym_ctx_valid; // if ResolveSymbolContextForAddress fails, don't try to
                         // use m_sym_ctx
 
   uint32_t m_frame_number; // What stack frame this RegisterContext is
 
   std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation>
       m_registers; // where to find reg values for this frame
 
   lldb_private::UnwindLLDB &m_parent_unwind; // The UnwindLLDB that is creating
-                                             // this RegisterContextLLDB
+                                             // this RegisterContextUnwind
 
-  // For RegisterContextLLDB only
-
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextLLDB);
+  DISALLOW_COPY_AND_ASSIGN(RegisterContextUnwind);
 };
 
 } // namespace lldb_private
 
-#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLLDB_H
+#endif // LLDB_TARGET_REGISTERCONTEXTUNWIND_H

lldb/include/lldb/Target/UnwindLLDB.h

 //===-- UnwindLLDB.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDLLDB_H
-#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDLLDB_H
+#ifndef LLDB_TARGET_UNWINDLLDB_H
+#define LLDB_TARGET_UNWINDLLDB_H
 
 #include <vector>
 
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
-class RegisterContextLLDB;
+class RegisterContextUnwind;
 
 class UnwindLLDB : public lldb_private::Unwind {
 public:
   UnwindLLDB(lldb_private::Thread &thread);
 
   ~UnwindLLDB() override = default;
 
   enum RegisterSearchResult {
     eRegisterFound = 0,
     eRegisterNotFound,
     eRegisterIsVolatile
   };
 
 protected:
-  friend class lldb_private::RegisterContextLLDB;
+  friend class lldb_private::RegisterContextUnwind;
 
   struct RegisterLocation {
     enum RegisterLocationTypes {
       eRegisterNotSaved = 0, // register was not preserved by callee.  If
                              // volatile reg, is unavailable
       eRegisterSavedAtMemoryLocation, // register is saved at a specific word of
                                       // target mem (target_memory_location)
       eRegisterInRegister, // register is available in a (possible other)
protected:
 
   bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
                              lldb::addr_t &start_pc,
                              bool &behaves_like_zeroth_frame) override;
 
   lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
-  typedef std::shared_ptr<RegisterContextLLDB> RegisterContextLLDBSP;
+  typedef std::shared_ptr<RegisterContextUnwind> RegisterContextLLDBSP;
 
   // Needed to retrieve the "next" frame (e.g. frame 2 needs to retrieve frame
-  // 1's RegisterContextLLDB)
+  // 1's RegisterContextUnwind)
   // The RegisterContext for frame_num must already exist or this returns an
   // empty shared pointer.
   RegisterContextLLDBSP GetRegisterContextForFrameNum(uint32_t frame_num);
 
-  // Iterate over the RegisterContextLLDB's in our m_frames vector, look for the
-  // first one that
-  // has a saved location for this reg.
+  // Iterate over the RegisterContextUnwind's in our m_frames vector, look for
+  // the first one that has a saved location for this reg.
   bool SearchForSavedLocationForRegister(
       uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc,
       uint32_t starting_frame_num, bool pc_register);
 
   /// Provide the list of user-specified trap handler functions
   ///
   /// The Platform is one source of trap handler function names; that
   /// may be augmented via a setting.  The setting needs to be converted

 private:
   struct Cursor {
     lldb::addr_t start_pc; // The start address of the function/symbol for this
                            // frame - current pc if unknown
     lldb::addr_t cfa;      // The canonical frame address for this stack frame
     lldb_private::SymbolContext sctx; // A symbol context we'll contribute to &
                                       // provide to the StackFrame creation
     RegisterContextLLDBSP
-        reg_ctx_lldb_sp; // These are all RegisterContextLLDB's
+        reg_ctx_lldb_sp; // These are all RegisterContextUnwind's
 
     Cursor()
         : start_pc(LLDB_INVALID_ADDRESS), cfa(LLDB_INVALID_ADDRESS), sctx(),
           reg_ctx_lldb_sp() {}
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Cursor);
   };
private:
   bool AddFirstFrame();
 
   // For UnwindLLDB only
   DISALLOW_COPY_AND_ASSIGN(UnwindLLDB);
 };
 
 } // namespace lldb_private
 
-#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDLLDB_H
+#endif // LLDB_TARGET_UNWINDLLDB_H

lldb/source/Plugins/Process/Utility/CMakeLists.txt

add_lldb_library(lldbPluginProcessUtility
   RegisterContextFreeBSD_powerpc.cpp
   RegisterContextFreeBSD_x86_64.cpp
   RegisterContextHistory.cpp
   RegisterContextLinux_i386.cpp
   RegisterContextLinux_x86_64.cpp
   RegisterContextLinux_mips64.cpp
   RegisterContextLinux_mips.cpp
   RegisterContextLinux_s390x.cpp
-  RegisterContextLLDB.cpp
   RegisterContextMach_arm.cpp
   RegisterContextMach_i386.cpp
   RegisterContextMach_x86_64.cpp
   RegisterContextMemory.cpp
   RegisterContextNetBSD_i386.cpp
   RegisterContextNetBSD_x86_64.cpp
   RegisterContextOpenBSD_i386.cpp
   RegisterContextOpenBSD_x86_64.cpp
   RegisterContextPOSIX_arm.cpp
   RegisterContextPOSIX_arm64.cpp
   RegisterContextPOSIX_mips64.cpp
   RegisterContextPOSIX_powerpc.cpp
   RegisterContextPOSIX_ppc64le.cpp
   RegisterContextPOSIX_s390x.cpp
   RegisterContextPOSIX_x86.cpp
   RegisterContextThreadMemory.cpp
   RegisterContextWindows_i386.cpp
   RegisterContextWindows_x86_64.cpp
   RegisterInfoPOSIX_arm.cpp
   RegisterInfoPOSIX_arm64.cpp
   RegisterInfoPOSIX_ppc64le.cpp
   StopInfoMachException.cpp
   ThreadMemory.cpp
-  UnwindLLDB.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbExpression
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
   LINK_COMPONENTS
     Support
   )

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   OperatingSystem.cpp
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
   Queue.cpp
   QueueItem.cpp
   QueueList.cpp
   RegisterContext.cpp
+  RegisterContextUnwind.cpp
   RegisterNumber.cpp
   RemoteAwarePlatform.cpp
   SectionLoadHistory.cpp
   SectionLoadList.cpp
   StackFrame.cpp
   StackFrameList.cpp
   StackFrameRecognizer.cpp
   StackID.cpp
add_lldb_library(lldbTarget
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadSpec.cpp
   UnixSignals.cpp
   UnwindAssembly.cpp
+  UnwindLLDB.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol

lldb/source/Target/RegisterContextUnwind.cpp

-//===-- RegisterContextLLDB.cpp -------------------------------------------===//
+//===-- RegisterContextUnwind.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/Target/RegisterContextUnwind.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
-#include "RegisterContextLLDB.h"
-
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
   if (sym_ctx.symbol)
     return sym_ctx.symbol->GetName();
   else if (sym_ctx.function)
     return sym_ctx.function->GetName();
   return ConstString();
 }
 
-RegisterContextLLDB::RegisterContextLLDB(Thread &thread,
+RegisterContextUnwind::RegisterContextUnwind(Thread &thread,
                                              const SharedPtr &next_frame,
                                              SymbolContext &sym_ctx,
                                              uint32_t frame_number,
                                              UnwindLLDB &unwind_lldb)
     : RegisterContext(thread, frame_number), m_thread(thread),
       m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(),
       m_fallback_unwind_plan_sp(), m_all_registers_available(false),
       m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS),
       m_afa(LLDB_INVALID_ADDRESS), m_start_pc(),
       m_current_pc(), m_current_offset(0), m_current_offset_backed_up_one(0),
       m_sym_ctx(sym_ctx), m_sym_ctx_valid(false), m_frame_number(frame_number),
       m_registers(), m_parent_unwind(unwind_lldb) {
RegisterContextUnwind::RegisterContextUnwind(Thread &thread,
   // This same code exists over in the GetFullUnwindPlanForFrame() but it may
   // not have been executed yet
   if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
       next_frame->m_frame_type == eDebuggerFrame) {
     m_all_registers_available = true;
   }
 }
 
-bool RegisterContextLLDB::IsUnwindPlanValidForCurrentPC(
+bool RegisterContextUnwind::IsUnwindPlanValidForCurrentPC(
     lldb::UnwindPlanSP unwind_plan_sp, int &valid_pc_offset) {
   if (!unwind_plan_sp)
     return false;
 
   // check if m_current_pc is valid
   if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
     // yes - current offset can be used as is
     valid_pc_offset = m_current_offset;
if (unwind_plan_sp->PlanValidAtAddress(pc_minus_one)) {
     // *valid_pc_offset = m_current_offset - 1;
     valid_pc_offset = m_current_pc.GetOffset() - 1;
     return true;
   }
 
   return false;
 }
 
-// Initialize a RegisterContextLLDB which is the first frame of a stack -- the
+// Initialize a RegisterContextUnwind which is the first frame of a stack -- the
 // zeroth frame or currently executing frame.
 
-void RegisterContextLLDB::InitializeZerothFrame() {
+void RegisterContextUnwind::InitializeZerothFrame() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
   ExecutionContext exe_ctx(m_thread.shared_from_this());
   RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext();
 
   if (reg_ctx_sp.get() == nullptr) {
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("frame does not have a register context");
     return;
void RegisterContextUnwind::InitializeZerothFrame() {
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
                " afa is 0x%" PRIx64 " using %s UnwindPlan",
                (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
                (uint64_t)m_cfa,
                (uint64_t)m_afa,
                m_full_unwind_plan_sp->GetSourceName().GetCString());
 }
 
-// Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on the
-// RegisterContextLLDB "below" it to provide things like its current pc value.
+// Initialize a RegisterContextUnwind for the non-zeroth frame -- rely on the
+// RegisterContextUnwind "below" it to provide things like its current pc value.
 
-void RegisterContextLLDB::InitializeNonZerothFrame() {
+void RegisterContextUnwind::InitializeNonZerothFrame() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
   if (IsFrameZero()) {
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("non-zeroth frame tests positive for IsFrameZero -- that "
                  "shouldn't happen.");
     return;
   }
 
void RegisterContextUnwind::InitializeNonZerothFrame() {
 
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64
                " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
                (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
                (uint64_t)m_cfa,
                (uint64_t)m_afa);
 }
 
-bool RegisterContextLLDB::CheckIfLoopingStack() {
+bool RegisterContextUnwind::CheckIfLoopingStack() {
   // If we have a bad stack setup, we can get the same CFA value multiple times
   // -- or even more devious, we can actually oscillate between two CFA values.
   // Detect that here and break out to avoid a possible infinite loop in lldb
   // trying to unwind the stack. To detect when we have the same CFA value
   // multiple times, we compare the
   // CFA of the current
   // frame with the 2nd next frame because in some specail case (e.g. signal
   // hanlders, hand written assembly without ABI compiance) we can have 2
   // frames with the same
   // CFA (in theory we
   // can have arbitrary number of frames with the same CFA, but more then 2 is
   // very very unlikely)
 
-  RegisterContextLLDB::SharedPtr next_frame = GetNextFrame();
+  RegisterContextUnwind::SharedPtr next_frame = GetNextFrame();
   if (next_frame) {
-    RegisterContextLLDB::SharedPtr next_next_frame = next_frame->GetNextFrame();
+    RegisterContextUnwind::SharedPtr next_next_frame =
+        next_frame->GetNextFrame();
     addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
     if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa)) {
       if (next_next_frame_cfa == m_cfa) {
         // We have a loop in the stack unwind
         return true;
       }
     }
   }
   return false;
 }
 
-bool RegisterContextLLDB::IsFrameZero() const { return m_frame_number == 0; }
+bool RegisterContextUnwind::IsFrameZero() const { return m_frame_number == 0; }
 
 // Find a fast unwind plan for this frame, if possible.
 //
 // On entry to this method,
 //
 //   1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
 //   if either of those are correct,
 //   2. m_sym_ctx should already be filled in, and
 //   3. m_current_pc should have the current pc value for this frame
 //   4. m_current_offset_backed_up_one should have the current byte offset into
 //   the function, maybe backed up by 1, -1 if unknown
 
-UnwindPlanSP RegisterContextLLDB::GetFastUnwindPlanForFrame() {
+UnwindPlanSP RegisterContextUnwind::GetFastUnwindPlanForFrame() {
   UnwindPlanSP unwind_plan_sp;
   ModuleSP pc_module_sp(m_current_pc.GetModule());
 
   if (!m_current_pc.IsValid() || !pc_module_sp ||
       pc_module_sp->GetObjectFile() == nullptr)
     return unwind_plan_sp;
 
   if (IsFrameZero())

 //
 //   1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
 //   if either of those are correct,
 //   2. m_sym_ctx should already be filled in, and
 //   3. m_current_pc should have the current pc value for this frame
 //   4. m_current_offset_backed_up_one should have the current byte offset into
 //   the function, maybe backed up by 1, -1 if unknown
 
-UnwindPlanSP RegisterContextLLDB::GetFullUnwindPlanForFrame() {
+UnwindPlanSP RegisterContextUnwind::GetFullUnwindPlanForFrame() {
   UnwindPlanSP unwind_plan_sp;
   UnwindPlanSP arch_default_unwind_plan_sp;
   ExecutionContext exe_ctx(m_thread.shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   ABI *abi = process ? process->GetABI().get() : nullptr;
   if (abi) {
     arch_default_unwind_plan_sp =
         std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
UnwindLogMsgVerbose(
         arch_default_unwind_plan_sp->GetSourceName().GetCString());
   else
     UnwindLogMsg(
         "Unable to find any UnwindPlan for full unwind of this frame.");
 
   return arch_default_unwind_plan_sp;
 }
 
-void RegisterContextLLDB::InvalidateAllRegisters() {
+void RegisterContextUnwind::InvalidateAllRegisters() {
   m_frame_type = eNotAValidFrame;
 }
 
-size_t RegisterContextLLDB::GetRegisterCount() {
+size_t RegisterContextUnwind::GetRegisterCount() {
   return m_thread.GetRegisterContext()->GetRegisterCount();
 }
 
-const RegisterInfo *RegisterContextLLDB::GetRegisterInfoAtIndex(size_t reg) {
+const RegisterInfo *RegisterContextUnwind::GetRegisterInfoAtIndex(size_t reg) {
   return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
 }
 
-size_t RegisterContextLLDB::GetRegisterSetCount() {
+size_t RegisterContextUnwind::GetRegisterSetCount() {
   return m_thread.GetRegisterContext()->GetRegisterSetCount();
 }
 
-const RegisterSet *RegisterContextLLDB::GetRegisterSet(size_t reg_set) {
+const RegisterSet *RegisterContextUnwind::GetRegisterSet(size_t reg_set) {
   return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
 }
 
-uint32_t RegisterContextLLDB::ConvertRegisterKindToRegisterNumber(
+uint32_t RegisterContextUnwind::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
       kind, num);
 }
 
-bool RegisterContextLLDB::ReadRegisterValueFromRegisterLocation(
+bool RegisterContextUnwind::ReadRegisterValueFromRegisterLocation(
     lldb_private::UnwindLLDB::RegisterLocation regloc,
     const RegisterInfo *reg_info, RegisterValue &value) {
   if (!IsValid())
     return false;
   bool success = false;
 
   switch (regloc.type) {
   case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
     success = error.Success();
   } break;
   default:
     llvm_unreachable("Unknown RegisterLocation type.");
   }
   return success;
 }
 
-bool RegisterContextLLDB::WriteRegisterValueToRegisterLocation(
+bool RegisterContextUnwind::WriteRegisterValueToRegisterLocation(
     lldb_private::UnwindLLDB::RegisterLocation regloc,
     const RegisterInfo *reg_info, const RegisterValue &value) {
   if (!IsValid())
     return false;
 
   bool success = false;
 
   switch (regloc.type) {
case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
     success = error.Success();
   } break;
   default:
     llvm_unreachable("Unknown RegisterLocation type.");
   }
   return success;
 }
 
-bool RegisterContextLLDB::IsValid() const {
+bool RegisterContextUnwind::IsValid() const {
   return m_frame_type != eNotAValidFrame;
 }
 
 // After the final stack frame in a stack walk we'll get one invalid
 // (eNotAValidFrame) stack frame -- one past the end of the stack walk.  But
 // higher-level code will need to tell the differnece between "the unwind plan
 // below this frame failed" versus "we successfully completed the stack walk"
 // so this method helps to disambiguate that.
 
-bool RegisterContextLLDB::IsTrapHandlerFrame() const {
+bool RegisterContextUnwind::IsTrapHandlerFrame() const {
   return m_frame_type == eTrapHandlerFrame;
 }
 
 // A skip frame is a bogus frame on the stack -- but one where we're likely to
 // find a real frame farther
 // up the stack if we keep looking.  It's always the second frame in an unwind
 // (i.e. the first frame after frame zero) where unwinding can be the
 // trickiest.  Ideally we'll mark up this frame in some way so the user knows
 // we're displaying bad data and we may have skipped one frame of their real
 // program in the process of getting back on track.
 
-bool RegisterContextLLDB::IsSkipFrame() const {
+bool RegisterContextUnwind::IsSkipFrame() const {
   return m_frame_type == eSkipFrame;
 }
 
-bool RegisterContextLLDB::IsTrapHandlerSymbol(
+bool RegisterContextUnwind::IsTrapHandlerSymbol(
     lldb_private::Process *process,
     const lldb_private::SymbolContext &m_sym_ctx) const {
   PlatformSP platform_sp(process->GetTarget().GetPlatform());
   if (platform_sp) {
     const std::vector<ConstString> trap_handler_names(
         platform_sp->GetTrapHandlerSymbolNames());
     for (ConstString name : trap_handler_names) {
       if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
bool RegisterContextUnwind::IsTrapHandlerSymbol(
 
   return false;
 }
 
 // Answer the question: Where did THIS frame save the CALLER frame ("previous"
 // frame)'s register value?
 
 enum UnwindLLDB::RegisterSearchResult
-RegisterContextLLDB::SavedLocationForRegister(
+RegisterContextUnwind::SavedLocationForRegister(
     uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
   RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
 
   // Have we already found this register location?
   if (!m_registers.empty()) {
     std::map<uint32_t,
              lldb_private::UnwindLLDB::RegisterLocation>::const_iterator
         iterator;

 // inspection is not correct -- mostly with hand-written assembly functions or
 // functions where the stack frame is set up "out of band", e.g. the kernel
 // saved the register context and then called an asynchronous trap handler like
 // _sigtramp.
 //
 // Often in these cases, if we just do a dumb stack walk we'll get past this
 // tricky frame and our usual techniques can continue to be used.
 
-bool RegisterContextLLDB::TryFallbackUnwindPlan() {
+bool RegisterContextUnwind::TryFallbackUnwindPlan() {
   if (m_fallback_unwind_plan_sp.get() == nullptr)
     return false;
 
   if (m_full_unwind_plan_sp.get() == nullptr)
     return false;
 
   if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
       m_full_unwind_plan_sp->GetSourceName() ==
if (active_row &&
     // fallback.
     m_fallback_unwind_plan_sp.reset();
     PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
   }
 
   return true;
 }
 
-bool RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan() {
+bool RegisterContextUnwind::ForceSwitchToFallbackUnwindPlan() {
   if (m_fallback_unwind_plan_sp.get() == nullptr)
     return false;
 
   if (m_full_unwind_plan_sp.get() == nullptr)
     return false;
 
   if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
       m_full_unwind_plan_sp->GetSourceName() ==
if (active_row &&
 
     UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
                  m_full_unwind_plan_sp->GetSourceName().GetCString());
     return true;
   }
   return false;
 }
 
-void RegisterContextLLDB::PropagateTrapHandlerFlagFromUnwindPlan(
+void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan(
     lldb::UnwindPlanSP unwind_plan) {
   if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
     // Unwind plan does not indicate trap handler.  Do nothing.  We may
     // already be flagged as trap handler flag due to the symbol being
     // in the trap handler symbol list, and that should take precedence.
     return;
   } else if (m_frame_type != eNormalFrame) {
     // If this is already a trap handler frame, nothing to do.
if (m_current_offset_backed_up_one != m_current_offset) {
     Target *target = &process->GetTarget();
 
     m_start_pc = addr_range.GetBaseAddress();
     m_current_offset =
         m_current_pc.GetLoadAddress(target) - m_start_pc.GetLoadAddress(target);
   }
 }
 
-bool RegisterContextLLDB::ReadFrameAddress(
+bool RegisterContextUnwind::ReadFrameAddress(
     lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
     addr_t &address) {
   RegisterValue reg_value;
 
   address = LLDB_INVALID_ADDRESS;
   addr_t cfa_reg_contents;
 
   switch (fa.GetValueType()) {
case UnwindPlan::Row::FAValue::isRaSearch: {
     break;
   }
   default:
     return false;
   }
   return false;
 }
 
-lldb::addr_t RegisterContextLLDB::GetReturnAddressHint(int32_t plan_offset) {
+lldb::addr_t RegisterContextUnwind::GetReturnAddressHint(int32_t plan_offset) {
   addr_t hint;
   if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, hint))
     return LLDB_INVALID_ADDRESS;
   if (!m_sym_ctx.module_sp || !m_sym_ctx.symbol)
     return LLDB_INVALID_ADDRESS;
 
   hint += plan_offset;
 

 //  stopped in foo() so
 //     frame 0 - foo
 //     frame 1 - bar
 //     frame 2 - main
 //  and this RegisterContext is for frame 1 (bar) - if we want to get the pc
 //  value for frame 1, we need to ask
 //  where frame 0 (the "next" frame) saved that and retrieve the value.
 
-bool RegisterContextLLDB::ReadGPRValue(lldb::RegisterKind register_kind,
+bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
                                          uint32_t regnum, addr_t &value) {
   if (!IsValid())
     return false;
 
   uint32_t lldb_regnum;
   if (register_kind == eRegisterKindLLDB) {
     lldb_regnum = regnum;
   } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
                  register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
   }
   if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
     value = reg_value.GetAsUInt64();
     return true;
   }
   return false;
 }
 
-bool RegisterContextLLDB::ReadGPRValue(const RegisterNumber &regnum,
+bool RegisterContextUnwind::ReadGPRValue(const RegisterNumber &regnum,
                                          addr_t &value) {
   return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
                       value);
 }
 
 // Find the value of a register in THIS frame
 
-bool RegisterContextLLDB::ReadRegister(const RegisterInfo *reg_info,
+bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info,
                                          RegisterValue &value) {
   if (!IsValid())
     return false;
 
   const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
   UnwindLogMsgVerbose("looking for register saved location for reg %d",
                       lldb_regnum);
 
   // If this is the 0th frame, hand this over to the live register context
bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info,
   // Find out where the NEXT frame saved THIS frame's register contents
   if (!m_parent_unwind.SearchForSavedLocationForRegister(
           lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum))
     return false;
 
   return ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
 }
 
-bool RegisterContextLLDB::WriteRegister(const RegisterInfo *reg_info,
+bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info,
                                           const RegisterValue &value) {
   if (!IsValid())
     return false;
 
   const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
   UnwindLogMsgVerbose("looking for register saved location for reg %d",
                       lldb_regnum);
 
   // If this is the 0th frame, hand this over to the live register context
   if (IsFrameZero()) {
     UnwindLogMsgVerbose("passing along to the live register context for reg %d",
                         lldb_regnum);
     return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
   }
 
   lldb_private::UnwindLLDB::RegisterLocation regloc;
   // Find out where the NEXT frame saved THIS frame's register contents
   if (!m_parent_unwind.SearchForSavedLocationForRegister(
           lldb_regnum, regloc, m_frame_number - 1, false))
     return false;
 
   return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
 }
 
 // Don't need to implement this one
-bool RegisterContextLLDB::ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
+bool RegisterContextUnwind::ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 // Don't need to implement this one
-bool RegisterContextLLDB::WriteAllRegisterValues(
+bool RegisterContextUnwind::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 // Retrieve the pc value for THIS from
 
-bool RegisterContextLLDB::GetCFA(addr_t &cfa) {
+bool RegisterContextUnwind::GetCFA(addr_t &cfa) {
   if (!IsValid()) {
     return false;
   }
   if (m_cfa == LLDB_INVALID_ADDRESS) {
     return false;
   }
   cfa = m_cfa;
   return true;
 }
 
-RegisterContextLLDB::SharedPtr RegisterContextLLDB::GetNextFrame() const {
-  RegisterContextLLDB::SharedPtr regctx;
+RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetNextFrame() const {
+  RegisterContextUnwind::SharedPtr regctx;
   if (m_frame_number == 0)
     return regctx;
   return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number - 1);
 }
 
-RegisterContextLLDB::SharedPtr RegisterContextLLDB::GetPrevFrame() const {
-  RegisterContextLLDB::SharedPtr regctx;
+RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetPrevFrame() const {
+  RegisterContextUnwind::SharedPtr regctx;
   return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number + 1);
 }
 
 // Retrieve the address of the start of the function of THIS frame
 
-bool RegisterContextLLDB::GetStartPC(addr_t &start_pc) {
+bool RegisterContextUnwind::GetStartPC(addr_t &start_pc) {
   if (!IsValid())
     return false;
 
   if (!m_start_pc.IsValid()) {
         bool read_successfully = ReadPC (start_pc);
         if (read_successfully)
         {
             ProcessSP process_sp (m_thread.GetProcess());
             if (process_sp)
             {
                 ABI *abi = process_sp->GetABI().get();
                 if (abi)
                     start_pc = abi->FixCodeAddress(start_pc);
             }
         }
         return read_successfully;
   }
   start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get());
   return true;
 }
 
 // Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
 
-bool RegisterContextLLDB::ReadPC(addr_t &pc) {
+bool RegisterContextUnwind::ReadPC(addr_t &pc) {
   if (!IsValid())
     return false;
 
   bool above_trap_handler = false;
   if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
       GetNextFrame()->IsTrapHandlerFrame())
     above_trap_handler = true;
 
if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) {
 
     return !(m_all_registers_available == false &&
              above_trap_handler == false && (pc == 0 || pc == 1));
   } else {
     return false;
   }
 }
 
-void RegisterContextLLDB::UnwindLogMsg(const char *fmt, ...) {
+void RegisterContextUnwind::UnwindLogMsg(const char *fmt, ...) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
   if (log) {
     va_list args;
     va_start(args, fmt);
 
     char *logmsg;
     if (vasprintf(&logmsg, fmt, args) == -1 || logmsg == nullptr) {
       if (logmsg)
         free(logmsg);
       va_end(args);
       return;
     }
     va_end(args);
 
     LLDB_LOGF(log, "%*sth%d/fr%u %s",
               m_frame_number < 100 ? m_frame_number : 100, "",
               m_thread.GetIndexID(), m_frame_number, logmsg);
     free(logmsg);
   }
 }
 
-void RegisterContextLLDB::UnwindLogMsgVerbose(const char *fmt, ...) {
+void RegisterContextUnwind::UnwindLogMsgVerbose(const char *fmt, ...) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
   if (log && log->GetVerbose()) {
     va_list args;
     va_start(args, fmt);
 
     char *logmsg;
     if (vasprintf(&logmsg, fmt, args) == -1 || logmsg == nullptr) {
       if (logmsg)

lldb/source/Target/Thread.cpp

 //===-- Thread.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Thread.h"
-#include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"

 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
 #include "lldb/Target/ThreadPlanStepOverRange.h"
 #include "lldb/Target/ThreadPlanStepThrough.h"
 #include "lldb/Target/ThreadPlanStepUntil.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Target/Unwind.h"
+#include "lldb/Target/UnwindLLDB.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 
 #include <memory>

lldb/source/Target/UnwindLLDB.cpp

 //===-- UnwindLLDB.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/Target/UnwindLLDB.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/RegisterContextUnwind.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 
-#include "RegisterContextLLDB.h"
-#include "UnwindLLDB.h"
-
 using namespace lldb;
 using namespace lldb_private;
 
 UnwindLLDB::UnwindLLDB(Thread &thread)
     : Unwind(thread), m_frames(), m_unwind_complete(false),
       m_user_supplied_trap_handler_functions() {
   ProcessSP process_sp(thread.GetProcess());
   if (process_sp) {
bool UnwindLLDB::AddFirstFrame() {
   if (m_frames.size() > 0)
     return true;
 
   ProcessSP process_sp(m_thread.GetProcess());
   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
 
   // First, set up the 0th (initial) frame
   CursorSP first_cursor_sp(new Cursor());
-  RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
+  RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
       m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
   if (reg_ctx_sp.get() == nullptr)
     goto unwind_done;
 
   if (!reg_ctx_sp->IsValid())
     goto unwind_done;
 
   if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
if (m_unwind_complete)
     return nullptr;
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   CursorSP prev_frame = m_frames.back();
   uint32_t cur_idx = m_frames.size();
 
   CursorSP cursor_sp(new Cursor());
-  RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
+  RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
       m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
 
   uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth();
 
   // We want to detect an unwind that cycles erroneously and stop backtracing.
   // Don't want this maximum unwind limit to be too low -- if you have a
   // backtrace with an "infinitely recursing" bug, it will crash when the stack
   // blows out and the first 35,000 frames are uninteresting - it's the top
   // most 5 frames that you actually care about.  So you can't just cap the
   // unwind at 10,000 or something. Realistically anything over around 200,000
   // is going to blow out the stack space. If we're still unwinding at that
   // point, we're probably never going to finish.
   if (cur_idx >= max_stack_depth) {
     LLDB_LOGF(log,
               "%*sFrame %d unwound too many frames, assuming unwind has "
               "gone astray, stopping.",
               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
     return nullptr;
   }
 
   if (reg_ctx_sp.get() == nullptr) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
+    // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
     // return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
       // still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
if (!reg_ctx_sp->IsValid()) {
 
     LLDB_LOGF(log,
               "%*sFrame %d invalid RegisterContext for this frame, "
               "stopping stack walk",
               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
     return nullptr;
   }
   if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
+    // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
     // return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
       // still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
if (!reg_ctx_sp->IsTrapHandlerFrame()) {
                   "%*sFrame %d had a bad CFA value but we switched the "
                   "UnwindPlan being used and got one that looks more "
                   "realistic.",
                   cur_idx < 100 ? cur_idx : 100, "", cur_idx);
       }
     }
   }
   if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
+    // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
     // return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
       // still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;
 
       return GetOneMoreFrame(abi);
     }
 
     LLDB_LOGF(log,
               "%*sFrame %d did not get PC for this frame, stopping stack walk",
               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
     return nullptr;
   }
   if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
-    // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
+    // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
     // return false.
     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
       // TryFallbackUnwindPlan for prev_frame succeeded and updated
       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
       // still needs to be updated. Hence updating it.
       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
         return nullptr;