[lldb] Make Target::CleanupProcess consistent for breakpoints and watchpoints

[tatyana-krasnukha]

Summary

Target clears watchpoints hit count but doesn't do the same for breakpoints. As was discussed in D84527, this behavior should be unified.

Now responsibility for cleanup lies on *List symmetrically for breakpoints and watchpoints.

The test case verifies that hit counts are reset to 0 after killing the process.

[tatyana-krasnukha]

TestAddressBreakpoints.py fails on the last check - it expects hit count to be saved after re-launching the process. Removed that check.

lldb/include/lldb/Breakpoint/Breakpoint.h

 //===-- Breakpoint.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_BREAKPOINT_BREAKPOINT_H
 #define LLDB_BREAKPOINT_BREAKPOINT_H
 
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "lldb/Breakpoint/BreakpointID.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointLocationList.h"
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Breakpoint/Stoppoint.h"
 #include "lldb/Breakpoint/StoppointHitCounter.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Utility/Event.h"
public:
   ///    The number of breakpoint hits to ignore.
   void SetIgnoreCount(uint32_t count);
 
   /// Return the current ignore count/
   /// \return
   ///     The number of breakpoint hits to be ignored.
   uint32_t GetIgnoreCount() const;
 
-  /// Return the current hit count for all locations. \return
+  /// Return the current hit count.
+  /// \return
   ///     The current hit count for all locations.
   uint32_t GetHitCount() const;
 
+  /// Reset the current hit count for itself and for all locations.
+  void ResetHitCount();
+
   /// If \a one_shot is \b true, breakpoint will be deleted on first hit.
   void SetOneShot(bool one_shot);
 
   /// Check the OneShot state.
   /// \return
   ///     \b true if the breakpoint is one shot, \b false otherwise.
   bool IsOneShot() const;
 

