[lldb] Remove ThreadPlan::ShouldAutoContinue (NFC)

[kastiglione]

Summary

Remove ShouldAutoContinue, implemented in only one subclass.

In ThreadPlanStepOverBreakpoint::ShouldAutoContinue, its return value will always be
the inverse of ShouldStop.

In the one call site of ShouldAutoContinue, its value only matters if ShouldStop is
also true. Since that can never be the case (as above, they'll always be opposite), this
function will never apply, and can be removed.

[kastiglione]

Even though the tests pass, I see that my logic was flawed. In theory, if autocontinue is true, and MischiefManaged returns true, then previous (parent) plans will be asked whether to ShouldStop. So the semantics of ShouldAutoContinue is whether a later plan wants to override should stop of an earlier plan.

lldb/include/lldb/Target/ThreadPlan.h

public:
   }
 
   lldb::StateType RunState();
 
   bool PlanExplainsStop(Event *event_ptr);
 
   virtual bool ShouldStop(Event *event_ptr) = 0;
 
-  virtual bool ShouldAutoContinue(Event *event_ptr) { return false; }
-
   // Whether a "stop class" event should be reported to the "outside world".
   // In general if a thread plan is active, events should not be reported.
 
   virtual Vote ShouldReportStop(Event *event_ptr);
 
   Vote ShouldReportRun(Event *event_ptr);
 
   virtual void SetStopOthers(bool new_value);

lldb/include/lldb/Target/ThreadPlanStepOverBreakpoint.h

public:
   bool ShouldStop(Event *event_ptr) override;
   bool StopOthers() override;
   lldb::StateType GetPlanRunState() 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; }
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 

lldb/source/Target/Thread.cpp

 //===-- Thread.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
if (current_plan->TracerExplainsStop()) {
 
           break;
         }
       }
     }
   }
 
   if (!done_processing_current_plan) {
-    bool over_ride_stop = current_plan->ShouldAutoContinue(event_ptr);
-
-    LLDB_LOGF(log, "Plan %s explains stop, auto-continue %i.",
-              current_plan->GetName(), over_ride_stop);
+    LLDB_LOGF(log, "Plan %s explains stop.", current_plan->GetName());
 
     // We're starting from the base plan, so just let it decide;
     if (current_plan->IsBasePlan()) {
       should_stop = current_plan->ShouldStop(event_ptr);
       LLDB_LOGF(log, "Base plan says should stop: %i.", should_stop);
     } else {
       // Otherwise, don't let the base plan override what the other plans say
       // to do, since presumably if there were other plans they would know what
if (current_plan->IsBasePlan()) {
               break;
             }
           }
         } else {
           break;
         }
       }
     }
-
-    if (over_ride_stop)
-      should_stop = false;
   }
 
   // One other potential problem is that we set up a master plan, then stop in
   // before it is complete - for instance by hitting a breakpoint during a
   // step-over - then do some step/finish/etc operations that wind up past the
   // end point condition of the initial plan.  We don't want to strand the
   // original plan on the stack, This code clears stale plans off the stack.
 

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;
switch (reason) {
       default:
         return false;
     }
   }
   return false;
 }
 
 bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) {
-  return !ShouldAutoContinue(event_ptr);
+  return !m_auto_continue;
 }
 
 bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; }
 
 StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
   return eStateStepping;
 }
 

 void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
   ReenableBreakpointSite();
 }
 
 void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
   m_auto_continue = do_it;
 }
 
-bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
-  return m_auto_continue;
-}
-
 bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
   return GetThread().GetRegisterContext()->GetPC() != m_breakpoint_addr;
 }