[lldb] Remove unused bool return type of ThreadPlan::WillStop (NFC)

[kastiglione]

Summary

The calls to ThreadPlan::WillStop do not use the return value. This changes WillStop
to a void return type, and since most subclasses don't implement this event, the base
class is given an empty implementation, instead of being pure virtual. Do-nothing
implementations are removed.

lldb/include/lldb/Target/ThreadPlan.h

 //===-- ThreadPlan.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_TARGET_THREADPLAN_H
 #define LLDB_TARGET_THREADPLAN_H
 
 #include <mutex>
 #include <string>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanTracer.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
public:
   virtual void SetStopOthers(bool new_value);
 
   virtual bool StopOthers();
 
   // This is the wrapper for DoWillResume that does generic ThreadPlan logic,
   // then calls DoWillResume.
   bool WillResume(lldb::StateType resume_state, bool current_plan);
 
-  virtual bool WillStop() = 0;
+  virtual void WillStop();
 
   bool IsMasterPlan() { return m_is_master_plan; }
 
   bool SetIsMasterPlan(bool value) {
     bool old_value = m_is_master_plan;
     m_is_master_plan = value;
     return old_value;
   }
public:
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ValidatePlan(Stream *error) override;
 
   bool ShouldStop(Event *event_ptr) override;
 
   bool MischiefManaged() override;
 
-  bool WillStop() override;
+  void WillStop() override;
 
   bool IsBasePlan() override { return true; }
 
   bool OkayToDiscard() override { return false; }
 
   const Status &GetStatus() { return m_status; }
 
 protected:

lldb/include/lldb/Target/ThreadPlanBase.h

public:
   ~ThreadPlanBase() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   Vote ShouldReportStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
   bool MischiefManaged() override;
 
   bool OkayToDiscard() override { return false; }
 
   bool IsBasePlan() override { return true; }
 
 protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;

lldb/include/lldb/Target/ThreadPlanCallFunction.h

public:
   Vote ShouldReportStop(Event *event_ptr) override;
 
   bool StopOthers() override;
 
   lldb::StateType GetPlanRunState() override;
 
   void DidPush() override;
 
-  bool WillStop() override;
-
   bool MischiefManaged() override;
 
   // To get the return value from a function call you must create a
   // lldb::ValueSP that contains a valid clang type in its context and call
   // RequestReturnValue. The ValueSP will be stored and when the function is
   // done executing, the object will check if there is a requested return
   // value. If there is, the return value will be retrieved using the
   // ABI::GetReturnValue() for the ABI in the process. Then after the thread

lldb/include/lldb/Target/ThreadPlanCallOnFunctionExit.h

public:
   // ThreadPlan API
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ValidatePlan(Stream *error) override;
 
   bool ShouldStop(Event *event_ptr) override;
 
-  bool WillStop() override;
-
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   lldb::StateType GetPlanRunState() override;
 
 private:
   Callback m_callback;
   lldb::ThreadPlanSP m_step_out_threadplan_sp;
 };
 }
 
 #endif // LLDB_TARGET_THREADPLANCALLONFUNCTIONEXIT_H

lldb/include/lldb/Target/ThreadPlanPython.h

 //===-- ThreadPlanPython.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_TARGET_THREADPLANPYTHON_H
 #define LLDB_TARGET_THREADPLANPYTHON_H
 
 #include <string>
 
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanTracer.h"
 #include "lldb/Utility/StructuredData.h"
public:
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ValidatePlan(Stream *error) override;
 
   bool ShouldStop(Event *event_ptr) override;
 
   bool MischiefManaged() override;
 
-  bool WillStop() override;
+  void WillStop() override;
 
   bool StopOthers() override { return m_stop_others; }
 
   void SetStopOthers(bool new_value) override { m_stop_others = new_value; }
 
   void DidPush() override;
 
   bool IsPlanStale() override;

lldb/include/lldb/Target/ThreadPlanRunToAddress.h

public:
   bool ShouldStop(Event *event_ptr) override;
 
   bool StopOthers() override;
 
   void SetStopOthers(bool new_value) override;
 
   lldb::StateType GetPlanRunState() override;
 
-  bool WillStop() override;
-
   bool MischiefManaged() override;
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   void SetInitialBreakpoints();
   bool AtOurAddress();
 

lldb/include/lldb/Target/ThreadPlanStepInstruction.h

public:
 
   ~ThreadPlanStepInstruction() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
   bool MischiefManaged() override;
   bool IsPlanStale() override;
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   void SetUpState();
 