lldb/include/lldb/Breakpoint/BreakpointList.h

 //===-- BreakpointList.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_BREAKPOINT_BREAKPOINTLIST_H
 #define LLDB_BREAKPOINT_BREAKPOINTLIST_H
 
 #include <list>
 #include <mutex>
 
 #include "lldb/Breakpoint/Breakpoint.h"
 
 namespace lldb_private {
 
 /// \class BreakpointList BreakpointList.h "lldb/Breakpoint/BreakpointList.h"
 /// This class manages a list of breakpoints.
 
 /// General Outline:
 /// Allows adding and removing breakpoints and find by ID and index.
public:
   ///   If \a load is \b false, then delete breakpoint locations when
   ///   when updating breakpoints.
   void UpdateBreakpoints(ModuleList &module_list, bool load,
                          bool delete_locations);
 
   void UpdateBreakpointsWhenModuleIsReplaced(lldb::ModuleSP old_module_sp,
                                              lldb::ModuleSP new_module_sp);
 
-  void ClearAllBreakpointSites();
+  /// Clears BreakpointSites and resets breakpoint hit counts.
+  void CleanupBreakpoints();
 
   /// Sets the passed in Locker to hold the Breakpoint List mutex.
   ///
   /// \param[in] lock
   ///   The locker object that is set.
   void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
 
 protected:

lldb/include/lldb/Breakpoint/BreakpointLocation.h

 //===-- BreakpointLocation.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_BREAKPOINT_BREAKPOINTLOCATION_H
 #define LLDB_BREAKPOINT_BREAKPOINTLOCATION_H
 
 #include <memory>
 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Breakpoint/StoppointHitCounter.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class BreakpointLocation BreakpointLocation.h
public:
   ///
   /// \return
   ///     \b true if the breakpoint is set to auto-continue, \b false if not.
   bool IsAutoContinue() const;
 
   /// Return the current Hit Count.
   uint32_t GetHitCount() const { return m_hit_counter.GetValue(); }
 
+  /// Reset the current Hit Count.
+  void ResetHitCount() { return m_hit_counter.Reset(); }
+
   /// Return the current Ignore Count.
   ///
   /// \return
   ///     The number of breakpoint hits to be ignored.
   uint32_t GetIgnoreCount() const;
 
   /// Set the breakpoint to ignore the next \a count breakpoint hits.
   ///

lldb/include/lldb/Breakpoint/BreakpointLocationList.h

 //===-- BreakpointLocationList.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_BREAKPOINT_BREAKPOINTLOCATIONLIST_H
 #define LLDB_BREAKPOINT_BREAKPOINTLOCATIONLIST_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Utility/Iterable.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class BreakpointLocationList BreakpointLocationList.h
 /// "lldb/Breakpoint/BreakpointLocationList.h" This class is used by
 /// Breakpoint to manage a list of breakpoint locations, each breakpoint
public:
 
   /// Returns the number of breakpoint locations in this list with resolved
   /// breakpoints.
   ///
   /// \result
   ///     Number of qualifying breakpoint locations.
   size_t GetNumResolvedLocations() const;
 
-  /// Returns the number hit count of all locations in this list.
-  ///
-  /// \result
-  ///     Hit count of all locations in this list.
-  uint32_t GetHitCount() const;
+  /// Clears the hit count of all locations in this list.
+  void ResetHitCount();
 
   /// Enquires of the breakpoint location in this list with ID \a breakID
   /// whether we should stop.
   ///
   /// \param[in] context
   ///     This contains the information about this stop.
   ///
   /// \param[in] breakID

lldb/include/lldb/Breakpoint/WatchpointList.h

 //===-- WatchpointList.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_BREAKPOINT_WATCHPOINTLIST_H
 #define LLDB_BREAKPOINT_WATCHPOINTLIST_H
 
 #include <list>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Core/Address.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class WatchpointList WatchpointList.h "lldb/Breakpoint/WatchpointList.h"
 /// This class is used by Watchpoint to manage a list of watchpoints,
 //  each watchpoint in the list has a unique ID, and is unique by Address as
 //  well.
public:
   ///
   /// \see lldb::DescriptionLevel
   void GetDescription(Stream *s, lldb::DescriptionLevel level);
 
   void SetEnabledAll(bool enabled);
 
   void RemoveAll(bool notify);
 
+  /// Clears all watchpoints hit counts and historic values.
+  void CleanupWatchpoints();
+
   /// Sets the passed in Locker to hold the Watchpoint List mutex.
   ///
   /// \param[in] lock
   ///   The locker object that is set.
   void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
 
 protected:
   typedef std::list<lldb::WatchpointSP> wp_collection;

lldb/include/lldb/Target/Target.h

public:
   // performed end to end, for both the debugger and the debuggee.
 
   bool RemoveAllWatchpoints(bool end_to_end = true);
 
   bool DisableAllWatchpoints(bool end_to_end = true);
 
   bool EnableAllWatchpoints(bool end_to_end = true);
 
-  bool ClearAllWatchpointHitCounts();
-
-  bool ClearAllWatchpointHistoricValues();
-
   bool IgnoreAllWatchpoints(uint32_t ignore_count);
 
   bool DisableWatchpointByID(lldb::watch_id_t watch_id);
 
   bool EnableWatchpointByID(lldb::watch_id_t watch_id);
 
   bool RemoveWatchpointByID(lldb::watch_id_t watch_id);
 

lldb/source/Breakpoint/Breakpoint.cpp

 //===-- Breakpoint.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 "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
if (ignore != 0) {
     DecrementIgnoreCount();
     return false;
   } else
     return true;
 }
 
 uint32_t Breakpoint::GetHitCount() const { return m_hit_counter.GetValue(); }
 
