[lldb] Remove unused ThreadPlan tracer utilities (NFC)

[kastiglione]

Summary

Delete unused EnableTracer() and SetTracer() functions on Thread. By deleting
these, their ThreadPlan counterparts also become unused.

Then, by deleting ThreadPlanStack::EnableTracer, EnableSingleStep becomes unused.
With no more callers to EnableSingleStep, the value m_single_step is always true and
can be removed as well.

[jingham]

At some point I had the idea that there would be a whole plugin architecture where you could add observers on all the stops & steps the lldb's execution control did. But for lldb command line & SB API usages, the scripted thread plans add a more natural way to do this. We probably shouldn't take the tracers out altogether. I used them a couple of times (though admittedly pretty far back in the day) for debugging stepping issues. But we don't need the higher level bindings.

lldb/include/lldb/Target/Thread.h

public:
 
   virtual bool CheckpointThreadState(ThreadStateCheckpoint &saved_state);
 
   virtual bool
   RestoreRegisterStateFromCheckpoint(ThreadStateCheckpoint &saved_state);
 
   void RestoreThreadStateFromCheckpoint(ThreadStateCheckpoint &saved_state);
 
-  void EnableTracer(bool value, bool single_step);
-
-  void SetTracer(lldb::ThreadPlanTracerSP &tracer_sp);
-
   // Get the thread index ID. The index ID that is guaranteed to not be re-used
   // by a process. They start at 1 and increase with each new thread. This
   // allows easy command line access by a unique ID that is easier to type than
   // the actual system thread ID.
   uint32_t GetIndexID() const;
 
   // Get the originating thread's index ID.
   // In the case of an "extended" thread -- a thread which represents the stack

lldb/include/lldb/Target/ThreadPlanStack.h

public:
   size_t CheckpointCompletedPlans();
 
   void RestoreCompletedPlanCheckpoint(size_t checkpoint);
 
   void DiscardCompletedPlanCheckpoint(size_t checkpoint);
 
   void ThreadDestroyed(Thread *thread);
 
-  void EnableTracer(bool value, bool single_stepping);
-
-  void SetTracer(lldb::ThreadPlanTracerSP &tracer_sp);
-
   void PushPlan(lldb::ThreadPlanSP new_plan_sp);
 
   lldb::ThreadPlanSP PopPlan();
 
   lldb::ThreadPlanSP DiscardPlan();
 
   // If the input plan is nullptr, discard all plans.  Otherwise make sure this
   // plan is in the stack, and if so discard up to and including it.

lldb/include/lldb/Target/ThreadPlanTracer.h

bool EnableTracing(bool value) {
     else if (old_value == true && value == false)
       TracingEnded();
 
     return old_value;
   }
 
   bool TracingEnabled() { return m_enabled; }
 
-  bool EnableSingleStep(bool value) {
-    bool old_value = m_single_step;
-    m_single_step = value;
-    return old_value;
-  }
-
-  bool SingleStepEnabled() { return m_single_step; }
-  
   Thread &GetThread();
 
 protected:
   Process &m_process;
   lldb::tid_t m_tid;
 
   Stream *GetLogStream();
 
   virtual void Log();
 
 private:
   bool TracerExplainsStop();
 
-  bool m_single_step;
   bool m_enabled;
   lldb::StreamSP m_stream_sp;
   Thread *m_thread;
 };
 
 class ThreadPlanAssemblyTracer : public ThreadPlanTracer {
 public:
   ThreadPlanAssemblyTracer(Thread &thread, lldb::StreamSP &stream_sp);

lldb/source/Target/Thread.cpp

if (!thread_plan_sp->ValidatePlan(&s)) {
     thread_plan_sp.reset();
     status.SetErrorString(s.GetString());
     return status;
   }
 
   return status;
 }
 
