LLDB mainline
StopInfo.cpp
Go to the documentation of this file.
1//===-- StopInfo.cpp ------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include <string>
10
15#include "lldb/Core/Debugger.h"
18#include "lldb/Target/Process.h"
20#include "lldb/Target/Target.h"
21#include "lldb/Target/Thread.h"
26#include "lldb/Utility/Log.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
32StopInfo::StopInfo(Thread &thread, uint64_t value)
33 : m_thread_wp(thread.shared_from_this()),
34 m_stop_id(thread.GetProcess()->GetStopID()),
35 m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
36 m_description(), m_override_should_notify(eLazyBoolCalculate),
37 m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
38
39bool StopInfo::IsValid() const {
40 ThreadSP thread_sp(m_thread_wp.lock());
41 if (thread_sp)
42 return thread_sp->GetProcess()->GetStopID() == m_stop_id;
43 return false;
44}
45
47 ThreadSP thread_sp(m_thread_wp.lock());
48 if (thread_sp) {
49 m_stop_id = thread_sp->GetProcess()->GetStopID();
50 m_resume_id = thread_sp->GetProcess()->GetResumeID();
51 }
52}
53
55 ThreadSP thread_sp(m_thread_wp.lock());
56
57 if (thread_sp) {
58 lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
59 if (ret_type == eStateRunning) {
60 return true;
61 } else if (ret_type == eStateStopped) {
62 // This is a little tricky. We want to count "run and stopped again
63 // before you could ask this question as a "TRUE" answer to
64 // HasTargetRunSinceMe. But we don't want to include any running of the
65 // target done for expressions. So we track both resumes, and resumes
66 // caused by expressions, and check if there are any resumes
67 // NOT caused
68 // by expressions.
69
70 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
71 uint32_t last_user_expression_id =
72 thread_sp->GetProcess()->GetLastUserExpressionResumeID();
73 if (curr_resume_id == m_resume_id) {
74 return false;
75 } else if (curr_resume_id > last_user_expression_id) {
76 return true;
77 }
78 }
79 }
80 return false;
81}
82
83// StopInfoBreakpoint
84
85namespace lldb_private {
87public:
89 : StopInfo(thread, break_id), m_should_stop(false),
92 m_was_all_internal(false), m_was_one_shot(false) {
94 }
95
96 StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
97 : StopInfo(thread, break_id), m_should_stop(should_stop),
100 m_was_all_internal(false), m_was_one_shot(false) {
101 StoreBPInfo();
102 }
103
104 ~StopInfoBreakpoint() override = default;
105
106 void StoreBPInfo() {
107 ThreadSP thread_sp(m_thread_wp.lock());
108 if (thread_sp) {
109 BreakpointSiteSP bp_site_sp(
110 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
111 if (bp_site_sp) {
112 uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
113 if (num_owners == 1) {
114 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
115 if (bp_loc_sp) {
116 Breakpoint & bkpt = bp_loc_sp->GetBreakpoint();
117 m_break_id = bkpt.GetID();
118 m_was_one_shot = bkpt.IsOneShot();
120 }
121 } else {
122 m_was_all_internal = true;
123 for (uint32_t i = 0; i < num_owners; i++) {
124 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
125 m_was_all_internal = false;
126 break;
127 }
128 }
129 }
130 m_address = bp_site_sp->GetLoadAddress();
131 }
132 }
133 }
134
136 ProcessSP process_sp(thread.GetProcess());
137 if (process_sp) {
138 BreakpointSiteSP bp_site_sp(
139 process_sp->GetBreakpointSiteList().FindByID(m_value));
140 if (bp_site_sp)
141 return bp_site_sp->ValidForThisThread(thread);
142 }
143 return false;
144 }
145
146 StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
147
148 bool ShouldStopSynchronous(Event *event_ptr) override {
149 ThreadSP thread_sp(m_thread_wp.lock());
150 if (thread_sp) {
152 // Only check once if we should stop at a breakpoint
153 BreakpointSiteSP bp_site_sp(
154 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
155 if (bp_site_sp) {
156 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
157 StoppointCallbackContext context(event_ptr, exe_ctx, true);
158 bp_site_sp->BumpHitCounts();
159 m_should_stop = bp_site_sp->ShouldStop(&context);
160 } else {
162
163 LLDB_LOGF(log,
164 "Process::%s could not find breakpoint site id: %" PRId64
165 "...",
166 __FUNCTION__, m_value);
167
168 m_should_stop = true;
169 }
171 }
172 return m_should_stop;
173 }
174 return false;
175 }
176
177 bool DoShouldNotify(Event *event_ptr) override {
178 return !m_was_all_internal;
179 }
180
181 const char *GetDescription() override {
182 if (m_description.empty()) {
183 ThreadSP thread_sp(m_thread_wp.lock());
184 if (thread_sp) {
185 BreakpointSiteSP bp_site_sp(
186 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
187 if (bp_site_sp) {
188 StreamString strm;
189 // If we have just hit an internal breakpoint, and it has a kind
190 // description, print that instead of the full breakpoint printing:
191 if (bp_site_sp->IsInternal()) {
192 size_t num_owners = bp_site_sp->GetNumberOfOwners();
193 for (size_t idx = 0; idx < num_owners; idx++) {
194 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
195 ->GetBreakpoint()
196 .GetBreakpointKind();
197 if (kind != nullptr) {
198 m_description.assign(kind);
199 return kind;
200 }
201 }
202 }
203
204 strm.Printf("breakpoint ");
205 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
206 m_description = std::string(strm.GetString());
207 } else {
208 StreamString strm;
210 BreakpointSP break_sp =
211 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
212 m_break_id);
213 if (break_sp) {
214 if (break_sp->IsInternal()) {
215 const char *kind = break_sp->GetBreakpointKind();
216 if (kind)
217 strm.Printf("internal %s breakpoint(%d).", kind, m_break_id);
218 else
219 strm.Printf("internal breakpoint(%d).", m_break_id);
220 } else {
221 strm.Printf("breakpoint %d.", m_break_id);
222 }
223 } else {
224 if (m_was_one_shot)
225 strm.Printf("one-shot breakpoint %d", m_break_id);
226 else
227 strm.Printf("breakpoint %d which has been deleted.",
228 m_break_id);
229 }
230 } else if (m_address == LLDB_INVALID_ADDRESS)
231 strm.Printf("breakpoint site %" PRIi64
232 " which has been deleted - unknown address",
233 m_value);
234 else
235 strm.Printf("breakpoint site %" PRIi64
236 " which has been deleted - was at 0x%" PRIx64,
238
239 m_description = std::string(strm.GetString());
240 }
241 }
242 }
243 return m_description.c_str();
244 }
245
246protected:
247 bool ShouldStop(Event *event_ptr) override {
248 // This just reports the work done by PerformAction or the synchronous
249 // stop. It should only ever get called after they have had a chance to
250 // run.
252 return m_should_stop;
253 }
254
255 void PerformAction(Event *event_ptr) override {
257 return;
259 bool all_stopping_locs_internal = true;
260
261 ThreadSP thread_sp(m_thread_wp.lock());
262
263 if (thread_sp) {
265
266 if (!thread_sp->IsValid()) {
267 // This shouldn't ever happen, but just in case, don't do more harm.
268 if (log) {
269 LLDB_LOGF(log, "PerformAction got called with an invalid thread.");
270 }
271 m_should_stop = true;
273 return;
274 }
275
276 BreakpointSiteSP bp_site_sp(
277 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
278 std::unordered_set<break_id_t> precondition_breakpoints;
279 // Breakpoints that fail their condition check are not considered to
280 // have been hit. If the only locations at this site have failed their
281 // conditions, we should change the stop-info to none. Otherwise, if we
282 // hit another breakpoint on a different thread which does stop, users
283 // will see a breakpont hit with a failed condition, which is wrong.
284 // Use this variable to tell us if that is true.
285 bool actually_hit_any_locations = false;
286 if (bp_site_sp) {
287 // Let's copy the owners list out of the site and store them in a local
288 // list. That way if one of the breakpoint actions changes the site,
289 // then we won't be operating on a bad list.
290 BreakpointLocationCollection site_locations;
291 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
292
293 if (num_owners == 0) {
294 m_should_stop = true;
295 actually_hit_any_locations = true; // We're going to stop, don't
296 // change the stop info.
297 } else {
298 // We go through each location, and test first its precondition -
299 // this overrides everything. Note, we only do this once per
300 // breakpoint - not once per location... Then check the condition.
301 // If the condition says to stop, then we run the callback for that
302 // location. If that callback says to stop as well, then we set
303 // m_should_stop to true; we are going to stop. But we still want to
304 // give all the breakpoints whose conditions say we are going to stop
305 // a chance to run their callbacks. Of course if any callback
306 // restarts the target by putting "continue" in the callback, then
307 // we're going to restart, without running the rest of the callbacks.
308 // And in this case we will end up not stopping even if another
309 // location said we should stop. But that's better than not running
310 // all the callbacks.
311
312 // There's one other complication here. We may have run an async
313 // breakpoint callback that said we should stop. We only want to
314 // override that if another breakpoint action says we shouldn't
315 // stop. If nobody else has an opinion, then we should stop if the
316 // async callback says we should. An example of this is the async
317 // shared library load notification breakpoint and the setting
318 // stop-on-sharedlibrary-events.
319 // We'll keep the async value in async_should_stop, and track whether
320 // anyone said we should NOT stop in actually_said_continue.
321 bool async_should_stop = false;
323 async_should_stop = m_should_stop;
324 bool actually_said_continue = false;
325
326 m_should_stop = false;
327
328 // We don't select threads as we go through them testing breakpoint
329 // conditions and running commands. So we need to set the thread for
330 // expression evaluation here:
331 ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
332
333 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
334 Process *process = exe_ctx.GetProcessPtr();
335 if (process->GetModIDRef().IsRunningExpression()) {
336 // If we are in the middle of evaluating an expression, don't run
337 // asynchronous breakpoint commands or expressions. That could
338 // lead to infinite recursion if the command or condition re-calls
339 // the function with this breakpoint.
340 // TODO: We can keep a list of the breakpoints we've seen while
341 // running expressions in the nested
342 // PerformAction calls that can arise when the action runs a
343 // function that hits another breakpoint, and only stop running
344 // commands when we see the same breakpoint hit a second time.
345
347
348 // It is possible that the user has a breakpoint at the same site
349 // as the completed plan had (e.g. user has a breakpoint
350 // on a module entry point, and `ThreadPlanCallFunction` ends
351 // also there). We can't find an internal breakpoint in the loop
352 // later because it was already removed on the plan completion.
353 // So check if the plan was completed, and stop if so.
354 if (thread_sp->CompletedPlanOverridesBreakpoint()) {
355 m_should_stop = true;
356 thread_sp->ResetStopInfo();
357 return;
358 }
359
360 LLDB_LOGF(log, "StopInfoBreakpoint::PerformAction - Hit a "
361 "breakpoint while running an expression,"
362 " not running commands to avoid recursion.");
363 bool ignoring_breakpoints =
365 // Internal breakpoints should be allowed to do their job, we
366 // can make sure they don't do anything that would cause recursive
367 // command execution:
368 if (!m_was_all_internal) {
369 m_should_stop = !ignoring_breakpoints;
370 LLDB_LOGF(log,
371 "StopInfoBreakpoint::PerformAction - in expression, "
372 "continuing: %s.",
373 m_should_stop ? "true" : "false");
375 "hit breakpoint while running function, skipping commands "
376 "and conditions to prevent recursion",
377 process->GetTarget().GetDebugger().GetID());
378 return;
379 }
380 }
381
382 StoppointCallbackContext context(event_ptr, exe_ctx, false);
383
384 // For safety's sake let's also grab an extra reference to the
385 // breakpoint owners of the locations we're going to examine, since
386 // the locations are going to have to get back to their breakpoints,
387 // and the locations don't keep their owners alive. I'm just
388 // sticking the BreakpointSP's in a vector since I'm only using it to
389 // locally increment their retain counts.
390
391 std::vector<lldb::BreakpointSP> location_owners;
392
393 for (size_t j = 0; j < num_owners; j++) {
394 BreakpointLocationSP loc(site_locations.GetByIndex(j));
395 location_owners.push_back(loc->GetBreakpoint().shared_from_this());
396 }
397
398 for (size_t j = 0; j < num_owners; j++) {
399 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
400 StreamString loc_desc;
401 if (log) {
402 bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
403 }
404 // If another action disabled this breakpoint or its location, then
405 // don't run the actions.
406 if (!bp_loc_sp->IsEnabled() ||
407 !bp_loc_sp->GetBreakpoint().IsEnabled())
408 continue;
409
410 // The breakpoint site may have many locations associated with it,
411 // not all of them valid for this thread. Skip the ones that
412 // aren't:
413 if (!bp_loc_sp->ValidForThisThread(*thread_sp)) {
414 if (log) {
415 LLDB_LOGF(log,
416 "Breakpoint %s hit on thread 0x%llx but it was not "
417 "for this thread, continuing.",
418 loc_desc.GetData(),
419 static_cast<unsigned long long>(thread_sp->GetID()));
420 }
421 continue;
422 }
423
424 // First run the precondition, but since the precondition is per
425 // breakpoint, only run it once per breakpoint.
426 std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
427 precondition_breakpoints.insert(
428 bp_loc_sp->GetBreakpoint().GetID());
429 if (!result.second)
430 continue;
431
432 bool precondition_result =
433 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
434 if (!precondition_result) {
435 actually_said_continue = true;
436 continue;
437 }
438 // Next run the condition for the breakpoint. If that says we
439 // should stop, then we'll run the callback for the breakpoint. If
440 // the callback says we shouldn't stop that will win.
441
442 if (bp_loc_sp->GetConditionText() == nullptr)
443 actually_hit_any_locations = true;
444 else {
445 Status condition_error;
446 bool condition_says_stop =
447 bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
448
449 if (!condition_error.Success()) {
450 // If the condition fails to evaluate, we are going to stop
451 // at it, so the location was hit.
452 actually_hit_any_locations = true;
453 const char *err_str =
454 condition_error.AsCString("<unknown error>");
455 LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
456
457 StreamString strm;
458 strm << "stopped due to an error evaluating condition of "
459 "breakpoint ";
460 bp_loc_sp->GetDescription(&strm, eDescriptionLevelBrief);
461 strm << ": \"" << bp_loc_sp->GetConditionText() << "\"\n";
462 strm << err_str;
463
465 strm.GetString().str(),
466 exe_ctx.GetTargetRef().GetDebugger().GetID());
467 } else {
468 LLDB_LOGF(log,
469 "Condition evaluated for breakpoint %s on thread "
470 "0x%llx condition_says_stop: %i.",
471 loc_desc.GetData(),
472 static_cast<unsigned long long>(thread_sp->GetID()),
473 condition_says_stop);
474 if (condition_says_stop)
475 actually_hit_any_locations = true;
476 else {
477 // We don't want to increment the hit count of breakpoints if
478 // the condition fails. We've already bumped it by the time
479 // we get here, so undo the bump:
480 bp_loc_sp->UndoBumpHitCount();
481 actually_said_continue = true;
482 continue;
483 }
484 }
485 }
486
487 // We've done all the checks whose failure means "we consider lldb
488 // not to have hit the breakpoint". Now we're going to check for
489 // conditions that might continue after hitting. Start with the
490 // ignore count:
491 if (!bp_loc_sp->IgnoreCountShouldStop()) {
492 actually_said_continue = true;
493 continue;
494 }
495
496 // Check the auto-continue bit on the location, do this before the
497 // callback since it may change this, but that would be for the
498 // NEXT hit. Note, you might think you could check auto-continue
499 // before the condition, and not evaluate the condition if it says
500 // to continue. But failing the condition means the breakpoint was
501 // effectively NOT HIT. So these two states are different.
502 bool auto_continue_says_stop = true;
503 if (bp_loc_sp->IsAutoContinue())
504 {
505 LLDB_LOGF(log,
506 "Continuing breakpoint %s as AutoContinue was set.",
507 loc_desc.GetData());
508 // We want this stop reported, so you will know we auto-continued
509 // but only for external breakpoints:
510 if (!bp_loc_sp->GetBreakpoint().IsInternal())
511 thread_sp->SetShouldReportStop(eVoteYes);
512 auto_continue_says_stop = false;
513 }
514
515 bool callback_says_stop = true;
516
517 // FIXME: For now the callbacks have to run in async mode - the
518 // first time we restart we need
519 // to get out of there. So set it here.
520 // When we figure out how to nest breakpoint hits then this will
521 // change.
522
523 // Don't run async callbacks in PerformAction. They have already
524 // been taken into account with async_should_stop.
525 if (!bp_loc_sp->IsCallbackSynchronous()) {
526 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
527 bool old_async = debugger.GetAsyncExecution();
528 debugger.SetAsyncExecution(true);
529
530 callback_says_stop = bp_loc_sp->InvokeCallback(&context);
531
532 debugger.SetAsyncExecution(old_async);
533
534 if (callback_says_stop && auto_continue_says_stop)
535 m_should_stop = true;
536 else
537 actually_said_continue = true;
538 }
539
540 if (m_should_stop && !bp_loc_sp->GetBreakpoint().IsInternal())
541 all_stopping_locs_internal = false;
542
543 // If we are going to stop for this breakpoint, then remove the
544 // breakpoint.
545 if (callback_says_stop && bp_loc_sp &&
546 bp_loc_sp->GetBreakpoint().IsOneShot()) {
547 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
548 bp_loc_sp->GetBreakpoint().GetID());
549 }
550 // Also make sure that the callback hasn't continued the target. If
551 // it did, when we'll set m_should_start to false and get out of
552 // here.
553 if (HasTargetRunSinceMe()) {
554 m_should_stop = false;
555 actually_said_continue = true;
556 break;
557 }
558 }
559 // At this point if nobody actually told us to continue, we should
560 // give the async breakpoint callback a chance to weigh in:
561 if (!actually_said_continue && !m_should_stop) {
562 m_should_stop = async_should_stop;
563 }
564 }
565 // We've figured out what this stop wants to do, so mark it as valid so
566 // we don't compute it again.
568 } else {
569 m_should_stop = true;
571 actually_hit_any_locations = true;
572 Log *log_process(GetLog(LLDBLog::Process));
573
574 LLDB_LOGF(log_process,
575 "Process::%s could not find breakpoint site id: %" PRId64
576 "...",
577 __FUNCTION__, m_value);
578 }
579
580 if ((!m_should_stop || all_stopping_locs_internal) &&
581 thread_sp->CompletedPlanOverridesBreakpoint()) {
582
583 // Override should_stop decision when we have completed step plan
584 // additionally to the breakpoint
585 m_should_stop = true;
586
587 // We know we're stopping for a completed plan and we don't want to
588 // show the breakpoint stop, so compute the public stop info immediately
589 // here.
590 thread_sp->CalculatePublicStopInfo();
591 } else if (!actually_hit_any_locations) {
592 // In the end, we didn't actually have any locations that passed their
593 // "was I hit" checks. So say we aren't stopped.
594 GetThread()->ResetStopInfo();
595 LLDB_LOGF(log, "Process::%s all locations failed condition checks.",
596 __FUNCTION__);
597 }
598
599 LLDB_LOGF(log,
600 "Process::%s returning from action with m_should_stop: %d.",
601 __FUNCTION__, m_should_stop);
602 }
603 }
604
605private:
608 bool m_should_perform_action; // Since we are trying to preserve the "state"
609 // of the system even if we run functions
610 // etc. behind the users backs, we need to make sure we only REALLY perform
611 // the action once.
612 lldb::addr_t m_address; // We use this to capture the breakpoint site address
613 // when we create the StopInfo,
614 // in case somebody deletes it between the time the StopInfo is made and the
615 // description is asked for.
619};
620
621// StopInfoWatchpoint
622
624public:
625 // Make sure watchpoint is properly disabled and subsequently enabled while
626 // performing watchpoint actions.
628 public:
630 watchpoint_sp(w_sp) {
631 if (process_sp && watchpoint_sp) {
632 const bool notify = false;
633 watchpoint_sp->TurnOnEphemeralMode();
634 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
635 process_sp->AddPreResumeAction(SentryPreResumeAction, this);
636 }
637 }
638
639 void DoReenable() {
640 if (process_sp && watchpoint_sp) {
641 bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
642 watchpoint_sp->TurnOffEphemeralMode();
643 const bool notify = false;
644 if (was_disabled) {
645 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
646 } else {
647 process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
648 }
649 }
650 }
651
653 DoReenable();
654 if (process_sp)
655 process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
656 }
657
658 static bool SentryPreResumeAction(void *sentry_void) {
659 WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
660 sentry->DoReenable();
661 return true;
662 }
663
664 private:
667 };
668
669 StopInfoWatchpoint(Thread &thread, break_id_t watch_id, bool silently_skip_wp)
670 : StopInfo(thread, watch_id), m_silently_skip_wp(silently_skip_wp) {}
671
672 ~StopInfoWatchpoint() override = default;
673
674 StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
675
676 const char *GetDescription() override {
677 if (m_description.empty()) {
678 StreamString strm;
679 strm.Printf("watchpoint %" PRIi64, m_value);
680 m_description = std::string(strm.GetString());
681 }
682 return m_description.c_str();
683 }
684
685protected:
686 using StopInfoWatchpointSP = std::shared_ptr<StopInfoWatchpoint>;
687 // This plan is used to orchestrate stepping over the watchpoint for
688 // architectures (e.g. ARM) that report the watch before running the watched
689 // access. This is the sort of job you have to defer to the thread plans,
690 // if you try to do it directly in the stop info and there are other threads
691 // that needed to process this stop you will have yanked control away from
692 // them and they won't behave correctly.
694 public:
696 StopInfoWatchpointSP stop_info_sp,
697 WatchpointSP watch_sp)
698 : ThreadPlanStepInstruction(thread, false, true, eVoteNoOpinion,
700 m_stop_info_sp(stop_info_sp), m_watch_sp(watch_sp) {
701 assert(watch_sp);
702 m_watch_index = watch_sp->GetHardwareIndex();
703 }
704
705 bool DoWillResume(lldb::StateType resume_state,
706 bool current_plan) override {
707 if (resume_state == eStateSuspended)
708 return true;
709
710 if (!m_did_disable_wp) {
711 GetThread().GetProcess()->DisableWatchpoint(m_watch_sp.get(), false);
712 m_did_disable_wp = true;
713 }
714 return true;
715 }
716
717 bool DoPlanExplainsStop(Event *event_ptr) override {
719 return true;
720 StopInfoSP stop_info_sp = GetThread().GetPrivateStopInfo();
721 // lldb-server resets the stop info for threads that didn't get to run,
722 // so we might have not gotten to run, but still have a watchpoint stop
723 // reason, in which case this will indeed be for us.
724 if (stop_info_sp
725 && stop_info_sp->GetStopReason() == eStopReasonWatchpoint)
726 return true;
727 return false;
728 }
729
730 void DidPop() override {
731 // Don't artifically keep the watchpoint alive.
732 m_watch_sp.reset();
733 }
734
735 bool ShouldStop(Event *event_ptr) override {
736 bool should_stop = ThreadPlanStepInstruction::ShouldStop(event_ptr);
737 bool plan_done = MischiefManaged();
738 if (plan_done) {
739 m_stop_info_sp->SetStepOverPlanComplete();
742 }
743 return should_stop;
744 }
745
747 return true;
748 }
749
750 protected:
752 if (!m_did_disable_wp)
753 return;
754 m_did_disable_wp = true;
755 GetThread().GetProcess()->EnableWatchpoint(m_watch_sp.get(), true);
756 m_watch_sp->SetHardwareIndex(m_watch_index);
757 }
758
759 private:
763 bool m_did_disable_wp = false;
764 };
765
766 bool ShouldStopSynchronous(Event *event_ptr) override {
767 // If we are running our step-over the watchpoint plan, stop if it's done
768 // and continue if it's not:
770 return m_should_stop;
771
772 // If we are running our step over plan, then stop here and let the regular
773 // ShouldStop figure out what we should do: Otherwise, give our plan
774 // more time to get run:
777
779 ThreadSP thread_sp(m_thread_wp.lock());
780 assert(thread_sp);
781
782 if (thread_sp->GetTemporaryResumeState() == eStateSuspended) {
783 // This is the second firing of a watchpoint so don't process it again.
784 LLDB_LOG(log, "We didn't run but stopped with a StopInfoWatchpoint, we "
785 "have already handled this one, don't do it again.");
786 m_should_stop = false;
788 return m_should_stop;
789 }
790
791 WatchpointSP wp_sp(
792 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
793 // If we can no longer find the watchpoint, we just have to stop:
794 if (!wp_sp) {
795
796 LLDB_LOGF(log,
797 "Process::%s could not find watchpoint location id: %" PRId64
798 "...",
799 __FUNCTION__, GetValue());
800
801 m_should_stop = true;
803 return true;
804 }
805
806 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
807 StoppointCallbackContext context(event_ptr, exe_ctx, true);
808 m_should_stop = wp_sp->ShouldStop(&context);
809 if (!m_should_stop) {
810 // This won't happen at present because we only allow one watchpoint per
811 // watched range. So we won't stop at a watched address with a disabled
812 // watchpoint. If we start allowing overlapping watchpoints, then we
813 // will have to make watchpoints be real "WatchpointSite" and delegate to
814 // all the watchpoints sharing the site. In that case, the code below
815 // would be the right thing to do.
817 return m_should_stop;
818 }
819 // If this is a system where we need to execute the watchpoint by hand
820 // after the hit, queue a thread plan to do that, and then say not to stop.
821 // Otherwise, let the async action figure out whether the watchpoint should
822 // stop
823
824 ProcessSP process_sp = exe_ctx.GetProcessSP();
825 bool wp_triggers_after = process_sp->GetWatchpointReportedAfter();
826
827 if (!wp_triggers_after) {
828 // We have to step over the watchpoint before we know what to do:
829 StopInfoWatchpointSP me_as_siwp_sp
830 = std::static_pointer_cast<StopInfoWatchpoint>(shared_from_this());
831 ThreadPlanSP step_over_wp_sp(new ThreadPlanStepOverWatchpoint(
832 *(thread_sp.get()), me_as_siwp_sp, wp_sp));
833 // When this plan is done we want to stop, so set this as a Controlling
834 // plan.
835 step_over_wp_sp->SetIsControllingPlan(true);
836 step_over_wp_sp->SetOkayToDiscard(false);
837
839 error = thread_sp->QueueThreadPlan(step_over_wp_sp, false);
840 // If we couldn't push the thread plan, just stop here:
841 if (!error.Success()) {
842 LLDB_LOGF(log, "Could not push our step over watchpoint plan: %s",
843 error.AsCString());
844
845 m_should_stop = true;
847 return true;
848 } else {
849 // Otherwise, don't set m_should_stop, we don't know that yet. Just
850 // say we should continue, and tell the thread we really should do so:
851 thread_sp->SetShouldRunBeforePublicStop(true);
853 return false;
854 }
855 } else {
856 // We didn't have to do anything special
858 return m_should_stop;
859 }
860
861 return m_should_stop;
862 }
863
864 bool ShouldStop(Event *event_ptr) override {
865 // This just reports the work done by PerformAction or the synchronous
866 // stop. It should only ever get called after they have had a chance to
867 // run.
869 return m_should_stop;
870 }
871
872 void PerformAction(Event *event_ptr) override {
874 // We're going to calculate if we should stop or not in some way during the
875 // course of this code. Also by default we're going to stop, so set that
876 // here.
877 m_should_stop = true;
878
879
880 ThreadSP thread_sp(m_thread_wp.lock());
881 if (thread_sp) {
882
883 WatchpointSP wp_sp(
884 thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
885 GetValue()));
886 if (wp_sp) {
887 // This sentry object makes sure the current watchpoint is disabled
888 // while performing watchpoint actions, and it is then enabled after we
889 // are finished.
890 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
891 ProcessSP process_sp = exe_ctx.GetProcessSP();
892
893 WatchpointSentry sentry(process_sp, wp_sp);
894
895 if (m_silently_skip_wp) {
896 m_should_stop = false;
897 wp_sp->UndoHitCount();
898 }
899
900 if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount()) {
901 m_should_stop = false;
903 }
904
905 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
906
907 if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
908 // We need to make sure the user sees any parse errors in their
909 // condition, so we'll hook the constructor errors up to the
910 // debugger's Async I/O.
911 ExpressionResults result_code;
912 EvaluateExpressionOptions expr_options;
913 expr_options.SetUnwindOnError(true);
914 expr_options.SetIgnoreBreakpoints(true);
915 ValueObjectSP result_value_sp;
917 result_code = UserExpression::Evaluate(
918 exe_ctx, expr_options, wp_sp->GetConditionText(),
919 llvm::StringRef(), result_value_sp, error);
920
921 if (result_code == eExpressionCompleted) {
922 if (result_value_sp) {
923 Scalar scalar_value;
924 if (result_value_sp->ResolveValue(scalar_value)) {
925 if (scalar_value.ULongLong(1) == 0) {
926 // The condition failed, which we consider "not having hit
927 // the watchpoint" so undo the hit count here.
928 wp_sp->UndoHitCount();
929 m_should_stop = false;
930 } else
931 m_should_stop = true;
932 LLDB_LOGF(log,
933 "Condition successfully evaluated, result is %s.\n",
934 m_should_stop ? "true" : "false");
935 } else {
936 m_should_stop = true;
937 LLDB_LOGF(
938 log,
939 "Failed to get an integer result from the expression.");
940 }
941 }
942 } else {
943 const char *err_str = error.AsCString("<unknown error>");
944 LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
945
946 StreamString strm;
947 strm << "stopped due to an error evaluating condition of "
948 "watchpoint ";
949 wp_sp->GetDescription(&strm, eDescriptionLevelBrief);
950 strm << ": \"" << wp_sp->GetConditionText() << "\"\n";
951 strm << err_str;
952
953 Debugger::ReportError(strm.GetString().str(),
954 exe_ctx.GetTargetRef().GetDebugger().GetID());
955 }
956 }
957
958 // If the condition says to stop, we run the callback to further decide
959 // whether to stop.
960 if (m_should_stop) {
961 // FIXME: For now the callbacks have to run in async mode - the
962 // first time we restart we need
963 // to get out of there. So set it here.
964 // When we figure out how to nest watchpoint hits then this will
965 // change.
966
967 bool old_async = debugger.GetAsyncExecution();
968 debugger.SetAsyncExecution(true);
969
970 StoppointCallbackContext context(event_ptr, exe_ctx, false);
971 bool stop_requested = wp_sp->InvokeCallback(&context);
972
973 debugger.SetAsyncExecution(old_async);
974
975 // Also make sure that the callback hasn't continued the target. If
976 // it did, when we'll set m_should_stop to false and get out of here.
978 m_should_stop = false;
979
980 if (m_should_stop && !stop_requested) {
981 // We have been vetoed by the callback mechanism.
982 m_should_stop = false;
983 }
984 }
985
986 // Don't stop if the watched region value is unmodified, and
987 // this is a Modify-type watchpoint.
988 if (m_should_stop && !wp_sp->WatchedValueReportable(exe_ctx))
989 m_should_stop = false;
990
991 // Finally, if we are going to stop, print out the new & old values:
992 if (m_should_stop) {
993 wp_sp->CaptureWatchedValue(exe_ctx);
994
995 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
996 StreamSP output_sp = debugger.GetAsyncOutputStream();
997 wp_sp->DumpSnapshots(output_sp.get());
998 output_sp->EOL();
999 output_sp->Flush();
1000 }
1001
1002 } else {
1003 Log *log_process(GetLog(LLDBLog::Process));
1004
1005 LLDB_LOGF(log_process,
1006 "Process::%s could not find watchpoint id: %" PRId64 "...",
1007 __FUNCTION__, m_value);
1008 }
1009 LLDB_LOGF(log,
1010 "Process::%s returning from action with m_should_stop: %d.",
1011 __FUNCTION__, m_should_stop);
1012
1014 }
1015 }
1016
1017private:
1019 assert(m_using_step_over_plan);
1021 }
1022
1023 bool m_should_stop = false;
1025 // A false watchpoint hit has happened -
1026 // the thread stopped with a watchpoint
1027 // hit notification, but the watched region
1028 // was not actually accessed (as determined
1029 // by the gdb stub we're talking to).
1030 // Continue past this watchpoint without
1031 // notifying the user; on some targets this
1032 // may mean disable wp, instruction step,
1033 // re-enable wp, continue.
1034 // On others, just continue.
1038};
1039
1040// StopInfoUnixSignal
1041
1043public:
1044 StopInfoUnixSignal(Thread &thread, int signo, const char *description,
1045 std::optional<int> code)
1046 : StopInfo(thread, signo), m_code(code) {
1047 SetDescription(description);
1048 }
1049
1050 ~StopInfoUnixSignal() override = default;
1051
1052 StopReason GetStopReason() const override { return eStopReasonSignal; }
1053
1054 bool ShouldStopSynchronous(Event *event_ptr) override {
1055 ThreadSP thread_sp(m_thread_wp.lock());
1056 if (thread_sp)
1057 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
1058 return false;
1059 }
1060
1061 bool ShouldStop(Event *event_ptr) override {
1062 ThreadSP thread_sp(m_thread_wp.lock());
1063 if (thread_sp)
1064 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
1065 return false;
1066 }
1067
1068 // If should stop returns false, check if we should notify of this event
1069 bool DoShouldNotify(Event *event_ptr) override {
1070 ThreadSP thread_sp(m_thread_wp.lock());
1071 if (thread_sp) {
1072 bool should_notify =
1073 thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
1074 if (should_notify) {
1075 StreamString strm;
1076 strm.Format(
1077 "thread {0:d} received signal: {1}", thread_sp->GetIndexID(),
1078 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsStringRef(
1079 m_value));
1081 strm.GetData());
1082 }
1083 return should_notify;
1084 }
1085 return true;
1086 }
1087
1088 void WillResume(lldb::StateType resume_state) override {
1089 ThreadSP thread_sp(m_thread_wp.lock());
1090 if (thread_sp) {
1091 if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
1092 m_value))
1093 thread_sp->SetResumeSignal(m_value);
1094 }
1095 }
1096
1097 const char *GetDescription() override {
1098 if (m_description.empty()) {
1099 ThreadSP thread_sp(m_thread_wp.lock());
1100 if (thread_sp) {
1101 UnixSignalsSP unix_signals = thread_sp->GetProcess()->GetUnixSignals();
1102 StreamString strm;
1103 strm << "signal ";
1104
1105 std::string signal_name =
1106 unix_signals->GetSignalDescription(m_value, m_code);
1107 if (signal_name.size())
1108 strm << signal_name;
1109 else
1110 strm.Printf("%" PRIi64, m_value);
1111
1112 m_description = std::string(strm.GetString());
1113 }
1114 }
1115 return m_description.c_str();
1116 }
1117
1118private:
1119 // In siginfo_t terms, if m_value is si_signo, m_code is si_code.
1120 std::optional<int> m_code;
1121};
1122
1123// StopInfoTrace
1124
1125class StopInfoTrace : public StopInfo {
1126public:
1128
1129 ~StopInfoTrace() override = default;
1130
1131 StopReason GetStopReason() const override { return eStopReasonTrace; }
1132
1133 const char *GetDescription() override {
1134 if (m_description.empty())
1135 return "trace";
1136 else
1137 return m_description.c_str();
1138 }
1139};
1140
1141// StopInfoException
1142
1144public:
1145 StopInfoException(Thread &thread, const char *description)
1146 : StopInfo(thread, LLDB_INVALID_UID) {
1147 if (description)
1148 SetDescription(description);
1149 }
1150
1151 ~StopInfoException() override = default;
1152
1153 StopReason GetStopReason() const override { return eStopReasonException; }
1154
1155 const char *GetDescription() override {
1156 if (m_description.empty())
1157 return "exception";
1158 else
1159 return m_description.c_str();
1160 }
1161};
1162
1163// StopInfoProcessorTrace
1164
1166public:
1167 StopInfoProcessorTrace(Thread &thread, const char *description)
1168 : StopInfo(thread, LLDB_INVALID_UID) {
1169 if (description)
1170 SetDescription(description);
1171 }
1172
1173 ~StopInfoProcessorTrace() override = default;
1174
1175 StopReason GetStopReason() const override {
1177 }
1178
1179 const char *GetDescription() override {
1180 if (m_description.empty())
1181 return "processor trace event";
1182 else
1183 return m_description.c_str();
1184 }
1185};
1186
1187// StopInfoThreadPlan
1188
1190public:
1191 StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
1192 ExpressionVariableSP &expression_variable_sp)
1193 : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
1194 m_return_valobj_sp(return_valobj_sp),
1195 m_expression_variable_sp(expression_variable_sp) {}
1196
1197 ~StopInfoThreadPlan() override = default;
1198
1200
1201 const char *GetDescription() override {
1202 if (m_description.empty()) {
1203 StreamString strm;
1204 m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
1205 m_description = std::string(strm.GetString());
1206 }
1207 return m_description.c_str();
1208 }
1209
1211
1214 }
1215
1216protected:
1217 bool ShouldStop(Event *event_ptr) override {
1218 if (m_plan_sp)
1219 return m_plan_sp->ShouldStop(event_ptr);
1220 else
1221 return StopInfo::ShouldStop(event_ptr);
1222 }
1223
1224private:
1228};
1229
1230// StopInfoExec
1231
1232class StopInfoExec : public StopInfo {
1233public:
1235
1236 ~StopInfoExec() override = default;
1237
1238 bool ShouldStop(Event *event_ptr) override {
1239 ThreadSP thread_sp(m_thread_wp.lock());
1240 if (thread_sp)
1241 return thread_sp->GetProcess()->GetStopOnExec();
1242 return false;
1243 }
1244
1245 StopReason GetStopReason() const override { return eStopReasonExec; }
1246
1247 const char *GetDescription() override { return "exec"; }
1248
1249protected:
1250 void PerformAction(Event *event_ptr) override {
1251 // Only perform the action once
1253 return;
1254 m_performed_action = true;
1255 ThreadSP thread_sp(m_thread_wp.lock());
1256 if (thread_sp)
1257 thread_sp->GetProcess()->DidExec();
1258 }
1259
1261};
1262
1263// StopInfoFork
1264
1265class StopInfoFork : public StopInfo {
1266public:
1267 StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
1268 : StopInfo(thread, child_pid), m_child_pid(child_pid),
1269 m_child_tid(child_tid) {}
1270
1271 ~StopInfoFork() override = default;
1272
1273 bool ShouldStop(Event *event_ptr) override { return false; }
1274
1275 StopReason GetStopReason() const override { return eStopReasonFork; }
1276
1277 const char *GetDescription() override { return "fork"; }
1278
1279protected:
1280 void PerformAction(Event *event_ptr) override {
1281 // Only perform the action once
1283 return;
1284 m_performed_action = true;
1285 ThreadSP thread_sp(m_thread_wp.lock());
1286 if (thread_sp)
1287 thread_sp->GetProcess()->DidFork(m_child_pid, m_child_tid);
1288 }
1289
1291
1292private:
1295};
1296
1297// StopInfoVFork
1298
1299class StopInfoVFork : public StopInfo {
1300public:
1301 StopInfoVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
1302 : StopInfo(thread, child_pid), m_child_pid(child_pid),
1303 m_child_tid(child_tid) {}
1304
1305 ~StopInfoVFork() override = default;
1306
1307 bool ShouldStop(Event *event_ptr) override { return false; }
1308
1309 StopReason GetStopReason() const override { return eStopReasonVFork; }
1310
1311 const char *GetDescription() override { return "vfork"; }
1312
1313protected:
1314 void PerformAction(Event *event_ptr) override {
1315 // Only perform the action once
1317 return;
1318 m_performed_action = true;
1319 ThreadSP thread_sp(m_thread_wp.lock());
1320 if (thread_sp)
1321 thread_sp->GetProcess()->DidVFork(m_child_pid, m_child_tid);
1322 }
1323
1325
1326private:
1329};
1330
1331// StopInfoVForkDone
1332
1334public:
1335 StopInfoVForkDone(Thread &thread) : StopInfo(thread, 0) {}
1336
1337 ~StopInfoVForkDone() override = default;
1338
1339 bool ShouldStop(Event *event_ptr) override { return false; }
1340
1341 StopReason GetStopReason() const override { return eStopReasonVForkDone; }
1342
1343 const char *GetDescription() override { return "vforkdone"; }
1344
1345protected:
1346 void PerformAction(Event *event_ptr) override {
1347 // Only perform the action once
1349 return;
1350 m_performed_action = true;
1351 ThreadSP thread_sp(m_thread_wp.lock());
1352 if (thread_sp)
1353 thread_sp->GetProcess()->DidVForkDone();
1354 }
1355
1357};
1358
1359} // namespace lldb_private
1360
1362 break_id_t break_id) {
1363 return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
1364}
1365
1367 break_id_t break_id,
1368 bool should_stop) {
1369 return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
1370}
1371
1373 break_id_t watch_id,
1374 bool silently_continue) {
1375 return StopInfoSP(
1376 new StopInfoWatchpoint(thread, watch_id, silently_continue));
1377}
1378
1380 const char *description,
1381 std::optional<int> code) {
1382 thread.GetProcess()->GetUnixSignals()->IncrementSignalHitCount(signo);
1383 return StopInfoSP(new StopInfoUnixSignal(thread, signo, description, code));
1384}
1385
1387 return StopInfoSP(new StopInfoTrace(thread));
1388}
1389
1391 ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
1392 ExpressionVariableSP expression_variable_sp) {
1393 return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
1394 expression_variable_sp));
1395}
1396
1398 const char *description) {
1399 return StopInfoSP(new StopInfoException(thread, description));
1400}
1401
1403 const char *description) {
1404 return StopInfoSP(new StopInfoProcessorTrace(thread, description));
1405}
1406
1408 return StopInfoSP(new StopInfoExec(thread));
1409}
1410
1412 lldb::pid_t child_pid,
1413 lldb::tid_t child_tid) {
1414 return StopInfoSP(new StopInfoFork(thread, child_pid, child_tid));
1415}
1416
1417
1419 lldb::pid_t child_pid,
1420 lldb::tid_t child_tid) {
1421 return StopInfoSP(new StopInfoVFork(thread, child_pid, child_tid));
1422}
1423
1425 return StopInfoSP(new StopInfoVForkDone(thread));
1426}
1427
1429 if (stop_info_sp &&
1430 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1431 StopInfoThreadPlan *plan_stop_info =
1432 static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1433 return plan_stop_info->GetReturnValueObject();
1434 } else
1435 return ValueObjectSP();
1436}
1437
1439 if (stop_info_sp &&
1440 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1441 StopInfoThreadPlan *plan_stop_info =
1442 static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1443 return plan_stop_info->GetExpressionVariable();
1444 } else
1445 return ExpressionVariableSP();
1446}
1447
1450 lldb::addr_t *crashing_address) {
1451 if (!stop_info_sp) {
1452 return ValueObjectSP();
1453 }
1454
1455 const char *description = stop_info_sp->GetDescription();
1456 if (!description) {
1457 return ValueObjectSP();
1458 }
1459
1460 ThreadSP thread_sp = stop_info_sp->GetThread();
1461 if (!thread_sp) {
1462 return ValueObjectSP();
1463 }
1464
1465 StackFrameSP frame_sp =
1466 thread_sp->GetSelectedFrame(DoNoSelectMostRelevantFrame);
1467
1468 if (!frame_sp) {
1469 return ValueObjectSP();
1470 }
1471
1472 const char address_string[] = "address=";
1473
1474 const char *address_loc = strstr(description, address_string);
1475 if (!address_loc) {
1476 return ValueObjectSP();
1477 }
1478
1479 address_loc += (sizeof(address_string) - 1);
1480
1481 uint64_t address = strtoull(address_loc, nullptr, 0);
1482 if (crashing_address) {
1483 *crashing_address = address;
1484 }
1485
1486 return frame_sp->GuessValueForAddress(address);
1487}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
#define LLDB_LOGF(log,...)
Definition: Log.h:349
lldb::BreakpointLocationSP GetByIndex(size_t i)
Returns a shared pointer to the breakpoint location with index i.
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:81
bool IsOneShot() const
Check the OneShot state.
Definition: Breakpoint.cpp:331
bool IsInternal() const
Tell whether this breakpoint is an "internal" breakpoint.
Definition: Breakpoint.cpp:254
A class to manage flag bits.
Definition: Debugger.h:79
lldb::StreamSP GetAsyncOutputStream()
Definition: Debugger.cpp:1263
void SetAsyncExecution(bool async)
Definition: Debugger.cpp:955
static void ReportWarning(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report warning events.
Definition: Debugger.cpp:1532
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
Definition: Debugger.cpp:1539
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:332
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:336
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
Target & GetTargetRef() const
Returns a reference to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
bool IsRunningExpression() const
Definition: Process.h:273
bool GetIgnoreBreakpointsInExpressions() const
Definition: Process.cpp:244
static void AddRestartedReason(Event *event_ptr, const char *reason)
Definition: Process.cpp:4211
A plug-in interface definition class for debugging a process.
Definition: Process.h:336
const ProcessModID & GetModIDRef() const
Definition: Process.h:1425
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1242
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:335
An error handling class.
Definition: Status.h:44
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
bool Success() const
Test for success condition.
Definition: Status.cpp:287
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:255
const char * GetDescription() override
Definition: StopInfo.cpp:181
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:148
bool IsValidForOperatingSystemThread(Thread &thread) override
Definition: StopInfo.cpp:135
bool DoShouldNotify(Event *event_ptr) override
Definition: StopInfo.cpp:177
~StopInfoBreakpoint() override=default
StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
Definition: StopInfo.cpp:96
StopInfoBreakpoint(Thread &thread, break_id_t break_id)
Definition: StopInfo.cpp:88
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:247
StopReason GetStopReason() const override
Definition: StopInfo.cpp:146
const char * GetDescription() override
Definition: StopInfo.cpp:1155
~StopInfoException() override=default
StopInfoException(Thread &thread, const char *description)
Definition: StopInfo.cpp:1145
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1153
~StopInfoExec() override=default
StopInfoExec(Thread &thread)
Definition: StopInfo.cpp:1234
const char * GetDescription() override
Definition: StopInfo.cpp:1247
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1245
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:1250
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1238
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:1280
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1273
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1275
StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: StopInfo.cpp:1267
~StopInfoFork() override=default
const char * GetDescription() override
Definition: StopInfo.cpp:1277
StopInfoProcessorTrace(Thread &thread, const char *description)
Definition: StopInfo.cpp:1167
~StopInfoProcessorTrace() override=default
const char * GetDescription() override
Definition: StopInfo.cpp:1179
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1175
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1217
~StopInfoThreadPlan() override=default
ExpressionVariableSP m_expression_variable_sp
Definition: StopInfo.cpp:1227
ExpressionVariableSP GetExpressionVariable()
Definition: StopInfo.cpp:1212
const char * GetDescription() override
Definition: StopInfo.cpp:1201
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1199
ValueObjectSP GetReturnValueObject()
Definition: StopInfo.cpp:1210
StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp)
Definition: StopInfo.cpp:1191
const char * GetDescription() override
Definition: StopInfo.cpp:1133
~StopInfoTrace() override=default
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1131
StopInfoTrace(Thread &thread)
Definition: StopInfo.cpp:1127
StopInfoUnixSignal(Thread &thread, int signo, const char *description, std::optional< int > code)
Definition: StopInfo.cpp:1044
void WillResume(lldb::StateType resume_state) override
Definition: StopInfo.cpp:1088
bool DoShouldNotify(Event *event_ptr) override
Definition: StopInfo.cpp:1069
~StopInfoUnixSignal() override=default
const char * GetDescription() override
Definition: StopInfo.cpp:1097
std::optional< int > m_code
Definition: StopInfo.cpp:1120
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:1054
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1061
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1052
const char * GetDescription() override
Definition: StopInfo.cpp:1343
~StopInfoVForkDone() override=default
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1339
StopInfoVForkDone(Thread &thread)
Definition: StopInfo.cpp:1335
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1341
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:1346
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1307
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1309
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:1314
~StopInfoVFork() override=default
StopInfoVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: StopInfo.cpp:1301
const char * GetDescription() override
Definition: StopInfo.cpp:1311
ThreadPlanStepOverWatchpoint(Thread &thread, StopInfoWatchpointSP stop_info_sp, WatchpointSP watch_sp)
Definition: StopInfo.cpp:695
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
Definition: StopInfo.cpp:705
WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp)
Definition: StopInfo.cpp:629
static bool SentryPreResumeAction(void *sentry_void)
Definition: StopInfo.cpp:658
~StopInfoWatchpoint() override=default
std::shared_ptr< StopInfoWatchpoint > StopInfoWatchpointSP
Definition: StopInfo.cpp:686
StopInfoWatchpoint(Thread &thread, break_id_t watch_id, bool silently_skip_wp)
Definition: StopInfo.cpp:669
const char * GetDescription() override
Definition: StopInfo.cpp:676
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:872
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:864
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:766
StopReason GetStopReason() const override
Definition: StopInfo.cpp:674
std::string m_description
Definition: StopInfo.h:180
static lldb::StopInfoSP CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan, lldb::ValueObjectSP return_valobj_sp, lldb::ExpressionVariableSP expression_variable_sp)
Definition: StopInfo.cpp:1390
uint64_t GetValue() const
Definition: StopInfo.h:45
static lldb::ExpressionVariableSP GetExpressionVariable(lldb::StopInfoSP &stop_info_sp)
Definition: StopInfo.cpp:1438
static lldb::ValueObjectSP GetReturnValueObject(lldb::StopInfoSP &stop_info_sp)
Definition: StopInfo.cpp:1428
static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread)
Definition: StopInfo.cpp:1386
static lldb::StopInfoSP CreateStopReasonVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: StopInfo.cpp:1418
bool IsValid() const
Definition: StopInfo.cpp:39
static lldb::StopInfoSP CreateStopReasonWithSignal(Thread &thread, int signo, const char *description=nullptr, std::optional< int > code=std::nullopt)
Definition: StopInfo.cpp:1379
lldb::ThreadSP GetThread() const
Definition: StopInfo.h:34
static lldb::StopInfoSP CreateStopReasonFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
Definition: StopInfo.cpp:1411
static lldb::StopInfoSP CreateStopReasonVForkDone(Thread &thread)
Definition: StopInfo.cpp:1424
static lldb::StopInfoSP CreateStopReasonWithWatchpointID(Thread &thread, lldb::break_id_t watch_id, bool silently_continue=false)
Definition: StopInfo.cpp:1372
virtual void SetDescription(const char *desc_cstr)
Definition: StopInfo.h:73
static lldb::StopInfoSP CreateStopReasonWithException(Thread &thread, const char *description)
Definition: StopInfo.cpp:1397
static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(Thread &thread, lldb::break_id_t break_id)
static lldb::ValueObjectSP GetCrashingDereference(lldb::StopInfoSP &stop_info_sp, lldb::addr_t *crashing_address=nullptr)
Definition: StopInfo.cpp:1449
static lldb::StopInfoSP CreateStopReasonProcessorTrace(Thread &thread, const char *description)
Definition: StopInfo.cpp:1402
static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread)
Definition: StopInfo.cpp:1407
StopInfo(Thread &thread, uint64_t value)
Definition: StopInfo.cpp:32
lldb::ThreadWP m_thread_wp
Definition: StopInfo.h:175
virtual bool ShouldStop(Event *event_ptr)
Definition: StopInfo.h:172
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
const char * GetData() const
Definition: StreamString.h:43
llvm::StringRef GetString() const
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
Debugger & GetDebugger()
Definition: Target.h:1050
bool DoPlanExplainsStop(Event *event_ptr) override
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
virtual lldb::StopInfoSP GetPrivateStopInfo(bool calculate=true)
Definition: Thread.cpp:376
void SetStopInfo(const lldb::StopInfoSP &stop_info_sp)
Definition: Thread.cpp:448
lldb::ProcessSP GetProcess() const
Definition: Thread.h:153
static lldb::ExpressionResults Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, llvm::StringRef expr_cstr, llvm::StringRef expr_prefix, lldb::ValueObjectSP &result_valobj_sp, Status &error, std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Evaluate one expression in the scratch context of the target passed in the exe_ctx and return its res...
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:77
#define LLDB_INVALID_UID
Definition: lldb-defines.h:82
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:76
@ DoNoSelectMostRelevantFrame
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:428
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:399
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
Definition: lldb-forward.h:305
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
Definition: lldb-forward.h:306
@ eDescriptionLevelBrief
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:425
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:458
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:333
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
Definition: lldb-forward.h:454
StateType
Process and Thread States.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:407
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:303
ExpressionResults
The results of expression evaluation.
@ eExpressionCompleted
int32_t break_id_t
Definition: lldb-types.h:84
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:368
uint64_t pid_t
Definition: lldb-types.h:81
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
Definition: lldb-forward.h:463
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:406
uint64_t addr_t
Definition: lldb-types.h:79
StopReason
Thread stop reasons.
@ eStopReasonPlanComplete
@ eStopReasonTrace
@ eStopReasonBreakpoint
@ eStopReasonExec
Program was re-exec'ed.
@ eStopReasonVForkDone
@ eStopReasonProcessorTrace
@ eStopReasonException
@ eStopReasonWatchpoint
@ eStopReasonVFork
@ eStopReasonSignal
uint64_t tid_t
Definition: lldb-types.h:82
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47