Revert "[lldb] Implement basic support for reverse-continue (#112079)"

This reverts commit b7b9ccf.

Author: labath

lldb/include/lldb/API/SBProcess.h

@@ -159,7 +159,6 @@ class LLDB_API SBProcess {
   lldb::SBError Destroy();
 
   lldb::SBError Continue();
-  lldb::SBError ContinueInDirection(lldb::RunDirection direction);
 
   lldb::SBError Stop();
 

lldb/include/lldb/Target/Process.h

@@ -1089,13 +1089,6 @@ class Process : public std::enable_shared_from_this<Process>,
   ///     Returns an error object.
   virtual Status WillResume() { return Status(); }
 
-  /// Reports whether this process supports reverse execution.
-  ///
-  /// \return
-  ///     Returns true if the process supports reverse execution (at least
-  /// under some circumstances).
-  virtual bool SupportsReverseDirection() { return false; }
-
   /// Resumes all of a process's threads as configured using the Thread run
   /// control functions.
   ///
@@ -1111,13 +1104,9 @@ class Process : public std::enable_shared_from_this<Process>,
   /// \see Thread:Resume()
   /// \see Thread:Step()
   /// \see Thread:Suspend()
-  virtual Status DoResume(lldb::RunDirection direction) {
-    if (direction == lldb::RunDirection::eRunForward)
-      return Status::FromErrorStringWithFormatv(
-          "error: {0} does not support resuming processes", GetPluginName());
+  virtual Status DoResume() {
     return Status::FromErrorStringWithFormatv(
-        "error: {0} does not support reverse execution of processes",
-        GetPluginName());
+        "error: {0} does not support resuming processes", GetPluginName());
   }
 
   /// Called after resuming a process.
@@ -2687,18 +2676,6 @@ void PruneThreadPlans();
                             const AddressRange &range, size_t alignment,
                             Status &error);
 
-  /// Get the base run direction for the process.
-  /// The base direction is the direction the process will execute in
-  /// (forward or backward) if no thread plan overrides the direction.
-  lldb::RunDirection GetBaseDirection() const { return m_base_direction; }
-  /// Set the base run direction for the process.
-  /// As a side-effect, if this changes the base direction, then we
-  /// discard all non-base thread plans to ensure that when execution resumes
-  /// we definitely execute in the requested direction.
-  /// FIXME: this is overkill. In some situations ensuring the latter
-  /// would not require discarding all non-base thread plans.
-  void SetBaseDirection(lldb::RunDirection direction);
-
 protected:
   friend class Trace;
 
@@ -3098,7 +3075,6 @@ void PruneThreadPlans();
   ThreadList
       m_extended_thread_list; ///< Constituent for extended threads that may be
                               /// generated, cleared on natural stops
-  lldb::RunDirection m_base_direction; ///< ThreadPlanBase run direction
   uint32_t m_extended_thread_stop_id; ///< The natural stop id when
                                       ///extended_thread_list was last updated
   QueueList

lldb/include/lldb/Target/StopInfo.h

