1 //===-- StopInfo.cpp ---------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/lldb-python.h"
12 #include "lldb/Target/StopInfo.h"
18 // Other libraries and framework includes
20 #include "lldb/Core/Log.h"
21 #include "lldb/Breakpoint/Breakpoint.h"
22 #include "lldb/Breakpoint/BreakpointLocation.h"
23 #include "lldb/Breakpoint/StoppointCallbackContext.h"
24 #include "lldb/Breakpoint/Watchpoint.h"
25 #include "lldb/Core/Debugger.h"
26 #include "lldb/Core/StreamString.h"
27 #include "lldb/Expression/ClangUserExpression.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Target/Thread.h"
30 #include "lldb/Target/ThreadPlan.h"
31 #include "lldb/Target/Process.h"
32 #include "lldb/Target/UnixSignals.h"
35 using namespace lldb_private;
37 StopInfo::StopInfo (Thread &thread, uint64_t value) :
38 m_thread_wp (thread.shared_from_this()),
39 m_stop_id (thread.GetProcess()->GetStopID()),
40 m_resume_id (thread.GetProcess()->GetResumeID()),
42 m_override_should_notify (eLazyBoolCalculate),
43 m_override_should_stop (eLazyBoolCalculate)
48 StopInfo::IsValid () const
50 ThreadSP thread_sp (m_thread_wp.lock());
52 return thread_sp->GetProcess()->GetStopID() == m_stop_id;
57 StopInfo::MakeStopInfoValid ()
59 ThreadSP thread_sp (m_thread_wp.lock());
62 m_stop_id = thread_sp->GetProcess()->GetStopID();
63 m_resume_id = thread_sp->GetProcess()->GetResumeID();
68 StopInfo::HasTargetRunSinceMe ()
70 ThreadSP thread_sp (m_thread_wp.lock());
74 lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
75 if (ret_type == eStateRunning)
79 else if (ret_type == eStateStopped)
81 // This is a little tricky. We want to count "run and stopped again before you could
82 // ask this question as a "TRUE" answer to HasTargetRunSinceMe. But we don't want to
83 // include any running of the target done for expressions. So we track both resumes,
84 // and resumes caused by expressions, and check if there are any resumes NOT caused
87 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
88 uint32_t last_user_expression_id = thread_sp->GetProcess()->GetLastUserExpressionResumeID ();
89 if (curr_resume_id == m_resume_id)
93 else if (curr_resume_id > last_user_expression_id)
102 //----------------------------------------------------------------------
103 // StopInfoBreakpoint
104 //----------------------------------------------------------------------
106 namespace lldb_private
108 class StopInfoBreakpoint : public StopInfo
112 StopInfoBreakpoint (Thread &thread, break_id_t break_id) :
113 StopInfo (thread, break_id),
115 m_should_stop (false),
116 m_should_stop_is_valid (false),
117 m_should_perform_action (true),
118 m_address (LLDB_INVALID_ADDRESS),
119 m_break_id(LLDB_INVALID_BREAK_ID),
120 m_was_one_shot (false)
125 StopInfoBreakpoint (Thread &thread, break_id_t break_id, bool should_stop) :
126 StopInfo (thread, break_id),
128 m_should_stop (should_stop),
129 m_should_stop_is_valid (true),
130 m_should_perform_action (true),
131 m_address (LLDB_INVALID_ADDRESS),
132 m_break_id(LLDB_INVALID_BREAK_ID),
133 m_was_one_shot (false)
141 ThreadSP thread_sp (m_thread_wp.lock());
144 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
147 if (bp_site_sp->GetNumberOfOwners() == 1)
149 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
152 m_break_id = bp_loc_sp->GetBreakpoint().GetID();
153 m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
156 m_address = bp_site_sp->GetLoadAddress();
161 virtual ~StopInfoBreakpoint ()
166 GetStopReason () const
168 return eStopReasonBreakpoint;
172 ShouldStopSynchronous (Event *event_ptr)
174 ThreadSP thread_sp (m_thread_wp.lock());
177 if (!m_should_stop_is_valid)
179 // Only check once if we should stop at a breakpoint
180 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
183 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
184 StoppointCallbackContext context (event_ptr, exe_ctx, true);
185 m_should_stop = bp_site_sp->ShouldStop (&context);
189 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
192 log->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
194 m_should_stop = true;
196 m_should_stop_is_valid = true;
198 return m_should_stop;
204 DoShouldNotify (Event *event_ptr)
206 ThreadSP thread_sp (m_thread_wp.lock());
209 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
212 bool all_internal = true;
214 for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++)
216 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal())
218 all_internal = false;
222 return all_internal == false;
231 if (m_description.empty())
233 ThreadSP thread_sp (m_thread_wp.lock());
236 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
240 // If we have just hit an internal breakpoint, and it has a kind description, print that instead of the
241 // full breakpoint printing:
242 if (bp_site_sp->IsInternal())
244 size_t num_owners = bp_site_sp->GetNumberOfOwners();
245 for (size_t idx = 0; idx < num_owners; idx++)
247 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)->GetBreakpoint().GetBreakpointKind();
250 m_description.assign (kind);
256 strm.Printf("breakpoint ");
257 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
258 m_description.swap (strm.GetString());
263 if (m_break_id != LLDB_INVALID_BREAK_ID)
265 BreakpointSP break_sp = thread_sp->GetProcess()->GetTarget().GetBreakpointByID(m_break_id);
268 if (break_sp->IsInternal())
270 const char *kind = break_sp->GetBreakpointKind();
272 strm.Printf ("internal %s breakpoint(%d).", kind, m_break_id);
274 strm.Printf ("internal breakpoint(%d).", m_break_id);
278 strm.Printf ("breakpoint %d.", m_break_id);
284 strm.Printf ("one-shot breakpoint %d", m_break_id);
286 strm.Printf ("breakpoint %d which has been deleted.", m_break_id);
289 else if (m_address == LLDB_INVALID_ADDRESS)
290 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - unknown address", m_value);
292 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - was at 0x%" PRIx64, m_value, m_address);
294 m_description.swap (strm.GetString());
298 return m_description.c_str();
303 ShouldStop (Event *event_ptr)
305 // This just reports the work done by PerformAction or the synchronous stop. It should
306 // only ever get called after they have had a chance to run.
307 assert (m_should_stop_is_valid);
308 return m_should_stop;
312 PerformAction (Event *event_ptr)
314 if (!m_should_perform_action)
316 m_should_perform_action = false;
318 ThreadSP thread_sp (m_thread_wp.lock());
322 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
324 if (!thread_sp->IsValid())
326 // This shouldn't ever happen, but just in case, don't do more harm.
329 log->Printf ("PerformAction got called with an invalid thread.");
331 m_should_stop = true;
332 m_should_stop_is_valid = true;
336 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
340 size_t num_owners = bp_site_sp->GetNumberOfOwners();
344 m_should_stop = true;
348 // We go through each location, and test first its condition. If the condition says to stop,
349 // then we run the callback for that location. If that callback says to stop as well, then
350 // we set m_should_stop to true; we are going to stop.
351 // But we still want to give all the breakpoints whose conditions say we are going to stop a
352 // chance to run their callbacks.
353 // Of course if any callback restarts the target by putting "continue" in the callback, then
354 // we're going to restart, without running the rest of the callbacks. And in this case we will
355 // end up not stopping even if another location said we should stop. But that's better than not
356 // running all the callbacks.
358 m_should_stop = false;
360 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
361 Process *process = exe_ctx.GetProcessPtr();
362 if (process->GetModIDRef().IsLastResumeForUserExpression())
364 // If we are in the middle of evaluating an expression, don't run asynchronous breakpoint commands or
365 // expressions. That could lead to infinite recursion if the command or condition re-calls the function
366 // with this breakpoint.
367 // TODO: We can keep a list of the breakpoints we've seen while running expressions in the nested
368 // PerformAction calls that can arise when the action runs a function that hits another breakpoint,
369 // and only stop running commands when we see the same breakpoint hit a second time.
371 m_should_stop_is_valid = true;
373 log->Printf ("StopInfoBreakpoint::PerformAction - Hit a breakpoint while running an expression,"
374 " not running commands to avoid recursion.");
375 bool ignoring_breakpoints = process->GetIgnoreBreakpointsInExpressions();
376 if (ignoring_breakpoints)
378 m_should_stop = false;
379 // Internal breakpoints will always stop.
380 for (size_t j = 0; j < num_owners; j++)
382 lldb::BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(j);
383 if (bp_loc_sp->GetBreakpoint().IsInternal())
385 m_should_stop = true;
392 m_should_stop = true;
395 log->Printf ("StopInfoBreakpoint::PerformAction - in expression, continuing: %s.",
396 m_should_stop ? "true" : "false");
397 process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf("Warning: hit breakpoint while "
398 "running function, skipping commands and conditions to prevent recursion.");
402 StoppointCallbackContext context (event_ptr, exe_ctx, false);
404 // Let's copy the breakpoint locations out of the site and store them in a local list. That way if
405 // one of the breakpoint actions changes the site, then we won't be operating on a bad list.
407 BreakpointLocationCollection site_locations;
408 for (size_t j = 0; j < num_owners; j++)
409 site_locations.Add(bp_site_sp->GetOwnerAtIndex(j));
411 for (size_t j = 0; j < num_owners; j++)
413 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
415 // If another action disabled this breakpoint or its location, then don't run the actions.
416 if (!bp_loc_sp->IsEnabled() || !bp_loc_sp->GetBreakpoint().IsEnabled())
419 // The breakpoint site may have many locations associated with it, not all of them valid for
420 // this thread. Skip the ones that aren't:
421 if (!bp_loc_sp->ValidForThisThread(thread_sp.get()))
424 // First run the condition for the breakpoint. If that says we should stop, then we'll run
425 // the callback for the breakpoint. If the callback says we shouldn't stop that will win.
427 if (bp_loc_sp->GetConditionText() != NULL)
429 Error condition_error;
430 bool condition_says_stop = bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
432 if (!condition_error.Success())
434 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
435 StreamSP error_sp = debugger.GetAsyncErrorStream ();
436 error_sp->Printf ("Stopped due to an error evaluating condition of breakpoint ");
437 bp_loc_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
438 error_sp->Printf (": \"%s\"",
439 bp_loc_sp->GetConditionText());
441 const char *err_str = condition_error.AsCString("<Unknown Error>");
443 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
445 error_sp->PutCString (err_str);
448 // If the condition fails to be parsed or run, we should stop.
449 condition_says_stop = true;
453 if (!condition_says_stop)
458 bool callback_says_stop;
460 // FIXME: For now the callbacks have to run in async mode - the first time we restart we need
461 // to get out of there. So set it here.
462 // When we figure out how to nest breakpoint hits then this will change.
464 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
465 bool old_async = debugger.GetAsyncExecution();
466 debugger.SetAsyncExecution (true);
468 callback_says_stop = bp_loc_sp->InvokeCallback (&context);
470 debugger.SetAsyncExecution (old_async);
472 if (callback_says_stop)
473 m_should_stop = true;
475 // If we are going to stop for this breakpoint, then remove the breakpoint.
476 if (callback_says_stop && bp_loc_sp && bp_loc_sp->GetBreakpoint().IsOneShot())
478 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID (bp_loc_sp->GetBreakpoint().GetID());
481 // Also make sure that the callback hasn't continued the target.
482 // If it did, when we'll set m_should_start to false and get out of here.
483 if (HasTargetRunSinceMe ())
485 m_should_stop = false;
490 // We've figured out what this stop wants to do, so mark it as valid so we don't compute it again.
491 m_should_stop_is_valid = true;
496 m_should_stop = true;
497 m_should_stop_is_valid = true;
498 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
501 log_process->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
504 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
509 std::string m_description;
511 bool m_should_stop_is_valid;
512 bool m_should_perform_action; // Since we are trying to preserve the "state" of the system even if we run functions
513 // etc. behind the users backs, we need to make sure we only REALLY perform the action once.
514 lldb::addr_t m_address; // We use this to capture the breakpoint site address when we create the StopInfo,
515 // in case somebody deletes it between the time the StopInfo is made and the
516 // description is asked for.
517 lldb::break_id_t m_break_id;
522 //----------------------------------------------------------------------
523 // StopInfoWatchpoint
524 //----------------------------------------------------------------------
526 class StopInfoWatchpoint : public StopInfo
529 // Make sure watchpoint is properly disabled and subsequently enabled while performing watchpoint actions.
530 class WatchpointSentry {
532 WatchpointSentry(Process *p, Watchpoint *w):
536 if (process && watchpoint)
538 const bool notify = false;
539 watchpoint->TurnOnEphemeralMode();
540 process->DisableWatchpoint(watchpoint, notify);
545 if (process && watchpoint)
547 if (!watchpoint->IsDisabledDuringEphemeralMode())
549 const bool notify = false;
550 process->EnableWatchpoint(watchpoint, notify);
552 watchpoint->TurnOffEphemeralMode();
557 Watchpoint *watchpoint;
560 StopInfoWatchpoint (Thread &thread, break_id_t watch_id) :
561 StopInfo(thread, watch_id),
563 m_should_stop(false),
564 m_should_stop_is_valid(false)
568 virtual ~StopInfoWatchpoint ()
573 GetStopReason () const
575 return eStopReasonWatchpoint;
581 if (m_description.empty())
584 strm.Printf("watchpoint %" PRIi64, m_value);
585 m_description.swap (strm.GetString());
587 return m_description.c_str();
592 ShouldStopSynchronous (Event *event_ptr)
594 // ShouldStop() method is idempotent and should not affect hit count.
595 // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
596 // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
597 // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
598 // StopInfoWatchpoint::ShouldStop() and
599 // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
600 // StopInfoWatchpoint::PerformAction().
601 if (m_should_stop_is_valid)
602 return m_should_stop;
604 ThreadSP thread_sp (m_thread_wp.lock());
607 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
610 // Check if we should stop at a watchpoint.
611 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
612 StoppointCallbackContext context (event_ptr, exe_ctx, true);
613 m_should_stop = wp_sp->ShouldStop (&context);
617 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
620 log->Printf ("Process::%s could not find watchpoint location id: %" PRId64 "...",
621 __FUNCTION__, GetValue());
623 m_should_stop = true;
626 m_should_stop_is_valid = true;
627 return m_should_stop;
631 ShouldStop (Event *event_ptr)
633 // This just reports the work done by PerformAction or the synchronous stop. It should
634 // only ever get called after they have had a chance to run.
635 assert (m_should_stop_is_valid);
636 return m_should_stop;
640 PerformAction (Event *event_ptr)
642 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS);
643 // We're going to calculate if we should stop or not in some way during the course of
644 // this code. Also by default we're going to stop, so set that here.
645 m_should_stop = true;
647 ThreadSP thread_sp (m_thread_wp.lock());
651 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
654 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
655 Process* process = exe_ctx.GetProcessPtr();
657 // This sentry object makes sure the current watchpoint is disabled while performing watchpoint actions,
658 // and it is then enabled after we are finished.
659 WatchpointSentry sentry(process, wp_sp.get());
662 // check if this process is running on an architecture where watchpoints trigger
663 // before the associated instruction runs. if so, disable the WP, single-step and then
664 // re-enable the watchpoint
668 bool wp_triggers_after;
669 if (process->GetWatchpointSupportInfo(num, wp_triggers_after).Success())
671 if (!wp_triggers_after)
673 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
674 assert (stored_stop_info_sp.get() == this);
676 ThreadPlanSP new_plan_sp(thread_sp->QueueThreadPlanForStepSingleInstruction(false, // step-over
677 false, // abort_other_plans
678 true)); // stop_other_threads
679 new_plan_sp->SetIsMasterPlan (true);
680 new_plan_sp->SetOkayToDiscard (false);
681 new_plan_sp->SetPrivate (true);
682 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
684 process->WaitForProcessToStop (NULL);
685 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
686 thread_sp->SetStopInfo(stored_stop_info_sp);
692 if (m_should_stop && wp_sp->GetConditionText() != NULL)
694 // We need to make sure the user sees any parse errors in their condition, so we'll hook the
695 // constructor errors up to the debugger's Async I/O.
696 ExecutionResults result_code;
697 ValueObjectSP result_value_sp;
698 const bool unwind_on_error = true;
699 const bool ignore_breakpoints = true;
701 result_code = ClangUserExpression::EvaluateWithError (exe_ctx,
702 eExecutionPolicyOnlyWhenNeeded,
703 lldb::eLanguageTypeUnknown,
704 ClangUserExpression::eResultTypeAny,
707 wp_sp->GetConditionText(),
712 ClangUserExpression::kDefaultTimeout);
713 if (result_code == eExecutionCompleted)
718 if (result_value_sp->ResolveValue (scalar_value))
720 if (scalar_value.ULongLong(1) == 0)
722 // We have been vetoed. This takes precedence over querying
723 // the watchpoint whether it should stop (aka ignore count and
724 // friends). See also StopInfoWatchpoint::ShouldStop() as well
725 // as Process::ProcessEventData::DoOnRemoval().
726 m_should_stop = false;
729 m_should_stop = true;
731 log->Printf("Condition successfully evaluated, result is %s.\n",
732 m_should_stop ? "true" : "false");
736 m_should_stop = true;
738 log->Printf("Failed to get an integer result from the expression.");
744 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
745 StreamSP error_sp = debugger.GetAsyncErrorStream ();
746 error_sp->Printf ("Stopped due to an error evaluating condition of watchpoint ");
747 wp_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
748 error_sp->Printf (": \"%s\"",
749 wp_sp->GetConditionText());
751 const char *err_str = error.AsCString("<Unknown Error>");
753 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
755 error_sp->PutCString (err_str);
758 // If the condition fails to be parsed or run, we should stop.
759 m_should_stop = true;
763 // If the condition says to stop, we run the callback to further decide whether to stop.
766 StoppointCallbackContext context (event_ptr, exe_ctx, false);
767 bool stop_requested = wp_sp->InvokeCallback (&context);
768 // Also make sure that the callback hasn't continued the target.
769 // If it did, when we'll set m_should_stop to false and get out of here.
770 if (HasTargetRunSinceMe ())
771 m_should_stop = false;
773 if (m_should_stop && !stop_requested)
775 // We have been vetoed by the callback mechanism.
776 m_should_stop = false;
779 // Finally, if we are going to stop, print out the new & old values:
782 wp_sp->CaptureWatchedValue(exe_ctx);
784 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
785 StreamSP output_sp = debugger.GetAsyncOutputStream ();
786 wp_sp->DumpSnapshots(output_sp.get());
794 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
797 log_process->Printf ("Process::%s could not find watchpoint id: %" PRId64 "...", __FUNCTION__, m_value);
800 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
802 m_should_stop_is_valid = true;
807 std::string m_description;
809 bool m_should_stop_is_valid;
814 //----------------------------------------------------------------------
815 // StopInfoUnixSignal
816 //----------------------------------------------------------------------
818 class StopInfoUnixSignal : public StopInfo
822 StopInfoUnixSignal (Thread &thread, int signo) :
823 StopInfo (thread, signo)
827 virtual ~StopInfoUnixSignal ()
833 GetStopReason () const
835 return eStopReasonSignal;
839 ShouldStopSynchronous (Event *event_ptr)
841 ThreadSP thread_sp (m_thread_wp.lock());
843 return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value);
848 ShouldStop (Event *event_ptr)
850 ThreadSP thread_sp (m_thread_wp.lock());
852 return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value);
857 // If should stop returns false, check if we should notify of this event
859 DoShouldNotify (Event *event_ptr)
861 ThreadSP thread_sp (m_thread_wp.lock());
864 bool should_notify = thread_sp->GetProcess()->GetUnixSignals().GetShouldNotify (m_value);
868 strm.Printf ("thread %d received signal: %s",
869 thread_sp->GetIndexID(),
870 thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value));
871 Process::ProcessEventData::AddRestartedReason(event_ptr, strm.GetData());
873 return should_notify;
880 WillResume (lldb::StateType resume_state)
882 ThreadSP thread_sp (m_thread_wp.lock());
885 if (thread_sp->GetProcess()->GetUnixSignals().GetShouldSuppress(m_value) == false)
886 thread_sp->SetResumeSignal(m_value);
893 if (m_description.empty())
895 ThreadSP thread_sp (m_thread_wp.lock());
899 const char *signal_name = thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value);
901 strm.Printf("signal %s", signal_name);
903 strm.Printf("signal %" PRIi64, m_value);
904 m_description.swap (strm.GetString());
907 return m_description.c_str();
911 //----------------------------------------------------------------------
913 //----------------------------------------------------------------------
915 class StopInfoTrace : public StopInfo
919 StopInfoTrace (Thread &thread) :
920 StopInfo (thread, LLDB_INVALID_UID)
924 virtual ~StopInfoTrace ()
929 GetStopReason () const
931 return eStopReasonTrace;
937 if (m_description.empty())
940 return m_description.c_str();
945 //----------------------------------------------------------------------
947 //----------------------------------------------------------------------
949 class StopInfoException : public StopInfo
953 StopInfoException (Thread &thread, const char *description) :
954 StopInfo (thread, LLDB_INVALID_UID)
957 SetDescription (description);
961 ~StopInfoException ()
966 GetStopReason () const
968 return eStopReasonException;
974 if (m_description.empty())
977 return m_description.c_str();
982 //----------------------------------------------------------------------
983 // StopInfoThreadPlan
984 //----------------------------------------------------------------------
986 class StopInfoThreadPlan : public StopInfo
990 StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp) :
991 StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID),
993 m_return_valobj_sp (return_valobj_sp)
997 virtual ~StopInfoThreadPlan ()
1002 GetStopReason () const
1004 return eStopReasonPlanComplete;
1007 virtual const char *
1010 if (m_description.empty())
1013 m_plan_sp->GetDescription (&strm, eDescriptionLevelBrief);
1014 m_description.swap (strm.GetString());
1016 return m_description.c_str();
1020 GetReturnValueObject()
1022 return m_return_valobj_sp;
1027 ShouldStop (Event *event_ptr)
1030 return m_plan_sp->ShouldStop(event_ptr);
1032 return StopInfo::ShouldStop(event_ptr);
1036 ThreadPlanSP m_plan_sp;
1037 ValueObjectSP m_return_valobj_sp;
1040 class StopInfoExec : public StopInfo
1044 StopInfoExec (Thread &thread) :
1045 StopInfo (thread, LLDB_INVALID_UID),
1046 m_performed_action (false)
1056 GetStopReason () const
1058 return eStopReasonExec;
1061 virtual const char *
1069 PerformAction (Event *event_ptr)
1071 // Only perform the action once
1072 if (m_performed_action)
1074 m_performed_action = true;
1075 ThreadSP thread_sp (m_thread_wp.lock());
1077 thread_sp->GetProcess()->DidExec();
1080 bool m_performed_action;
1083 } // namespace lldb_private
1086 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id)
1088 return StopInfoSP (new StopInfoBreakpoint (thread, break_id));
1092 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id, bool should_stop)
1094 return StopInfoSP (new StopInfoBreakpoint (thread, break_id, should_stop));
1098 StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id)
1100 return StopInfoSP (new StopInfoWatchpoint (thread, watch_id));
1104 StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo)
1106 return StopInfoSP (new StopInfoUnixSignal (thread, signo));
1110 StopInfo::CreateStopReasonToTrace (Thread &thread)
1112 return StopInfoSP (new StopInfoTrace (thread));
1116 StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp)
1118 return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp));
1122 StopInfo::CreateStopReasonWithException (Thread &thread, const char *description)
1124 return StopInfoSP (new StopInfoException (thread, description));
1128 StopInfo::CreateStopReasonWithExec (Thread &thread)
1130 return StopInfoSP (new StopInfoExec (thread));
1134 StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp)
1136 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
1138 StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1139 return plan_stop_info->GetReturnValueObject();
1142 return ValueObjectSP();