+void Breakpoint::ResetHitCount() {
+  m_hit_counter.Reset();
+  m_locations.ResetHitCount();
+}
+
 bool Breakpoint::IsOneShot() const { return m_options_up->IsOneShot(); }
 
 void Breakpoint::SetOneShot(bool one_shot) {
   m_options_up->SetOneShot(one_shot);
 }
 
 bool Breakpoint::IsAutoContinue() const { 
   return m_options_up->IsAutoContinue();

lldb/source/Breakpoint/BreakpointList.cpp

 //===-- BreakpointList.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/Breakpoint/BreakpointList.h"
 
 #include "lldb/Target/Target.h"
 
 #include "llvm/Support/Errc.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
void BreakpointList::SetEnabledAllowed(bool enabled) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   for (const auto &bp_sp : m_breakpoints)
     if (bp_sp->AllowDisable())
       bp_sp->SetEnabled(enabled);
 }
 
 void BreakpointList::RemoveAll(bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  ClearAllBreakpointSites();
 
-  if (notify) {
-    for (const auto &bp_sp : m_breakpoints)
+  for (const auto &bp_sp : m_breakpoints) {
+    bp_sp->ClearAllBreakpointSites();
+    if (notify)
       NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
   }
 
   m_breakpoints.clear();
 }
 
 void BreakpointList::RemoveAllowed(bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);

 
 void BreakpointList::UpdateBreakpointsWhenModuleIsReplaced(
     ModuleSP old_module_sp, ModuleSP new_module_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   for (const auto &bp_sp : m_breakpoints)
     bp_sp->ModuleReplaced(old_module_sp, new_module_sp);
 }
 
-void BreakpointList::ClearAllBreakpointSites() {
+void BreakpointList::CleanupBreakpoints() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  for (const auto &bp_sp : m_breakpoints)
+  for (const auto &bp_sp : m_breakpoints) {
     bp_sp->ClearAllBreakpointSites();
+    bp_sp->ResetHitCount();
+  }
 }
 
 void BreakpointList::GetListMutex(
     std::unique_lock<std::recursive_mutex> &lock) {
   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 }

lldb/source/Breakpoint/BreakpointLocationList.cpp

 //===-- BreakpointLocationList.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/Breakpoint/BreakpointLocationList.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
void BreakpointLocationList::ResolveAllBreakpointSites() {
   collection::iterator pos, end = m_locations.end();
 
   for (pos = m_locations.begin(); pos != end; ++pos) {
     if ((*pos)->IsEnabled())
       (*pos)->ResolveBreakpointSite();
   }
 }
 
-uint32_t BreakpointLocationList::GetHitCount() const {
-  uint32_t hit_count = 0;
+void BreakpointLocationList::ResetHitCount() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   collection::const_iterator pos, end = m_locations.end();
-  for (pos = m_locations.begin(); pos != end; ++pos)
-    hit_count += (*pos)->GetHitCount();
-  return hit_count;
+  for (auto &location : m_locations)
+    location->ResetHitCount();
 }
 
 size_t BreakpointLocationList::GetNumResolvedLocations() const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   size_t resolve_count = 0;
   collection::const_iterator pos, end = m_locations.end();
   for (pos = m_locations.begin(); pos != end; ++pos) {
     if ((*pos)->IsResolved())

lldb/source/Breakpoint/WatchpointList.cpp

 //===-- WatchpointList.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/Breakpoint/WatchpointList.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 WatchpointList::WatchpointList()
     : m_watchpoints(), m_mutex(), m_next_wp_id(0) {}
 
if (notify) {
                                                   *pos));
         }
       }
     }
   }
   m_watchpoints.clear();
 }
 
+void WatchpointList::CleanupWatchpoints() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+
+  for (const auto &wp_sp : m_watchpoints) {
+    if (!wp_sp)
+      return;
+
+    wp_sp->ResetHitCount();
+    wp_sp->ResetHistoricValues();
+  }
+}
+
 void WatchpointList::GetListMutex(
     std::unique_lock<std::recursive_mutex> &lock) {
   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 }

lldb/source/Target/Target.cpp

 //===-- Target.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/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"
else
       s->PutCString("No executable module.");
   }
 }
 
 void Target::CleanupProcess() {
   // Do any cleanup of the target we need to do between process instances.
   // NB It is better to do this before destroying the process in case the
   // clean up needs some help from the process.
-  m_breakpoint_list.ClearAllBreakpointSites();
-  m_internal_breakpoint_list.ClearAllBreakpointSites();
+  m_breakpoint_list.CleanupBreakpoints();
+  m_internal_breakpoint_list.CleanupBreakpoints();
   // Disable watchpoints just on the debugger side.
-  std::unique_lock<std::recursive_mutex> lock;
-  this->GetWatchpointList().GetListMutex(lock);
-  DisableAllWatchpoints(false);
-  ClearAllWatchpointHitCounts();
-  ClearAllWatchpointHistoricValues();
+  m_watchpoint_list.SetEnabledAll(false);
+  m_watchpoint_list.CleanupWatchpoints();
 }
 
 void Target::DeleteCurrentProcess() {
   if (m_process_sp) {
     m_section_load_history.Clear();
     if (m_process_sp->IsAlive())
       m_process_sp->Destroy(false);
 
for (size_t i = 0; i < num_watchpoints; ++i) {
 
     Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
     if (rc.Fail())
       return false;
   }
   return true; // Success!
 }
 
-// Assumption: Caller holds the list mutex lock for m_watchpoint_list.
-bool Target::ClearAllWatchpointHitCounts() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
-  LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
-
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
-    if (!wp_sp)
-      return false;
-
-    wp_sp->ResetHitCount();
-  }
-  return true; // Success!
-}
-
-// Assumption: Caller holds the list mutex lock for m_watchpoint_list.
-bool Target::ClearAllWatchpointHistoricValues() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
-  LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
-
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
-    if (!wp_sp)
-      return false;
-
-    wp_sp->ResetHistoricValues();
-  }
-  return true; // Success!
-}
-
 // Assumption: Caller holds the list mutex lock for m_watchpoint_list during
 // these operations.
 bool Target::IgnoreAllWatchpoints(uint32_t ignore_count) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
 
   if (!ProcessIsValid())
     return false;

lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

def address_breakpoints(self):
         from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
         threads = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
         self.assertEquals(breakpoint.GetHitCount(), 1)
-
-        process.Kill()
-
-        # Now re-launch and see that we hit the breakpoint again:
-        launch_info.Clear()
-        launch_info.SetLaunchFlags(flags)
-
-        process = target.Launch(launch_info, error)
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        thread = get_threads_stopped_at_breakpoint(process, breakpoint)
-        self.assertTrue(
-            len(threads) == 1,
-            "There should be a thread stopped at our breakpoint")
-
-        # The hit count for the breakpoint should now be 2.
-        self.assertEquals(breakpoint.GetHitCount(), 2)

lldb/test/API/functionalities/breakpoint/breakpoint_hit_count/TestBreakpointHitCount.py

class BreakpointHitCountTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     def test_breakpoint_location_hit_count(self):
         """Use Python APIs to check breakpoint hit count."""
         self.build()
-        self.do_test_breakpoint_location_hit_count()
+        target = self.create_target()
+        breakpoint = self.create_breakpoint(target)
+        process = self.launch_process(target)
+        self.do_test_breakpoint_location_hit_count(process, breakpoint)
+
+    def test_breakpoint_hit_count_cleanup(self):
+        """Use Python APIs to check that breakpoint hit count is cleared
+           as well as locations hit counts when process dies."""
+        self.build()
+        target = self.create_target()
+        breakpoint = self.create_breakpoint(target)
+        process = self.launch_process(target)
+        self.do_test_breakpoint_location_hit_count(process, breakpoint)
+
+        # Kill the process and launch a new one.
+        status = process.Kill()
+        self.assertTrue(status, "The process was killed.")
+        new_process = self.launch_process(target)
+
+        # Test hit location of the existing breakpoint. It should be like we didn't have hits before.
+        self.do_test_breakpoint_location_hit_count(new_process, breakpoint)
 
     def test_breakpoint_one_shot(self):
         """Check that one-shot breakpoints trigger only once."""
         self.build()
-
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.create_target()
 
         self.runCmd("tb a")
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         from lldbsuite.test.lldbutil import get_stopped_thread
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
class BreakpointHitCountTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.a_int_body_line_no = line_number(
             'main.cpp', '// Breakpoint Location 1')
         self.a_float_body_line_no = line_number(
             'main.cpp', '// Breakpoint Location 2')
 
-    def do_test_breakpoint_location_hit_count(self):
-        """Use Python APIs to check breakpoint hit count."""
+    def create_target(self):
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
+        return target
 
+    def create_breakpoint(self, target):
         # Create a breakpoint in main.cpp by name 'a',
         # there should be two locations.
         breakpoint = target.BreakpointCreateByName('a', 'a.out')
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 2,
                         VALID_BREAKPOINT)
 
         # Verify all breakpoint locations are enabled.
         location1 = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location1 and
                         location1.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
 
         location2 = breakpoint.GetLocationAtIndex(1)
         self.assertTrue(location2 and
                         location2.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
 
+        return breakpoint
+
+    def launch_process(self, target):
         # Launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
+        return process
+
+    def do_test_breakpoint_location_hit_count(self, process, breakpoint):
+        """Use Python APIs to check breakpoint hit count."""
+
         # Verify 1st breakpoint location is hit.
         from lldbsuite.test.lldbutil import get_stopped_thread
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint")
 
         frame0 = thread.GetFrameAtIndex(0)
def do_test_breakpoint_location_hit_count(self, process, breakpoint):
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint")
 
         self.assertEqual(location2.GetHitCount(), 2)
         self.assertEqual(location1.GetHitCount(), 1)
         self.assertEqual(breakpoint.GetHitCount(), 3)
-
-        process.Continue()