LLDB bug 30863: "Step" doesn't stop with conditional breakpoint on the next line

[boris.ulasevich]

Summary

The issue is that

• breakpoint handler issues the breakpoint event and discards step plan (ThreadPlanBase::ShouldStop method)
• breakpoint event handler skips breakpoint (because its condition is false) and resumes the execution

Final fix includes:

• additional check for completed plans while discarding stale plans
• GetStopInfo algorithm rework
• reset StopInfo on breakpoint condition fail

[jingham]

This isn't quite right. If the condition was false, the breakpoint formally didn't get hit. That means its commands shouldn't get run. So you can't just fall through in the case where you want to treat the "unhit" breakpoint hit as a step end. You need to have that location vote to stop, but then skip all the rest of the handling of that location.

Also, instead of calling it "WasThreadStepPlanDiscarded" I would prefer to name it by what you are using it for, like "StepPlanOverridesBreakpoint".

Also, why is the plan you are checking for on the discarded plan stack? That seems wrong to me. If the step was successful, it should be on the completed plan stack. A step plan will end up getting discarded, for instance, if you were stepping over a function that threw an exception, and you ended up stopping in a frame above where you were stepping. In that case, the plan would return IsStale = false, and get discarded. But if the step completes it should be in the completed plan stack.

[jingham]

I'm supposed to also say "request changes"...

[boris.ulasevich]

Thank you for the review. I really appreciate it.

You are right about breakpoint commands, my bad, breakpoint commands should not run. I moved the check later.

I fixed function name. Actually I don't like both names, but I do not see better option :)

