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 //===----------------------------------------------------------------------===//
14 // Other libraries and framework includes
16 #include "lldb/Target/StopInfo.h"
17 #include "lldb/Core/Log.h"
18 #include "lldb/Breakpoint/Breakpoint.h"
19 #include "lldb/Breakpoint/BreakpointLocation.h"
20 #include "lldb/Breakpoint/StoppointCallbackContext.h"
21 #include "lldb/Breakpoint/Watchpoint.h"
22 #include "lldb/Core/Debugger.h"
23 #include "lldb/Core/StreamString.h"
24 #include "lldb/Core/ValueObject.h"
25 #include "lldb/Expression/UserExpression.h"
26 #include "lldb/Target/Target.h"
27 #include "lldb/Target/Thread.h"
28 #include "lldb/Target/ThreadPlan.h"
29 #include "lldb/Target/Process.h"
30 #include "lldb/Target/UnixSignals.h"
33 using namespace lldb_private;
35 StopInfo::StopInfo (Thread &thread, uint64_t value) :
36 m_thread_wp (thread.shared_from_this()),
37 m_stop_id (thread.GetProcess()->GetStopID()),
38 m_resume_id (thread.GetProcess()->GetResumeID()),
41 m_override_should_notify (eLazyBoolCalculate),
42 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
111 StopInfoBreakpoint (Thread &thread, break_id_t break_id) :
112 StopInfo (thread, break_id),
113 m_should_stop (false),
114 m_should_stop_is_valid (false),
115 m_should_perform_action (true),
116 m_address (LLDB_INVALID_ADDRESS),
117 m_break_id(LLDB_INVALID_BREAK_ID),
118 m_was_one_shot (false)
123 StopInfoBreakpoint (Thread &thread, break_id_t break_id, bool should_stop) :
124 StopInfo (thread, break_id),
125 m_should_stop (should_stop),
126 m_should_stop_is_valid (true),
127 m_should_perform_action (true),
128 m_address (LLDB_INVALID_ADDRESS),
129 m_break_id(LLDB_INVALID_BREAK_ID),
130 m_was_one_shot (false)
135 ~StopInfoBreakpoint() override = default;
140 ThreadSP thread_sp (m_thread_wp.lock());
143 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
146 if (bp_site_sp->GetNumberOfOwners() == 1)
148 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
151 m_break_id = bp_loc_sp->GetBreakpoint().GetID();
152 m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
155 m_address = bp_site_sp->GetLoadAddress();
161 IsValidForOperatingSystemThread(Thread &thread) override
163 ProcessSP process_sp (thread.GetProcess());
166 BreakpointSiteSP bp_site_sp (process_sp->GetBreakpointSiteList().FindByID (m_value));
168 return bp_site_sp->ValidForThisThread (&thread);
174 GetStopReason() const override
176 return eStopReasonBreakpoint;
180 ShouldStopSynchronous(Event *event_ptr) override
182 ThreadSP thread_sp (m_thread_wp.lock());
185 if (!m_should_stop_is_valid)
187 // Only check once if we should stop at a breakpoint
188 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
191 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
192 StoppointCallbackContext context (event_ptr, exe_ctx, true);
193 bp_site_sp->BumpHitCounts();
194 m_should_stop = bp_site_sp->ShouldStop (&context);
198 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
201 log->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
203 m_should_stop = true;
205 m_should_stop_is_valid = true;
207 return m_should_stop;
213 DoShouldNotify(Event *event_ptr) override
215 ThreadSP thread_sp (m_thread_wp.lock());
218 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
221 bool all_internal = true;
223 for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++)
225 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal())
227 all_internal = false;
231 return !all_internal;
238 GetDescription() override
240 if (m_description.empty())
242 ThreadSP thread_sp (m_thread_wp.lock());
245 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
249 // If we have just hit an internal breakpoint, and it has a kind description, print that instead of the
250 // full breakpoint printing:
251 if (bp_site_sp->IsInternal())
253 size_t num_owners = bp_site_sp->GetNumberOfOwners();
254 for (size_t idx = 0; idx < num_owners; idx++)
256 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)->GetBreakpoint().GetBreakpointKind();
259 m_description.assign (kind);
265 strm.Printf("breakpoint ");
266 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
267 m_description.swap (strm.GetString());
272 if (m_break_id != LLDB_INVALID_BREAK_ID)
274 BreakpointSP break_sp = thread_sp->GetProcess()->GetTarget().GetBreakpointByID(m_break_id);
277 if (break_sp->IsInternal())
279 const char *kind = break_sp->GetBreakpointKind();
281 strm.Printf ("internal %s breakpoint(%d).", kind, m_break_id);
283 strm.Printf ("internal breakpoint(%d).", m_break_id);
287 strm.Printf ("breakpoint %d.", m_break_id);
293 strm.Printf ("one-shot breakpoint %d", m_break_id);
295 strm.Printf ("breakpoint %d which has been deleted.", m_break_id);
298 else if (m_address == LLDB_INVALID_ADDRESS)
299 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - unknown address", m_value);
301 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - was at 0x%" PRIx64, m_value, m_address);
303 m_description.swap (strm.GetString());
307 return m_description.c_str();
312 ShouldStop(Event *event_ptr) override
314 // This just reports the work done by PerformAction or the synchronous stop. It should
315 // only ever get called after they have had a chance to run.
316 assert (m_should_stop_is_valid);
317 return m_should_stop;
321 PerformAction(Event *event_ptr) override
323 if (!m_should_perform_action)
325 m_should_perform_action = false;
327 ThreadSP thread_sp (m_thread_wp.lock());
331 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
333 if (!thread_sp->IsValid())
335 // This shouldn't ever happen, but just in case, don't do more harm.
338 log->Printf ("PerformAction got called with an invalid thread.");
340 m_should_stop = true;
341 m_should_stop_is_valid = true;
345 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
346 std::unordered_set<break_id_t> precondition_breakpoints;
350 // Let's copy the owners list out of the site and store them in a local list. That way if
351 // one of the breakpoint actions changes the site, then we won't be operating on a bad list.
352 BreakpointLocationCollection site_locations;
353 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
357 m_should_stop = true;
361 // We go through each location, and test first its precondition - this overrides everything. Note,
362 // we only do this once per breakpoint - not once per location...
363 // Then check the condition. If the condition says to stop,
364 // then we run the callback for that location. If that callback says to stop as well, then
365 // we set m_should_stop to true; we are going to stop.
366 // But we still want to give all the breakpoints whose conditions say we are going to stop a
367 // chance to run their callbacks.
368 // Of course if any callback restarts the target by putting "continue" in the callback, then
369 // we're going to restart, without running the rest of the callbacks. And in this case we will
370 // end up not stopping even if another location said we should stop. But that's better than not
371 // running all the callbacks.
373 m_should_stop = false;
375 // We don't select threads as we go through them testing breakpoint conditions and running commands.
376 // So we need to set the thread for expression evaluation here:
377 ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
379 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
380 Process *process = exe_ctx.GetProcessPtr();
381 if (process->GetModIDRef().IsLastResumeForUserExpression())
383 // If we are in the middle of evaluating an expression, don't run asynchronous breakpoint commands or
384 // expressions. That could lead to infinite recursion if the command or condition re-calls the function
385 // with this breakpoint.
386 // TODO: We can keep a list of the breakpoints we've seen while running expressions in the nested
387 // PerformAction calls that can arise when the action runs a function that hits another breakpoint,
388 // and only stop running commands when we see the same breakpoint hit a second time.
390 m_should_stop_is_valid = true;
392 log->Printf ("StopInfoBreakpoint::PerformAction - Hit a breakpoint while running an expression,"
393 " not running commands to avoid recursion.");
394 bool ignoring_breakpoints = process->GetIgnoreBreakpointsInExpressions();
395 if (ignoring_breakpoints)
397 m_should_stop = false;
398 // Internal breakpoints will always stop.
399 for (size_t j = 0; j < num_owners; j++)
401 lldb::BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(j);
402 if (bp_loc_sp->GetBreakpoint().IsInternal())
404 m_should_stop = true;
411 m_should_stop = true;
414 log->Printf ("StopInfoBreakpoint::PerformAction - in expression, continuing: %s.",
415 m_should_stop ? "true" : "false");
416 process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf("Warning: hit breakpoint while "
417 "running function, skipping commands and conditions to prevent recursion.");
421 StoppointCallbackContext context (event_ptr, exe_ctx, false);
423 // For safety's sake let's also grab an extra reference to the breakpoint owners of the locations we're
424 // going to examine, since the locations are going to have to get back to their breakpoints, and the
425 // locations don't keep their owners alive. I'm just sticking the BreakpointSP's in a vector since
426 // I'm only using it to locally increment their retain counts.
428 std::vector<lldb::BreakpointSP> location_owners;
430 for (size_t j = 0; j < num_owners; j++)
432 BreakpointLocationSP loc(site_locations.GetByIndex(j));
433 location_owners.push_back(loc->GetBreakpoint().shared_from_this());
437 for (size_t j = 0; j < num_owners; j++)
439 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
441 // If another action disabled this breakpoint or its location, then don't run the actions.
442 if (!bp_loc_sp->IsEnabled() || !bp_loc_sp->GetBreakpoint().IsEnabled())
445 // The breakpoint site may have many locations associated with it, not all of them valid for
446 // this thread. Skip the ones that aren't:
447 if (!bp_loc_sp->ValidForThisThread(thread_sp.get()))
452 bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
453 log->Printf ("Breakpoint %s hit on thread 0x%llx but it was not for this thread, continuing.",
455 static_cast<unsigned long long>(thread_sp->GetID()));
460 // First run the precondition, but since the precondition is per breakpoint, only run it once
462 std::pair<std::unordered_set<break_id_t>::iterator, bool> result
463 = precondition_breakpoints.insert(bp_loc_sp->GetBreakpoint().GetID());
467 bool precondition_result = bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
468 if (!precondition_result)
471 // Next run the condition for the breakpoint. If that says we should stop, then we'll run
472 // the callback for the breakpoint. If the callback says we shouldn't stop that will win.
474 if (bp_loc_sp->GetConditionText() != nullptr)
476 Error condition_error;
477 bool condition_says_stop = bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
479 if (!condition_error.Success())
481 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
482 StreamSP error_sp = debugger.GetAsyncErrorStream ();
483 error_sp->Printf ("Stopped due to an error evaluating condition of breakpoint ");
484 bp_loc_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
485 error_sp->Printf (": \"%s\"",
486 bp_loc_sp->GetConditionText());
488 const char *err_str = condition_error.AsCString("<Unknown Error>");
490 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
492 error_sp->PutCString (err_str);
501 bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
502 log->Printf ("Condition evaluated for breakpoint %s on thread 0x%llx conditon_says_stop: %i.",
504 static_cast<unsigned long long>(thread_sp->GetID()),
505 condition_says_stop);
507 if (!condition_says_stop)
509 // We don't want to increment the hit count of breakpoints if the condition fails.
510 // We've already bumped it by the time we get here, so undo the bump:
511 bp_loc_sp->UndoBumpHitCount();
517 bool callback_says_stop;
519 // FIXME: For now the callbacks have to run in async mode - the first time we restart we need
520 // to get out of there. So set it here.
521 // When we figure out how to nest breakpoint hits then this will change.
523 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
524 bool old_async = debugger.GetAsyncExecution();
525 debugger.SetAsyncExecution (true);
527 callback_says_stop = bp_loc_sp->InvokeCallback (&context);
529 debugger.SetAsyncExecution (old_async);
531 if (callback_says_stop)
532 m_should_stop = true;
534 // If we are going to stop for this breakpoint, then remove the breakpoint.
535 if (callback_says_stop && bp_loc_sp && bp_loc_sp->GetBreakpoint().IsOneShot())
537 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID (bp_loc_sp->GetBreakpoint().GetID());
540 // Also make sure that the callback hasn't continued the target.
541 // If it did, when we'll set m_should_start to false and get out of here.
542 if (HasTargetRunSinceMe ())
544 m_should_stop = false;
549 // We've figured out what this stop wants to do, so mark it as valid so we don't compute it again.
550 m_should_stop_is_valid = true;
554 m_should_stop = true;
555 m_should_stop_is_valid = true;
556 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
559 log_process->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
562 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
568 bool m_should_stop_is_valid;
569 bool m_should_perform_action; // Since we are trying to preserve the "state" of the system even if we run functions
570 // etc. behind the users backs, we need to make sure we only REALLY perform the action once.
571 lldb::addr_t m_address; // We use this to capture the breakpoint site address when we create the StopInfo,
572 // in case somebody deletes it between the time the StopInfo is made and the
573 // description is asked for.
574 lldb::break_id_t m_break_id;
578 //----------------------------------------------------------------------
579 // StopInfoWatchpoint
580 //----------------------------------------------------------------------
582 class StopInfoWatchpoint : public StopInfo
585 // Make sure watchpoint is properly disabled and subsequently enabled while performing watchpoint actions.
586 class WatchpointSentry {
588 WatchpointSentry(Process *p, Watchpoint *w):
592 if (process && watchpoint)
594 const bool notify = false;
595 watchpoint->TurnOnEphemeralMode();
596 process->DisableWatchpoint(watchpoint, notify);
602 if (process && watchpoint)
604 if (!watchpoint->IsDisabledDuringEphemeralMode())
606 const bool notify = false;
607 process->EnableWatchpoint(watchpoint, notify);
609 watchpoint->TurnOffEphemeralMode();
615 Watchpoint *watchpoint;
618 StopInfoWatchpoint (Thread &thread, break_id_t watch_id, lldb::addr_t watch_hit_addr) :
619 StopInfo(thread, watch_id),
620 m_should_stop(false),
621 m_should_stop_is_valid(false),
622 m_watch_hit_addr(watch_hit_addr)
626 ~StopInfoWatchpoint() override = default;
629 GetStopReason() const override
631 return eStopReasonWatchpoint;
635 GetDescription() override
637 if (m_description.empty())
640 strm.Printf("watchpoint %" PRIi64, m_value);
641 m_description.swap (strm.GetString());
643 return m_description.c_str();
648 ShouldStopSynchronous(Event *event_ptr) override
650 // ShouldStop() method is idempotent and should not affect hit count.
651 // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
652 // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
653 // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
654 // StopInfoWatchpoint::ShouldStop() and
655 // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
656 // StopInfoWatchpoint::PerformAction().
657 if (m_should_stop_is_valid)
658 return m_should_stop;
660 ThreadSP thread_sp (m_thread_wp.lock());
663 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
666 // Check if we should stop at a watchpoint.
667 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
668 StoppointCallbackContext context (event_ptr, exe_ctx, true);
669 m_should_stop = wp_sp->ShouldStop (&context);
673 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
676 log->Printf ("Process::%s could not find watchpoint location id: %" PRId64 "...",
677 __FUNCTION__, GetValue());
679 m_should_stop = true;
682 m_should_stop_is_valid = true;
683 return m_should_stop;
687 ShouldStop(Event *event_ptr) override
689 // This just reports the work done by PerformAction or the synchronous stop. It should
690 // only ever get called after they have had a chance to run.
691 assert (m_should_stop_is_valid);
692 return m_should_stop;
696 PerformAction(Event *event_ptr) override
698 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS);
699 // We're going to calculate if we should stop or not in some way during the course of
700 // this code. Also by default we're going to stop, so set that here.
701 m_should_stop = true;
703 ThreadSP thread_sp (m_thread_wp.lock());
707 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
710 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
711 Process* process = exe_ctx.GetProcessPtr();
713 // This sentry object makes sure the current watchpoint is disabled while performing watchpoint actions,
714 // and it is then enabled after we are finished.
715 WatchpointSentry sentry(process, wp_sp.get());
718 // check if this process is running on an architecture where watchpoints trigger
719 // before the associated instruction runs. if so, disable the WP, single-step and then
720 // re-enable the watchpoint
724 bool wp_triggers_after;
725 if (process->GetWatchpointSupportInfo(num, wp_triggers_after).Success())
727 if (!wp_triggers_after)
729 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
730 assert (stored_stop_info_sp.get() == this);
732 ThreadPlanSP new_plan_sp(thread_sp->QueueThreadPlanForStepSingleInstruction(false, // step-over
733 false, // abort_other_plans
734 true)); // stop_other_threads
735 new_plan_sp->SetIsMasterPlan (true);
736 new_plan_sp->SetOkayToDiscard (false);
737 new_plan_sp->SetPrivate (true);
738 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
739 process->ResumeSynchronous(nullptr);
740 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
741 thread_sp->SetStopInfo(stored_stop_info_sp);
748 * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For example:
749 * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at 'm', then
750 * watch exception is generated even when 'n' is read/written. To handle this case,
751 * server emulates the instruction at PC and finds the base address of the load/store
752 * instruction and appends it in the description of the stop-info packet. If watchpoint
753 * is not set on this address by user then this do not stop.
755 if (m_watch_hit_addr != LLDB_INVALID_ADDRESS)
757 WatchpointSP wp_hit_sp = thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(m_watch_hit_addr);
760 m_should_stop = false;
761 wp_sp->IncrementFalseAlarmsAndReviseHitCount();
765 // TODO: This condition should be checked in the synchronous part of the watchpoint code
766 // (Watchpoint::ShouldStop), so that we avoid pulling an event even if the watchpoint fails
767 // the ignore count condition. It is moved here temporarily, because for archs with
768 // watchpoint_exceptions_received=before, the code in the previous lines takes care of moving
769 // the inferior to next PC. We have to check the ignore count condition after this is done,
770 // otherwise we will hit same watchpoint multiple times until we pass ignore condition, but we
771 // won't actually be ignoring them.
772 if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
773 m_should_stop = false;
775 if (m_should_stop && wp_sp->GetConditionText() != nullptr)
777 // We need to make sure the user sees any parse errors in their condition, so we'll hook the
778 // constructor errors up to the debugger's Async I/O.
779 ExpressionResults result_code;
780 EvaluateExpressionOptions expr_options;
781 expr_options.SetUnwindOnError(true);
782 expr_options.SetIgnoreBreakpoints(true);
783 ValueObjectSP result_value_sp;
785 result_code = UserExpression::Evaluate(exe_ctx,
787 wp_sp->GetConditionText(),
792 if (result_code == eExpressionCompleted)
797 if (result_value_sp->ResolveValue (scalar_value))
799 if (scalar_value.ULongLong(1) == 0)
801 // We have been vetoed. This takes precedence over querying
802 // the watchpoint whether it should stop (aka ignore count and
803 // friends). See also StopInfoWatchpoint::ShouldStop() as well
804 // as Process::ProcessEventData::DoOnRemoval().
805 m_should_stop = false;
808 m_should_stop = true;
810 log->Printf("Condition successfully evaluated, result is %s.\n",
811 m_should_stop ? "true" : "false");
815 m_should_stop = true;
817 log->Printf("Failed to get an integer result from the expression.");
823 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
824 StreamSP error_sp = debugger.GetAsyncErrorStream ();
825 error_sp->Printf ("Stopped due to an error evaluating condition of watchpoint ");
826 wp_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
827 error_sp->Printf (": \"%s\"",
828 wp_sp->GetConditionText());
830 const char *err_str = error.AsCString("<Unknown Error>");
832 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
834 error_sp->PutCString (err_str);
837 // If the condition fails to be parsed or run, we should stop.
838 m_should_stop = true;
842 // If the condition says to stop, we run the callback to further decide whether to stop.
845 StoppointCallbackContext context (event_ptr, exe_ctx, false);
846 bool stop_requested = wp_sp->InvokeCallback (&context);
847 // Also make sure that the callback hasn't continued the target.
848 // If it did, when we'll set m_should_stop to false and get out of here.
849 if (HasTargetRunSinceMe ())
850 m_should_stop = false;
852 if (m_should_stop && !stop_requested)
854 // We have been vetoed by the callback mechanism.
855 m_should_stop = false;
858 // Finally, if we are going to stop, print out the new & old values:
861 wp_sp->CaptureWatchedValue(exe_ctx);
863 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
864 StreamSP output_sp = debugger.GetAsyncOutputStream ();
865 wp_sp->DumpSnapshots(output_sp.get());
873 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
876 log_process->Printf ("Process::%s could not find watchpoint id: %" PRId64 "...", __FUNCTION__, m_value);
879 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
881 m_should_stop_is_valid = true;
887 bool m_should_stop_is_valid;
888 lldb::addr_t m_watch_hit_addr;
891 //----------------------------------------------------------------------
892 // StopInfoUnixSignal
893 //----------------------------------------------------------------------
895 class StopInfoUnixSignal : public StopInfo
898 StopInfoUnixSignal (Thread &thread, int signo, const char *description) :
899 StopInfo (thread, signo)
901 SetDescription (description);
904 ~StopInfoUnixSignal() override = default;
907 GetStopReason() const override
909 return eStopReasonSignal;
913 ShouldStopSynchronous(Event *event_ptr) override
915 ThreadSP thread_sp (m_thread_wp.lock());
917 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
922 ShouldStop(Event *event_ptr) override
924 ThreadSP thread_sp (m_thread_wp.lock());
926 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
930 // If should stop returns false, check if we should notify of this event
932 DoShouldNotify(Event *event_ptr) override
934 ThreadSP thread_sp (m_thread_wp.lock());
937 bool should_notify = thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
941 strm.Printf ("thread %d received signal: %s",
942 thread_sp->GetIndexID(),
943 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value));
944 Process::ProcessEventData::AddRestartedReason(event_ptr, strm.GetData());
946 return should_notify;
952 WillResume(lldb::StateType resume_state) override
954 ThreadSP thread_sp (m_thread_wp.lock());
957 if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(m_value))
958 thread_sp->SetResumeSignal(m_value);
963 GetDescription() override
965 if (m_description.empty())
967 ThreadSP thread_sp (m_thread_wp.lock());
971 const char *signal_name = thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value);
973 strm.Printf("signal %s", signal_name);
975 strm.Printf("signal %" PRIi64, m_value);
976 m_description.swap (strm.GetString());
979 return m_description.c_str();
983 //----------------------------------------------------------------------
985 //----------------------------------------------------------------------
987 class StopInfoTrace : public StopInfo
990 StopInfoTrace (Thread &thread) :
991 StopInfo (thread, LLDB_INVALID_UID)
995 ~StopInfoTrace() override = default;
998 GetStopReason() const override
1000 return eStopReasonTrace;
1004 GetDescription() override
1006 if (m_description.empty())
1009 return m_description.c_str();
1013 //----------------------------------------------------------------------
1014 // StopInfoException
1015 //----------------------------------------------------------------------
1017 class StopInfoException : public StopInfo
1020 StopInfoException (Thread &thread, const char *description) :
1021 StopInfo (thread, LLDB_INVALID_UID)
1024 SetDescription (description);
1027 ~StopInfoException() override = default;
1030 GetStopReason() const override
1032 return eStopReasonException;
1036 GetDescription() override
1038 if (m_description.empty())
1041 return m_description.c_str();
1045 //----------------------------------------------------------------------
1046 // StopInfoThreadPlan
1047 //----------------------------------------------------------------------
1049 class StopInfoThreadPlan : public StopInfo
1052 StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp) :
1053 StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID),
1054 m_plan_sp (plan_sp),
1055 m_return_valobj_sp (return_valobj_sp),
1056 m_expression_variable_sp (expression_variable_sp)
1060 ~StopInfoThreadPlan() override = default;
1063 GetStopReason() const override
1065 return eStopReasonPlanComplete;
1069 GetDescription() override
1071 if (m_description.empty())
1074 m_plan_sp->GetDescription (&strm, eDescriptionLevelBrief);
1075 m_description.swap (strm.GetString());
1077 return m_description.c_str();
1081 GetReturnValueObject()
1083 return m_return_valobj_sp;
1086 ExpressionVariableSP
1087 GetExpressionVariable()
1089 return m_expression_variable_sp;
1094 ShouldStop(Event *event_ptr) override
1097 return m_plan_sp->ShouldStop(event_ptr);
1099 return StopInfo::ShouldStop(event_ptr);
1103 ThreadPlanSP m_plan_sp;
1104 ValueObjectSP m_return_valobj_sp;
1105 ExpressionVariableSP m_expression_variable_sp;
1108 class StopInfoExec : public StopInfo
1111 StopInfoExec (Thread &thread) :
1112 StopInfo (thread, LLDB_INVALID_UID),
1113 m_performed_action (false)
1117 ~StopInfoExec() override = default;
1120 GetStopReason() const override
1122 return eStopReasonExec;
1126 GetDescription() override
1133 PerformAction(Event *event_ptr) override
1135 // Only perform the action once
1136 if (m_performed_action)
1138 m_performed_action = true;
1139 ThreadSP thread_sp (m_thread_wp.lock());
1141 thread_sp->GetProcess()->DidExec();
1144 bool m_performed_action;
1147 } // namespace lldb_private
1150 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id)
1152 return StopInfoSP (new StopInfoBreakpoint (thread, break_id));
1156 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id, bool should_stop)
1158 return StopInfoSP (new StopInfoBreakpoint (thread, break_id, should_stop));
1162 StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id, lldb::addr_t watch_hit_addr)
1164 return StopInfoSP (new StopInfoWatchpoint (thread, watch_id, watch_hit_addr));
1168 StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo, const char *description)
1170 return StopInfoSP (new StopInfoUnixSignal (thread, signo, description));
1174 StopInfo::CreateStopReasonToTrace (Thread &thread)
1176 return StopInfoSP (new StopInfoTrace (thread));
1180 StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp,
1181 ValueObjectSP return_valobj_sp,
1182 ExpressionVariableSP expression_variable_sp)
1184 return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp, expression_variable_sp));
1188 StopInfo::CreateStopReasonWithException (Thread &thread, const char *description)
1190 return StopInfoSP (new StopInfoException (thread, description));
1194 StopInfo::CreateStopReasonWithExec (Thread &thread)
1196 return StopInfoSP (new StopInfoExec (thread));
1200 StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp)
1202 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
1204 StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1205 return plan_stop_info->GetReturnValueObject();
1208 return ValueObjectSP();
1211 ExpressionVariableSP
1212 StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp)
1214 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
1216 StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1217 return plan_stop_info->GetExpressionVariable();
1220 return ExpressionVariableSP();