lldb/include/lldb/Target/ThreadPlanStepOut.h

 //===-- ThreadPlanStepOut.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_TARGET_THREADPLANSTEPOUT_H
 #define LLDB_TARGET_THREADPLANSTEPOUT_H
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanShouldStopHere.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepOut : public ThreadPlan, public ThreadPlanShouldStopHere {
 public:
   ThreadPlanStepOut(Thread &thread, SymbolContext *addr_context,
                     bool first_insn, bool stop_others, Vote stop_vote,
                     Vote run_vote, uint32_t frame_idx,
                     LazyBool step_out_avoids_code_without_debug_info,
                     bool continue_to_next_branch = false,
                     bool gather_return_value = true);
 
   ~ThreadPlanStepOut() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
+  void WillStop() override;
   bool MischiefManaged() override;
   void DidPush() override;
   bool IsPlanStale() override;
 
   lldb::ValueObjectSP GetReturnValueObject() override {
     return m_return_valobj_sp;
   }
 

lldb/include/lldb/Target/ThreadPlanStepOverBreakpoint.h

 //===-- ThreadPlanStepOverBreakpoint.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_TARGET_THREADPLANSTEPOVERBREAKPOINT_H
 #define LLDB_TARGET_THREADPLANSTEPOVERBREAKPOINT_H
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepOverBreakpoint : public ThreadPlan {
 public:
   ThreadPlanStepOverBreakpoint(Thread &thread);
 
   ~ThreadPlanStepOverBreakpoint() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
+  void WillStop() override;
   void WillPop() override;
   bool MischiefManaged() override;
   void ThreadDestroyed() override;
   void SetAutoContinue(bool do_it);
   bool ShouldAutoContinue(Event *event_ptr) override;
   bool IsPlanStale() override;
 
   lldb::addr_t GetBreakpointLoadAddress() const { return m_breakpoint_addr; }

lldb/include/lldb/Target/ThreadPlanStepRange.h

public:
   ~ThreadPlanStepRange() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override = 0;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override = 0;
   Vote ShouldReportStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
   bool MischiefManaged() override;
   void DidPush() override;
   bool IsPlanStale() override;
 
   void AddRange(const AddressRange &new_range);
 
 protected:
   bool InRange();

lldb/include/lldb/Target/ThreadPlanStepThrough.h

 public:
   ~ThreadPlanStepThrough() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
   bool MischiefManaged() override;
   void DidPush() override;
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
   ThreadPlanStepThrough(Thread &thread, StackID &return_stack_id,

lldb/include/lldb/Target/ThreadPlanStepUntil.h

 //===-- ThreadPlanStepUntil.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_TARGET_THREADPLANSTEPUNTIL_H
 #define LLDB_TARGET_THREADPLANSTEPUNTIL_H
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepUntil : public ThreadPlan {
 public:
   ~ThreadPlanStepUntil() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ValidatePlan(Stream *error) override;
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() override;
-  bool WillStop() override;
+  void WillStop() override;
   bool MischiefManaged() override;
 
 protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   ThreadPlanStepUntil(Thread &thread, lldb::addr_t *address_list,
                       size_t num_addresses, bool stop_others,

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h

public:
   bool StopOthers() override { return false; }
 
   // The base class MischiefManaged does some cleanup - so you have to call it
   // in your MischiefManaged derived class.
   bool MischiefManaged() override;
 
   void DidPush() override;
 
-  bool WillStop() override;
-
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
 private:
   bool InitializeFunctionCaller();
 
   AppleObjCTrampolineHandler &m_trampoline_handler; /// The handler itself.
   lldb::addr_t m_args_addr; /// Stores the address for our step through function

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

 }
 
 // The base class MischiefManaged does some cleanup - so you have to call it in
 // your MischiefManaged derived class.
 bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
   return IsPlanComplete();
 }
 
-bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }
-
 // Objective-C uses optimized dispatch functions for some common and seldom
 // overridden methods.  For instance
 //      [object respondsToSelector:];
 // will get compiled to:
 //      objc_opt_respondsToSelector(object);
 // This checks whether the selector has been overridden, directly calling the
 // implementation if it hasn't and calling objc_msgSend if it has.
 //

lldb/source/Target/ThreadPlan.cpp

 //===-- ThreadPlan.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/ThreadPlan.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
bool ThreadPlan::WillResume(StateType resume_state, bool current_plan) {
   }
   bool success = DoWillResume(resume_state, current_plan);
   ClearThreadCache(); // We don't cache the thread pointer over resumes.  This
                       // Thread might go away, and another Thread represent
                       // the same underlying object on a later stop.
   return success;
 }
 
+void ThreadPlan::WillStop() {}
+
 lldb::user_id_t ThreadPlan::GetNextID() {
   static uint32_t g_nextPlanID = 0;
   return ++g_nextPlanID;
 }
 
 void ThreadPlan::DidPush() {}
 
 void ThreadPlan::WillPop() {}
#else
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
                LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return true;
 }
 
