[lldb] Rename {stop,run}_vote to report_{stop,run}_vote (NFC)

[kastiglione]

Summary

Rename stop_vote and run_vote to report_stop_vote and report_run_vote
respectively. These variables are limited to logic involving (event) reporting only.
This naming is intended to make their context more clear.

[jingham]

Sure, that's clearer.

lldb/include/lldb/Target/Thread.h

public:
   //   FIXME: Currently unused.
   ///
   /// \param[in] first_insn
   ///     \b true if this is the first instruction of a function.
   ///
   /// \param[in] stop_other_threads
   ///    \b true if we will stop other threads while we single step this one.
   ///
-  /// \param[in] stop_vote
+  /// \param[in] report_stop_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
-  /// \param[in] run_vote
+  /// \param[in] report_run_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
   /// \param[out] status
   ///     A status with an error if queuing failed.
   ///
   /// \param[in] step_out_avoids_code_without_debug_info
   ///    If eLazyBoolYes, if the step over steps out it will continue to step
   ///    out till it comes to a frame with debug info.
   ///    If eLazyBoolCalculate, it will consult the default set in the thread.
   ///
   /// \return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOut(
       bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_other_threads, Vote stop_vote, Vote run_vote,
+      bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote,
       uint32_t frame_idx, Status &status,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   /// Queue the plan used to step out of the function at the current PC of
   /// a thread.  This version does not consult the should stop here callback,
   /// and should only
   /// be used by other thread plans when they need to retain control of the step
   /// out.
public:
   //   FIXME: Currently unused.
   ///
   /// \param[in] first_insn
   ///     \b true if this is the first instruction of a function.
   ///
   /// \param[in] stop_other_threads
   ///    \b true if we will stop other threads while we single step this one.
   ///
-  /// \param[in] stop_vote
+  /// \param[in] report_stop_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
-  /// \param[in] run_vote
+  /// \param[in] report_run_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
   /// \param[in] frame_idx
   ///     The fame index.
   ///
   /// \param[out] status
   ///     A status with an error if queuing failed.
   ///
public:
   ///    registers which are overwritten
   ///    before the next branch instruction.
   ///
   /// \return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOutNoShouldStop(
       bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_other_threads, Vote stop_vote, Vote run_vote,
+      bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote,
       uint32_t frame_idx, Status &status, bool continue_to_next_branch = false);
 
   /// Gets the plan used to step through the code that steps from a function
   /// call site at the current PC into the actual function call.
   ///
   /// \param[in] return_stack_id
   ///    The stack id that we will return to (by setting backstop breakpoints on
   ///    the return

lldb/include/lldb/Target/ThreadPlan.h

 //  thread list will decide what to do (at present it will pretty much always
 //  suppress these stopped events.) If there is an eVoteYes, then the event
 //  will be reported regardless of the other votes.  If there is an eVoteNo and
 //  no eVoteYes's, then the event won't be reported.
 //
 //  One other little detail here, sometimes a plan will push another plan onto
 //  the plan stack to do some part of the first plan's job, and it would be
 //  convenient to tell that plan how it should respond to ShouldReportStop.
-//  You can do that by setting the stop_vote in the child plan when you create
-//  it.
+//  You can do that by setting the report_stop_vote in the child plan when you
+//  create it.
 //
 //  Suppressing the initial eStateRunning event:
 //
 //  The private process running thread will take care of ensuring that only one
 //  "eStateRunning" event will be delivered to the public Process broadcaster
 //  per public eStateStopped event.  However there are some cases where the
 //  public state of this process is eStateStopped, but a thread plan needs to
 //  restart the target, but doesn't want the running event to be publicly
 //  broadcast.  The obvious example of this is running functions by hand as
 //  part of expression evaluation.  To suppress the running event return
 //  eVoteNo from ShouldReportStop, to force a running event to be reported
 //  return eVoteYes, in general though you should return eVoteNoOpinion which
 //  will allow the ThreadList to figure out the right thing to do.  The
