[debugserver] Share code between Enable/DisableHardwareWatchpoint (NFC)

[JDevlieghere]

Summary

This extract the common functionality of enabling and disabling hardware watchpoints into a single function.

[jasonmolenda]

Yep, looks good.

lldb/tools/debugserver/source/MacOSX/MachThreadList.h

public:
   nub_thread_t GetThreadIDByMachPortNumber(thread_t mach_port_number) const;
   thread_t GetMachPortNumberByThreadID(nub_thread_t globally_unique_id) const;
 
 protected:
   typedef std::vector<MachThreadSP> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
+  enum class HardwareBreakpointAction {
+    EnableWatchpoint,
+    DisableWatchpoint,
+  };
+
+  uint32_t DoHardwareBreakpointAction(const DNBBreakpoint *wp,
+                                      HardwareBreakpointAction action) const;
+
   uint32_t UpdateThreadList(MachProcess *process, bool update,
                             collection *num_threads = NULL);
   //  const_iterator  FindThreadByID (thread_t tid) const;
 
   collection m_threads;
   mutable PThreadMutex m_threads_mutex;
   MachThreadSP m_current_thread;
   bool m_is_64_bit;
 };
 
 #endif // #ifndef __MachThreadList_h__

lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp

bool MachThreadList::DisableHardwareBreakpoint(const DNBBreakpoint *bp) const {
   if (bp != NULL) {
     const size_t num_threads = m_threads.size();
     for (uint32_t idx = 0; idx < num_threads; ++idx)
       m_threads[idx]->DisableHardwareBreakpoint(bp);
   }
   return false;
 }
 
-// DNBWatchpointSet() -> MachProcess::CreateWatchpoint() ->
-// MachProcess::EnableWatchpoint()
-// -> MachThreadList::EnableHardwareWatchpoint().
-uint32_t
-MachThreadList::EnableHardwareWatchpoint(const DNBBreakpoint *wp) const {
+uint32_t MachThreadList::DoHardwareBreakpointAction(
+    const DNBBreakpoint *wp, HardwareBreakpointAction action) const {
+  if (wp == NULL)
+    return INVALID_NUB_HW_INDEX;
+
   uint32_t hw_index = INVALID_NUB_HW_INDEX;
-  if (wp != NULL) {
-    PTHREAD_MUTEX_LOCKER(locker, m_threads_mutex);
-    const size_t num_threads = m_threads.size();
-    // On Mac OS X we have to prime the control registers for new threads.  We
-    // do this
-    // using the control register data for the first thread, for lack of a
-    // better way of choosing.
-    bool also_set_on_task = true;
-    for (uint32_t idx = 0; idx < num_threads; ++idx) {
-      if ((hw_index = m_threads[idx]->EnableHardwareWatchpoint(
-               wp, also_set_on_task)) == INVALID_NUB_HW_INDEX) {
-        // We know that idx failed for some reason.  Let's rollback the
-        // transaction for [0, idx).
-        for (uint32_t i = 0; i < idx; ++i)
-          m_threads[i]->RollbackTransForHWP();
-        return INVALID_NUB_HW_INDEX;
-      }
-      also_set_on_task = false;
-    }
-    // Notify each thread to commit the pending transaction.
-    for (uint32_t idx = 0; idx < num_threads; ++idx)
-      m_threads[idx]->FinishTransForHWP();
-  }
+  // On Mac OS X we have to prime the control registers for new threads.  We do
+  // this using the control register data for the first thread, for lack of a
+    switch (action) {
+    case HardwareBreakpointAction::EnableWatchpoint:
+      hw_index = m_threads[idx]->EnableHardwareWatchpoint(wp, also_set_on_task);
+      break;
+    case HardwareBreakpointAction::DisableWatchpoint:
+      hw_index =
+          m_threads[idx]->DisableHardwareWatchpoint(wp, also_set_on_task);
+      break;
+    }
+    if (hw_index == INVALID_NUB_HW_INDEX) {
   return hw_index;
 }
 
-bool MachThreadList::DisableHardwareWatchpoint(const DNBBreakpoint *wp) const {
-  if (wp != NULL) {
-    PTHREAD_MUTEX_LOCKER(locker, m_threads_mutex);
-    const size_t num_threads = m_threads.size();
-
-    // On Mac OS X we have to prime the control registers for new threads.  We
-    // do this
-    // using the control register data for the first thread, for lack of a
-    // better way of choosing.
-    bool also_set_on_task = true;
-    for (uint32_t idx = 0; idx < num_threads; ++idx) {
-      if (!m_threads[idx]->DisableHardwareWatchpoint(wp, also_set_on_task)) {
-        // We know that idx failed for some reason.  Let's rollback the
-        // transaction for [0, idx).
-        for (uint32_t i = 0; i < idx; ++i)
-          m_threads[i]->RollbackTransForHWP();
-        return false;
-      }
-      also_set_on_task = false;
-    }
-    // Notify each thread to commit the pending transaction.
-    for (uint32_t idx = 0; idx < num_threads; ++idx)
-      m_threads[idx]->FinishTransForHWP();
+// DNBWatchpointSet() -> MachProcess::CreateWatchpoint() ->
+// MachProcess::EnableWatchpoint()
+// -> MachThreadList::EnableHardwareWatchpoint().
+uint32_t
+MachThreadList::EnableHardwareWatchpoint(const DNBBreakpoint *wp) const {
+  return DoHardwareBreakpointAction(wp,
+                                    HardwareBreakpointAction::EnableWatchpoint);
 
-    return true;
-  }
-  return false;
+bool MachThreadList::DisableHardwareWatchpoint(const DNBBreakpoint *wp) const {
+  return DoHardwareBreakpointAction(
+             wp, HardwareBreakpointAction::DisableWatchpoint) !=
+         INVALID_NUB_HW_INDEX;
 }
 
 uint32_t MachThreadList::NumSupportedHardwareWatchpoints() const {
   PTHREAD_MUTEX_LOCKER(locker, m_threads_mutex);
   const size_t num_threads = m_threads.size();
   // Use an arbitrary thread to retrieve the number of supported hardware
   // watchpoints.
   if (num_threads)