-bool ThreadPlanNull::WillStop() {
+void ThreadPlanNull::WillStop() {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
           LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
                LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
-  return true;
 }
 
 bool ThreadPlanNull::DoPlanExplainsStop(Event *event_ptr) {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
           LLVM_PRETTY_FUNCTION, GetThread().GetID(), GetThread().GetProtocolID());

lldb/source/Target/ThreadPlanBase.cpp

bool ThreadPlanBase::ShouldStop(Event *event_ptr) {
   // If there's no explicit reason to stop, then we will continue.
   return false;
 }
 
 bool ThreadPlanBase::StopOthers() { return false; }
 
 StateType ThreadPlanBase::GetPlanRunState() { return eStateRunning; }
 
-bool ThreadPlanBase::WillStop() { return true; }
-
 bool ThreadPlanBase::DoWillResume(lldb::StateType resume_state,
                                   bool current_plan) {
   // Reset these to the default values so we don't set them wrong, then not get
   // asked for a while, then return the wrong answer.
   m_run_vote = eVoteNoOpinion;
   m_stop_vote = eVoteNo;
   return true;
 }
 
 // The base plan is never done.
 bool ThreadPlanBase::MischiefManaged() {
   // The base plan is never done.
   return false;
 }

lldb/source/Target/ThreadPlanCallFunction.cpp

#ifndef SINGLE_STEP_EXPRESSIONS
   m_subplan_sp = std::make_shared<ThreadPlanRunToAddress>(thread, m_start_addr, 
                                                           m_stop_other_threads);
 
   thread.QueueThreadPlan(m_subplan_sp, false);
   m_subplan_sp->SetPrivate(true);
 #endif
 }
 
-bool ThreadPlanCallFunction::WillStop() { return true; }
-
 bool ThreadPlanCallFunction::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (IsPlanComplete()) {
     LLDB_LOGF(log, "ThreadPlanCallFunction(%p): Completed call function plan.",
               static_cast<void *>(this));
 
     ThreadPlan::MischiefManaged();

lldb/source/Target/ThreadPlanCallOnFunctionExit.cpp

if (m_step_out_threadplan_sp && m_step_out_threadplan_sp->IsPlanComplete()) {
 
     // We're done now, but we want to return false so that we don't cause the
     // thread to really stop.
   }
 
   return false;
 }
 
-bool ThreadPlanCallOnFunctionExit::WillStop() {
-  // The code looks like the return value is ignored via ThreadList::
-  // ShouldStop(). This is called when we really are going to stop.  We don't
-  // care and don't need to do anything here.
-  return false;
-}
-
 bool ThreadPlanCallOnFunctionExit::DoPlanExplainsStop(Event *event_ptr) {
   // We don't ever explain a stop.  The only stop that is relevant to us
   // directly is the step_out plan we added to do the heavy lifting of getting
   // us past the current method.
   return false;
 }
 
 lldb::StateType ThreadPlanCallOnFunctionExit::GetPlanRunState() {
   // This value doesn't matter - we'll never be the top thread plan, so nobody
   // will ask us this question.
   return eStateRunning;
 }

lldb/source/Target/ThreadPlanPython.cpp

 //===-- ThreadPlanPython.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/ThreadPlan.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"

 }
 
 // The ones below are not currently exported to Python.
 void ThreadPlanPython::GetDescription(Stream *s, lldb::DescriptionLevel level) {
   s->Printf("Python thread plan implemented by class %s.",
             m_class_name.c_str());
 }
 
-bool ThreadPlanPython::WillStop() {
+void ThreadPlanPython::WillStop() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());
-  return true;
 }

lldb/source/Target/ThreadPlanRunToAddress.cpp

 bool ThreadPlanRunToAddress::StopOthers() { return m_stop_others; }
 
 void ThreadPlanRunToAddress::SetStopOthers(bool new_value) {
   m_stop_others = new_value;
 }
 
 StateType ThreadPlanRunToAddress::GetPlanRunState() { return eStateRunning; }
 
-bool ThreadPlanRunToAddress::WillStop() { return true; }
-
 bool ThreadPlanRunToAddress::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (AtOurAddress()) {
     // Remove the breakpoint
     size_t num_break_ids = m_break_ids.size();
 
     for (size_t i = 0; i < num_break_ids; i++) {

lldb/source/Target/ThreadPlanStepInstruction.cpp

 }
 
 bool ThreadPlanStepInstruction::StopOthers() { return m_stop_other_threads; }
 
 StateType ThreadPlanStepInstruction::GetPlanRunState() {
   return eStateStepping;
 }
 
-bool ThreadPlanStepInstruction::WillStop() { return true; }
-
 bool ThreadPlanStepInstruction::MischiefManaged() {
   if (IsPlanComplete()) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     LLDB_LOGF(log, "Completed single instruction step plan.");
     ThreadPlan::MischiefManaged();
     return true;
   } else {
     return false;
   }
 }