-//  run_vote argument to the constructor works like stop_vote, and is a way for
-//  a plan to instruct a sub-plan on how to respond to ShouldReportStop.
+//  report_run_vote argument to the constructor works like report_stop_vote, and
+//  is a way for a plan to instruct a sub-plan on how to respond to
+//  ShouldReportStop.
 
 class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
                    public UserID {
 public:
   // We use these enums so that we can cast a base thread plan to it's real
   // type without having to resort to dynamic casting.
   enum ThreadPlanKind {
     eKindGeneric,
if (m_takes_iteration_count) {
       m_iteration_count = count;
     }
     return m_takes_iteration_count;
   }
 
 protected:
   // Constructors and Destructors
   ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
-             Vote stop_vote, Vote run_vote);
+             Vote report_stop_vote, Vote report_run_vote);
 
   // Classes that inherit from ThreadPlan can see and modify these
 
   virtual bool DoWillResume(lldb::StateType resume_state, bool current_plan) {
     return true;
   }
 
   virtual bool DoPlanExplainsStop(Event *event_ptr) = 0;
protected:
 
   virtual lldb::StateType GetPlanRunState() = 0;
 
   bool IsUsuallyUnexplainedStopReason(lldb::StopReason);
 
   Status m_status;
   Process &m_process;
   lldb::tid_t m_tid;
-  Vote m_stop_vote;
-  Vote m_run_vote;
+  Vote m_report_stop_vote;
+  Vote m_report_run_vote;
   bool m_takes_iteration_count;
   bool m_could_not_resolve_hw_bp;
   int32_t m_iteration_count = 1;
 
 private:
   void CachePlanExplainsStop(bool does_explain) {
     m_cached_plan_explains_stop = does_explain ? eLazyBoolYes : eLazyBoolNo;
   }

lldb/include/lldb/Target/ThreadPlanStepInstruction.h

 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepInstruction : public ThreadPlan {
 public:
   ThreadPlanStepInstruction(Thread &thread, bool step_over, bool stop_others,
-                            Vote stop_vote, Vote run_vote);
+                            Vote report_stop_vote, Vote report_run_vote);
 
   ~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;

lldb/include/lldb/Target/ThreadPlanStepOut.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,
+                    bool first_insn, bool stop_others, Vote report_stop_vote,
+                    Vote report_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;
private:
   Function *m_immediate_step_from_function;
   std::vector<lldb::StackFrameSP> m_stepped_past_frames;
   lldb::ValueObjectSP m_return_valobj_sp;
   bool m_calculate_return_value;
   StreamString m_constructor_errors;
 
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepOut(
       bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_others, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-      Status &status, LazyBool step_out_avoids_code_without_debug_info);
+      bool stop_others, Vote report_stop_vote, Vote report_run_vote,
+      uint32_t frame_idx, Status &status,
+      LazyBool step_out_avoids_code_without_debug_info);
 
   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
   // Need an appropriate marker for the current stack so we can tell step out
   // from step in.
 
   void CalculateReturnValue();
 
   ThreadPlanStepOut(const ThreadPlanStepOut &) = delete;
   const ThreadPlanStepOut &operator=(const ThreadPlanStepOut &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPOUT_H

lldb/source/Target/Process.cpp

if (ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
       // It makes no sense to ask "ShouldStop" if we've already been
       // restarted... Asking the thread list is also not likely to go well,
       // since we are running again. So in that case just report the event.
 
       if (!was_restarted)
         should_resume = !m_thread_list.ShouldStop(event_ptr);
 
       if (was_restarted || should_resume || m_resume_requested) {
-        Vote stop_vote = m_thread_list.ShouldReportStop(event_ptr);
+        Vote report_stop_vote = m_thread_list.ShouldReportStop(event_ptr);
         LLDB_LOGF(log,
                   "Process::ShouldBroadcastEvent: should_resume: %i state: "
-                  "%s was_restarted: %i stop_vote: %d.",
+                  "%s was_restarted: %i report_stop_vote: %d.",
                   should_resume, StateAsCString(state), was_restarted,
-                  stop_vote);
+                  report_stop_vote);
 
-        switch (stop_vote) {
+        switch (report_stop_vote) {
         case eVoteYes:
           return_value = true;
           break;
         case eVoteNoOpinion:
         case eVoteNo:
           return_value = false;
           break;
         }

lldb/source/Target/Thread.cpp

return QueueThreadPlanForStepInRange(
       line_entry.GetSameLineContiguousAddressRange(include_inlined_functions),
       addr_context, step_in_target, stop_other_threads, status,
       step_in_avoids_code_without_debug_info,
       step_out_avoids_code_without_debug_info);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOut(
     bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-    bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-    Status &status, LazyBool step_out_avoids_code_without_debug_info) {
+    bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote,
+    uint32_t frame_idx, Status &status,
+    LazyBool step_out_avoids_code_without_debug_info) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
-      *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
-      frame_idx, step_out_avoids_code_without_debug_info));
+      *this, addr_context, first_insn, stop_other_threads, report_stop_vote,
+      report_run_vote, frame_idx, step_out_avoids_code_without_debug_info));
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOutNoShouldStop(
     bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-    bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-    Status &status, bool continue_to_next_branch) {
+    bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote,
+    uint32_t frame_idx, Status &status, bool continue_to_next_branch) {
   const bool calculate_return_value =
       false; // No need to calculate the return value here.
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
-      *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
-      frame_idx, eLazyBoolNo, continue_to_next_branch, calculate_return_value));
+      *this, addr_context, first_insn, stop_other_threads, report_stop_vote,
+      report_run_vote, frame_idx, eLazyBoolNo, continue_to_next_branch,
+      calculate_return_value));
 
   ThreadPlanStepOut *new_plan =
       static_cast<ThreadPlanStepOut *>(thread_plan_sp.get());
   new_plan->ClearShouldStopHereCallbacks();
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }

lldb/source/Target/ThreadPlan.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlan constructor
 ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
-                       Vote stop_vote, Vote run_vote)
+                       Vote report_stop_vote, Vote report_run_vote)
     : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
-      m_stop_vote(stop_vote), m_run_vote(run_vote),
+      m_report_stop_vote(report_stop_vote), m_report_run_vote(report_run_vote),
       m_takes_iteration_count(false), m_could_not_resolve_hw_bp(false),
       m_thread(&thread), m_kind(kind), m_name(name), m_plan_complete_mutex(),
       m_cached_plan_explains_stop(eLazyBoolCalculate), m_plan_complete(false),
       m_plan_private(false), m_okay_to_discard(true), m_is_master_plan(false),
       m_plan_succeeded(true) {
   SetID(GetNextID());
 }
 
bool ThreadPlan::MischiefManaged() {
   // Mark the plan is complete, but don't override the success flag.
   m_plan_complete = true;
   return true;
 }
 
 Vote ThreadPlan::ShouldReportStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
-  if (m_stop_vote == eVoteNoOpinion) {
+  if (m_report_stop_vote == eVoteNoOpinion) {
     ThreadPlan *prev_plan = GetPreviousPlan();
     if (prev_plan) {
       Vote prev_vote = prev_plan->ShouldReportStop(event_ptr);
       LLDB_LOG(log, "returning previous thread plan vote: {0}", prev_vote);
       return prev_vote;
     }
   }
-  LLDB_LOG(log, "Returning vote: {0}", m_stop_vote);
-  return m_stop_vote;
+  LLDB_LOG(log, "Returning vote: {0}", m_report_stop_vote);
+  return m_report_stop_vote;
 }
 
 Vote ThreadPlan::ShouldReportRun(Event *event_ptr) {
-  if (m_run_vote == eVoteNoOpinion) {
+  if (m_report_run_vote == eVoteNoOpinion) {
     ThreadPlan *prev_plan = GetPreviousPlan();
     if (prev_plan)
       return prev_plan->ShouldReportRun(event_ptr);
   }
-  return m_run_vote;
+  return m_report_run_vote;
 }
 
 void ThreadPlan::ClearThreadCache() { m_thread = nullptr; }
 
 bool ThreadPlan::StopOthers() {
   ThreadPlan *prev_plan;
   prev_plan = GetPreviousPlan();
   return (prev_plan == nullptr) ? false : prev_plan->StopOthers();

lldb/source/Target/ThreadPlanBase.cpp

if (should_notify)
       return eVoteYes;
     else
       return eVoteNoOpinion;
   } else
     return eVoteNoOpinion;
 }
 
 bool ThreadPlanBase::ShouldStop(Event *event_ptr) {
-  m_stop_vote = eVoteYes;
-  m_run_vote = eVoteYes;
+  m_report_stop_vote = eVoteYes;
+  m_report_run_vote = eVoteYes;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
   if (stop_info_sp) {
     StopReason reason = stop_info_sp->GetStopReason();
     switch (reason) {
     case eStopReasonInvalid:
     case eStopReasonNone:
       // This
-      m_run_vote = eVoteNoOpinion;
-      m_stop_vote = eVoteNo;
+      m_report_run_vote = eVoteNoOpinion;
+      m_report_stop_vote = eVoteNo;
       return false;
 
     case eStopReasonBreakpoint:
     case eStopReasonWatchpoint:
       if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
         // If we are going to stop for a breakpoint, then unship the other
         // plans at this point.  Don't force the discard, however, so Master
         // plans can stay in place if they want to.
         LLDB_LOGF(
             log,
             "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
             " (breakpoint hit.)",
             m_tid);
         GetThread().DiscardThreadPlans(false);
         return true;
       }
       // If we aren't going to stop at this breakpoint, and it is internal,
       // don't report this stop or the subsequent running event. Otherwise we
       // will post the stopped & running, but the stopped event will get marked
       // with "restarted" so the UI will know to wait and expect the consequent
       // "running".
       if (stop_info_sp->ShouldNotify(event_ptr)) {
-        m_stop_vote = eVoteYes;
-        m_run_vote = eVoteYes;
+        m_report_stop_vote = eVoteYes;
+        m_report_run_vote = eVoteYes;
       } else {
-        m_stop_vote = eVoteNo;
-        m_run_vote = eVoteNo;
+        m_report_stop_vote = eVoteNo;
+        m_report_run_vote = eVoteNo;
       }
       return false;
 
       // TODO: the break below was missing, was this intentional??? If so
       // please mention it
       break;
 
     case eStopReasonException:
case eStopReasonSignal:
             " (signal: %s)", 
             m_tid, stop_info_sp->GetDescription());
         GetThread().DiscardThreadPlans(false);
         return true;
       } else {
         // We're not going to stop, but while we are here, let's figure out
         // whether to report this.
         if (stop_info_sp->ShouldNotify(event_ptr))
-          m_stop_vote = eVoteYes;
+          m_report_stop_vote = eVoteYes;
         else
-          m_stop_vote = eVoteNo;
+          m_report_stop_vote = eVoteNo;
       }
       return false;
 
     default:
       return true;
     }
 
   } else {
-    m_run_vote = eVoteNoOpinion;
-    m_stop_vote = eVoteNo;
+    m_report_run_vote = eVoteNoOpinion;
+    m_report_stop_vote = eVoteNo;
   }
 
   // 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;