-void Thread::EnableTracer(bool value, bool single_stepping) {
-  GetPlans().EnableTracer(value, single_stepping);
-}
-
-void Thread::SetTracer(lldb::ThreadPlanTracerSP &tracer_sp) {
-  GetPlans().SetTracer(tracer_sp);
-}
-
 bool Thread::DiscardUserThreadPlansUpToIndex(uint32_t plan_index) {
   // Count the user thread plans from the back end to get the number of the one
   // we want to discard:
 
   ThreadPlan *up_to_plan_ptr = GetPlans().GetPlanByIndex(plan_index).get();
   if (up_to_plan_ptr == nullptr)
     return false;
 

lldb/source/Target/ThreadPlan.cpp

 
 void ThreadPlan::WillPop() {}
 
 bool ThreadPlan::OkayToDiscard() {
   return IsMasterPlan() ? m_okay_to_discard : true;
 }
 
 lldb::StateType ThreadPlan::RunState() {
-  if (m_tracer_sp && m_tracer_sp->TracingEnabled() &&
-      m_tracer_sp->SingleStepEnabled())
+  if (m_tracer_sp && m_tracer_sp->TracingEnabled())
     return eStateStepping;
   else
     return GetPlanRunState();
 }
 
 bool ThreadPlan::IsUsuallyUnexplainedStopReason(lldb::StopReason reason) {
   switch (reason) {
   case eStopReasonWatchpoint:

lldb/source/Target/ThreadPlanStack.cpp

void ThreadPlanStack::ThreadDestroyed(Thread *thread) {
   // questions of a destroyed thread without checking first whether it is
   // destroyed, they won't crash.
   if (thread != nullptr) {
     lldb::ThreadPlanSP null_plan_sp(new ThreadPlanNull(*thread));
     m_plans.push_back(null_plan_sp);
   }
 }
 
-void ThreadPlanStack::EnableTracer(bool value, bool single_stepping) {
-  for (ThreadPlanSP plan : m_plans) {
-    if (plan->GetThreadPlanTracer()) {
-      plan->GetThreadPlanTracer()->EnableTracing(value);
-      plan->GetThreadPlanTracer()->EnableSingleStep(single_stepping);
-    }
-  }
-}
-
-void ThreadPlanStack::SetTracer(lldb::ThreadPlanTracerSP &tracer_sp) {
-  for (ThreadPlanSP plan : m_plans)
-    plan->SetThreadPlanTracer(tracer_sp);
-}
-
 void ThreadPlanStack::PushPlan(lldb::ThreadPlanSP new_plan_sp) {
   // If the thread plan doesn't already have a tracer, give it its parent's
   // tracer:
   // The first plan has to be a base plan:
   assert((m_plans.size() > 0 || new_plan_sp->IsBasePlan()) &&
          "Zeroth plan must be a base plan");
 
   if (!new_plan_sp->GetThreadPlanTracer()) {

lldb/source/Target/ThreadPlanTracer.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark ThreadPlanTracer
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp)
     : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
-      m_single_step(true), m_enabled(false), m_stream_sp(stream_sp) {}
+      m_enabled(false), m_stream_sp(stream_sp) {}
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread)
     : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
-      m_single_step(true), m_enabled(false), m_stream_sp() {}
+      m_enabled(false), m_stream_sp() {}
 
 Stream *ThreadPlanTracer::GetLogStream() {
   if (m_stream_sp)
     return m_stream_sp.get();
   else {
     TargetSP target_sp(GetThread().CalculateTarget());
     if (target_sp)
       return &(target_sp->GetDebugger().GetOutputStream());
if (stream) {
     GetThread().GetStackFrameAtIndex(0)->Dump(stream, show_frame_index,
                                               show_fullpaths);
     stream->Printf("\n");
     stream->Flush();
   }
 }
 
 bool ThreadPlanTracer::TracerExplainsStop() {
-  if (m_enabled && m_single_step) {
+  if (m_enabled) {
     lldb::StopInfoSP stop_info = GetThread().GetStopInfo();
     return (stop_info->GetStopReason() == eStopReasonTrace);
   } else
     return false;
 }
 
 #pragma mark ThreadPlanAssemblyTracer