[Lldb-commits] [lldb] r181381 - Figure out the reply to "PlanExplainsStop" once when we stop and then use the cached
Jim Ingham
jingham at apple.com
Tue May 7 17:35:17 PDT 2013
Author: jingham
Date: Tue May 7 19:35:16 2013
New Revision: 181381
URL: http://llvm.org/viewvc/llvm-project?rev=181381&view=rev
Log:
Figure out the reply to "PlanExplainsStop" once when we stop and then use the cached
value. This fixes problems, for instance, with the StepRange plans, where they know that
they explained the stop because they were at their "run to here" breakpoint, then deleted
that breakpoint, so when they got asked again, doh! I had done this for a couple of plans
in an ad hoc fashion, this just formalizes it.
Also add a "ResumeRequested" in Process so that the code in the completion handlers can
tell the ShouldStop logic they want to resume rather than just directly resuming. That allows
us to handle resuming in a more controlled fashion.
Also, SetPublicState can take a "restarted" flag, so that it doesn't drop the run lock when
the target was immediately restarted.
--This line, and those below , will be ignored--
M test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
M include/lldb/Target/ThreadList.h
M include/lldb/Target/ThreadPlanStepOut.h
M include/lldb/Target/Thread.h
M include/lldb/Target/ThreadPlanBase.h
M include/lldb/Target/ThreadPlanStepThrough.h
M include/lldb/Target/ThreadPlanStepInstruction.h
M include/lldb/Target/ThreadPlanStepInRange.h
M include/lldb/Target/ThreadPlanStepOverBreakpoint.h
M include/lldb/Target/ThreadPlanStepUntil.h
M include/lldb/Target/StopInfo.h
M include/lldb/Target/Process.h
M include/lldb/Target/ThreadPlanRunToAddress.h
M include/lldb/Target/ThreadPlan.h
M include/lldb/Target/ThreadPlanCallFunction.h
M include/lldb/Target/ThreadPlanStepOverRange.h
M source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
M source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
M source/Target/StopInfo.cpp
M source/Target/Process.cpp
M source/Target/ThreadPlanRunToAddress.cpp
M source/Target/ThreadPlan.cpp
M source/Target/ThreadPlanCallFunction.cpp
M source/Target/ThreadPlanStepOverRange.cpp
M source/Target/ThreadList.cpp
M source/Target/ThreadPlanStepOut.cpp
M source/Target/Thread.cpp
M source/Target/ThreadPlanBase.cpp
M source/Target/ThreadPlanStepThrough.cpp
M source/Target/ThreadPlanStepInstruction.cpp
M source/Target/ThreadPlanStepInRange.cpp
M source/Target/ThreadPlanStepOverBreakpoint.cpp
M source/Target/ThreadPlanStepUntil.cpp
M lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme
Modified:
lldb/trunk/include/lldb/Target/Process.h
lldb/trunk/include/lldb/Target/StopInfo.h
lldb/trunk/include/lldb/Target/Thread.h
lldb/trunk/include/lldb/Target/ThreadList.h
lldb/trunk/include/lldb/Target/ThreadPlan.h
lldb/trunk/include/lldb/Target/ThreadPlanBase.h
lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h
lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h
lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h
lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h
lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h
lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h
lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h
lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h
lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h
lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme
lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
lldb/trunk/source/Target/Process.cpp
lldb/trunk/source/Target/StopInfo.cpp
lldb/trunk/source/Target/Thread.cpp
lldb/trunk/source/Target/ThreadList.cpp
lldb/trunk/source/Target/ThreadPlan.cpp
lldb/trunk/source/Target/ThreadPlanBase.cpp
lldb/trunk/source/Target/ThreadPlanCallFunction.cpp
lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp
lldb/trunk/source/Target/ThreadPlanStepInRange.cpp
lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp
lldb/trunk/source/Target/ThreadPlanStepOut.cpp
lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp
lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp
lldb/trunk/source/Target/ThreadPlanStepThrough.cpp
lldb/trunk/source/Target/ThreadPlanStepUntil.cpp
lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
Modified: lldb/trunk/include/lldb/Target/Process.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Process.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Process.h (original)
+++ lldb/trunk/include/lldb/Target/Process.h Tue May 7 19:35:16 2013
@@ -3348,13 +3348,15 @@ public:
void
RestoreProcessEvents ();
-protected:
+private:
//------------------------------------------------------------------
/// This is the part of the event handling that for a process event.
/// It decides what to do with the event and returns true if the
/// event needs to be propagated to the user, and false otherwise.
/// If the event is not propagated, this call will most likely set
/// the target to executing again.
+ /// There is only one place where this call should be called, HandlePrivateEvent.
+ /// Don't call it from anywhere else...
///
/// @param[in] event_ptr
/// This is the event we are handling.
@@ -3526,6 +3528,9 @@ protected:
// new "NextEventAction" is added while one is already present, the
// old action will be discarded (with HandleBeingUnshipped called
// after it is discarded.)
+ //
+ // If you want to resume the process as a result of a resume action,
+ // call RequestResume, don't call Resume directly.
//------------------------------------------------------------------
class NextEventAction
{
@@ -3551,6 +3556,10 @@ protected:
virtual void HandleBeingUnshipped () {}
virtual EventActionResult HandleBeingInterrupted () = 0;
virtual const char *GetExitString() = 0;
+ void RequestResume()
+ {
+ m_process->m_resume_requested = true;
+ }
protected:
Process *m_process;
};
@@ -3661,7 +3670,9 @@ protected:
#if defined(__APPLE__)
ReadWriteLock m_private_run_lock;
#endif
- Predicate<bool> m_currently_handling_event;
+ Predicate<bool> m_currently_handling_event; // This predicate is set in HandlePrivateEvent while all its business is being done.
+ bool m_currently_handling_do_on_removals;
+ bool m_resume_requested; // If m_currently_handling_event or m_currently_handling_do_on_removals are true, Resume will only request a resume, using this flag to check.
bool m_finalize_called;
lldb::StateType m_last_broadcast_state; /// This helps with the Public event coalescing in ShouldBroadcastEvent.
bool m_destroy_in_process;
@@ -3679,7 +3690,7 @@ protected:
SynchronouslyNotifyStateChanged (lldb::StateType state);
void
- SetPublicState (lldb::StateType new_state);
+ SetPublicState (lldb::StateType new_state, bool restarted);
void
SetPrivateState (lldb::StateType state);
Modified: lldb/trunk/include/lldb/Target/StopInfo.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/StopInfo.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/StopInfo.h (original)
+++ lldb/trunk/include/lldb/Target/StopInfo.h Tue May 7 19:35:16 2013
@@ -79,11 +79,20 @@ public:
return true;
}
+ void
+ OverrideShouldNotify (bool override_value)
+ {
+ m_override_should_notify = override_value ? eLazyBoolYes : eLazyBoolNo;
+ }
+
// If should stop returns false, check if we should notify of this event
virtual bool
ShouldNotify (Event *event_ptr)
{
- return false;
+ if (m_override_should_notify == eLazyBoolCalculate)
+ return DoShouldNotify (event_ptr);
+ else
+ return m_override_should_notify == eLazyBoolYes;
}
virtual void
@@ -116,20 +125,19 @@ public:
void
OverrideShouldStop (bool override_value)
{
- m_override_set = true;
- m_override_value = override_value;
+ m_override_should_stop = override_value ? eLazyBoolYes : eLazyBoolNo;
}
bool
GetOverrideShouldStop()
{
- return m_override_set;
+ return m_override_should_stop != eLazyBoolCalculate;
}
bool
GetOverriddenShouldStopValue ()
{
- return m_override_value;
+ return m_override_should_stop == eLazyBoolYes;
}
static lldb::StopInfoSP
@@ -169,6 +177,12 @@ protected:
{
}
+ virtual bool
+ DoShouldNotify (Event *event_ptr)
+ {
+ return false;
+ }
+
// Stop the thread by default. Subclasses can override this to allow
// the thread to continue if desired. The ShouldStop method should not do anything
// that might run code. If you need to run code when deciding whether to stop
@@ -189,8 +203,8 @@ protected:
uint32_t m_resume_id; // This is the resume ID when we made this stop ID.
uint64_t m_value; // A generic value that can be used for things pertaining to this stop info
std::string m_description; // A textual description describing this stop.
- bool m_override_set;
- bool m_override_value;
+ LazyBool m_override_should_notify;
+ LazyBool m_override_should_stop;
// This determines whether the target has run since this stop info.
// N.B. running to evaluate a user expression does not count.
Modified: lldb/trunk/include/lldb/Target/Thread.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Thread.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Thread.h (original)
+++ lldb/trunk/include/lldb/Target/Thread.h Tue May 7 19:35:16 2013
@@ -288,7 +288,7 @@ public:
Vote
ShouldReportStop (Event *event_ptr);
-
+
Vote
ShouldReportRun (Event *event_ptr);
@@ -927,6 +927,9 @@ public:
void
SetStopInfo (const lldb::StopInfoSP &stop_info_sp);
+ void
+ SetShouldReportStop (Vote vote);
+
protected:
friend class ThreadPlan;
@@ -1015,7 +1018,7 @@ protected:
bool m_destroy_called; // This is used internally to make sure derived Thread classes call DestroyThread.
uint32_t m_thread_stop_reason_stop_id; // This is the stop id for which the StopInfo is valid. Can use this so you know that
// the thread's m_actual_stop_info_sp is current and you don't have to fetch it again
-
+ LazyBool m_override_should_notify;
private:
//------------------------------------------------------------------
// For Thread only
Modified: lldb/trunk/include/lldb/Target/ThreadList.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadList.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadList.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadList.h Tue May 7 19:35:16 2013
@@ -137,6 +137,9 @@ public:
protected:
void
+ SetShouldReportStop (Vote vote);
+
+ void
NotifySelectedThreadChanged (lldb::tid_t tid);
typedef std::vector<lldb::ThreadSP> collection;
Modified: lldb/trunk/include/lldb/Target/ThreadPlan.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlan.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlan.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlan.h Tue May 7 19:35:16 2013
@@ -92,7 +92,8 @@ namespace lldb_private {
// When the target process is about to be restarted, the plan's WillResume method is called,
// giving the plan a chance to prepare for the run. If WillResume returns false, then the
// process is not restarted. Be sure to set an appropriate error value in the Process if
-// you have to do this.
+// you have to do this. Note, ThreadPlans actually implement DoWillResume, WillResume wraps that call.
+//
// Next the "StopOthers" method of all the threads are polled, and if one thread's Current plan
// returns "true" then only that thread gets to run. If more than one returns "true" the threads that want to run solo
// get run one by one round robin fashion. Otherwise all are let to run.
@@ -115,6 +116,8 @@ namespace lldb_private {
// figure out what to do about the plans below it in the stack. If the stop is recoverable, then the plan that
// understands it can just do what it needs to set up to restart, and then continue.
// Otherwise, the plan that understood the stop should call DiscardPlanStack to clean up the stack below it.
+// Note, plans actually implement DoPlanExplainsStop, the result is cached in PlanExplainsStop so the DoPlanExplainsStop
+// itself will only get called once per stop.
//
// Master plans:
//
@@ -331,9 +334,6 @@ public:
virtual bool
ValidatePlan (Stream *error) = 0;
- virtual bool
- PlanExplainsStop (Event *event_ptr) = 0;
-
bool
TracerExplainsStop ()
{
@@ -347,6 +347,9 @@ public:
lldb::StateType
RunState ();
+ bool
+ PlanExplainsStop (Event *event_ptr);
+
virtual bool
ShouldStop (Event *event_ptr) = 0;
@@ -371,9 +374,11 @@ public:
virtual bool
StopOthers ();
- virtual bool
+ // This is the wrapper for DoWillResume that does generic ThreadPlan logic, then
+ // calls DoWillResume.
+ bool
WillResume (lldb::StateType resume_state, bool current_plan);
-
+
virtual bool
WillStop () = 0;
@@ -510,6 +515,12 @@ protected:
// Classes that inherit from ThreadPlan can see and modify these
//------------------------------------------------------------------
+ virtual bool
+ DoWillResume (lldb::StateType resume_state, bool current_plan) { return true; };
+
+ virtual bool
+ DoPlanExplainsStop (Event *event_ptr) = 0;
+
// This gets the previous plan to the current plan (for forwarding requests).
// This is mostly a formal requirement, it allows us to make the Thread's
// GetPreviousPlan protected, but only friend ThreadPlan to thread.
@@ -535,6 +546,18 @@ protected:
m_thread.SetStopInfo (stop_reason_sp);
}
+ void
+ CachePlanExplainsStop (bool does_explain)
+ {
+ m_cached_plan_explains_stop = does_explain ? eLazyBoolYes : eLazyBoolNo;
+ }
+
+ LazyBool
+ GetCachedPlanExplainsStop () const
+ {
+ return m_cached_plan_explains_stop;
+ }
+
virtual lldb::StateType
GetPlanRunState () = 0;
@@ -551,6 +574,7 @@ private:
ThreadPlanKind m_kind;
std::string m_name;
Mutex m_plan_complete_mutex;
+ LazyBool m_cached_plan_explains_stop;
bool m_plan_complete;
bool m_plan_private;
bool m_okay_to_discard;
Modified: lldb/trunk/include/lldb/Target/ThreadPlanBase.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanBase.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanBase.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanBase.h Tue May 7 19:35:16 2013
@@ -35,13 +35,12 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
+ virtual Vote ShouldReportStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
virtual bool WillStop ();
virtual bool MischiefManaged ();
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool OkayToDiscard()
{
@@ -55,6 +54,8 @@ public:
}
protected:
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
ThreadPlanBase (Thread &thread);
private:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h Tue May 7 19:35:16 2013
@@ -59,9 +59,6 @@ public:
ValidatePlan (Stream *error);
virtual bool
- PlanExplainsStop (Event *event_ptr);
-
- virtual bool
ShouldStop (Event *event_ptr);
virtual Vote
@@ -135,8 +132,12 @@ public:
virtual bool
RestoreThreadState();
-protected:
+protected:
void ReportRegisterState (const char *message);
+
+ virtual bool
+ DoPlanExplainsStop (Event *event_ptr);
+
private:
bool
Modified: lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h Tue May 7 19:35:16 2013
@@ -47,9 +47,6 @@ public:
ValidatePlan (Stream *error);
virtual bool
- PlanExplainsStop (Event *event_ptr);
-
- virtual bool
ShouldStop (Event *event_ptr);
virtual bool
@@ -68,6 +65,9 @@ public:
MischiefManaged ();
protected:
+ virtual bool
+ DoPlanExplainsStop (Event *event_ptr);
+
void SetInitialBreakpoints();
bool AtOurAddress();
private:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h Tue May 7 19:35:16 2013
@@ -59,13 +59,12 @@ public:
static void
SetDefaultFlagValue (uint32_t new_value);
-
- virtual bool
- PlanExplainsStop (Event *event_ptr);
-
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
protected:
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+
+ virtual bool
+ DoPlanExplainsStop (Event *event_ptr);
virtual void
SetFlagsToDefault ();
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h Tue May 7 19:35:16 2013
@@ -27,7 +27,6 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
@@ -35,6 +34,8 @@ public:
virtual bool MischiefManaged ();
protected:
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+
ThreadPlanStepInstruction (Thread &thread,
bool step_over,
bool stop_others,
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h Tue May 7 19:35:16 2013
@@ -34,11 +34,9 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool WillStop ();
virtual bool MischiefManaged ();
virtual void DidPush();
@@ -50,6 +48,8 @@ public:
}
protected:
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
bool QueueInlinedStepPlan (bool queue_now);
private:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h Tue May 7 19:35:16 2013
@@ -27,17 +27,17 @@ public:
ThreadPlanStepOverBreakpoint (Thread &thread);
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool WillStop ();
virtual bool MischiefManaged ();
void SetAutoContinue (bool do_it);
virtual bool ShouldAutoContinue(Event *event_ptr);
protected:
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
private:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h Tue May 7 19:35:16 2013
@@ -34,10 +34,10 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ShouldStop (Event *event_ptr);
- virtual bool PlanExplainsStop (Event *event_ptr);
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
protected:
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
private:
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h Tue May 7 19:35:16 2013
@@ -26,16 +26,17 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool WillStop ();
virtual bool MischiefManaged ();
virtual void DidPush();
protected:
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+
ThreadPlanStepThrough (Thread &thread,
StackID &return_stack_id,
bool stop_others);
Modified: lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h (original)
+++ lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h Tue May 7 19:35:16 2013
@@ -27,15 +27,16 @@ public:
virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
virtual bool ValidatePlan (Stream *error);
- virtual bool PlanExplainsStop (Event *event_ptr);
virtual bool ShouldStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
- virtual bool WillResume (lldb::StateType resume_state, bool current_plan);
virtual bool WillStop ();
virtual bool MischiefManaged ();
protected:
+ virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+ virtual bool DoPlanExplainsStop (Event *event_ptr);
+
ThreadPlanStepUntil (Thread &thread,
lldb::addr_t *address_list,
size_t num_addresses,
Modified: lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/Run%20Testsuite.xcscheme?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme (original)
+++ lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/Run Testsuite.xcscheme Tue May 7 19:35:16 2013
@@ -79,7 +79,11 @@
isEnabled = "YES">
</CommandLineArgument>
<CommandLineArgument
- argument = "python_api/hello_world"
+ argument = "-f"
+ isEnabled = "YES">
+ </CommandLineArgument>
+ <CommandLineArgument
+ argument = "ConditionalBreakTestCase.test_with_dwarf_command"
isEnabled = "YES">
</CommandLineArgument>
</CommandLineArguments>
Modified: lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp (original)
+++ lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp Tue May 7 19:35:16 2013
@@ -126,7 +126,7 @@ AppleThreadPlanStepThroughObjCTrampoline
}
bool
-AppleThreadPlanStepThroughObjCTrampoline::PlanExplainsStop (Event *event_ptr)
+AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop (Event *event_ptr)
{
// If we get asked to explain the stop it will be because something went
// wrong (like the implementation for selector function crashed... We're going
Modified: lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h (original)
+++ lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h Tue May 7 19:35:16 2013
@@ -45,10 +45,6 @@ public:
virtual bool
ValidatePlan (Stream *error);
- virtual bool
- PlanExplainsStop (Event *event_ptr);
-
-
virtual lldb::StateType
GetPlanRunState ();
@@ -81,6 +77,8 @@ protected:
//------------------------------------------------------------------
// Classes that inherit from AppleThreadPlanStepThroughObjCTrampoline can see and modify these
//------------------------------------------------------------------
+ virtual bool
+ DoPlanExplainsStop (Event *event_ptr);
private:
bool
Modified: lldb/trunk/source/Target/Process.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/Process.cpp (original)
+++ lldb/trunk/source/Target/Process.cpp Tue May 7 19:35:16 2013
@@ -1643,11 +1643,11 @@ Process::GetState()
}
void
-Process::SetPublicState (StateType new_state)
+Process::SetPublicState (StateType new_state, bool restarted)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
if (log)
- log->Printf("Process::SetPublicState (%s)", StateAsCString(new_state));
+ log->Printf("Process::SetPublicState (state = %s, restarted = %i)", StateAsCString(new_state), restarted);
const StateType old_state = m_public_state.GetValue();
m_public_state.SetValue (new_state);
@@ -1666,9 +1666,9 @@ Process::SetPublicState (StateType new_s
{
const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
- if (old_state_is_stopped != new_state_is_stopped)
+ if ((old_state_is_stopped != new_state_is_stopped))
{
- if (new_state_is_stopped)
+ if (new_state_is_stopped && !restarted)
{
if (log)
log->Printf("Process::SetPublicState (%s) -- unlocking run lock", StateAsCString(new_state));
@@ -2866,7 +2866,8 @@ Process::Launch (const ProcessLaunchInfo
error = WillLaunch (exe_module);
if (error.Success())
{
- SetPublicState (eStateLaunching);
+ const bool restarted = false;
+ SetPublicState (eStateLaunching, restarted);
m_should_detach = false;
if (m_public_run_lock.WriteTryLock())
@@ -2993,11 +2994,13 @@ Process::AttachCompletionHandler::Perfor
// During attach, prior to sending the eStateStopped event,
// lldb_private::Process subclasses must set the new process ID.
assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
+ // We don't want these events to be reported, so go set the ShouldReportStop here:
+ m_process->GetThreadList().SetShouldReportStop (eVoteNo);
+
if (m_exec_count > 0)
{
--m_exec_count;
- m_process->PrivateResume ();
- Process::ProcessEventData::SetRestartedInEvent (event_sp.get(), true);
+ RequestResume();
return eEventActionRetry;
}
else
@@ -3056,7 +3059,8 @@ Process::Attach (ProcessAttachInfo &atta
if (m_public_run_lock.WriteTryLock())
{
m_should_detach = true;
- SetPublicState (eStateAttaching);
+ const bool restarted = false;
+ SetPublicState (eStateAttaching, restarted);
// Now attach using these arguments.
error = DoAttachToProcessWithName (process_name, wait_for_launch, attach_info);
}
@@ -3134,7 +3138,8 @@ Process::Attach (ProcessAttachInfo &atta
{
// Now attach using these arguments.
m_should_detach = true;
- SetPublicState (eStateAttaching);
+ const bool restarted = false;
+ SetPublicState (eStateAttaching, restarted);
error = DoAttachToProcessWithID (attach_pid, attach_info);
}
else
@@ -3287,7 +3292,7 @@ Process::PrivateResume ()
// that they are supposed to have when the process is resumed
// (suspended/running/stepping). Threads should also check
// their resume signal in lldb::Thread::GetResumeSignal()
- // to see if they are suppoed to start back up with a signal.
+ // to see if they are supposed to start back up with a signal.
if (m_thread_list.WillResume())
{
// Last thing, do the PreResumeActions.
@@ -3677,6 +3682,7 @@ Process::ShouldBroadcastEvent (Event *ev
// If we are going to stop, then we always broadcast the event.
// If we aren't going to stop, let the thread plans decide if we're going to report this event.
// If no thread has an opinion, we don't report it.
+
RefreshStateAfterStop ();
if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
{
@@ -3688,15 +3694,17 @@ Process::ShouldBroadcastEvent (Event *ev
}
else
{
+ bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
+ bool should_resume = false;
+
// It makes no sense to ask "ShouldStop" if we've already been restarted...
// Asking the thread list is also not likely to go well, since we are running again.
// So in that case just report the event.
- bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
- bool should_resume = false;
if (!was_restarted)
should_resume = m_thread_list.ShouldStop (event_ptr) == false;
- if (was_restarted || should_resume)
+
+ if (was_restarted || should_resume || m_resume_requested)
{
Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
if (log)
@@ -3883,6 +3891,8 @@ void
Process::HandlePrivateEvent (EventSP &event_sp)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ m_resume_requested = false;
+
m_currently_handling_event.SetValue(true, eBroadcastNever);
const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
@@ -3911,6 +3921,7 @@ Process::HandlePrivateEvent (EventSP &ev
{
// FIXME: should cons up an exited event, and discard this one.
SetExitStatus(0, m_next_event_action_ap->GetExitString());
+ m_currently_handling_event.SetValue(false, eBroadcastAlways);
SetNextEventAction(NULL);
return;
}
@@ -4095,12 +4106,11 @@ Process::ProcessEventData::DoOnRemoval (
// the public event queue, then other times when we're pretending that this is where we stopped at the
// end of expression evaluation. m_update_state is used to distinguish these
// three cases; it is 0 when we're just pulling it off for private handling,
- // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
-
+ // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
if (m_update_state != 1)
return;
- m_process_sp->SetPublicState (m_state);
+ m_process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
// If we're stopped and haven't restarted, then do the breakpoint commands here:
if (m_state == eStateStopped && ! m_restarted)
Modified: lldb/trunk/source/Target/StopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/StopInfo.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/StopInfo.cpp (original)
+++ lldb/trunk/source/Target/StopInfo.cpp Tue May 7 19:35:16 2013
@@ -39,8 +39,8 @@ StopInfo::StopInfo (Thread &thread, uint
m_stop_id (thread.GetProcess()->GetStopID()),
m_resume_id (thread.GetProcess()->GetResumeID()),
m_value (value),
- m_override_set(false),
- m_override_value(true)
+ m_override_should_notify (eLazyBoolCalculate),
+ m_override_should_stop (eLazyBoolCalculate)
{
}
@@ -201,7 +201,7 @@ public:
}
virtual bool
- ShouldNotify (Event *event_ptr)
+ DoShouldNotify (Event *event_ptr)
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@@ -849,7 +849,7 @@ public:
// If should stop returns false, check if we should notify of this event
virtual bool
- ShouldNotify (Event *event_ptr)
+ DoShouldNotify (Event *event_ptr)
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
Modified: lldb/trunk/source/Target/Thread.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Thread.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/Thread.cpp (original)
+++ lldb/trunk/source/Target/Thread.cpp Tue May 7 19:35:16 2013
@@ -259,7 +259,8 @@ Thread::Thread (Process &process, lldb::
m_temporary_resume_state (eStateRunning),
m_unwinder_ap (),
m_destroy_called (false),
- m_thread_stop_reason_stop_id (0)
+ m_thread_stop_reason_stop_id (0),
+ m_override_should_notify (eLazyBoolCalculate)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
if (log)
@@ -394,7 +395,13 @@ Thread::SetStopInfo (const lldb::StopInf
{
m_actual_stop_info_sp = stop_info_sp;
if (m_actual_stop_info_sp)
+ {
m_actual_stop_info_sp->MakeStopInfoValid();
+ // If we are overriding the ShouldReportStop, do that here:
+ if (m_override_should_notify != eLazyBoolCalculate)
+ m_actual_stop_info_sp->OverrideShouldNotify (m_override_should_notify == eLazyBoolYes);
+ }
+
ProcessSP process_sp (GetProcess());
if (process_sp)
m_thread_stop_reason_stop_id = process_sp->GetStopID();
@@ -403,6 +410,19 @@ Thread::SetStopInfo (const lldb::StopInf
}
void
+Thread::SetShouldReportStop (Vote vote)
+{
+ if (vote == eVoteNoOpinion)
+ return;
+ else
+ {
+ m_override_should_notify = (vote == eVoteYes ? eLazyBoolYes : eLazyBoolNo);
+ if (m_actual_stop_info_sp)
+ m_actual_stop_info_sp->OverrideShouldNotify (m_override_should_notify == eLazyBoolYes);
+ }
+}
+
+void
Thread::SetStopInfoToNothing()
{
// Note, we can't just NULL out the private reason, or the native thread implementation will try to
@@ -530,6 +550,7 @@ Thread::ShouldResume (StateType resume_s
// At this point clear the completed plan stack.
m_completed_plan_stack.clear();
m_discarded_plan_stack.clear();
+ m_override_should_notify = eLazyBoolCalculate;
m_temporary_resume_state = resume_state;
Modified: lldb/trunk/source/Target/ThreadList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadList.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadList.cpp (original)
+++ lldb/trunk/source/Target/ThreadList.cpp Tue May 7 19:35:16 2013
@@ -376,6 +376,19 @@ ThreadList::ShouldReportStop (Event *eve
return result;
}
+void
+ThreadList::SetShouldReportStop (Vote vote)
+{
+ Mutex::Locker locker(GetMutex());
+ m_process->UpdateThreadListIfNeeded();
+ collection::iterator pos, end = m_threads.end();
+ for (pos = m_threads.begin(); pos != end; ++pos)
+ {
+ ThreadSP thread_sp(*pos);
+ thread_sp->SetShouldReportStop (vote);
+ }
+}
+
Vote
ThreadList::ShouldReportRun (Event *event_ptr)
{
Modified: lldb/trunk/source/Target/ThreadPlan.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlan.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlan.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlan.cpp Tue May 7 19:35:16 2013
@@ -36,6 +36,7 @@ ThreadPlan::ThreadPlan(ThreadPlanKind ki
m_kind (kind),
m_name (name),
m_plan_complete_mutex (Mutex::eMutexTypeRecursive),
+ m_cached_plan_explains_stop (eLazyBoolCalculate),
m_plan_complete (false),
m_plan_private (false),
m_okay_to_discard (true),
@@ -53,6 +54,21 @@ ThreadPlan::~ThreadPlan()
}
bool
+ThreadPlan::PlanExplainsStop (Event *event_ptr)
+{
+ if (m_cached_plan_explains_stop == eLazyBoolCalculate)
+ {
+ bool actual_value = DoPlanExplainsStop(event_ptr);
+ m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo;
+ return actual_value;
+ }
+ else
+ {
+ return m_cached_plan_explains_stop == eLazyBoolYes;
+ }
+}
+
+bool
ThreadPlan::IsPlanComplete ()
{
Mutex::Locker locker(m_plan_complete_mutex);
@@ -131,6 +147,8 @@ ThreadPlan::SetStopOthers (bool new_valu
bool
ThreadPlan::WillResume (StateType resume_state, bool current_plan)
{
+ m_cached_plan_explains_stop = eLazyBoolCalculate;
+
if (current_plan)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
@@ -154,7 +172,7 @@ ThreadPlan::WillResume (StateType resume
StopOthers());
}
}
- return true;
+ return DoWillResume (resume_state, current_plan);
}
lldb::user_id_t
Modified: lldb/trunk/source/Target/ThreadPlanBase.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanBase.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanBase.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanBase.cpp Tue May 7 19:35:16 2013
@@ -68,7 +68,7 @@ ThreadPlanBase::ValidatePlan (Stream *er
}
bool
-ThreadPlanBase::PlanExplainsStop (Event *event_ptr)
+ThreadPlanBase::DoPlanExplainsStop (Event *event_ptr)
{
// The base plan should defer to its tracer, since by default it
// always handles the stop.
@@ -78,6 +78,22 @@ ThreadPlanBase::PlanExplainsStop (Event
return true;
}
+Vote
+ThreadPlanBase::ShouldReportStop(Event *event_ptr)
+{
+ StopInfoSP stop_info_sp = m_thread.GetStopInfo ();
+ if (stop_info_sp)
+ {
+ bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
+ if (should_notify)
+ return eVoteYes;
+ else
+ return eVoteNoOpinion;
+ }
+ else
+ return eVoteNoOpinion;
+}
+
bool
ThreadPlanBase::ShouldStop (Event *event_ptr)
{
@@ -201,7 +217,7 @@ ThreadPlanBase::WillStop ()
}
bool
-ThreadPlanBase::WillResume (lldb::StateType resume_state, bool current_plan)
+ThreadPlanBase::DoWillResume (lldb::StateType resume_state, bool current_plan)
{
// Reset these to the default values so we don't set them wrong, then not get asked
// for a while, then return the wrong answer.
Modified: lldb/trunk/source/Target/ThreadPlanCallFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanCallFunction.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanCallFunction.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanCallFunction.cpp Tue May 7 19:35:16 2013
@@ -362,7 +362,7 @@ ThreadPlanCallFunction::ShouldReportStop
}
bool
-ThreadPlanCallFunction::PlanExplainsStop (Event *event_ptr)
+ThreadPlanCallFunction::DoPlanExplainsStop (Event *event_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP|LIBLLDB_LOG_PROCESS));
m_real_stop_info_sp = GetPrivateStopReason();
@@ -475,9 +475,9 @@ ThreadPlanCallFunction::PlanExplainsStop
bool
ThreadPlanCallFunction::ShouldStop (Event *event_ptr)
{
- // We do some computation in PlanExplainsStop that may or may not set the plan as complete.
+ // We do some computation in DoPlanExplainsStop that may or may not set the plan as complete.
// We need to do that here to make sure our state is correct.
- PlanExplainsStop(event_ptr);
+ DoPlanExplainsStop(event_ptr);
if (IsPlanComplete())
{
Modified: lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp Tue May 7 19:35:16 2013
@@ -188,7 +188,7 @@ ThreadPlanRunToAddress::ValidatePlan (St
}
bool
-ThreadPlanRunToAddress::PlanExplainsStop (Event *event_ptr)
+ThreadPlanRunToAddress::DoPlanExplainsStop (Event *event_ptr)
{
return AtOurAddress();
}
Modified: lldb/trunk/source/Target/ThreadPlanStepInRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepInRange.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepInRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepInRange.cpp Tue May 7 19:35:16 2013
@@ -379,7 +379,7 @@ ThreadPlanStepInRange::DefaultShouldStop
}
bool
-ThreadPlanStepInRange::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepInRange::DoPlanExplainsStop (Event *event_ptr)
{
// 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
@@ -394,41 +394,54 @@ ThreadPlanStepInRange::PlanExplainsStop
//
// The only variation is that if we are doing "step by running to next branch" in which case
// if we hit our branch breakpoint we don't set the plan to complete.
+
+ bool return_value;
if (m_virtual_step)
- return true;
-
- StopInfoSP stop_info_sp = GetPrivateStopReason();
- if (stop_info_sp)
{
- StopReason reason = stop_info_sp->GetStopReason();
-
- switch (reason)
+ return_value = true;
+ }
+ else
+ {
+ StopInfoSP stop_info_sp = GetPrivateStopReason();
+ if (stop_info_sp)
{
- case eStopReasonBreakpoint:
- if (NextRangeBreakpointExplainsStop(stop_info_sp))
- return true;
- case eStopReasonWatchpoint:
- case eStopReasonSignal:
- case eStopReasonException:
- case eStopReasonExec:
- case eStopReasonThreadExiting:
+ StopReason reason = stop_info_sp->GetStopReason();
+
+ switch (reason)
{
- Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
- if (log)
- log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
+ case eStopReasonBreakpoint:
+ if (NextRangeBreakpointExplainsStop(stop_info_sp))
+ {
+ return_value = true;
+ break;
+ }
+ case eStopReasonWatchpoint:
+ case eStopReasonSignal:
+ case eStopReasonException:
+ case eStopReasonExec:
+ case eStopReasonThreadExiting:
+ {
+ Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+ if (log)
+ log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
+ }
+ return_value = false;
+ break;
+ default:
+ return_value = true;
+ break;
}
- return false;
- break;
- default:
- break;
}
+ else
+ return_value = true;
}
- return true;
+
+ return return_value;
}
bool
-ThreadPlanStepInRange::WillResume (lldb::StateType resume_state, bool current_plan)
+ThreadPlanStepInRange::DoWillResume (lldb::StateType resume_state, bool current_plan)
{
if (resume_state == eStateStepping && current_plan)
{
@@ -438,7 +451,7 @@ ThreadPlanStepInRange::WillResume (lldb:
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (log)
- log->Printf ("ThreadPlanStepInRange::WillResume: returning false, inline_depth: %d",
+ log->Printf ("ThreadPlanStepInRange::DoWillResume: returning false, inline_depth: %d",
m_thread.GetCurrentInlinedDepth());
SetStopInfo(StopInfo::CreateStopReasonToTrace(m_thread));
@@ -448,7 +461,5 @@ ThreadPlanStepInRange::WillResume (lldb:
}
return !step_without_resume;
}
- else
- return ThreadPlan::WillResume(resume_state, current_plan);
-
+ return true;
}
Modified: lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp Tue May 7 19:35:16 2013
@@ -81,7 +81,7 @@ ThreadPlanStepInstruction::ValidatePlan
}
bool
-ThreadPlanStepInstruction::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepInstruction::DoPlanExplainsStop (Event *event_ptr)
{
StopInfoSP stop_info_sp = GetPrivateStopReason();
if (stop_info_sp)
Modified: lldb/trunk/source/Target/ThreadPlanStepOut.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepOut.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepOut.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepOut.cpp Tue May 7 19:35:16 2013
@@ -174,7 +174,7 @@ ThreadPlanStepOut::ValidatePlan (Stream
}
bool
-ThreadPlanStepOut::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepOut::DoPlanExplainsStop (Event *event_ptr)
{
// If one of our child plans just finished, then we do explain the stop.
if (m_step_out_plan_sp)
@@ -336,9 +336,8 @@ ThreadPlanStepOut::GetPlanRunState ()
}
bool
-ThreadPlanStepOut::WillResume (StateType resume_state, bool current_plan)
+ThreadPlanStepOut::DoWillResume (StateType resume_state, bool current_plan)
{
- ThreadPlan::WillResume (resume_state, current_plan);
if (m_step_out_plan_sp || m_step_through_inline_plan_sp)
return true;
Modified: lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp Tue May 7 19:35:16 2013
@@ -58,7 +58,7 @@ ThreadPlanStepOverBreakpoint::ValidatePl
}
bool
-ThreadPlanStepOverBreakpoint::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepOverBreakpoint::DoPlanExplainsStop (Event *event_ptr)
{
StopInfoSP stop_info_sp = GetPrivateStopReason();
if (stop_info_sp)
@@ -91,10 +91,8 @@ ThreadPlanStepOverBreakpoint::GetPlanRun
}
bool
-ThreadPlanStepOverBreakpoint::WillResume (StateType resume_state, bool current_plan)
+ThreadPlanStepOverBreakpoint::DoWillResume (StateType resume_state, bool current_plan)
{
- ThreadPlan::WillResume (resume_state, current_plan);
-
if (current_plan)
{
BreakpointSiteSP bp_site_sp (m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress (m_breakpoint_addr));
Modified: lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp Tue May 7 19:35:16 2013
@@ -290,7 +290,7 @@ ThreadPlanStepOverRange::ShouldStop (Eve
}
bool
-ThreadPlanStepOverRange::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepOverRange::DoPlanExplainsStop (Event *event_ptr)
{
// For crashes, breakpoint hits, signals, etc, let the base plan (or some plan above us)
// handle the stop. That way the user can see the stop, step around, and then when they
@@ -301,6 +301,8 @@ ThreadPlanStepOverRange::PlanExplainsSto
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
StopInfoSP stop_info_sp = GetPrivateStopReason();
+ bool return_value;
+
if (stop_info_sp)
{
StopReason reason = stop_info_sp->GetStopReason();
@@ -308,13 +310,13 @@ ThreadPlanStepOverRange::PlanExplainsSto
switch (reason)
{
case eStopReasonTrace:
- return true;
+ return_value = true;
break;
case eStopReasonBreakpoint:
if (NextRangeBreakpointExplainsStop(stop_info_sp))
- return true;
+ return_value = true;
else
- return false;
+ return_value = false;
break;
case eStopReasonWatchpoint:
case eStopReasonSignal:
@@ -324,15 +326,18 @@ ThreadPlanStepOverRange::PlanExplainsSto
default:
if (log)
log->PutCString ("ThreadPlanStepInRange got asked if it explains the stop for some reason other than step.");
- return false;
+ return_value = false;
break;
}
}
- return true;
+ else
+ return_value = true;
+
+ return return_value;
}
bool
-ThreadPlanStepOverRange::WillResume (lldb::StateType resume_state, bool current_plan)
+ThreadPlanStepOverRange::DoWillResume (lldb::StateType resume_state, bool current_plan)
{
if (resume_state != eStateSuspended && m_first_resume)
{
@@ -346,7 +351,7 @@ ThreadPlanStepOverRange::WillResume (lld
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (log)
- log->Printf ("ThreadPlanStepInRange::WillResume: adjusting range to the frame at inlined depth %d.",
+ log->Printf ("ThreadPlanStepInRange::DoWillResume: adjusting range to the frame at inlined depth %d.",
m_thread.GetCurrentInlinedDepth());
StackFrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
if (stack_sp)
@@ -379,5 +384,5 @@ ThreadPlanStepOverRange::WillResume (lld
}
}
- return ThreadPlan::WillResume(resume_state, current_plan);
+ return true;
}
Modified: lldb/trunk/source/Target/ThreadPlanStepThrough.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepThrough.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepThrough.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepThrough.cpp Tue May 7 19:35:16 2013
@@ -139,7 +139,7 @@ ThreadPlanStepThrough::ValidatePlan (Str
}
bool
-ThreadPlanStepThrough::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepThrough::DoPlanExplainsStop (Event *event_ptr)
{
// 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
@@ -223,9 +223,8 @@ ThreadPlanStepThrough::GetPlanRunState (
}
bool
-ThreadPlanStepThrough::WillResume (StateType resume_state, bool current_plan)
+ThreadPlanStepThrough::DoWillResume (StateType resume_state, bool current_plan)
{
- ThreadPlan::WillResume(resume_state, current_plan);
return true;
}
Modified: lldb/trunk/source/Target/ThreadPlanStepUntil.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanStepUntil.cpp?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanStepUntil.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanStepUntil.cpp Tue May 7 19:35:16 2013
@@ -305,7 +305,7 @@ ThreadPlanStepUntil::AnalyzeStop()
}
bool
-ThreadPlanStepUntil::PlanExplainsStop (Event *event_ptr)
+ThreadPlanStepUntil::DoPlanExplainsStop (Event *event_ptr)
{
// We don't explain signals or breakpoints (breakpoints that handle stepping in or
// out will be handled by a child plan.
@@ -341,9 +341,8 @@ ThreadPlanStepUntil::GetPlanRunState ()
}
bool
-ThreadPlanStepUntil::WillResume (StateType resume_state, bool current_plan)
+ThreadPlanStepUntil::DoWillResume (StateType resume_state, bool current_plan)
{
- ThreadPlan::WillResume (resume_state, current_plan);
if (current_plan)
{
TargetSP target_sp (m_thread.CalculateTarget());
Modified: lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py?rev=181381&r1=181380&r2=181381&view=diff
==============================================================================
--- lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py (original)
+++ lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py Tue May 7 19:35:16 2013
@@ -129,6 +129,8 @@ class ObjCDynamicValueTestCase(TestBase)
threads = lldbutil.get_stopped_threads (process, lldb.eStopReasonPlanComplete)
self.assertTrue (len(threads) == 1)
line_entry = threads[0].GetFrameAtIndex(0).GetLineEntry()
+ print "Line entry is: ", line_entry
+
self.assertTrue (line_entry.GetLine() == self.set_property_line)
self.assertTrue (line_entry.GetFileSpec().GetFilename() == self.source_name)
More information about the lldb-commits
mailing list