+  m_report_run_vote = eVoteNoOpinion;
+  m_report_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/ThreadPlanStepInstruction.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlanStepInstruction: Step over the current instruction
 
 ThreadPlanStepInstruction::ThreadPlanStepInstruction(Thread &thread,
                                                      bool step_over,
                                                      bool stop_other_threads,
-                                                     Vote stop_vote,
-                                                     Vote run_vote)
+                                                     Vote report_stop_vote,
+                                                     Vote report_run_vote)
     : ThreadPlan(ThreadPlan::eKindStepInstruction,
-                 "Step over single instruction", thread, stop_vote, run_vote),
+                 "Step over single instruction", thread, report_stop_vote,
+                 report_run_vote),
       m_instruction_addr(0), m_stop_other_threads(stop_other_threads),
       m_step_over(step_over) {
   m_takes_iteration_count = true;
   SetUpState();
 }
 
 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
 

lldb/source/Target/ThreadPlanStepOut.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 uint32_t ThreadPlanStepOut::s_default_flag_values = 0;
 
 // ThreadPlanStepOut: Step out of the current frame
 ThreadPlanStepOut::ThreadPlanStepOut(
     Thread &thread, SymbolContext *context, bool first_insn, bool stop_others,
-    Vote stop_vote, Vote run_vote, uint32_t frame_idx,
+    Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx,
     LazyBool step_out_avoids_code_without_debug_info,
     bool continue_to_next_branch, bool gather_return_value)
-    : ThreadPlan(ThreadPlan::eKindStepOut, "Step out", thread, stop_vote,
-                 run_vote),
+    : ThreadPlan(ThreadPlan::eKindStepOut, "Step out", thread, report_stop_vote,
+                 report_run_vote),
       ThreadPlanShouldStopHere(this), m_step_from_insn(LLDB_INVALID_ADDRESS),
       m_return_bp_id(LLDB_INVALID_BREAK_ID),
       m_return_addr(LLDB_INVALID_ADDRESS), m_stop_others(stop_others),
       m_immediate_step_from_function(nullptr),
       m_calculate_return_value(gather_return_value) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   SetFlagsToDefault();
   SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);