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/Breakpoint/Breakpoint.h"
17 #include "lldb/Breakpoint/BreakpointLocation.h"
18 #include "lldb/Breakpoint/StoppointCallbackContext.h"
19 #include "lldb/Breakpoint/Watchpoint.h"
20 #include "lldb/Core/Debugger.h"
21 #include "lldb/Core/ValueObject.h"
22 #include "lldb/Expression/UserExpression.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/StopInfo.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Target/Thread.h"
27 #include "lldb/Target/ThreadPlan.h"
28 #include "lldb/Target/UnixSignals.h"
29 #include "lldb/Utility/Log.h"
30 #include "lldb/Utility/StreamString.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()), m_value(value),
39 m_description(), m_override_should_notify(eLazyBoolCalculate),
40 m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
42 bool StopInfo::IsValid() const {
43 ThreadSP thread_sp(m_thread_wp.lock());
45 return thread_sp->GetProcess()->GetStopID() == m_stop_id;
49 void StopInfo::MakeStopInfoValid() {
50 ThreadSP thread_sp(m_thread_wp.lock());
52 m_stop_id = thread_sp->GetProcess()->GetStopID();
53 m_resume_id = thread_sp->GetProcess()->GetResumeID();
57 bool StopInfo::HasTargetRunSinceMe() {
58 ThreadSP thread_sp(m_thread_wp.lock());
61 lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
62 if (ret_type == eStateRunning) {
64 } else if (ret_type == eStateStopped) {
65 // This is a little tricky. We want to count "run and stopped again
67 // ask this question as a "TRUE" answer to HasTargetRunSinceMe. But we
69 // include any running of the target done for expressions. So we track
71 // and resumes caused by expressions, and check if there are any resumes
75 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
76 uint32_t last_user_expression_id =
77 thread_sp->GetProcess()->GetLastUserExpressionResumeID();
78 if (curr_resume_id == m_resume_id) {
80 } else if (curr_resume_id > last_user_expression_id) {
88 //----------------------------------------------------------------------
90 //----------------------------------------------------------------------
92 namespace lldb_private {
93 class StopInfoBreakpoint : public StopInfo {
95 StopInfoBreakpoint(Thread &thread, break_id_t break_id)
96 : StopInfo(thread, break_id), m_should_stop(false),
97 m_should_stop_is_valid(false), m_should_perform_action(true),
98 m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
99 m_was_one_shot(false) {
103 StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
104 : StopInfo(thread, break_id), m_should_stop(should_stop),
105 m_should_stop_is_valid(true), m_should_perform_action(true),
106 m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
107 m_was_one_shot(false) {
111 ~StopInfoBreakpoint() override = default;
114 ThreadSP thread_sp(m_thread_wp.lock());
116 BreakpointSiteSP bp_site_sp(
117 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
119 if (bp_site_sp->GetNumberOfOwners() == 1) {
120 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
122 m_break_id = bp_loc_sp->GetBreakpoint().GetID();
123 m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
126 m_address = bp_site_sp->GetLoadAddress();
131 bool IsValidForOperatingSystemThread(Thread &thread) override {
132 ProcessSP process_sp(thread.GetProcess());
134 BreakpointSiteSP bp_site_sp(
135 process_sp->GetBreakpointSiteList().FindByID(m_value));
137 return bp_site_sp->ValidForThisThread(&thread);
142 StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
144 bool ShouldStopSynchronous(Event *event_ptr) override {
145 ThreadSP thread_sp(m_thread_wp.lock());
147 if (!m_should_stop_is_valid) {
148 // Only check once if we should stop at a breakpoint
149 BreakpointSiteSP bp_site_sp(
150 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
152 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
153 StoppointCallbackContext context(event_ptr, exe_ctx, true);
154 bp_site_sp->BumpHitCounts();
155 m_should_stop = bp_site_sp->ShouldStop(&context);
157 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
161 "Process::%s could not find breakpoint site id: %" PRId64 "...",
162 __FUNCTION__, m_value);
164 m_should_stop = true;
166 m_should_stop_is_valid = true;
168 return m_should_stop;
173 bool DoShouldNotify(Event *event_ptr) override {
174 ThreadSP thread_sp(m_thread_wp.lock());
176 BreakpointSiteSP bp_site_sp(
177 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
179 bool all_internal = true;
181 for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
182 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
183 all_internal = false;
187 return !all_internal;
193 const char *GetDescription() override {
194 if (m_description.empty()) {
195 ThreadSP thread_sp(m_thread_wp.lock());
197 BreakpointSiteSP bp_site_sp(
198 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
201 // If we have just hit an internal breakpoint, and it has a kind
202 // description, print that instead of the
203 // full breakpoint printing:
204 if (bp_site_sp->IsInternal()) {
205 size_t num_owners = bp_site_sp->GetNumberOfOwners();
206 for (size_t idx = 0; idx < num_owners; idx++) {
207 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
209 .GetBreakpointKind();
210 if (kind != nullptr) {
211 m_description.assign(kind);
217 strm.Printf("breakpoint ");
218 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
219 m_description = strm.GetString();
222 if (m_break_id != LLDB_INVALID_BREAK_ID) {
223 BreakpointSP break_sp =
224 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
227 if (break_sp->IsInternal()) {
228 const char *kind = break_sp->GetBreakpointKind();
230 strm.Printf("internal %s breakpoint(%d).", kind, m_break_id);
232 strm.Printf("internal breakpoint(%d).", m_break_id);
234 strm.Printf("breakpoint %d.", m_break_id);
238 strm.Printf("one-shot breakpoint %d", m_break_id);
240 strm.Printf("breakpoint %d which has been deleted.",
243 } else if (m_address == LLDB_INVALID_ADDRESS)
244 strm.Printf("breakpoint site %" PRIi64
245 " which has been deleted - unknown address",
248 strm.Printf("breakpoint site %" PRIi64
249 " which has been deleted - was at 0x%" PRIx64,
252 m_description = strm.GetString();
256 return m_description.c_str();
260 bool ShouldStop(Event *event_ptr) override {
261 // This just reports the work done by PerformAction or the synchronous stop.
263 // only ever get called after they have had a chance to run.
264 assert(m_should_stop_is_valid);
265 return m_should_stop;
268 void PerformAction(Event *event_ptr) override {
269 if (!m_should_perform_action)
271 m_should_perform_action = false;
272 bool internal_breakpoint = true;
274 ThreadSP thread_sp(m_thread_wp.lock());
277 Log *log = lldb_private::GetLogIfAnyCategoriesSet(
278 LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
280 if (!thread_sp->IsValid()) {
281 // This shouldn't ever happen, but just in case, don't do more harm.
283 log->Printf("PerformAction got called with an invalid thread.");
285 m_should_stop = true;
286 m_should_stop_is_valid = true;
290 BreakpointSiteSP bp_site_sp(
291 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
292 std::unordered_set<break_id_t> precondition_breakpoints;
295 // Let's copy the owners list out of the site and store them in a local
297 // one of the breakpoint actions changes the site, then we won't be
298 // operating on a bad list.
299 BreakpointLocationCollection site_locations;
300 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
302 if (num_owners == 0) {
303 m_should_stop = true;
305 // We go through each location, and test first its precondition - this
306 // overrides everything. Note,
307 // we only do this once per breakpoint - not once per location...
308 // Then check the condition. If the condition says to stop,
309 // then we run the callback for that location. If that callback says
310 // to stop as well, then
311 // we set m_should_stop to true; we are going to stop.
312 // But we still want to give all the breakpoints whose conditions say
313 // we are going to stop a
314 // chance to run their callbacks.
315 // Of course if any callback restarts the target by putting "continue"
316 // in the callback, then
317 // we're going to restart, without running the rest of the callbacks.
318 // And in this case we will
319 // end up not stopping even if another location said we should stop.
320 // But that's better than not
321 // running all the callbacks.
323 m_should_stop = false;
325 // We don't select threads as we go through them testing breakpoint
326 // conditions and running commands.
327 // So we need to set the thread for expression evaluation here:
328 ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
330 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
331 Process *process = exe_ctx.GetProcessPtr();
332 if (process->GetModIDRef().IsLastResumeForUserExpression()) {
333 // If we are in the middle of evaluating an expression, don't run
334 // asynchronous breakpoint commands or
335 // expressions. That could lead to infinite recursion if the
336 // command or condition re-calls the function
337 // with this breakpoint.
338 // TODO: We can keep a list of the breakpoints we've seen while
339 // running expressions in the nested
340 // PerformAction calls that can arise when the action runs a
341 // function that hits another breakpoint,
342 // and only stop running commands when we see the same breakpoint
343 // hit a second time.
345 m_should_stop_is_valid = true;
347 log->Printf("StopInfoBreakpoint::PerformAction - Hit a "
348 "breakpoint while running an expression,"
349 " not running commands to avoid recursion.");
350 bool ignoring_breakpoints =
351 process->GetIgnoreBreakpointsInExpressions();
352 if (ignoring_breakpoints) {
353 m_should_stop = false;
354 // Internal breakpoints will always stop.
355 for (size_t j = 0; j < num_owners; j++) {
356 lldb::BreakpointLocationSP bp_loc_sp =
357 bp_site_sp->GetOwnerAtIndex(j);
358 if (bp_loc_sp->GetBreakpoint().IsInternal()) {
359 m_should_stop = true;
364 m_should_stop = true;
367 log->Printf("StopInfoBreakpoint::PerformAction - in expression, "
369 m_should_stop ? "true" : "false");
370 process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
371 "Warning: hit breakpoint while "
372 "running function, skipping commands and conditions to prevent "
377 StoppointCallbackContext context(event_ptr, exe_ctx, false);
379 // For safety's sake let's also grab an extra reference to the
380 // breakpoint owners of the locations we're
381 // going to examine, since the locations are going to have to get back
382 // to their breakpoints, and the
383 // locations don't keep their owners alive. I'm just sticking the
384 // BreakpointSP's in a vector since
385 // I'm only using it to locally increment their retain counts.
387 std::vector<lldb::BreakpointSP> location_owners;
389 for (size_t j = 0; j < num_owners; j++) {
390 BreakpointLocationSP loc(site_locations.GetByIndex(j));
391 location_owners.push_back(loc->GetBreakpoint().shared_from_this());
394 for (size_t j = 0; j < num_owners; j++) {
395 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
396 StreamString loc_desc;
398 bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
400 // If another action disabled this breakpoint or its location, then
401 // don't run the actions.
402 if (!bp_loc_sp->IsEnabled() ||
403 !bp_loc_sp->GetBreakpoint().IsEnabled())
406 // The breakpoint site may have many locations associated with it,
407 // not all of them valid for
408 // this thread. Skip the ones that aren't:
409 if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
411 log->Printf("Breakpoint %s hit on thread 0x%llx but it was not "
412 "for this thread, continuing.",
413 loc_desc.GetData(), static_cast<unsigned long long>(
414 thread_sp->GetID()));
419 internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
421 // First run the precondition, but since the precondition is per
422 // breakpoint, only run it once
424 std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
425 precondition_breakpoints.insert(
426 bp_loc_sp->GetBreakpoint().GetID());
430 bool precondition_result =
431 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
432 if (!precondition_result)
435 // Next run the condition for the breakpoint. If that says we
436 // should stop, then we'll run
437 // the callback for the breakpoint. If the callback says we
438 // shouldn't stop that will win.
440 if (bp_loc_sp->GetConditionText() != nullptr) {
441 Status condition_error;
442 bool condition_says_stop =
443 bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
445 if (!condition_error.Success()) {
446 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
447 StreamSP error_sp = debugger.GetAsyncErrorStream();
448 error_sp->Printf("Stopped due to an error evaluating condition "
450 bp_loc_sp->GetDescription(error_sp.get(),
451 eDescriptionLevelBrief);
452 error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
454 const char *err_str =
455 condition_error.AsCString("<Unknown Error>");
457 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
459 error_sp->PutCString(err_str);
464 log->Printf("Condition evaluated for breakpoint %s on thread "
465 "0x%llx conditon_says_stop: %i.",
467 static_cast<unsigned long long>(
469 condition_says_stop);
471 if (!condition_says_stop) {
472 // We don't want to increment the hit count of breakpoints if
473 // the condition fails.
474 // We've already bumped it by the time we get here, so undo
476 bp_loc_sp->UndoBumpHitCount();
482 // Check the auto-continue bit on the location, do this before the
483 // callback since it may change this, but that would be for the
484 // NEXT hit. Note, you might think you could check auto-continue
485 // before the condition, and not evaluate the condition if it says
486 // to continue. But failing the condition means the breakpoint was
487 // effectively NOT HIT. So these two states are different.
488 bool auto_continue_says_stop = true;
489 if (bp_loc_sp->IsAutoContinue())
492 log->Printf("Continuing breakpoint %s as AutoContinue was set.",
494 // We want this stop reported, so you will know we auto-continued
495 // but only for external breakpoints:
496 if (!internal_breakpoint)
497 thread_sp->SetShouldReportStop(eVoteYes);
498 auto_continue_says_stop = false;
501 bool callback_says_stop = true;
503 // FIXME: For now the callbacks have to run in async mode - the
504 // first time we restart we need
505 // to get out of there. So set it here.
506 // When we figure out how to nest breakpoint hits then this will
509 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
510 bool old_async = debugger.GetAsyncExecution();
511 debugger.SetAsyncExecution(true);
513 callback_says_stop = bp_loc_sp->InvokeCallback(&context);
515 debugger.SetAsyncExecution(old_async);
517 if (callback_says_stop && auto_continue_says_stop)
518 m_should_stop = true;
520 // If we are going to stop for this breakpoint, then remove the
522 if (callback_says_stop && bp_loc_sp &&
523 bp_loc_sp->GetBreakpoint().IsOneShot()) {
524 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
525 bp_loc_sp->GetBreakpoint().GetID());
527 // Also make sure that the callback hasn't continued the target.
528 // If it did, when we'll set m_should_start to false and get out of
530 if (HasTargetRunSinceMe()) {
531 m_should_stop = false;
536 // We've figured out what this stop wants to do, so mark it as valid so
537 // we don't compute it again.
538 m_should_stop_is_valid = true;
540 m_should_stop = true;
541 m_should_stop_is_valid = true;
543 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
547 "Process::%s could not find breakpoint site id: %" PRId64 "...",
548 __FUNCTION__, m_value);
551 if ((m_should_stop == false || internal_breakpoint)
552 && thread_sp->CompletedPlanOverridesBreakpoint()) {
554 // Override should_stop decision when we have
555 // completed step plan additionally to the breakpoint
556 m_should_stop = true;
558 // Here we clean the preset stop info so the next
559 // GetStopInfo call will find the appropriate stop info,
560 // which should be the stop info related to the completed plan
561 thread_sp->ResetStopInfo();
565 log->Printf("Process::%s returning from action with m_should_stop: %d.",
566 __FUNCTION__, m_should_stop);
572 bool m_should_stop_is_valid;
573 bool m_should_perform_action; // Since we are trying to preserve the "state"
574 // of the system even if we run functions
575 // etc. behind the users backs, we need to make sure we only REALLY perform
577 lldb::addr_t m_address; // We use this to capture the breakpoint site address
578 // when we create the StopInfo,
579 // in case somebody deletes it between the time the StopInfo is made and the
580 // description is asked for.
581 lldb::break_id_t m_break_id;
585 //----------------------------------------------------------------------
586 // StopInfoWatchpoint
587 //----------------------------------------------------------------------
589 class StopInfoWatchpoint : public StopInfo {
591 // Make sure watchpoint is properly disabled and subsequently enabled while
592 // performing watchpoint actions.
593 class WatchpointSentry {
595 WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
596 watchpoint_sp(w_sp) {
597 if (process_sp && watchpoint_sp) {
598 const bool notify = false;
599 watchpoint_sp->TurnOnEphemeralMode();
600 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
601 process_sp->AddPreResumeAction(SentryPreResumeAction, this);
606 if (process_sp && watchpoint_sp) {
607 bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
608 watchpoint_sp->TurnOffEphemeralMode();
609 const bool notify = false;
611 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
613 process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
618 ~WatchpointSentry() {
621 process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
624 static bool SentryPreResumeAction(void *sentry_void) {
625 WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
626 sentry->DoReenable();
631 ProcessSP process_sp;
632 WatchpointSP watchpoint_sp;
635 StopInfoWatchpoint(Thread &thread, break_id_t watch_id,
636 lldb::addr_t watch_hit_addr)
637 : StopInfo(thread, watch_id), m_should_stop(false),
638 m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
640 ~StopInfoWatchpoint() override = default;
642 StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
644 const char *GetDescription() override {
645 if (m_description.empty()) {
647 strm.Printf("watchpoint %" PRIi64, m_value);
648 m_description = strm.GetString();
650 return m_description.c_str();
654 bool ShouldStopSynchronous(Event *event_ptr) override {
655 // ShouldStop() method is idempotent and should not affect hit count.
656 // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
657 // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
658 // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
659 // StopInfoWatchpoint::ShouldStop() and
660 // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
661 // StopInfoWatchpoint::PerformAction().
662 if (m_should_stop_is_valid)
663 return m_should_stop;
665 ThreadSP thread_sp(m_thread_wp.lock());
668 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
671 // Check if we should stop at a watchpoint.
672 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
673 StoppointCallbackContext context(event_ptr, exe_ctx, true);
674 m_should_stop = wp_sp->ShouldStop(&context);
676 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
680 "Process::%s could not find watchpoint location id: %" PRId64
682 __FUNCTION__, GetValue());
684 m_should_stop = true;
687 m_should_stop_is_valid = true;
688 return m_should_stop;
691 bool ShouldStop(Event *event_ptr) override {
692 // This just reports the work done by PerformAction or the synchronous stop.
694 // only ever get called after they have had a chance to run.
695 assert(m_should_stop_is_valid);
696 return m_should_stop;
699 void PerformAction(Event *event_ptr) override {
700 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
701 // We're going to calculate if we should stop or not in some way during the
703 // this code. Also by default we're going to stop, so set that here.
704 m_should_stop = true;
707 ThreadSP thread_sp(m_thread_wp.lock());
711 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
714 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
715 ProcessSP process_sp = exe_ctx.GetProcessSP();
718 // check if this process is running on an architecture where
719 // watchpoints trigger
720 // before the associated instruction runs. if so, disable the WP,
721 // single-step and then
722 // re-enable the watchpoint
725 bool wp_triggers_after;
727 if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
729 if (!wp_triggers_after) {
730 // We need to preserve the watch_index before watchpoint
731 // is disable. Since Watchpoint::SetEnabled will clear the
733 // This will fix TestWatchpointIter failure
734 Watchpoint *wp = wp_sp.get();
735 uint32_t watch_index = wp->GetHardwareIndex();
736 process_sp->DisableWatchpoint(wp, false);
737 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
738 assert(stored_stop_info_sp.get() == this);
740 ThreadPlanSP new_plan_sp(
741 thread_sp->QueueThreadPlanForStepSingleInstruction(
743 false, // abort_other_plans
744 true)); // stop_other_threads
745 new_plan_sp->SetIsMasterPlan(true);
746 new_plan_sp->SetOkayToDiscard(false);
747 new_plan_sp->SetPrivate(true);
748 process_sp->GetThreadList().SetSelectedThreadByID(
750 process_sp->ResumeSynchronous(nullptr);
751 process_sp->GetThreadList().SetSelectedThreadByID(
753 thread_sp->SetStopInfo(stored_stop_info_sp);
754 process_sp->EnableWatchpoint(wp, false);
755 wp->SetHardwareIndex(watch_index);
761 // This sentry object makes sure the current watchpoint is disabled
762 // while performing watchpoint actions,
763 // and it is then enabled after we are finished.
764 WatchpointSentry sentry(process_sp, wp_sp);
767 * MIPS: Last 3bits of the watchpoint address are masked by the kernel.
769 * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is
771 * watch exception is generated even when 'n' is read/written. To handle
773 * server emulates the instruction at PC and finds the base address of
775 * instruction and appends it in the description of the stop-info
776 * packet. If watchpoint
777 * is not set on this address by user then this do not stop.
779 if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) {
780 WatchpointSP wp_hit_sp =
781 thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
784 m_should_stop = false;
785 wp_sp->IncrementFalseAlarmsAndReviseHitCount();
789 // TODO: This condition should be checked in the synchronous part of the
791 // (Watchpoint::ShouldStop), so that we avoid pulling an event even if
792 // the watchpoint fails
793 // the ignore count condition. It is moved here temporarily, because for
795 // watchpoint_exceptions_received=before, the code in the previous lines
796 // takes care of moving
797 // the inferior to next PC. We have to check the ignore count condition
798 // after this is done,
799 // otherwise we will hit same watchpoint multiple times until we pass
800 // ignore condition, but we
801 // won't actually be ignoring them.
802 if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
803 m_should_stop = false;
805 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
807 if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
808 // We need to make sure the user sees any parse errors in their
809 // condition, so we'll hook the constructor errors up to the
810 // debugger's Async I/O.
811 ExpressionResults result_code;
812 EvaluateExpressionOptions expr_options;
813 expr_options.SetUnwindOnError(true);
814 expr_options.SetIgnoreBreakpoints(true);
815 ValueObjectSP result_value_sp;
817 result_code = UserExpression::Evaluate(
818 exe_ctx, expr_options, wp_sp->GetConditionText(),
819 llvm::StringRef(), result_value_sp, error);
821 if (result_code == eExpressionCompleted) {
822 if (result_value_sp) {
824 if (result_value_sp->ResolveValue(scalar_value)) {
825 if (scalar_value.ULongLong(1) == 0) {
826 // We have been vetoed. This takes precedence over querying
827 // the watchpoint whether it should stop (aka ignore count and
828 // friends). See also StopInfoWatchpoint::ShouldStop() as
829 // well as Process::ProcessEventData::DoOnRemoval().
830 m_should_stop = false;
832 m_should_stop = true;
835 "Condition successfully evaluated, result is %s.\n",
836 m_should_stop ? "true" : "false");
838 m_should_stop = true;
841 "Failed to get an integer result from the expression.");
845 StreamSP error_sp = debugger.GetAsyncErrorStream();
847 "Stopped due to an error evaluating condition of watchpoint ");
848 wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief);
849 error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
851 const char *err_str = error.AsCString("<Unknown Error>");
853 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
855 error_sp->PutCString(err_str);
858 // If the condition fails to be parsed or run, we should stop.
859 m_should_stop = true;
863 // If the condition says to stop, we run the callback to further decide
866 // FIXME: For now the callbacks have to run in async mode - the
867 // first time we restart we need
868 // to get out of there. So set it here.
869 // When we figure out how to nest watchpoint hits then this will
872 bool old_async = debugger.GetAsyncExecution();
873 debugger.SetAsyncExecution(true);
875 StoppointCallbackContext context(event_ptr, exe_ctx, false);
876 bool stop_requested = wp_sp->InvokeCallback(&context);
878 debugger.SetAsyncExecution(old_async);
880 // Also make sure that the callback hasn't continued the target.
881 // If it did, when we'll set m_should_stop to false and get out of
883 if (HasTargetRunSinceMe())
884 m_should_stop = false;
886 if (m_should_stop && !stop_requested) {
887 // We have been vetoed by the callback mechanism.
888 m_should_stop = false;
891 // Finally, if we are going to stop, print out the new & old values:
893 wp_sp->CaptureWatchedValue(exe_ctx);
895 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
896 StreamSP output_sp = debugger.GetAsyncOutputStream();
897 wp_sp->DumpSnapshots(output_sp.get());
904 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
908 "Process::%s could not find watchpoint id: %" PRId64 "...",
909 __FUNCTION__, m_value);
912 log->Printf("Process::%s returning from action with m_should_stop: %d.",
913 __FUNCTION__, m_should_stop);
915 m_should_stop_is_valid = true;
921 bool m_should_stop_is_valid;
922 lldb::addr_t m_watch_hit_addr;
925 //----------------------------------------------------------------------
926 // StopInfoUnixSignal
927 //----------------------------------------------------------------------
929 class StopInfoUnixSignal : public StopInfo {
931 StopInfoUnixSignal(Thread &thread, int signo, const char *description)
932 : StopInfo(thread, signo) {
933 SetDescription(description);
936 ~StopInfoUnixSignal() override = default;
938 StopReason GetStopReason() const override { return eStopReasonSignal; }
940 bool ShouldStopSynchronous(Event *event_ptr) override {
941 ThreadSP thread_sp(m_thread_wp.lock());
943 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
947 bool ShouldStop(Event *event_ptr) override {
948 ThreadSP thread_sp(m_thread_wp.lock());
950 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
954 // If should stop returns false, check if we should notify of this event
955 bool DoShouldNotify(Event *event_ptr) override {
956 ThreadSP thread_sp(m_thread_wp.lock());
959 thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
963 "thread %d received signal: %s", thread_sp->GetIndexID(),
964 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
966 Process::ProcessEventData::AddRestartedReason(event_ptr,
969 return should_notify;
974 void WillResume(lldb::StateType resume_state) override {
975 ThreadSP thread_sp(m_thread_wp.lock());
977 if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
979 thread_sp->SetResumeSignal(m_value);
983 const char *GetDescription() override {
984 if (m_description.empty()) {
985 ThreadSP thread_sp(m_thread_wp.lock());
988 const char *signal_name =
989 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
992 strm.Printf("signal %s", signal_name);
994 strm.Printf("signal %" PRIi64, m_value);
995 m_description = strm.GetString();
998 return m_description.c_str();
1002 //----------------------------------------------------------------------
1004 //----------------------------------------------------------------------
1006 class StopInfoTrace : public StopInfo {
1008 StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
1010 ~StopInfoTrace() override = default;
1012 StopReason GetStopReason() const override { return eStopReasonTrace; }
1014 const char *GetDescription() override {
1015 if (m_description.empty())
1018 return m_description.c_str();
1022 //----------------------------------------------------------------------
1023 // StopInfoException
1024 //----------------------------------------------------------------------
1026 class StopInfoException : public StopInfo {
1028 StopInfoException(Thread &thread, const char *description)
1029 : StopInfo(thread, LLDB_INVALID_UID) {
1031 SetDescription(description);
1034 ~StopInfoException() override = default;
1036 StopReason GetStopReason() const override { return eStopReasonException; }
1038 const char *GetDescription() override {
1039 if (m_description.empty())
1042 return m_description.c_str();
1046 //----------------------------------------------------------------------
1047 // StopInfoThreadPlan
1048 //----------------------------------------------------------------------
1050 class StopInfoThreadPlan : public StopInfo {
1052 StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
1053 ExpressionVariableSP &expression_variable_sp)
1054 : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
1055 m_return_valobj_sp(return_valobj_sp),
1056 m_expression_variable_sp(expression_variable_sp) {}
1058 ~StopInfoThreadPlan() override = default;
1060 StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
1062 const char *GetDescription() override {
1063 if (m_description.empty()) {
1065 m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
1066 m_description = strm.GetString();
1068 return m_description.c_str();
1071 ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
1073 ExpressionVariableSP GetExpressionVariable() {
1074 return m_expression_variable_sp;
1078 bool ShouldStop(Event *event_ptr) override {
1080 return m_plan_sp->ShouldStop(event_ptr);
1082 return StopInfo::ShouldStop(event_ptr);
1086 ThreadPlanSP m_plan_sp;
1087 ValueObjectSP m_return_valobj_sp;
1088 ExpressionVariableSP m_expression_variable_sp;
1091 //----------------------------------------------------------------------
1093 //----------------------------------------------------------------------
1095 class StopInfoExec : public StopInfo {
1097 StopInfoExec(Thread &thread)
1098 : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
1100 ~StopInfoExec() override = default;
1102 bool ShouldStop(Event *event_ptr) override {
1103 ThreadSP thread_sp(m_thread_wp.lock());
1105 return thread_sp->GetProcess()->GetStopOnExec();
1109 StopReason GetStopReason() const override { return eStopReasonExec; }
1111 const char *GetDescription() override { return "exec"; }
1114 void PerformAction(Event *event_ptr) override {
1115 // Only perform the action once
1116 if (m_performed_action)
1118 m_performed_action = true;
1119 ThreadSP thread_sp(m_thread_wp.lock());
1121 thread_sp->GetProcess()->DidExec();
1124 bool m_performed_action;
1127 } // namespace lldb_private
1129 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
1130 break_id_t break_id) {
1131 return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
1134 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
1135 break_id_t break_id,
1137 return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
1141 StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id,
1142 lldb::addr_t watch_hit_addr) {
1143 return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
1146 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
1147 const char *description) {
1148 return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
1151 StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
1152 return StopInfoSP(new StopInfoTrace(thread));
1155 StopInfoSP StopInfo::CreateStopReasonWithPlan(
1156 ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
1157 ExpressionVariableSP expression_variable_sp) {
1158 return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
1159 expression_variable_sp));
1162 StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
1163 const char *description) {
1164 return StopInfoSP(new StopInfoException(thread, description));
1167 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
1168 return StopInfoSP(new StopInfoExec(thread));
1171 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
1173 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1174 StopInfoThreadPlan *plan_stop_info =
1175 static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1176 return plan_stop_info->GetReturnValueObject();
1178 return ValueObjectSP();
1181 ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) {
1183 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1184 StopInfoThreadPlan *plan_stop_info =
1185 static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1186 return plan_stop_info->GetExpressionVariable();
1188 return ExpressionVariableSP();
1192 StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp,
1193 lldb::addr_t *crashing_address) {
1194 if (!stop_info_sp) {
1195 return ValueObjectSP();
1198 const char *description = stop_info_sp->GetDescription();
1200 return ValueObjectSP();
1203 ThreadSP thread_sp = stop_info_sp->GetThread();
1205 return ValueObjectSP();
1208 StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
1211 return ValueObjectSP();
1214 const char address_string[] = "address=";
1216 const char *address_loc = strstr(description, address_string);
1218 return ValueObjectSP();
1221 address_loc += (sizeof(address_string) - 1);
1223 uint64_t address = strtoull(address_loc, 0, 0);
1224 if (crashing_address) {
1225 *crashing_address = address;
1228 return frame_sp->GuessValueForAddress(address);