@@ -20,7 +20,6 @@ namespace lldb_private {
 class StopInfo : public std::enable_shared_from_this<StopInfo> {
   friend class Process::ProcessEventData;
   friend class ThreadPlanBase;
-  friend class ThreadPlanReverseContinue;
 
 public:
   // Constructors and Destructors
@@ -155,12 +154,6 @@ class StopInfo : public std::enable_shared_from_this<StopInfo> {
   static lldb::StopInfoSP
   CreateStopReasonProcessorTrace(Thread &thread, const char *description);
 
-  // This creates a StopInfo indicating that execution stopped because
-  // it was replaying some recorded execution history, and execution reached
-  // the end of that recorded history.
-  static lldb::StopInfoSP
-  CreateStopReasonHistoryBoundary(Thread &thread, const char *description);
-
   static lldb::StopInfoSP CreateStopReasonFork(Thread &thread,
                                                lldb::pid_t child_pid,
                                                lldb::tid_t child_tid);

lldb/include/lldb/Target/Thread.h

@@ -200,13 +200,14 @@ class Thread : public std::enable_shared_from_this<Thread>,
   ///    The User resume state for this thread.
   lldb::StateType GetResumeState() const { return m_resume_state; }
 
-  // This function is called to determine whether the thread needs to
-  // step over a breakpoint and if so, push a step-over-breakpoint thread
-  // plan.
+  /// This function is called on all the threads before "ShouldResume" and
+  /// "WillResume" in case a thread needs to change its state before the
+  /// ThreadList polls all the threads to figure out which ones actually will
+  /// get to run and how.
   ///
   /// \return
   ///    True if we pushed a ThreadPlanStepOverBreakpoint
-  bool SetupToStepOverBreakpointIfNeeded(lldb::RunDirection direction);
+  bool SetupForResume();
 
   // Do not override this function, it is for thread plan logic only
   bool ShouldResume(lldb::StateType resume_state);

lldb/include/lldb/Target/ThreadList.h

@@ -115,18 +115,14 @@ class ThreadList : public ThreadCollection {
   /// If a thread can "resume" without having to resume the target, it
   /// will return false for WillResume, and then the process will not be
   /// restarted.
-  /// Sets *direction to the run direction of the thread(s) that will
-  /// be resumed. If threads that we want to run disagree about the
-  /// direction, we execute forwards and pop any of the thread plans
-  /// that requested reverse execution.
   ///
   /// \return
   ///    \b true instructs the process to resume normally,
   ///    \b false means start & stopped events will be generated, but
   ///    the process will not actually run.  The thread must then return
   ///    the correct StopInfo when asked.
   ///
-  bool WillResume(lldb::RunDirection &direction);
+  bool WillResume();
 
   void DidResume();
 

lldb/include/lldb/Target/ThreadPlan.h

@@ -283,15 +283,6 @@ namespace lldb_private {
 //  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.
-//
-//  Reverse execution:
-//
-//  Every thread plan has an associated RunDirection (forward or backward).
-//  For ThreadPlanBase, this direction is the Process's base direction.
-//  Whenever we resume the target, we need to ensure that the topmost thread
-//  plans for each runnable thread all agree on their direction. This is
-//  ensured in ThreadList::WillResume(), which chooses a direction and then
-//  discards thread plans incompatible with that direction.
 
 class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
                    public UserID {
@@ -506,10 +497,6 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
 
   virtual lldb::StateType GetPlanRunState() = 0;
 
-  virtual lldb::RunDirection GetDirection() const {
-    return lldb::RunDirection::eRunForward;
-  }
-
 protected:
   // Constructors and Destructors
   ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,

lldb/include/lldb/Target/ThreadPlanBase.h

@@ -38,8 +38,6 @@ class ThreadPlanBase : public ThreadPlan {
 
   bool IsBasePlan() override { return true; }
 
-  lldb::RunDirection GetDirection() const override;
-
 protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
   bool DoPlanExplainsStop(Event *event_ptr) override;

lldb/include/lldb/lldb-enumerations.h

@@ -135,9 +135,6 @@ FLAGS_ENUM(LaunchFlags){
 /// Thread Run Modes.
 enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
 
-/// Execution directions
-enum RunDirection { eRunForward, eRunReverse };
-
 /// Byte ordering definitions.
 enum ByteOrder {
   eByteOrderInvalid = 0,
@@ -257,9 +254,6 @@ enum StopReason {
   eStopReasonVFork,
   eStopReasonVForkDone,
   eStopReasonInterrupt, ///< Thread requested interrupt
-  // Indicates that execution stopped because the debugger backend relies
-  // on recorded data and we reached the end of that data.
-  eStopReasonHistoryBoundary,
 };
 
 /// Command Return Status Types.

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

@@ -510,9 +510,8 @@ def start(self):
         self._thread.start()
 
     def stop(self):
-        if self._thread is not None:
-            self._thread.join()
-            self._thread = None
+        self._thread.join()
+        self._thread = None
 
     def get_connect_address(self):
         return self._socket.get_connect_address()