About the discarded plan stack: current logic is the following. Remaining plans are discarded intentionally because breakpoint stop is expected (as I can understand, we can't check breakpoint condition in PrivateState thread), and user will not be happy to get more than one stop:

ThreadPlanBase:112: ThreadPlanBase::ShouldStop: eStopReasonBreakpoint -> m_thread.DiscardThreadPlans(false)
Thread.cpp:908: Thread::ShouldStop: should_stop -> DiscardThreadPlansUpToPlan(examined_plan)

So for me it is quite Ok to check discarded plan stack on this unusual condition.

[jingham]

It is not the case in general that a breakpoint hit will discard thread plans. Suppose I'm doing a "step over", and in stepping over a function call I hit a breakpoint in the function. The "step over plan" doesn't get discarded, it stays on the plan stack so if you do a "continue" you will complete the step over. The "force" argument in ThreadPlanBasic says "only discard plans that say they can't persist over a breakpoint and other unrelated stop messages - and that's what the comment you adjusted in ThreadPlanBase.cpp is saying.

You can see this in practice:

(lldb) br s -n main
Breakpoint 1: where = foo`main + 15 at foo.c:11, address = 0x0000000100000f5f
(lldb) br s -p "Set a breakpoint here"
Breakpoint 2: where = foo`func + 11 at foo.c:5, address = 0x0000000100000f3b
(lldb) run
Process 16708 launched: '/private/tmp/foo' (x86_64)
Process 16708 stopped
* thread #1: tid = 0x9b1f6d, function: main , stop reason = breakpoint 1.1
    frame #0: 0x0000000100000f5f foo`main at foo.c:11
   8   	int
   9   	main()
   10  	{
-> 11  	  func();
   12  	  return 0;
   13  	} 
(lldb) n
Process 16708 stopped
* thread #1: tid = 0x9b1f6d, function: func , stop reason = breakpoint 2.1
    frame #0: 0x0000000100000f3b foo`func at foo.c:5
   2   	
   3   	int func()
   4   	{
-> 5   	  return printf("Set a breakpoint here\n");
   6   	}
   7   	
   8   	int
(lldb) thread plan list
thread #1: tid = 0x9b1f6d:
  Active plan stack:
    Element 0: Base thread plan.
    Element 1: Stepping over line foo.c:11.

The step over plan has NOT been discarded.

In this particular case, you are seeing an artifact of our choosing to discard the step plan when you hit a breakpoint when the step plan was done. That was done to make the breakpoint hit be the one reported rather than the step plan completion. But since you are now treating the step plan completion as the primary event, you may need to reverse that decision. If you can't easily figure out where that's being done, I'll have a look.

BTW, it's actually commands that we can't evaluate in the private state thread. We actually could test the conditions, since it turns out there are a bunch of instances which require expression evaluation on the private state thread, so I had to make that work. But it makes more sense to handle conditions & commands all together. The problem with running commands on the private state thread is side-stepped by having the PerformAction get run as part of the event's DoOnRemoval, which always happens on the client thread that's running the event loop. I don't think that is relevant.

[boris.ulasevich]

Thank you for guiding me though this stuff. For years I was responsible for similar debugging issues in Mobile Java, and my motivation now is to learn how it works in lldb world.

I see that not all plans discarded by breakpoint, thank you. But our stepOver plan is discarded, and the reason is that it is stale (PC is out of the range):

Thread.cpp:908: Thread::ShouldStop: if should_stop, if stale -> DiscardThreadPlansUpToPlan(examined_plan)

I do not think it is correct to treat step plan completion as the primary event. Breakpoint have bump counter and commands, and we should not skip its processing.

reverse that decision. If you can't easily figure out where that's being done

It can be done in Thread.cpp:908: call PopPlan instead of DiscardThreadPlans, then the stale step plan will be put to completed stack and next it will be treated as stop reason by event handler. But, again, for me it looks incorrect.

[apilipenko]

lldb/source/Target/ThreadPlanBase.cpp

104–105 ↗

(On Diff #78169)

This type of changes can go in separately without review. Having them in the review request only increases visual litter.

[boris.ulasevich]

Here I come with another fix. Additional code in ThreadPlanStepRange::IsPlanStale() checks if we are exactly on the next instruction just after the range, and sets plan Complete in this case. So for the case we have both breakpoint hit and step plan complete event, and further processing threats step plan complete as primary event (Thread::GetStopInfo), and stop works Ok. Please note that breakpoint's actions (condition check, bump count increase, commands) are skipped when step plan is treated as main event.

I want also to add lldb test for this case, but for now I did not succeed with correct work of lldb test suite on my Mac.

[boris.ulasevich]

Stop reason priorities was reworked, step plans gets a last chance to mark themselves complete while cleaning up stale plans, and breakpoint's PerformAction learned to take Completed Plans into account.

Test suite passed. New test was added to verify breakpoint vs stepping interaction.

[jingham]

The logic looks right to me. I suggested a few cleanups to the test case (for which, thanks!) and a couple of other little details. And I requested an overall comment for the logic rework GetStopInfo 'cause that is a little confusing. You can get the logic somewhat by looking at the variable names, but I think some discursive explanation would be really helpful.

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

52–56

You can do this check more compactly - and check that you stopped at the right breakpoint - with:

self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.breakpoint_1)
self.assertIsNotNone(self.thread, "Didn't stop at breakpoint 1.")

103–104

If you use assertTrue, you should print the wrong value in the error message, otherwise you'll end up with some weird failure that happens occasionally and you will really wish you knew what the actual stop reason was.

But in this case, I think you can use assertEquals for the stop reason test, and that will automatically print both the expected & actual values.

108–109

This doesn't actually check that you are stopped at breakpoint 4, just at some breakpoint. For breakpoint stop reasons, the stop info holds the BP ID and the location ID as the 0th and 1st data elements, so the bp id is:

self.thread.GetStopReasonDataAtIndex(0)

Or you can use get_one_thread_stopped_at_breakpoint, and make sure the thread is your thread.

source/Target/StopInfo.cpp

537–538

typo:

additionalluy -> additionally

539

I don't understand this comment.

source/Target/Thread.cpp

383

We use _sp suffix for shared pointers.

387–399

This bit of logic needs a comment to explain what it is doing.

920–921

Can you move this comment to before the while loop? It is explaining what the whole loops logic is doing, so it's easier to read if it comes before you dive into reading the loop.

source/Target/ThreadPlanStepInstruction.cpp

97

You mean "reach" not "stay on", right? Stay on makes it sound like we didn't move the pc from one run to the other.

source/Target/ThreadPlanStepRange.cpp

464

Again, "reach" not "stay on"?

[boris.ulasevich]

source/Target/StopInfo.cpp

539

new comment:

// Here we clean preset stop info.
// Neхt GetStopInfo call will find another stop info,
// and it should be stop info related to the completed plan

source/Target/Thread.cpp

387–399

Let me add a overall comment for the if-else-else block:

// Here we select the stop info according to priorirty:
// - m_stop_info_sp (if not trace) - preset value
// - completed plan stop info - new value with plan from completed plan stack
// - m_stop_info_sp (trace stop reason is OK now)
// - ask GetPrivateStopInfo to set stop info

920–921

Sure! New comment for the block will be:

// Discard stale plans and all plans below them in the stack,
// plus move completed plans to completed plan stack

[jingham]

I made some trivial grammar fixes, but other than that this looks good. Thanks for working on this.

source/Target/StopInfo.cpp

539

Maybe:

Here we clean the preset stop info so the next
GetStopInfo call will find the appropriate stop info,
which should be the stop info related to the completed plan

source/Target/Thread.cpp

387–399

Great.

920–921

Fine, but missing some articles:

Discard THE stale plans...
plus move THE completed plans to THE ...

include/lldb/Target/Thread.h

public:
   ///
   /// @return
   ///     Returns true if the input plan is in the discarded plan stack,
   ///     false otherwise.
   //------------------------------------------------------------------
   bool WasThreadPlanDiscarded(ThreadPlan *plan);
 
   //------------------------------------------------------------------
+  /// Check if we have completed plan to override breakpoint stop reason
+  ///
+  /// @return
+  ///     Returns true if completed plan stack is not empty
+  ///     false otherwise.
+  //------------------------------------------------------------------
+  bool CompletedPlanOverridesBreakpoint();
+                   
+  //------------------------------------------------------------------
   /// Queues a generic thread plan.
   ///
   /// @param[in] plan_sp
   ///    The plan to queue.
   ///
   /// @param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.

   //                    process is resumed
   //----------------------------------------------------------------------
   lldb::StateType GetTemporaryResumeState() const {
     return m_temporary_resume_state;
   }
 
   void SetStopInfo(const lldb::StopInfoSP &stop_info_sp);
 
+  void ResetStopInfo();
+
   void SetShouldReportStop(Vote vote);
 
   //----------------------------------------------------------------------
   /// Sets the extended backtrace token for this thread
   ///
   /// Some Thread subclasses may maintain a token to help with providing
   /// an extended backtrace.  The SystemRuntime plugin will set/request this.
   ///

include/lldb/Target/ThreadPlan.h

 //  Master plans:
 //
 //  In the normal case, when we decide to stop, we will  collapse the plan stack
 //  up to the point of the plan that understood
 //  the stop reason.  However, if a plan wishes to stay on the stack after an
 //  event it didn't directly handle
 //  it can designate itself a "Master" plan by responding true to IsMasterPlan,
 //  and then if it wants not to be
-//  discarded, it can return true to OkayToDiscard, and it and all its dependent
+//  discarded, it can return false to OkayToDiscard, and it and all its dependent
 //  plans will be preserved when
 //  we resume execution.
 //
 //  The other effect of being a master plan is that when the Master plan is done
 //  , if it has set "OkayToDiscard" to false,
 //  then it will be popped & execution will stop and return to the user.
 //  Remember that if OkayToDiscard is false, the
 //  plan will be popped and control will be given to the next plan above it on

 //  default, and you would set the ones you
 //  wanted to be "user level" in this way.
 //
 //
 //  Actually Stopping:
 //
 //  If a plan says responds "true" to ShouldStop, then it is asked if it's job
 //  is complete by calling
-//  MischiefManaged.  If that returns true, the thread is popped from the plan
+//  MischiefManaged.  If that returns true, the plan is popped from the plan
 //  stack and added to the
 //  Completed Plan Stack.  Then the next plan in the stack is asked if it
 //  ShouldStop, and  it returns "true",
 //  it is asked if it is done, and if yes popped, and so on till we reach a plan
 //  that is not done.
 //
 //  Since you often know in the ShouldStop method whether your plan is complete,
 //  as a convenience you can call

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+ifneq (,$(findstring icc,$(CC)))
+    CXXFLAGS += -debug inline-debug-info
+endif
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

+"""
+Test that breakpoints do not affect stepping.
+Check for correct StopReason when stepping to the line with breakpoint 
+which chould be eStopReasonBreakpoint in general,
+and eStopReasonPlanComplete when breakpoint's condition fails.  
+"""
+
+from __future__ import print_function
+
+import unittest2
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class StepOverBreakpointsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        TestBase.setUp(self)
+       
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        src = lldb.SBFileSpec("main.cpp")
+
+        # Create a target by the debugger.
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+
+        # Setup four breakpoints, two of them with false condition
+        self.line1 = line_number('main.cpp', "breakpoint_1")
+        self.line4 = line_number('main.cpp', "breakpoint_4")
+
+        self.breakpoint1 = self.target.BreakpointCreateByLocation(src, self.line1)        
+        self.assertTrue(
+            self.breakpoint1 and self.breakpoint1.GetNumLocations() == 1,
+            VALID_BREAKPOINT)
+
+        self.breakpoint2 = self.target.BreakpointCreateBySourceRegex("breakpoint_2", src)
+        self.breakpoint2.GetLocationAtIndex(0).SetCondition('false')
+
+        self.breakpoint3 = self.target.BreakpointCreateBySourceRegex("breakpoint_3", src)
+        self.breakpoint3.GetLocationAtIndex(0).SetCondition('false')
+
+        self.breakpoint4 = self.target.BreakpointCreateByLocation(src, self.line4)
+
+        # Start debugging
+        self.process = self.target.LaunchSimple(
+            None, None, self.get_process_working_directory())
+        self.assertIsNotNone(self.process, PROCESS_IS_VALID)
+        self.thread = self.process.GetThreadAtIndex(0)
+
+        # We should be stopped at the breakpoint_1
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonBreakpoint)
+
+    def test_step_instruction(self): 
+        # Count instructions between breakpoint_1 and breakpoint_4
+        contextList = self.target.FindFunctions('main', lldb.eFunctionNameTypeAuto)
+        self.assertTrue(contextList.GetSize() == 1)
+        symbolContext = contextList.GetContextAtIndex(0)
+        function = symbolContext.GetFunction()
+        self.assertTrue(function)
+        instructions = function.GetInstructions(self.target)
+        addr_1 = self.breakpoint1.GetLocationAtIndex(0).GetAddress()
+        addr_4 = self.breakpoint4.GetLocationAtIndex(0).GetAddress()
+        for i in range(instructions.GetSize()) :
+            addr = instructions.GetInstructionAtIndex(i).GetAddress()
+            if (addr == addr_1) : index_1 = i
+            if (addr == addr_4) : index_4 = i 
+
+        steps_expected = index_4 - index_1
+        step_count = 0
+        # Step from breakpoint_1 to breakpoint_4
+        while True:
+            self.thread.StepInstruction(True)
+            step_count = step_count + 1
+            self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+            self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonPlanComplete or
+                            self.thread.GetStopReason() == lldb.eStopReasonBreakpoint)
+            if (self.thread.GetStopReason() == lldb.eStopReasonBreakpoint) :
+                # we should not stop on breakpoint_2 and _3 because they have false condition
+                self.assertTrue(self.thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == self.line4)
+                # breakpoint_2 and _3 should not affect step count
+                self.assertTrue(step_count >= steps_expected)
+                break
+
+        # Run the process until termination
+        self.process.Continue()
+        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+
+    def test_step_over(self):
+        #lldb.DBG.EnableLog("lldb", ["step","breakpoint"])
+        
+        self.thread.StepOver()
+        # We should be stopped at the breakpoint_2 line with stop plan complete reason
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+
+        self.thread.StepOver()
+        # We should be stopped at the breakpoint_3 line with stop plan complete reason
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+
+        self.thread.StepOver()
+        # We should be stopped at the breakpoint_4
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonBreakpoint)
+
+        # Check that stepping does not affect breakpoint's hit count
+        self.assertEquals(self.breakpoint1.GetHitCount(), 1)
+        self.assertEquals(self.breakpoint2.GetHitCount(), 0)
+        self.assertEquals(self.breakpoint3.GetHitCount(), 0)
+        self.assertEquals(self.breakpoint4.GetHitCount(), 1)
+
+        # Run the process until termination
+        self.process.Continue()
+        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/main.cpp

