[Lldb-commits] [lldb] r303740 - Revert "RunThreadPlan: Fix halting logic in IgnoreBreakpoints = false"

Pavel Labath via lldb-commits lldb-commits at lists.llvm.org
Wed May 24 04:57:29 PDT 2017


Author: labath
Date: Wed May 24 06:57:28 2017
New Revision: 303740

URL: http://llvm.org/viewvc/llvm-project?rev=303740&view=rev
Log:
Revert "RunThreadPlan: Fix halting logic in IgnoreBreakpoints = false"

This reverts commit r303732, as it introduces a regression in
TestLoadUnload on android.

Modified:
    lldb/trunk/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py
    lldb/trunk/source/Target/Process.cpp

Modified: lldb/trunk/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py?rev=303740&r1=303739&r2=303740&view=diff
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py (original)
+++ lldb/trunk/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py Wed May 24 06:57:28 2017
@@ -57,27 +57,19 @@ class UnwindFromExpressionTest(TestBase)
         self.assertIsNotNone(
             thread, "Expected one thread to be stopped at the breakpoint")
 
-        # Next set a breakpoint in this function, set up Expression options to stop on
-        # breakpoint hits, and call the function.
-        fun_bkpt = target.BreakpointCreateBySourceRegex(
-            "// Stop inside the function here.", main_spec)
-        self.assertTrue(fun_bkpt, VALID_BREAKPOINT)
-
-        # Run test with varying one thread timeouts to also test the halting
-        # logic in the IgnoreBreakpoints = False case
-        self.do_test(thread, fun_bkpt, 1000)
-        self.do_test(thread, fun_bkpt, 100000)
-
-    def do_test(self, thread, bkpt, timeout):
         #
         # Use Python API to evaluate expressions while stopped in a stack frame.
         #
         main_frame = thread.GetFrameAtIndex(0)
 
+        # Next set a breakpoint in this function, set up Expression options to stop on
+        # breakpoint hits, and call the function.
+        fun_bkpt = target.BreakpointCreateBySourceRegex(
+            "// Stop inside the function here.", main_spec)
+        self.assertTrue(fun_bkpt, VALID_BREAKPOINT)
         options = lldb.SBExpressionOptions()
         options.SetIgnoreBreakpoints(False)
         options.SetUnwindOnError(False)
-        options.SetOneThreadTimeoutInMicroSeconds(timeout)
 
         val = main_frame.EvaluateExpression("a_function_to_call()", options)
 
@@ -90,7 +82,7 @@ class UnwindFromExpressionTest(TestBase)
             "And the reason was right.")
 
         thread = lldbutil.get_one_thread_stopped_at_breakpoint(
-            self.process(), bkpt)
+            process, fun_bkpt)
         self.assertTrue(
             thread.IsValid(),
             "We are indeed stopped at our breakpoint")

Modified: lldb/trunk/source/Target/Process.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=303740&r1=303739&r2=303740&view=diff
==============================================================================
--- lldb/trunk/source/Target/Process.cpp (original)
+++ lldb/trunk/source/Target/Process.cpp Wed May 24 06:57:28 2017
@@ -4823,47 +4823,6 @@ GetExpressionTimeout(const EvaluateExpre
     return *options.GetTimeout() - GetOneThreadExpressionTimeout(options);
 }
 
