WIP: Use SB APIs in CommandObjects

[shivammittal99]

Summary

Signed-off-by: Shivam Mittal <[e-mail]>

[shivammittal99]

• Extend SBTarget to enable/disable/ignore watchpoints

[JDevlieghere]

Given that the SB API is stable I wonder if we should be proactive and have these new functions return SBError instead of a bool so that they can be extended if we ever to decide to return a useful error.

[shivammittal99]

@JDevlieghere Sounds good! I'll make the changes and use that for any future additions.

[teemperor]

lldb/include/lldb/API/SBBreakpoint.h

142

I assume this is WIP code and we already told you that, but we can't expose the internal lldb_private::* classes (or their lldb::*SP typedef). So this needs to be replaced with SB API patches.

lldb/include/lldb/API/SBTarget.h

69

This should rather be a IsAlive function in SBProcess.

lldb/bindings/interface/SBTarget.i

BreakpointsWriteToFile(SBFileSpec &dest_file,
                            bool append = false);
 
     uint32_t
     GetNumWatchpoints () const;
 
     lldb::SBWatchpoint
     GetWatchpointAtIndex (uint32_t idx) const;
 
-    bool
-    DeleteWatchpoint (lldb::watch_id_t watch_id);
-
     lldb::SBWatchpoint
     FindWatchpointByID (lldb::watch_id_t watch_id);
 
     bool
     EnableAllWatchpoints ();
 
     bool
+    EnableWatchpoint (lldb::watch_id_t watch_id);
+
+    bool
     DisableAllWatchpoints ();
 
     bool
+    DisableWatchpoint (lldb::watch_id_t watch_id);
+
+    bool
     DeleteAllWatchpoints ();
 
+    bool
+    DeleteWatchpoint (lldb::watch_id_t watch_id);
+
+    bool
+    IgnoreAllWatchpoints (uint32_t ignore_count);
+
+    bool
+    IgnoreWatchpoint (lldb::watch_id_t watch_id, uint32_t ignore_count);
+
     lldb::SBWatchpoint
     WatchAddress (lldb::addr_t addr,
                   size_t size,
                   bool read,
                   bool write,
                   SBError &error);
 
 

lldb/include/lldb/API/SBBreakpoint.h

 //===-- SBBreakpoint.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_API_SBBREAKPOINT_H
 #define LLDB_API_SBBREAKPOINT_H
 
 #include "lldb/API/SBDefines.h"
 
 class SBBreakpointListImpl;
 
 namespace lldb {
 
 class LLDB_API SBBreakpoint {
 public:
 
public:
   static uint32_t
   GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp);
 
   bool IsHardware() const;
 
   // Can only be called from a ScriptedBreakpointResolver...
   SBError
   AddLocation(SBAddress &address);
-  
+  lldb::BreakpointSP GetSP() const;
+
 private:
   friend class SBBreakpointList;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTarget;
 
-  lldb::BreakpointSP GetSP() const;
-
   lldb::BreakpointWP m_opaque_wp;
 };
 
 class LLDB_API SBBreakpointList {
 public:
   SBBreakpointList(SBTarget &target);
 
   ~SBBreakpointList();

lldb/include/lldb/API/SBBreakpointLocation.h

 //===-- SBBreakpointLocation.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_API_SBBREAKPOINTLOCATION_H
 #define LLDB_API_SBBREAKPOINTLOCATION_H
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBBreakpointLocation {
 public:
   SBBreakpointLocation();
 
public:
   bool IsResolved();
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   SBBreakpoint GetBreakpoint();
 
   SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
 
+  BreakpointLocationSP GetSP() const;
+
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointCallbackBaton;
 
   void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
-  BreakpointLocationSP GetSP() const;
 
   lldb::BreakpointLocationWP m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBREAKPOINTLOCATION_H

lldb/include/lldb/API/SBTarget.h

 //===-- SBTarget.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_API_SBTARGET_H
 #define LLDB_API_SBTARGET_H
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBSymbolContextList.h"
public:
 
   static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
                                                   const lldb::SBEvent &event);
 
   static const char *GetBroadcasterClassName();
 
   lldb::SBProcess GetProcess();
 
+  bool IsProcessValid() const;
+
   /// Sets whether we should collect statistics on lldb or not.
   ///
   /// \param[in] v
   ///     A boolean to control the collection.
   void SetCollectingStats(bool v);
 
   /// Returns whether statistics collection are enabled.
   ///
public:
   bool DisableAllBreakpoints();
 
   bool DeleteAllBreakpoints();
 
   uint32_t GetNumWatchpoints() const;
 
   lldb::SBWatchpoint GetWatchpointAtIndex(uint32_t idx) const;
 
-  bool DeleteWatchpoint(lldb::watch_id_t watch_id);
+  lldb::SBWatchpoint GetLastCreatedWatchpoint() const;
 
   lldb::SBWatchpoint FindWatchpointByID(lldb::watch_id_t watch_id);
 
   lldb::SBWatchpoint WatchAddress(lldb::addr_t addr, size_t size, bool read,
                                   bool write, SBError &error);
 
   bool EnableAllWatchpoints();
+  bool EnableWatchpoint(lldb::watch_id_t watch_id);
 
   bool DisableAllWatchpoints();
+  bool DisableWatchpoint(lldb::watch_id_t watch_id);
 
   bool DeleteAllWatchpoints();
+  bool DeleteWatchpoint(lldb::watch_id_t watch_id);
+
+  bool IgnoreAllWatchpoints(uint32_t ignore_count);
+  bool IgnoreWatchpoint(lldb::watch_id_t watch_id, uint32_t ignore_count);
 
   lldb::SBBroadcaster GetBroadcaster() const;
 
   lldb::SBType FindFirstType(const char *type);
 
   lldb::SBTypeList FindTypes(const char *type);
 
   lldb::SBType GetBasicType(lldb::BasicType type);

lldb/source/API/SBTarget.cpp

 //===-- SBTarget.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/API/SBTarget.h"
 #include "SBReproducerPrivate.h"
 
 #include "lldb/lldb-public.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBEvent.h"
SBProcess SBTarget::GetProcess() {
   if (target_sp) {
     process_sp = target_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
 
   return LLDB_RECORD_RESULT(sb_process);
 }
 
+bool SBTarget::IsProcessValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsProcessValid);
+
+  return m_opaque_sp->GetProcessSP() && m_opaque_sp->GetProcessSP()->IsAlive();
+}
+
 SBPlatform SBTarget::GetPlatform() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return LLDB_RECORD_RESULT(SBPlatform());
 
   SBPlatform platform;
SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The watchpoint list is thread safe, no need to lock
     sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
   }
   return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
-bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
-  LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
-                     wp_id);
+SBWatchpoint SBTarget::GetLastCreatedWatchpoint() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBWatchpoint, SBTarget,
+                                   GetLastCreatedWatchpoint);
 
-
-  bool result = false;
+  SBWatchpoint sb_watchpoint;
   TargetSP target_sp(GetSP());
   if (target_sp) {
-    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
-    std::unique_lock<std::recursive_mutex> lock;
-    target_sp->GetWatchpointList().GetListMutex(lock);
-    result = target_sp->RemoveWatchpointByID(wp_id);
+    sb_watchpoint.SetSP(target_sp->GetLastCreatedWatchpoint());
   }
-
-  return result;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
                      (lldb::watch_id_t), wp_id);
 
 
   SBWatchpoint sb_watchpoint;
if (target_sp) {
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->EnableAllWatchpoints();
     return true;
   }
   return false;
 }
 
+bool SBTarget::EnableWatchpoint(lldb::watch_id_t watch_id) {
+  LLDB_RECORD_METHOD(bool, SBTarget, EnableWatchpoint, (lldb::watch_id_t),
+                     watch_id);
+
+  bool result = false;
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    result = target_sp->EnableWatchpointByID(watch_id);
+  }
+
+  return result;
+}
+
 bool SBTarget::DisableAllWatchpoints() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->DisableAllWatchpoints();
     return true;
   }
   return false;
 }
 
+bool SBTarget::DisableWatchpoint(lldb::watch_id_t watch_id) {
+  LLDB_RECORD_METHOD(bool, SBTarget, DisableWatchpoint, (lldb::watch_id_t),
+                     watch_id);
+
+  bool result = false;
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    result = target_sp->DisableWatchpointByID(watch_id);
+  }
+
+  return result;
+}
+
+bool SBTarget::DeleteAllWatchpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
+
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    target_sp->RemoveAllWatchpoints();
+    return true;
+  }
+  return false;
+}
+
+bool SBTarget::DeleteWatchpoint(lldb::watch_id_t watch_id) {
+  LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
+                     watch_id);
+
+  bool result = false;
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    result = target_sp->RemoveWatchpointByID(watch_id);
+  }
+
+  return result;
+}
+
+bool SBTarget::IgnoreAllWatchpoints(uint32_t ignore_count) {
+  LLDB_RECORD_METHOD(bool, SBTarget, IgnoreAllWatchpoints, (uint32_t),
+                     ignore_count);
+
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    return target_sp->IgnoreAllWatchpoints(ignore_count);
+  }
+
+  return false;
+}
+
+bool SBTarget::IgnoreWatchpoint(lldb::watch_id_t watch_id,
+                                uint32_t ignore_count) {
+  LLDB_RECORD_METHOD(bool, SBTarget, IgnoreWatchpoint,
+                     (lldb::watch_id_t, uint32_t), watch_id, ignore_count);
+
+  bool result = false;
+  TargetSP target_sp(GetSP());
+  if (target_sp) {
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+    std::unique_lock<std::recursive_mutex> lock;
+    target_sp->GetWatchpointList().GetListMutex(lock);
+    result = target_sp->IgnoreWatchpointByID(watch_id, ignore_count);
+  }
+
+  return result;
+}
+
 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
                                          SBType type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
                      (const char *, lldb::SBAddress, lldb::SBType), name, addr,
                      type);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     new_value_sp =
         ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
   }
   sb_value.SetSP(new_value_sp);
   return LLDB_RECORD_RESULT(sb_value);
 }
 