lldb/source/Target/ThreadPlanStepOut.cpp

 //===-- ThreadPlanStepOut.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/ThreadPlanStepOut.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ABI.h"
bool ThreadPlanStepOut::DoWillResume(StateType resume_state,
   if (current_plan) {
     Breakpoint *return_bp = GetTarget().GetBreakpointByID(m_return_bp_id).get();
     if (return_bp != nullptr)
       return_bp->SetEnabled(true);
   }
   return true;
 }
 
-bool ThreadPlanStepOut::WillStop() {
+void ThreadPlanStepOut::WillStop() {
   if (m_return_bp_id != LLDB_INVALID_BREAK_ID) {
     Breakpoint *return_bp = GetTarget().GetBreakpointByID(m_return_bp_id).get();
     if (return_bp != nullptr)
       return_bp->SetEnabled(false);
   }
-
-  return true;
 }
 
 bool ThreadPlanStepOut::MischiefManaged() {
   if (IsPlanComplete()) {
     // Did I reach my breakpoint?  If so I'm done.
     //
     // I also check the stack depth, since if we've blown past the breakpoint
     // for some

lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

 //===-- ThreadPlanStepOverBreakpoint.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/ThreadPlanStepOverBreakpoint.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (current_plan) {
     if (bp_site_sp && bp_site_sp->IsEnabled()) {
       m_process.DisableBreakpointSite(bp_site_sp.get());
       m_reenabled_breakpoint_site = false;
     }
   }
   return true;
 }
 
-bool ThreadPlanStepOverBreakpoint::WillStop() {
+void ThreadPlanStepOverBreakpoint::WillStop() {
   ReenableBreakpointSite();
-  return true;
 }
 
 void ThreadPlanStepOverBreakpoint::WillPop() {
   ReenableBreakpointSite();
 }
 
 bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
   lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();

lldb/source/Target/ThreadPlanStepRange.cpp

LLDB_LOGF(log,
               "next range breakpoint which has %" PRIu64
               " owners - explains stop: %u.",
               (uint64_t)num_owners, explains_stop);
     ClearNextBranchBreakpoint();
     return explains_stop;
   }
 }
 
-bool ThreadPlanStepRange::WillStop() { return true; }
-
 StateType ThreadPlanStepRange::GetPlanRunState() {
   if (m_next_branch_bp_sp)
     return eStateRunning;
   else
     return eStateStepping;
 }
 
 bool ThreadPlanStepRange::MischiefManaged() {

lldb/source/Target/ThreadPlanStepThrough.cpp

 
 StateType ThreadPlanStepThrough::GetPlanRunState() { return eStateRunning; }
 
 bool ThreadPlanStepThrough::DoWillResume(StateType resume_state,
                                          bool current_plan) {
   return true;
 }
 
-bool ThreadPlanStepThrough::WillStop() { return true; }
-
 void ThreadPlanStepThrough::ClearBackstopBreakpoint() {
   if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
     m_process.GetTarget().RemoveBreakpointByID(m_backstop_bkpt_id);
     m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
     m_could_not_resolve_hw_bp = false;
   }
 }
 

lldb/source/Target/ThreadPlanStepUntil.cpp

 //===-- ThreadPlanStepUntil.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/ThreadPlanStepUntil.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
bool ThreadPlanStepUntil::DoWillResume(StateType resume_state,
   }
 
   m_should_stop = true;
   m_ran_analyze = false;
   m_explains_stop = false;
   return true;
 }
 
-bool ThreadPlanStepUntil::WillStop() {
+void ThreadPlanStepUntil::WillStop() {
   Target &target = GetTarget();
   Breakpoint *return_bp = target.GetBreakpointByID(m_return_bp_id).get();
   if (return_bp != nullptr)
     return_bp->SetEnabled(false);
 
   until_collection::iterator pos, end = m_until_points.end();
   for (pos = m_until_points.begin(); pos != end; pos++) {
     Breakpoint *until_bp = target.GetBreakpointByID((*pos).second).get();
     if (until_bp != nullptr)
       until_bp->SetEnabled(false);
   }
-  return true;
 }
 
 bool ThreadPlanStepUntil::MischiefManaged() {
   // I'm letting "PlanExplainsStop" do all the work, and just reporting that
   // here.
   bool done = false;
   if (IsPlanComplete()) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));