[Lldb-commits] [lldb] r145740 - in /lldb/trunk: include/lldb/Target/ThreadPlanStepInRange.h include/lldb/Target/ThreadPlanStepOut.h include/lldb/Target/ThreadPlanStepOverRange.h include/lldb/Target/ThreadPlanStepRange.h include/lldb/Target/ThreadPlanStepThrough.h source/Target/Thread.cpp source/Target/ThreadPlanShouldStopHere.cpp source/Target/ThreadPlanStepInRange.cpp source/Target/ThreadPlanStepOverRange.cpp source/Target/ThreadPlanStepRange.cpp source/Target/ThreadPlanStepThrough.cpp
Jim Ingham
jingham at apple.com
Fri Dec 2 17:52:59 PST 2011
Author: jingham
Date: Fri Dec 2 19:52:59 2011
New Revision: 145740
URL: http://llvm.org/viewvc/llvm-project?rev=145740&view=rev
Log:
Make the ThreadPlanStepThrough set a backstop breakpoint on the return address from
the function it is being asked to step through, so that even if we get the trampoline
target wrong (for instance) we will still not lose control.
The other fix here is to tighten up the handling of the case where the current plan
doesn't explain the stop, but a plan above us does. In that case, if the plan that
does explain the stop says it is done, we need to clean up the plans below it and
continue on with our processing.
Modified:
lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h
lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h
lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h
lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h
lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h
lldb/trunk/source/Target/Thread.cpp
lldb/trunk/source/Target/ThreadPlanShouldStopHere.cpp
lldb/trunk/source/Target/ThreadPlanStepInRange.cpp
lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp
lldb/trunk/source/Target/ThreadPlanStepRange.cpp
lldb/trunk/source/Target/ThreadPlanStepThrough.cpp
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h Fri Dec 2 19:52:59 2011
@@ -42,6 +42,9 @@
ShouldStop (Event *event_ptr);
void SetAvoidRegexp(const char *name);
+
+ virtual bool
+ PlanExplainsStop ();
static ThreadPlan *
DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, void *baton);
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h Fri Dec 2 19:52:59 2011
@@ -19,8 +19,6 @@
namespace lldb_private {
-class ThreadPlanStepOverRange;
-
class ThreadPlanStepOut : public ThreadPlan
{
public:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h Fri Dec 2 19:52:59 2011
@@ -33,6 +33,7 @@
virtual ~ThreadPlanStepOverRange ();
+ virtual bool PlanExplainsStop ();
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ShouldStop (Event *event_ptr);
virtual bool
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h Fri Dec 2 19:52:59 2011
@@ -36,7 +36,6 @@
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level) = 0;
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop ();
virtual bool ShouldStop (Event *event_ptr) = 0;
virtual Vote ShouldReportStop (Event *event_ptr);
virtual bool StopOthers ();
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h Fri Dec 2 19:52:59 2011
@@ -33,21 +33,29 @@
virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool WillStop ();
virtual bool MischiefManaged ();
+ virtual void DidPush();
protected:
ThreadPlanStepThrough (Thread &thread,
bool stop_others);
- bool
- HappyToStopHere ();
+ void
+ LookForPlanToStepThroughFromCurrentPC ();
+
+ bool
+ HitOurBackstopBreakpoint();
private:
friend ThreadPlan *
Thread::QueueThreadPlanForStepThrough (bool abort_other_plans,
bool stop_others);
- lldb::addr_t m_start_address;
- bool m_stop_others;
+ lldb::ThreadPlanSP m_sub_plan_sp;
+ lldb::addr_t m_start_address;
+ lldb::break_id_t m_backstop_bkpt_id;
+ lldb::addr_t m_backstop_addr;
+ size_t m_stack_depth;
+ bool m_stop_others;
DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepThrough);
Modified: lldb/trunk/source/Target/Thread.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Thread.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/Thread.cpp (original)
+++ lldb/trunk/source/Target/Thread.cpp Fri Dec 2 19:52:59 2011
@@ -272,7 +272,59 @@
// The top most plan always gets to do the trace log...
current_plan->DoTraceLog ();
- if (current_plan->PlanExplainsStop())
+ // If the base plan doesn't understand why we stopped, then we have to find a plan that does.
+ // If that plan is still working, then we don't need to do any more work. If the plan that explains
+ // the stop is done, then we should pop all the plans below it, and pop it, and then let the plans above it decide
+ // whether they still need to do more work.
+
+ bool done_processing_current_plan = false;
+
+ if (!current_plan->PlanExplainsStop())
+ {
+ if (current_plan->TracerExplainsStop())
+ {
+ done_processing_current_plan = true;
+ should_stop = false;
+ }
+ else
+ {
+ // If the current plan doesn't explain the stop, then, find one that
+ // does and let it handle the situation.
+ ThreadPlan *plan_ptr = current_plan;
+ while ((plan_ptr = GetPreviousPlan(plan_ptr)) != NULL)
+ {
+ if (plan_ptr->PlanExplainsStop())
+ {
+ should_stop = plan_ptr->ShouldStop (event_ptr);
+
+ // plan_ptr explains the stop, next check whether plan_ptr is done, if so, then we should take it
+ // and all the plans below it off the stack.
+
+ if (plan_ptr->MischiefManaged())
+ {
+ // We're going to pop the plans up to AND INCLUDING the plan that explains the stop.
+ plan_ptr = GetPreviousPlan(plan_ptr);
+
+ do
+ {
+ if (should_stop)
+ current_plan->WillStop();
+ PopPlan();
+ }
+ while ((current_plan = GetCurrentPlan()) != plan_ptr);
+ done_processing_current_plan = false;
+ }
+ else
+ done_processing_current_plan = true;
+
+ break;
+ }
+
+ }
+ }
+ }
+
+ if (!done_processing_current_plan)
{
bool over_ride_stop = current_plan->ShouldAutoContinue(event_ptr);
@@ -333,25 +385,6 @@
if (over_ride_stop)
should_stop = false;
}
- else if (current_plan->TracerExplainsStop())
- {
- should_stop = false;
- }
- else
- {
- // If the current plan doesn't explain the stop, then, find one that
- // does and let it handle the situation.
- ThreadPlan *plan_ptr = current_plan;
- while ((plan_ptr = GetPreviousPlan(plan_ptr)) != NULL)
- {
- if (plan_ptr->PlanExplainsStop())
- {
- should_stop = plan_ptr->ShouldStop (event_ptr);
- break;
- }
-
- }
- }
if (log)
{
@@ -797,22 +830,10 @@
ThreadPlan *
Thread::QueueThreadPlanForStepThrough (bool abort_other_plans, bool stop_other_threads)
{
- // Try the dynamic loader first:
- ThreadPlanSP thread_plan_sp(GetProcess().GetDynamicLoader()->GetStepThroughTrampolinePlan (*this, stop_other_threads));
- // If that didn't come up with anything, try the ObjC runtime plugin:
- if (thread_plan_sp.get() == NULL)
- {
- ObjCLanguageRuntime *objc_runtime = GetProcess().GetObjCLanguageRuntime();
- if (objc_runtime)
- thread_plan_sp = objc_runtime->GetStepThroughTrampolinePlan (*this, stop_other_threads);
- }
-
- if (thread_plan_sp.get() == NULL)
- {
- thread_plan_sp.reset(new ThreadPlanStepThrough (*this, stop_other_threads));
- if (thread_plan_sp && !thread_plan_sp->ValidatePlan (NULL))
- return NULL;
- }
+ ThreadPlanSP thread_plan_sp(new ThreadPlanStepThrough (*this, stop_other_threads));
+ if (!thread_plan_sp || !thread_plan_sp->ValidatePlan (NULL))
+ return NULL;
+
QueueThreadPlan (thread_plan_sp, abort_other_plans);
return thread_plan_sp.get();
}
Modified: lldb/trunk/source/Target/ThreadPlanShouldStopHere.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanShouldStopHere.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanShouldStopHere.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanShouldStopHere.cpp Fri Dec 2 19:52:59 2011
@@ -7,8 +7,10 @@
//
//===----------------------------------------------------------------------===//
+#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanShouldStopHere.h"
+#include "lldb/Core/Log.h"
using namespace lldb;
using namespace lldb_private;
@@ -47,7 +49,26 @@
ThreadPlanShouldStopHere::InvokeShouldStopHereCallback ()
{
if (m_callback)
- return m_callback (m_owner, m_flags, m_baton);
+ {
+ ThreadPlan *return_plan = m_callback (m_owner, m_flags, m_baton);
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ if (log)
+ {
+ lldb::addr_t current_addr = m_owner->GetThread().GetRegisterContext()->GetPC(0);
+
+ if (return_plan)
+ {
+ StreamString s;
+ return_plan->GetDescription (&s, lldb::eDescriptionLevelFull);
+ log->Printf ("ShouldStopHere callback found a step out plan from 0x%llx: %s.", current_addr, s.GetData());
+ }
+ else
+ {
+ log->Printf ("ShouldStopHere callback didn't find a step out plan from: 0x%llx.", current_addr);
+ }
+ }
+ return return_plan;
+ }
else
return NULL;
}
Modified: lldb/trunk/source/Target/ThreadPlanStepInRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepInRange.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepInRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepInRange.cpp Fri Dec 2 19:52:59 2011
@@ -68,6 +68,37 @@
}
bool
+ThreadPlanStepInRange::PlanExplainsStop ()
+{
+ // We always explain a stop. Either we've just done a single step, in which
+ // case we'll do our ordinary processing, or we stopped for some
+ // reason that isn't handled by our sub-plans, in which case we want to just stop right
+ // away.
+
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ StopInfoSP stop_info_sp = GetPrivateStopReason();
+ if (stop_info_sp)
+ {
+ StopReason reason = stop_info_sp->GetStopReason();
+
+ switch (reason)
+ {
+ case eStopReasonBreakpoint:
+ case eStopReasonWatchpoint:
+ case eStopReasonSignal:
+ case eStopReasonException:
+ if (log)
+ log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
+ SetPlanComplete();
+ break;
+ default:
+ break;
+ }
+ }
+ return true;
+}
+
+bool
ThreadPlanStepInRange::ShouldStop (Event *event_ptr)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
@@ -81,6 +112,9 @@
log->Printf("ThreadPlanStepInRange reached %s.", s.GetData());
}
+ if (IsPlanComplete())
+ return true;
+
// If we're still in the range, keep going.
if (InRange())
return false;
Modified: lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp Fri Dec 2 19:52:59 2011
@@ -63,6 +63,31 @@
}
bool
+ThreadPlanStepOverRange::PlanExplainsStop ()
+{
+ // We don't explain signals or breakpoints (breakpoints that handle stepping in or
+ // out will be handled by a child plan.
+ StopInfoSP stop_info_sp = GetPrivateStopReason();
+ if (stop_info_sp)
+ {
+ StopReason reason = stop_info_sp->GetStopReason();
+
+ switch (reason)
+ {
+ case eStopReasonBreakpoint:
+ case eStopReasonWatchpoint:
+ case eStopReasonSignal:
+ case eStopReasonException:
+ return false;
+ default:
+ return true;
+ }
+ }
+ return true;
+}
+
+
+bool
ThreadPlanStepOverRange::ShouldStop (Event *event_ptr)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
Modified: lldb/trunk/source/Target/ThreadPlanStepRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepRange.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepRange.cpp Fri Dec 2 19:52:59 2011
@@ -63,30 +63,6 @@
return true;
}
-bool
-ThreadPlanStepRange::PlanExplainsStop ()
-{
- // We don't explain signals or breakpoints (breakpoints that handle stepping in or
- // out will be handled by a child plan.
- StopInfoSP stop_info_sp = GetPrivateStopReason();
- if (stop_info_sp)
- {
- StopReason reason = stop_info_sp->GetStopReason();
-
- switch (reason)
- {
- case eStopReasonBreakpoint:
- case eStopReasonWatchpoint:
- case eStopReasonSignal:
- case eStopReasonException:
- return false;
- default:
- return true;
- }
- }
- return true;
-}
-
Vote
ThreadPlanStepRange::ShouldReportStop (Event *event_ptr)
{
Modified: lldb/trunk/source/Target/ThreadPlanStepThrough.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepThrough.cpp?rev=145740&r1=145739&r2=145740&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepThrough.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepThrough.cpp Fri Dec 2 19:52:59 2011
@@ -20,6 +20,8 @@
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Breakpoint/Breakpoint.h"
using namespace lldb;
using namespace lldb_private;
@@ -33,13 +35,86 @@
ThreadPlanStepThrough::ThreadPlanStepThrough (Thread &thread, bool stop_others) :
ThreadPlan (ThreadPlan::eKindStepThrough, "Step through trampolines and prologues", thread, eVoteNoOpinion, eVoteNoOpinion),
m_start_address (0),
+ m_backstop_bkpt_id (LLDB_INVALID_BREAK_ID),
+ m_backstop_addr(LLDB_INVALID_ADDRESS),
+ m_stack_depth (0),
m_stop_others (stop_others)
{
- m_start_address = GetThread().GetRegisterContext()->GetPC(0);
+
+ LookForPlanToStepThroughFromCurrentPC();
+
+ // If we don't get a valid step through plan, don't bother to set up a backstop.
+ if (m_sub_plan_sp)
+ {
+ m_start_address = GetThread().GetRegisterContext()->GetPC(0);
+ m_stack_depth = m_thread.GetStackFrameCount() - 1;
+
+ // We are going to return back to the concrete frame 1, we might pass by some inlined code that we're in
+ // the middle of by doing this, but it's easier than trying to figure out where the inlined code might return to.
+
+ StackFrameSP return_frame_sp (m_thread.GetFrameWithConcreteFrameIndex(1));
+
+ if (return_frame_sp)
+ {
+ m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(&m_thread.GetProcess().GetTarget());
+ Breakpoint *return_bp = m_thread.GetProcess().GetTarget().CreateBreakpoint (m_backstop_addr, true).get();
+ if (return_bp != NULL)
+ {
+ return_bp->SetThreadID(m_thread.GetID());
+ m_backstop_bkpt_id = return_bp->GetID();
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ if (log)
+ {
+ log->Printf ("Setting backstop breakpoint %d at address: 0x%llx", m_backstop_bkpt_id, m_backstop_addr);
+ }
+ }
+ }
}
ThreadPlanStepThrough::~ThreadPlanStepThrough ()
{
+ if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
+ {
+ m_thread.GetProcess().GetTarget().RemoveBreakpointByID (m_backstop_bkpt_id);
+ m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
+ }
+}
+
+void
+ThreadPlanStepThrough::DidPush ()
+{
+ if (m_sub_plan_sp)
+ PushPlan(m_sub_plan_sp);
+}
+
+void
+ThreadPlanStepThrough::LookForPlanToStepThroughFromCurrentPC()
+{
+ m_sub_plan_sp = m_thread.GetProcess().GetDynamicLoader()->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
+ // If that didn't come up with anything, try the ObjC runtime plugin:
+ if (!m_sub_plan_sp.get())
+ {
+ ObjCLanguageRuntime *objc_runtime = m_thread.GetProcess().GetObjCLanguageRuntime();
+ if (objc_runtime)
+ m_sub_plan_sp = objc_runtime->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
+ }
+
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ if (log)
+ {
+ lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC(0);
+ if (m_sub_plan_sp)
+ {
+ StreamString s;
+ m_sub_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
+ log->Printf ("Found step through plan from 0x%llx: %s", current_address, s.GetData());
+ }
+ else
+ {
+ log->Printf ("Couldn't find step through plan from address 0x%llx.", current_address);
+ }
+ }
}
void
@@ -49,30 +124,80 @@
s->Printf ("Step through");
else
{
- s->Printf ("Stepping through trampoline code from: ");
+ s->PutCString ("Stepping through trampoline code from: ");
s->Address(m_start_address, sizeof (addr_t));
+ if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
+ {
+ s->Printf (" with backstop breakpoint id: %d at address: ", m_backstop_bkpt_id);
+ s->Address (m_backstop_addr, sizeof (addr_t));
+ }
+ else
+ s->PutCString (" unable to set a backstop breakpoint.");
}
}
bool
ThreadPlanStepThrough::ValidatePlan (Stream *error)
{
- if (HappyToStopHere())
- return false;
- else
- return true;
+ return m_sub_plan_sp.get() != NULL;
}
bool
ThreadPlanStepThrough::PlanExplainsStop ()
{
- return true;
+ // If we have a sub-plan, it will have been asked first if we explain the stop, and
+ // we won't get asked. The only time we would be the one directly asked this question
+ // is if we hit our backstop breakpoint.
+
+ if (HitOurBackstopBreakpoint())
+ return true;
+ else
+ return false;
}
bool
ThreadPlanStepThrough::ShouldStop (Event *event_ptr)
{
- return true;
+ // If we've already marked ourselves done, then we're done...
+ if (IsPlanComplete())
+ return true;
+
+ // If we don't have a sub-plan, then we're also done (can't see how we would ever get here
+ // without a plan, but just in case.
+
+ if (!m_sub_plan_sp)
+ {
+ SetPlanComplete();
+ return true;
+ }
+
+ // First, did we hit the backstop breakpoint?
+ if (HitOurBackstopBreakpoint())
+ {
+ SetPlanComplete();
+ return true;
+ }
+
+
+ // If the current sub plan is not done, we don't want to stop. Actually, we probably won't
+ // ever get here in this state, since we generally won't get asked any questions if out
+ // current sub-plan is not done...
+ if (!m_sub_plan_sp->IsPlanComplete())
+ return false;
+
+ // Next see if there is a specific step through plan at our current pc (these might
+ // chain, for instance stepping through a dylib trampoline to the objc dispatch function...)
+ LookForPlanToStepThroughFromCurrentPC();
+ if (m_sub_plan_sp)
+ {
+ PushPlan (m_sub_plan_sp);
+ return false;
+ }
+ else
+ {
+ SetPlanComplete();
+ return true;
+ }
}
bool
@@ -91,20 +216,6 @@
ThreadPlanStepThrough::WillResume (StateType resume_state, bool current_plan)
{
ThreadPlan::WillResume(resume_state, current_plan);
- if (current_plan)
- {
- ThreadPlanSP sub_plan_sp(m_thread.GetProcess().GetDynamicLoader()->GetStepThroughTrampolinePlan (m_thread, m_stop_others));
- // If that didn't come up with anything, try the ObjC runtime plugin:
- if (sub_plan_sp == NULL)
- {
- ObjCLanguageRuntime *objc_runtime = m_thread.GetProcess().GetObjCLanguageRuntime();
- if (objc_runtime)
- sub_plan_sp = objc_runtime->GetStepThroughTrampolinePlan (m_thread, m_stop_others);
- }
-
- if (sub_plan_sp != NULL)
- PushPlan (sub_plan_sp);
- }
return true;
}
@@ -119,11 +230,11 @@
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
- // Stop if we're happy with the place we've landed...
+ // ShouldStop will call HappyToStopHere, which will set the plan to complete if
+ // we're done. So we can just check that here.
- if (!HappyToStopHere())
+ if (!IsPlanComplete())
{
- // If we are still at the PC we were trying to step over.
return false;
}
else
@@ -131,16 +242,35 @@
if (log)
log->Printf("Completed step through step plan.");
ThreadPlan::MischiefManaged ();
+ if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID)
+ {
+ m_thread.GetProcess().GetTarget().RemoveBreakpointByID (m_backstop_bkpt_id);
+ m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
+ }
return true;
}
}
bool
-ThreadPlanStepThrough::HappyToStopHere()
+ThreadPlanStepThrough::HitOurBackstopBreakpoint()
{
- // This should again ask the various trampolines whether we are still at a
- // trampoline point, and if so, continue through the possibly nested trampolines.
-
- return true;
+ StopInfoSP stop_info_sp(m_thread.GetStopInfo());
+ if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint)
+ {
+ break_id_t stop_value = (break_id_t) stop_info_sp->GetValue();
+ BreakpointSiteSP cur_site_sp = m_thread.GetProcess().GetBreakpointSiteList().FindByID(stop_value);
+ if (cur_site_sp && cur_site_sp->IsBreakpointAtThisSite(m_backstop_bkpt_id))
+ {
+ size_t current_stack_depth = m_thread.GetStackFrameCount();
+ if (current_stack_depth == m_stack_depth)
+ {
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ if (log)
+ log->PutCString ("ThreadPlanStepThrough hit backstop breakpoint.");
+ return true;
+ }
+ }
+ }
+ return false;
}
More information about the lldb-commits
mailing list