-bool SBTarget::DeleteAllWatchpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
-
-  TargetSP target_sp(GetSP());
-  if (target_sp) {
-    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
-    std::unique_lock<std::recursive_mutex> lock;
-    target_sp->GetWatchpointList().GetListMutex(lock);
-    target_sp->RemoveAllWatchpoints();
-    return true;
-  }
-  return false;
-}
-
 void SBTarget::AppendImageSearchPath(const char *from, const char *to,
                                      lldb::SBError &error) {
   LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
                      (const char *, const char *, lldb::SBError &), from, to,
                      error);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
                               GetModuleAtIndexFromEvent,
                               (const uint32_t, const lldb::SBEvent &));
   LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
                               ());
   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsProcessValid, ());
   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
   LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
   LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
                        (const char *, lldb::SBError &));
LLDB_REGISTER_METHOD(
       (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
                        (lldb::SBFileSpec &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
                        (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
   LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
                              GetWatchpointAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
+  LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
+                             GetLastCreatedWatchpoint, ());
   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
                        (lldb::watch_id_t));
   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
                        (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
   LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
+  LLDB_REGISTER_METHOD(bool, SBTarget, EnableWatchpoint, (lldb::watch_id_t));
   LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
+  LLDB_REGISTER_METHOD(bool, SBTarget, DisableWatchpoint, (lldb::watch_id_t));
+  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
+  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
+  LLDB_REGISTER_METHOD(bool, SBTarget, IgnoreAllWatchpoints, (uint32_t));
+  LLDB_REGISTER_METHOD(bool, SBTarget, IgnoreWatchpoint,
+                       (lldb::watch_id_t, uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
                        (const char *, lldb::SBAddress, lldb::SBType));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
                        (const char *, lldb::SBData, lldb::SBType));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
                        (const char *, const char *));
-  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
   LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
                        (const char *, const char *, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
                        (const char *, const char *, const char *));
   LLDB_REGISTER_METHOD(
       lldb::SBModule, SBTarget, AddModule,
       (const char *, const char *, const char *, const char *));
   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

 #include "lldb/Core/IOHandler.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Target/Target.h"
 
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBBreakpointLocation.h"
+#include "lldb/API/SBTarget.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 // FIXME: "script-type" needs to have its contents determined dynamically, so
 // somebody can add a new scripting language to lldb and have it pickable here
 // without having to change this enumeration by hand and rebuild lldb proper.
 static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
     {
CommandObjectBreakpointCommandList(CommandInterpreter &interpreter)
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectBreakpointCommandList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    SBTarget sb_target(target_sp);
 
-    const BreakpointList &breakpoints = target->GetBreakpointList();
-    size_t num_breakpoints = breakpoints.GetSize();
+    size_t num_breakpoints = sb_target.GetNumBreakpoints();
 
     if (num_breakpoints == 0) {
       result.AppendError("No breakpoints exist for which to list commands");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.empty()) {
       result.AppendError(
           "No breakpoint specified for which to list the commands");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     BreakpointIDList valid_bp_ids;
     CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs(
-        command, target, result, &valid_bp_ids,
+        command, target_sp.get(), result, &valid_bp_ids,
         BreakpointName::Permissions::PermissionKinds::listPerm);
 
     if (result.Succeeded()) {
       const size_t count = valid_bp_ids.GetSize();
       for (size_t i = 0; i < count; ++i) {
         BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
         if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
-          Breakpoint *bp =
-              target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
+          SBBreakpoint sb_bp =
+              sb_target.FindBreakpointByID(cur_bp_id.GetBreakpointID());
 
-          if (bp) {
-            BreakpointLocationSP bp_loc_sp;
+          if (sb_bp) {
+            lldb::SBBreakpointLocation sb_bp_loc;
             if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {
-              bp_loc_sp = bp->FindLocationByID(cur_bp_id.GetLocationID());
-              if (!bp_loc_sp) {
+              sb_bp_loc = sb_bp.FindLocationByID(cur_bp_id.GetLocationID());
+              if (!sb_bp_loc) {
                 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",
                                              cur_bp_id.GetBreakpointID(),
                                              cur_bp_id.GetLocationID());
                 result.SetStatus(eReturnStatusFailed);
                 return false;
               }
             }
 
             StreamString id_str;
             BreakpointID::GetCanonicalReference(&id_str,
                                                 cur_bp_id.GetBreakpointID(),
                                                 cur_bp_id.GetLocationID());
             const Baton *baton = nullptr;
-            if (bp_loc_sp)
+            if (sb_bp_loc)
               baton =
-                  bp_loc_sp
+                  sb_bp_loc.GetSP()
                       ->GetOptionsSpecifyingKind(BreakpointOptions::eCallback)
                       ->GetBaton();
             else
-              baton = bp->GetOptions()->GetBaton();
+              baton = sb_bp.GetSP()->GetOptions()->GetBaton();
 
             if (baton) {
               result.GetOutputStream().Printf("Breakpoint %s:\n",
                                               id_str.GetData());
               baton->GetDescription(result.GetOutputStream().AsRawOstream(),
                                     eDescriptionLevelFull,
                                     result.GetOutputStream().GetIndentLevel() +
                                         2);

lldb/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatAdapters.h"
 
+#include "lldb/API/SBTarget.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void DumpTargetInfo(uint32_t target_idx, Target *target,
                            const char *prefix_cstr,
                            bool show_stopped_process_status, Stream &strm) {
   const ArchSpec &target_arch = target->GetArchitecture();
CommandObjectTargetModulesList(CommandInterpreter &interpreter)
         m_options() {}
 
   ~CommandObjectTargetModulesList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
     const bool use_global_module_list = m_options.m_use_global_module_list;
     // Define a local module list here to ensure it lives longer than any
     // "locker" object which might lock its contents below (through the
     // "module_list_ptr" variable).
     ModuleList module_list;
-    if (target == nullptr && !use_global_module_list) {
+    if (!target_sp && !use_global_module_list) {
       result.AppendError("invalid target, create a debug target using the "
                          "'target create' command");
       result.SetStatus(eReturnStatusFailed);
       return false;
     } else {
-      if (target) {
+      if (target_sp) {
         uint32_t addr_byte_size =
-            target->GetArchitecture().GetAddressByteSize();
+            target_sp->GetArchitecture().GetAddressByteSize();
         result.GetOutputStream().SetAddressByteSize(addr_byte_size);
         result.GetErrorStream().SetAddressByteSize(addr_byte_size);
       }
       // Dump all sections for all modules images
       Stream &strm = result.GetOutputStream();
 
       if (m_options.m_module_addr != LLDB_INVALID_ADDRESS) {
-        if (target) {
+        if (target_sp) {
           Address module_address;
-          if (module_address.SetLoadAddress(m_options.m_module_addr, target)) {
+          if (module_address.SetLoadAddress(m_options.m_module_addr,
+                                            target_sp.get())) {
             ModuleSP module_sp(module_address.GetModule());
             if (module_sp) {
-              PrintModule(target, module_sp.get(), 0, strm);
+              PrintModule(target_sp.get(), module_sp.get(), 0, strm);
               result.SetStatus(eReturnStatusSuccessFinishResult);
             } else {
               result.AppendErrorWithFormat(
                   "Couldn't find module matching address: 0x%" PRIx64 ".",
                   m_options.m_module_addr);
               result.SetStatus(eReturnStatusFailed);
             }
           } else {
if (!target_sp && !use_global_module_list) {
 
       const ModuleList *module_list_ptr = nullptr;
       const size_t argc = command.GetArgumentCount();
       if (argc == 0) {
         if (use_global_module_list) {
           guard.lock();
           num_modules = Module::GetNumberAllocatedModules();
         } else {
-          module_list_ptr = &target->GetImages();
+          module_list_ptr = &target_sp->GetImages();
         }
       } else {
         for (const Args::ArgEntry &arg : command) {
           // Dump specified images (by basename or fullpath)
-          const size_t num_matches = FindModulesByName(
-              target, arg.c_str(), module_list, use_global_module_list);
+          const size_t num_matches =
+              FindModulesByName(target_sp.get(), arg.c_str(), module_list,
+                                use_global_module_list);
           if (num_matches == 0) {
             if (argc == 1) {
               result.AppendErrorWithFormat("no modules found that match '%s'",
                                            arg.c_str());
               result.SetStatus(eReturnStatusFailed);
               return false;
             }
           }
if (!target_sp && !use_global_module_list) {
             module_sp = module_list_ptr->GetModuleAtIndexUnlocked(image_idx);
             module = module_sp.get();
           } else {
             module = Module::GetAllocatedModuleAtIndex(image_idx);
             module_sp = module->shared_from_this();
           }
 
           const size_t indent = strm.Printf("[%3u] ", image_idx);
-          PrintModule(target, module, indent, strm);
+          PrintModule(target_sp.get(), module, indent, strm);
         }
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         if (argc) {
           if (use_global_module_list)
             result.AppendError(
                 "the global module list has no matching modules");
           else

lldb/source/Commands/CommandObjectWatchpoint.h

 //===-- CommandObjectWatchpoint.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_COMMANDS_COMMANDOBJECTWATCHPOINT_H
 #define LLDB_SOURCE_COMMANDS_COMMANDOBJECTWATCHPOINT_H
 
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
 
+namespace lldb {
+class SBTarget;
+}
+
 namespace lldb_private {
 
 // CommandObjectMultiwordWatchpoint
 
 class CommandObjectMultiwordWatchpoint : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordWatchpoint(CommandInterpreter &interpreter);
 
   ~CommandObjectMultiwordWatchpoint() override;
 
-  static bool VerifyWatchpointIDs(Target *target, Args &args,
+  static bool VerifyWatchpointIDs(lldb::SBTarget sb_target, Args &args,
                                   std::vector<uint32_t> &wp_ids);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTWATCHPOINT_H

lldb/source/Commands/CommandObjectWatchpoint.cpp

 //===-- CommandObjectWatchpoint.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 "CommandObjectWatchpoint.h"
 #include "CommandObjectWatchpointCommand.h"
 
 #include <vector>
 
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "lldb/API/SBError.h"
+#include "lldb/API/SBProcess.h"
+#include "lldb/API/SBTarget.h"
+#include "lldb/API/SBWatchpoint.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
-static void AddWatchpointDescription(Stream *s, Watchpoint *wp,
+static void AddWatchpointDescription(Stream *s, WatchpointSP wp_sp,
                                      lldb::DescriptionLevel level) {
   s->IndentMore();
-  wp->GetDescription(s, level);
+  wp_sp->GetDescription(s, level);
   s->IndentLess();
   s->EOL();
 }
 
-static bool CheckTargetForWatchpointOperations(Target *target,
+static bool CheckTargetForWatchpointOperations(lldb::SBTarget sb_target,
                                                CommandReturnObject &result) {
-  bool process_is_valid =
-      target->GetProcessSP() && target->GetProcessSP()->IsAlive();
+  bool process_is_valid = sb_target.IsProcessValid();
   if (!process_is_valid) {
     result.AppendError("There's no process or it is not alive.");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
   // Target passes our checks, return true.
   return true;
 }
for (i = 0; i < 4; ++i)
     if (Arg.find(RSA[i]) != llvm::StringRef::npos)
       return i;
   return -1;
 }
 
 // Return true if wp_ids is successfully populated with the watch ids. False
 // otherwise.
 bool CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-    Target *target, Args &args, std::vector<uint32_t> &wp_ids) {
+    lldb::SBTarget sb_target, Args &args, std::vector<uint32_t> &wp_ids) {
   // Pre-condition: args.GetArgumentCount() > 0.
   if (args.GetArgumentCount() == 0) {
-    if (target == nullptr)
+    if (!sb_target)
       return false;
-    WatchpointSP watch_sp = target->GetLastCreatedWatchpoint();
-    if (watch_sp) {
-      wp_ids.push_back(watch_sp->GetID());
+    lldb::SBWatchpoint sb_wp = sb_target.GetLastCreatedWatchpoint();
+    if (sb_wp) {
+      wp_ids.push_back(sb_wp.GetID());
       return true;
     } else
       return false;
   }
 
   llvm::StringRef Minus("-");
   std::vector<llvm::StringRef> StrRefArgs;
   llvm::StringRef first;
public:
 
     // Instance variables to hold the values for command options.
 
     lldb::DescriptionLevel m_level;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
 
-    if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) {
-      uint32_t num_supported_hardware_watchpoints;
-      Status error = target->GetProcessSP()->GetWatchpointSupportInfo(
-          num_supported_hardware_watchpoints);
+    if (sb_target.IsProcessValid()) {
+      lldb::SBError error;
+      uint32_t num_supported_hardware_watchpoints =
+          sb_target.GetProcess().GetNumSupportedHardwareWatchpoints(error);
       if (error.Success())
         result.AppendMessageWithFormat(
             "Number of supported hardware watchpoints: %u\n",
             num_supported_hardware_watchpoints);
     }
 
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
-
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendMessage("No watchpoints currently set.");
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return true;
     }
 
     Stream &output_stream = result.GetOutputStream();
 
     if (command.GetArgumentCount() == 0) {
       // No watchpoint selected; show info about all currently set watchpoints.
       result.AppendMessage("Current watchpoints:");
       for (size_t i = 0; i < num_watchpoints; ++i) {
-        Watchpoint *wp = watchpoints.GetByIndex(i).get();
-        AddWatchpointDescription(&output_stream, wp, m_options.m_level);
+        WatchpointSP wp_sp = sb_target.GetWatchpointAtIndex(i).GetSP();
+        AddWatchpointDescription(&output_stream, wp_sp, m_options.m_level);
       }
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
       // Particular watchpoints selected; enable them.
       std::vector<uint32_t> wp_ids;
       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-              target, command, wp_ids)) {
+              sb_target, command, wp_ids)) {
         result.AppendError("Invalid watchpoints specification.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       const size_t size = wp_ids.size();
       for (size_t i = 0; i < size; ++i) {
-        Watchpoint *wp = watchpoints.FindByID(wp_ids[i]).get();
-        if (wp)
-          AddWatchpointDescription(&output_stream, wp, m_options.m_level);
+        WatchpointSP wp_sp = sb_target.GetWatchpointAtIndex(wp_ids[i]).GetSP();
+        if (wp_sp)
+          AddWatchpointDescription(&output_stream, wp_sp, m_options.m_level);
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
       }
     }
 
     return result.Succeeded();
   }
 
 private:
CommandObjectWatchpointEnable(CommandInterpreter &interpreter)
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointEnable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
-    if (!CheckTargetForWatchpointOperations(target, result))
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
+    if (!CheckTargetForWatchpointOperations(sb_target, result))
       return false;
 
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
-
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to be enabled.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
       // No watchpoint selected; enable all currently set watchpoints.
-      target->EnableAllWatchpoints();
+      sb_target.EnableAllWatchpoints();
       result.AppendMessageWithFormat("All watchpoints enabled. (%" PRIu64
                                      " watchpoints)\n",
                                      (uint64_t)num_watchpoints);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
       // Particular watchpoints selected; enable them.
       std::vector<uint32_t> wp_ids;
       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-              target, command, wp_ids)) {
+              sb_target, command, wp_ids)) {
         result.AppendError("Invalid watchpoints specification.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       int count = 0;
       const size_t size = wp_ids.size();
       for (size_t i = 0; i < size; ++i)
-        if (target->EnableWatchpointByID(wp_ids[i]))
+        if (sb_target.EnableWatchpoint(wp_ids[i]))
           ++count;
+
       result.AppendMessageWithFormat("%d watchpoints enabled.\n", count);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     }
 
     return result.Succeeded();
   }
 };
 
CommandObjectWatchpointDisable(CommandInterpreter &interpreter)
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointDisable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
-    if (!CheckTargetForWatchpointOperations(target, result))
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
+    if (!CheckTargetForWatchpointOperations(sb_target, result))
       return false;
 
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
-
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to be disabled.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
       // No watchpoint selected; disable all currently set watchpoints.
-      if (target->DisableAllWatchpoints()) {
+      if (sb_target.DisableAllWatchpoints()) {
         result.AppendMessageWithFormat("All watchpoints disabled. (%" PRIu64
                                        " watchpoints)\n",
                                        (uint64_t)num_watchpoints);
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
       } else {
         result.AppendError("Disable all watchpoints failed\n");
         result.SetStatus(eReturnStatusFailed);
       }
     } else {
       // Particular watchpoints selected; disable them.
       std::vector<uint32_t> wp_ids;
       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-              target, command, wp_ids)) {
+              sb_target, command, wp_ids)) {
         result.AppendError("Invalid watchpoints specification.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       int count = 0;
       const size_t size = wp_ids.size();
       for (size_t i = 0; i < size; ++i)
-        if (target->DisableWatchpointByID(wp_ids[i]))
+        if (sb_target.DisableWatchpoint(wp_ids[i]))
           ++count;
       result.AppendMessageWithFormat("%d watchpoints disabled.\n", count);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     }
 
     return result.Succeeded();
   }
 };
public:
     }
 
     // Instance variables to hold the values for command options.
     bool m_force;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
-    if (!CheckTargetForWatchpointOperations(target, result))
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
+    if (!CheckTargetForWatchpointOperations(sb_target, result))
       return false;
 
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
-
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to be deleted.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.empty()) {
       if (!m_options.m_force &&
           !m_interpreter.Confirm(
               "About to delete all watchpoints, do you want to do that?",
               true)) {
         result.AppendMessage("Operation cancelled...");
       } else {
-        target->RemoveAllWatchpoints();
+        sb_target.DeleteAllWatchpoints();
         result.AppendMessageWithFormat("All watchpoints removed. (%" PRIu64
                                        " watchpoints)\n",
                                        (uint64_t)num_watchpoints);
       }
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return result.Succeeded();
     }
 
     // Particular watchpoints selected; delete them.
     std::vector<uint32_t> wp_ids;
-    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command,
-                                                               wp_ids)) {
+    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
+            sb_target, command, wp_ids)) {
       result.AppendError("Invalid watchpoints specification.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     int count = 0;
     const size_t size = wp_ids.size();
     for (size_t i = 0; i < size; ++i)
-      if (target->RemoveWatchpointByID(wp_ids[i]))
+      if (sb_target.DeleteWatchpoint(wp_ids[i]))
         ++count;
     result.AppendMessageWithFormat("%d watchpoints deleted.\n", count);
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     return result.Succeeded();
   }
 
 private:
public:
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_ignore_count;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
-    if (!CheckTargetForWatchpointOperations(target, result))
-      return false;
-
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
 
-    const WatchpointList &watchpoints = target->GetWatchpointList();
+    if (!CheckTargetForWatchpointOperations(sb_target, result))
+      return false;
 
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to be ignored.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
-      target->IgnoreAllWatchpoints(m_options.m_ignore_count);
+      sb_target.IgnoreAllWatchpoints(m_options.m_ignore_count);
       result.AppendMessageWithFormat("All watchpoints ignored. (%" PRIu64
                                      " watchpoints)\n",
                                      (uint64_t)num_watchpoints);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
       // Particular watchpoints selected; ignore them.
       std::vector<uint32_t> wp_ids;
       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-              target, command, wp_ids)) {
+              sb_target, command, wp_ids)) {
         result.AppendError("Invalid watchpoints specification.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       int count = 0;
       const size_t size = wp_ids.size();
       for (size_t i = 0; i < size; ++i)
-        if (target->IgnoreWatchpointByID(wp_ids[i], m_options.m_ignore_count))
+        if (sb_target.IgnoreWatchpoint(wp_ids[i], m_options.m_ignore_count))
           ++count;
       result.AppendMessageWithFormat("%d watchpoints ignored.\n", count);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     }
 
     return result.Succeeded();
   }
 
public:
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     bool m_condition_passed;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
-    if (!CheckTargetForWatchpointOperations(target, result))
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
+    if (!CheckTargetForWatchpointOperations(sb_target, result))
       return false;
 
-    std::unique_lock<std::recursive_mutex> lock;
-    target->GetWatchpointList().GetListMutex(lock);
-
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to be modified.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
-      WatchpointSP wp_sp = target->GetLastCreatedWatchpoint();
+      WatchpointSP wp_sp = sb_target.GetLastCreatedWatchpoint().GetSP();
       wp_sp->SetCondition(m_options.m_condition.c_str());
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
       // Particular watchpoints selected; set condition on them.
       std::vector<uint32_t> wp_ids;
       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
-              target, command, wp_ids)) {
+              sb_target, command, wp_ids)) {
         result.AppendError("Invalid watchpoints specification.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       int count = 0;
       const size_t size = wp_ids.size();
       for (size_t i = 0; i < size; ++i) {
-        WatchpointSP wp_sp = watchpoints.FindByID(wp_ids[i]);
-        if (wp_sp) {
-          wp_sp->SetCondition(m_options.m_condition.c_str());
+        lldb::SBWatchpoint sb_wp = sb_target.FindWatchpointByID(wp_ids[i]);
+        if (sb_wp.GetSP()) {
+          sb_wp.SetCondition(m_options.m_condition.c_str());
           ++count;
         }
       }
       result.AppendMessageWithFormat("%d watchpoints modified.\n", count);
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     }
 
     return result.Succeeded();
static size_t GetVariableCallback(void *baton, const char *name,
     Target *target = static_cast<Target *>(baton);
     if (target)
       target->GetImages().FindGlobalVariables(ConstString(name), UINT32_MAX,
                                               variable_list);
     return variable_list.GetSize() - old_size;
   }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     // If no argument is present, issue an error message.  There's no way to
     // set a watchpoint.
     if (command.GetArgumentCount() <= 0) {
       result.GetErrorStream().Printf("error: required argument missing; "
                                      "specify your program variable to watch "
                                      "for\n");
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (!valobj_sp) {
       // Not in the frame; let's check the globals.
 
       VariableList variable_list;
       ValueObjectList valobj_list;
 
       Status error(Variable::GetValuesForVariableExpressionPath(
           command.GetArgumentAtIndex(0),
-          m_exe_ctx.GetBestExecutionContextScope(), GetVariableCallback, target,
-          variable_list, valobj_list));
+          m_exe_ctx.GetBestExecutionContextScope(), GetVariableCallback,
+          target_sp.get(), variable_list, valobj_list));
 
       if (valobj_list.GetSize())
         valobj_sp = valobj_list.GetValueObjectAtIndex(0);
     }
 
     CompilerType compiler_type;
 
     if (valobj_sp) {
if (valobj_sp) {
                                        command.GetArgumentAtIndex(0));
       return false;
     }
 
     // Now it's time to create the watchpoint.
     uint32_t watch_type = m_option_watchpoint.watch_type;
 
     error.Clear();
-    Watchpoint *wp =
-        target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error)
-            .get();
-    if (wp) {
-      wp->SetWatchSpec(command.GetArgumentAtIndex(0));
-      wp->SetWatchVariable(true);
+    WatchpointSP wp_sp = target_sp->CreateWatchpoint(addr, size, &compiler_type,
+                                                     watch_type, error);
+    if (wp_sp) {
+      wp_sp->SetWatchSpec(command.GetArgumentAtIndex(0));
+      wp_sp->SetWatchVariable(true);
       if (var_sp && var_sp->GetDeclaration().GetFile()) {
         StreamString ss;
         // True to show fullpath for declaration file.
         var_sp->GetDeclaration().DumpStopContext(&ss, true);
-        wp->SetDeclInfo(std::string(ss.GetString()));
+        wp_sp->SetDeclInfo(std::string(ss.GetString()));
       }
       output_stream.Printf("Watchpoint created: ");
-      wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
+      wp_sp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
       output_stream.EOL();
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendErrorWithFormat(
           "Watchpoint creation failed (addr=0x%" PRIx64 ", size=%" PRIu64
           ", variable expression='%s').\n",
           addr, (uint64_t)size, command.GetArgumentAtIndex(0));
       if (error.AsCString(nullptr))

 
 protected:
   bool DoExecute(llvm::StringRef raw_command,
                  CommandReturnObject &result) override {
     auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
     m_option_group.NotifyOptionParsingStarting(
         &exe_ctx); // This is a raw command, so notify the option group
 
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
+
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     OptionsWithRaw args(raw_command);
 
     llvm::StringRef expr = args.GetRawPart();
 
     if (args.HasArgs())
       if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
bool DoExecute(llvm::StringRef raw_command,
     EvaluateExpressionOptions options;
     options.SetCoerceToId(false);
     options.SetUnwindOnError(true);
     options.SetKeepInMemory(false);
     options.SetTryAllThreads(true);
     options.SetTimeout(llvm::None);
 
     ExpressionResults expr_result =
-        target->EvaluateExpression(expr, frame, valobj_sp, options);
+        target_sp->EvaluateExpression(expr, frame, valobj_sp, options);
     if (expr_result != eExpressionCompleted) {
       result.GetErrorStream().Printf(
           "error: expression evaluation of address to watch failed\n");
       result.GetErrorStream() << "expression evaluated: \n" << expr << "\n";
       if (valobj_sp && !valobj_sp->GetError().Success())
         result.GetErrorStream() << valobj_sp->GetError().AsCString() << "\n";
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // Get the address to watch.
     bool success = false;
     addr = valobj_sp->GetValueAsUnsigned(0, &success);
     if (!success) {
       result.GetErrorStream().Printf(
           "error: expression did not evaluate to an address\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (m_option_watchpoint.watch_size != 0)
       size = m_option_watchpoint.watch_size;
     else
-      size = target->GetArchitecture().GetAddressByteSize();
+      size = sb_target.GetAddressByteSize();
 
     // Now it's time to create the watchpoint.
     uint32_t watch_type = m_option_watchpoint.watch_type;
 
     // Fetch the type from the value object, the type of the watched object is
     // the pointee type
     /// of the expression, so convert to that if we  found a valid type.
     CompilerType compiler_type(valobj_sp->GetCompilerType());
 
     Status error;
-    Watchpoint *wp =
-        target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error)
-            .get();
-    if (wp) {
+    WatchpointSP wp_sp = target_sp->CreateWatchpoint(addr, size, &compiler_type,
+                                                     watch_type, error);
+    if (wp_sp) {
       Stream &output_stream = result.GetOutputStream();
       output_stream.Printf("Watchpoint created: ");
-      wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
+      wp_sp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
       output_stream.EOL();
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendErrorWithFormat("Watchpoint creation failed (addr=0x%" PRIx64
                                    ", size=%" PRIu64 ").\n",
                                    addr, (uint64_t)size);
       if (error.AsCString(nullptr))
         result.AppendError(error.AsCString());

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 
+#include "lldb/API/SBTarget.h"
+#include "lldb/API/SBWatchpoint.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 // FIXME: "script-type" needs to have its contents determined dynamically, so
 // somebody can add a new scripting language to lldb and have it pickable here
 // without having to change this enumeration by hand and rebuild lldb proper.
 static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
     {
public:
     bool m_use_one_liner;
     std::string m_one_liner;
     bool m_stop_on_error;
     std::string m_function_name;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
 
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to have commands added");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (!m_options.m_function_name.empty()) {
       if (!m_options.m_use_script_language) {
         m_options.m_script_language = GetDebugger().GetScriptLanguage();
         m_options.m_use_script_language = true;
       }
     }
 
     std::vector<uint32_t> valid_wp_ids;
-    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command,
-                                                               valid_wp_ids)) {
+    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
+            sb_target, command, valid_wp_ids)) {
       result.AppendError("Invalid watchpoints specification.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     const size_t count = valid_wp_ids.size();
     for (size_t i = 0; i < count; ++i) {
       uint32_t cur_wp_id = valid_wp_ids.at(i);
       if (cur_wp_id != LLDB_INVALID_WATCH_ID) {
-        Watchpoint *wp = target->GetWatchpointList().FindByID(cur_wp_id).get();
+        lldb::SBWatchpoint sb_wp = sb_target.FindWatchpointByID(cur_wp_id);
         // Sanity check wp first.
-        if (wp == nullptr)
+        if (!sb_wp)
           continue;
 
-        WatchpointOptions *wp_options = wp->GetOptions();
+        WatchpointOptions *wp_options = sb_wp.GetSP()->GetOptions();
         // Skip this watchpoint if wp_options is not good.
         if (wp_options == nullptr)
           continue;
 
         // If we are using script language, get the script interpreter in order
         // to set or collect command callback.  Otherwise, call the methods
         // associated with this object.
         if (m_options.m_use_script_language) {
CommandObjectWatchpointCommandDelete(CommandInterpreter &interpreter)
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointCommandDelete() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
 
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to have commands deleted");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
       result.AppendError(
           "No watchpoint specified from which to delete the commands");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     std::vector<uint32_t> valid_wp_ids;
-    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command,
-                                                               valid_wp_ids)) {
+    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
+            sb_target, command, valid_wp_ids)) {
       result.AppendError("Invalid watchpoints specification.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     const size_t count = valid_wp_ids.size();
     for (size_t i = 0; i < count; ++i) {
       uint32_t cur_wp_id = valid_wp_ids.at(i);
       if (cur_wp_id != LLDB_INVALID_WATCH_ID) {
-        Watchpoint *wp = target->GetWatchpointList().FindByID(cur_wp_id).get();
-        if (wp)
-          wp->ClearCallback();
+        SBWatchpoint sb_wp = sb_target.FindWatchpointByID(cur_wp_id);
+        if (sb_wp)
+          sb_wp.GetSP()->ClearCallback();
       } else {
         result.AppendErrorWithFormat("Invalid watchpoint ID: %u.\n", cur_wp_id);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
     return result.Succeeded();
   }
CommandObjectWatchpointCommandList(CommandInterpreter &interpreter)
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointCommandList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = &GetSelectedTarget();
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    lldb::SBTarget sb_target(target_sp);
 
-    const WatchpointList &watchpoints = target->GetWatchpointList();
-    size_t num_watchpoints = watchpoints.GetSize();
+    size_t num_watchpoints = sb_target.GetNumWatchpoints();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist for which to list commands");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (command.GetArgumentCount() == 0) {
       result.AppendError(
           "No watchpoint specified for which to list the commands");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     std::vector<uint32_t> valid_wp_ids;
-    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(target, command,
-                                                               valid_wp_ids)) {
+    if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
+            sb_target, command, valid_wp_ids)) {
       result.AppendError("Invalid watchpoints specification.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     const size_t count = valid_wp_ids.size();
     for (size_t i = 0; i < count; ++i) {
       uint32_t cur_wp_id = valid_wp_ids.at(i);
       if (cur_wp_id != LLDB_INVALID_WATCH_ID) {
-        Watchpoint *wp = target->GetWatchpointList().FindByID(cur_wp_id).get();
+        SBWatchpoint sb_wp = sb_target.FindWatchpointByID(cur_wp_id);
 
-        if (wp) {
-          const WatchpointOptions *wp_options = wp->GetOptions();
+        if (sb_wp) {
+          const WatchpointOptions *wp_options = sb_wp.GetSP()->GetOptions();
           if (wp_options) {
             // Get the callback baton associated with the current watchpoint.
             const Baton *baton = wp_options->GetBaton();
             if (baton) {
               result.GetOutputStream().Printf("Watchpoint %u:\n", cur_wp_id);
               baton->GetDescription(result.GetOutputStream().AsRawOstream(),
                                     eDescriptionLevelFull,
                                     result.GetOutputStream().GetIndentLevel() +