+
+int func() { return 1; }
+
+int
+main(int argc, char const *argv[])
+{
+    int a = 0;      // breakpoint_1
+    int b = func(); // breakpoint_2
+    a = b + func(); // breakpoint_3
+    return 0;       // breakpoint_4
+}
+

source/Target/StopInfo.cpp

bool ShouldStop(Event *event_ptr) override {
     assert(m_should_stop_is_valid);
     return m_should_stop;
   }
 
   void PerformAction(Event *event_ptr) override {
     if (!m_should_perform_action)
       return;
     m_should_perform_action = false;
+    bool internal_breakpoint = true;
 
     ThreadSP thread_sp(m_thread_wp.lock());
 
     if (thread_sp) {
       Log *log = lldb_private::GetLogIfAnyCategoriesSet(
           LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
 
       if (!thread_sp->IsValid()) {
if (thread_sp) {
 
             callback_says_stop = bp_loc_sp->InvokeCallback(&context);
 
             debugger.SetAsyncExecution(old_async);
 
             if (callback_says_stop)
               m_should_stop = true;
 
+            if (m_should_stop && !bp_loc_sp->GetBreakpoint().IsInternal())
+              internal_breakpoint = false;
+                  
             // If we are going to stop for this breakpoint, then remove the
             // breakpoint.
             if (callback_says_stop && bp_loc_sp &&
                 bp_loc_sp->GetBreakpoint().IsOneShot()) {
               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
                   bp_loc_sp->GetBreakpoint().GetID());
             }
 
if (thread_sp) {
         Log *log_process(
             lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
         if (log_process)
           log_process->Printf(
               "Process::%s could not find breakpoint site id: %" PRId64 "...",
               __FUNCTION__, m_value);
       }
+
+      if ((m_should_stop == false || internal_breakpoint)
+          && thread_sp->CompletedPlanOverridesBreakpoint()) {
+        // Override should_stop decision when we have
+        // completed step plan additionalluy to the breakpoint
+        m_should_stop = true;
+        // Completed Plan's StopInfo will be used up after reset
+        thread_sp->ResetStopInfo();
+      }
+
       if (log)
         log->Printf("Process::%s returning from action with m_should_stop: %d.",
                     __FUNCTION__, m_should_stop);
     }
   }
 
 private:
   bool m_should_stop;

source/Target/Thread.cpp

if (frame && frame->HasDebugInformation() &&
     GetProcess()->PrintWarningOptimization(sc);
   }
 }
 
 lldb::StopInfoSP Thread::GetStopInfo() {
   if (m_destroy_called)
     return m_stop_info_sp;
 
-  ThreadPlanSP plan_sp(GetCompletedPlan());
+  ThreadPlanSP completed_plan(GetCompletedPlan());
   ProcessSP process_sp(GetProcess());
   const uint32_t stop_id = process_sp ? process_sp->GetStopID() : UINT32_MAX;
-  if (plan_sp && plan_sp->PlanSucceeded()) {
-    return StopInfo::CreateStopReasonWithPlan(plan_sp, GetReturnValueObject(),
-                                              GetExpressionVariable());
-  } else {
-    if ((m_stop_info_stop_id == stop_id) || // Stop info is valid, just return
-                                            // what we have (even if empty)
-        (m_stop_info_sp &&
-         m_stop_info_sp
-             ->IsValid())) // Stop info is valid, just return what we have
-    {
-      return m_stop_info_sp;
-    } else {
-      GetPrivateStopInfo();
-      return m_stop_info_sp;
-    }
-  }
-}
+
+  bool have_valid_stop_info = m_stop_info_sp &&
+      m_stop_info_sp ->IsValid() &&
+      m_stop_info_stop_id == stop_id;
+  bool have_valid_completed_plan = completed_plan && completed_plan->PlanSucceeded();
+  bool plan_overrides_trace =
+    have_valid_stop_info && have_valid_completed_plan
+    && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
+    
+  if (have_valid_stop_info && !plan_overrides_trace) {
+  } else if (have_valid_completed_plan) {
+    return StopInfo::CreateStopReasonWithPlan(
+        completed_plan, GetReturnValueObject(), GetExpressionVariable());
 
 lldb::StopInfoSP Thread::GetPrivateStopInfo() {
   if (m_destroy_called)
     return m_stop_info_sp;
 
   ProcessSP process_sp(GetProcess());
   if (process_sp) {
     const uint32_t process_stop_id = process_sp->GetStopID();
bool Thread::StopInfoIsUpToDate() const {
   ProcessSP process_sp(GetProcess());
   if (process_sp)
     return m_stop_info_stop_id == process_sp->GetStopID();
   else
     return true; // Process is no longer around so stop info is always up to
                  // date...
 }
 
+void Thread::ResetStopInfo() {
+  if (m_stop_info_sp) {
+    m_stop_info_sp.reset();
+  }
+}
+
 void Thread::SetStopInfo(const lldb::StopInfoSP &stop_info_sp) {
   m_stop_info_sp = stop_info_sp;
   if (m_stop_info_sp) {
     m_stop_info_sp->MakeStopInfoValid();
     // If we are overriding the ShouldReportStop, do that here:
     if (m_override_should_notify != eLazyBoolCalculate)
       m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
                                            eLazyBoolYes);
while (!PlanIsBasePlan(plan_ptr)) {
       ThreadPlan *examined_plan = plan_ptr;
       plan_ptr = GetPreviousPlan(examined_plan);
 
       if (stale) {
         if (log)
           log->Printf(
               "Plan %s being discarded in cleanup, it says it is already done.",
               examined_plan->GetName());
-        DiscardThreadPlansUpToPlan(examined_plan);
+        while (GetCurrentPlan() != examined_plan) {
+          DiscardPlan();
+        }
+        if (examined_plan->IsPlanComplete()) {
+          // plan is complete but does not explain the stop (example: step to a line
+          // with breakpoint), let us move the plan to completed_plan_stack anyway
+          PopPlan();
+        } else
+          DiscardPlan();
       }
     }
   }
 
   if (log) {
     StreamString s;
     s.IndentMore();
     DumpThreadPlans(&s);
if (!m_discarded_plan_stack.empty()) {
     for (int i = m_discarded_plan_stack.size() - 1; i >= 0; i--) {
       if (m_discarded_plan_stack[i].get() == plan)
         return true;
     }
   }
   return false;
 }
 
+bool Thread::CompletedPlanOverridesBreakpoint() {
+  return (!m_completed_plan_stack.empty()) ;
+}
+
 ThreadPlan *Thread::GetPreviousPlan(ThreadPlan *current_plan) {
   if (current_plan == nullptr)
     return nullptr;
 
   int stack_size = m_completed_plan_stack.size();
   for (int i = stack_size - 1; i > 0; i--) {
     if (current_plan == m_completed_plan_stack[i].get())
       return m_completed_plan_stack[i - 1].get();

source/Target/ThreadPlanStepInstruction.cpp

bool ThreadPlanStepInstruction::DoPlanExplainsStop(Event *event_ptr) {
   }
   return false;
 }
 
 bool ThreadPlanStepInstruction::IsPlanStale() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
   if (cur_frame_id == m_stack_id) {
+    // Set plan Complete when we stay on next instruction
+    uint64_t pc = m_thread.GetRegisterContext()->GetPC(0);
+    uint32_t max_opcode_size = m_thread.CalculateTarget()
+        ->GetArchitecture().GetMaximumOpcodeByteSize();
+    bool next_instruction_reached = (pc > m_instruction_addr) &&
+        (pc <= m_instruction_addr + max_opcode_size);
+    if (next_instruction_reached) {
+      SetPlanComplete();
+    }
     return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
   } else if (cur_frame_id < m_stack_id) {
     // If the current frame is younger than the start frame and we are stepping
     // over, then we need to continue,
     // but if we are doing just one step, we're done.
     return !m_step_over;
   } else {
     if (log) {

source/Target/ThreadPlanStepRange.cpp

if (log) {
                   "stepped out.");
     }
     return true;
   } else if (frame_order == eFrameCompareEqual && InSymbol()) {
     // If we are not in a place we should step through, we've gotten stale.
     // One tricky bit here is that some stubs don't push a frame, so we should.
     // check that we are in the same symbol.
     if (!InRange()) {
+      // Set plan Complete when we stay on next instruction just after the range
+      lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
+      size_t num_ranges = m_address_ranges.size();
+      for (size_t i = 0; i < num_ranges; i++) {
+        bool in_range = m_address_ranges[i].ContainsLoadAddress(
+            addr, m_thread.CalculateTarget().get());
+        if (in_range) {
+          SetPlanComplete();
+        }
+      }
       return true;
     }
   }
   return false;
 }