[lldb] Minor refinements to ThreadPlan::RestoreThreadState (NFC)

[kastiglione]

Summary

Correct RestoreThreadState to a void return type. Also, update the signature of its
callee, Thread::RestoreThreadStateFromCheckpoint, by updating it to a void return
type, and making it non-virtual.

[jingham]

It is possible that the stub could fail to restore the checkpointed state, though apparently it either never has or never has mattered because no one if setting or checking the bool return. If this does end up failing we should plumb a Status through, since bool is too low information to be useful. This is fine for now.

lldb/include/lldb/Target/Thread.h

public:
   ///    otherwise.
   bool DiscardUserThreadPlansUpToIndex(uint32_t thread_index);
 
   virtual bool CheckpointThreadState(ThreadStateCheckpoint &saved_state);
 
   virtual bool
   RestoreRegisterStateFromCheckpoint(ThreadStateCheckpoint &saved_state);
 
-  virtual bool
-  RestoreThreadStateFromCheckpoint(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

lldb/include/lldb/Target/ThreadPlan.h

public:
   virtual lldb::ExpressionVariableSP GetExpressionVariable() {
     return lldb::ExpressionVariableSP();
   }
 
   // If a thread plan stores the state before it was run, then you might want
   // to restore the state when it is done.  This will do that job. This is
   // mostly useful for artificial plans like CallFunction plans.
 
-  virtual bool RestoreThreadState() {
-    // Nothing to do in general.
-    return true;
-  }
+  virtual void RestoreThreadState() {}
 
   virtual bool IsVirtualStep() { return false; }
 
   bool SetIterationCount(size_t count) {
     if (m_takes_iteration_count) {
       // Don't tell me to do something 0 times...
       if (count == 0)
         return false;

lldb/include/lldb/Target/ThreadPlanCallFunction.h

lldb::StopInfoSP GetRealStopInfo() override {
     if (m_real_stop_info_sp)
       return m_real_stop_info_sp;
     else
       return GetPrivateStopInfo();
   }
 
   lldb::addr_t GetStopAddress() { return m_stop_address; }
 
-  bool RestoreThreadState() override;
+  void RestoreThreadState() override;
 
   void ThreadDestroyed() override { m_takedown_done = true; }
 
   void SetStopOthers(bool new_value) override;
 
 protected:
   void ReportRegisterState(const char *message);
 

lldb/source/Target/Thread.cpp

if (frame_sp) {
           m_unwinder_up->Clear();
         return ret;
       }
     }
   }
   return false;
 }
 
-bool Thread::RestoreThreadStateFromCheckpoint(
+void Thread::RestoreThreadStateFromCheckpoint(
     ThreadStateCheckpoint &saved_state) {
   if (saved_state.stop_info_sp)
     saved_state.stop_info_sp->MakeStopInfoValid();
   SetStopInfo(saved_state.stop_info_sp);
   GetStackFrameList()->SetCurrentInlinedDepth(
       saved_state.current_inlined_depth);
   GetPlans().RestoreCompletedPlanCheckpoint(
       saved_state.m_completed_plan_checkpoint);
-  return true;
 }
 
 StateType Thread::GetState() const {
   // If any other threads access this we will need a mutex for it
   std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
   return m_state;
 }
 

lldb/source/Target/ThreadPlanCallFunction.cpp

bool ThreadPlanCallFunction::BreakpointsExplainStop() {
 
   return false;
 }
 
 void ThreadPlanCallFunction::SetStopOthers(bool new_value) {
   m_subplan_sp->SetStopOthers(new_value);
 }
 
-bool ThreadPlanCallFunction::RestoreThreadState() {
-  return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state);
+void ThreadPlanCallFunction::RestoreThreadState() {
+  GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state);
 }
 
 void ThreadPlanCallFunction::SetReturnValue() {
   const ABI *abi = m_process.GetABI().get();
   if (abi && m_return_type.IsValid()) {
     const bool persistent = false;
     m_return_valobj_sp =
         abi->GetReturnValueObject(GetThread(), m_return_type, persistent);
   }
 }