-static llvm::Optional<ExpressionResults>
-HandleStoppedEvent(Thread &thread, const ThreadPlanSP &thread_plan_sp,
-                   RestorePlanState &restorer, const EventSP &event_sp,
-                   EventSP &event_to_broadcast_sp,
-                   const EvaluateExpressionOptions &options, bool handle_interrupts) {
-  Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS);
-
-  ThreadPlanSP plan = thread.GetCompletedPlan();
-  if (plan == thread_plan_sp && plan->PlanSucceeded()) {
-    LLDB_LOG(log, "execution completed successfully");
-
-    // Restore the plan state so it will get reported as intended when we are
-    // done.
-    restorer.Clean();
-    return eExpressionCompleted;
-  }
-
-  StopInfoSP stop_info_sp = thread.GetStopInfo();
-  if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint) {
-    LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
-    if (!options.DoesIgnoreBreakpoints()) {
-      // Restore the plan state and then force Private to false.  We are going
-      // to stop because of this plan so we need it to become a public plan or
-      // it won't report correctly when we continue to its termination later on.
-      restorer.Clean();
-      thread_plan_sp->SetPrivate(false);
-      event_to_broadcast_sp = event_sp;
-    }
-    return eExpressionHitBreakpoint;
-  }
-
-  if (!handle_interrupts &&
-      Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
-    return llvm::None;
-
-  LLDB_LOG(log, "thread plan did not successfully complete");
-  if (!options.DoesUnwindOnError())
-    event_to_broadcast_sp = event_sp;
-  return eExpressionInterrupted;
-}
-
 ExpressionResults
 Process::RunThreadPlan(ExecutionContext &exe_ctx,
                        lldb::ThreadPlanSP &thread_plan_sp,
@@ -5269,22 +5228,65 @@ Process::RunThreadPlan(ExecutionContext
                               "but our thread (index-id=%u) has vanished.",
                               thread_idx_id);
                 return_value = eExpressionInterrupted;
-              } else if (Process::ProcessEventData::GetRestartedFromEvent(
-                             event_sp.get())) {
+              } else {
                 // If we were restarted, we just need to go back up to fetch
                 // another event.
-                if (log) {
-                  log->Printf("Process::RunThreadPlan(): Got a stop and "
-                              "restart, so we'll continue waiting.");
+                if (Process::ProcessEventData::GetRestartedFromEvent(
+                        event_sp.get())) {
+                  if (log) {
+                    log->Printf("Process::RunThreadPlan(): Got a stop and "
+                                "restart, so we'll continue waiting.");
+                  }
+                  keep_going = true;
+                  do_resume = false;
+                  handle_running_event = true;
+                } else {
+                  ThreadPlanSP plan = thread->GetCompletedPlan();
+                  if (plan == thread_plan_sp && plan->PlanSucceeded()) {
+
+                    if (log)
+                      log->PutCString("Process::RunThreadPlan(): execution "
+                                      "completed successfully.");
+
+                    // Restore the plan state so it will get reported as
+                    // intended when we are done.
+                    thread_plan_restorer.Clean();
+
+                    return_value = eExpressionCompleted;
+                  } else {
+                    StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
+                    // Something restarted the target, so just wait for it to
+                    // stop for real.
+                    if (stop_info_sp &&
+                        stop_info_sp->GetStopReason() == eStopReasonBreakpoint) {
+                      if (log)
+                        log->Printf("Process::RunThreadPlan() stopped for "
+                                    "breakpoint: %s.",
+                                    stop_info_sp->GetDescription());
+                      return_value = eExpressionHitBreakpoint;
+                      if (!options.DoesIgnoreBreakpoints()) {
+                        // Restore the plan state and then force Private to
+                        // false.  We are
+                        // going to stop because of this plan so we need it to
+                        // become a public
+                        // plan or it won't report correctly when we continue to
+                        // its termination
+                        // later on.
+                        thread_plan_restorer.Clean();
+                        if (thread_plan_sp)
+                          thread_plan_sp->SetPrivate(false);
+                        event_to_broadcast_sp = event_sp;
+                      }
+                    } else {
+                      if (log)
+                        log->PutCString("Process::RunThreadPlan(): thread plan "
+                                        "didn't successfully complete.");
+                      if (!options.DoesUnwindOnError())
+                        event_to_broadcast_sp = event_sp;
+                      return_value = eExpressionInterrupted;
+                    }
+                  }
                 }
-                keep_going = true;
-                do_resume = false;
-                handle_running_event = true;
-              } else {
-                const bool handle_interrupts = true;
-                return_value = *HandleStoppedEvent(
-                    *thread, thread_plan_sp, thread_plan_restorer, event_sp,
-                    event_to_broadcast_sp, options, handle_interrupts);
               }
             } break;
 
@@ -5390,6 +5392,20 @@ Process::RunThreadPlan(ExecutionContext
               }
 
               if (stop_state == lldb::eStateStopped) {
+                // Between the time we initiated the Halt and the time we
+                // delivered it, the process could have
+                // already finished its job.  Check that here:
+
+                if (thread->IsThreadPlanDone(thread_plan_sp.get())) {
+                  if (log)
+                    log->PutCString("Process::RunThreadPlan(): Even though we "
+                                    "timed out, the call plan was done.  "
+                                    "Exiting wait loop.");
+                  return_value = eExpressionCompleted;
+                  back_to_top = false;
+                  break;
+                }
+
                 if (Process::ProcessEventData::GetRestartedFromEvent(
                         event_sp.get())) {
                   if (log)
@@ -5403,18 +5419,6 @@ Process::RunThreadPlan(ExecutionContext
                   continue;
                 }
 
-                // Between the time we initiated the Halt and the time we
-                // delivered it, the process could have
-                // already finished its job.  Check that here:
-                const bool handle_interrupts = false;
-                if (auto result = HandleStoppedEvent(
-                        *thread, thread_plan_sp, thread_plan_restorer, event_sp,
-                        event_to_broadcast_sp, options, handle_interrupts)) {
-                  return_value = *result;
-                  back_to_top = false;
-                  break;
-                }
-
                 if (!options.GetTryAllThreads()) {
                   if (log)
                     log->PutCString("Process::RunThreadPlan(): try_all_threads "




More information about the lldb-commits mailing list