LLDB  mainline
StopInfo.cpp
Go to the documentation of this file.
1 //===-- StopInfo.cpp --------------------------------------------*- C++ -*-===//
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"
16 #include "lldb/Core/ValueObject.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Target/StopInfo.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Target/Thread.h"
22 #include "lldb/Target/ThreadPlan.h"
24 #include "lldb/Utility/Log.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 StopInfo::StopInfo(Thread &thread, uint64_t value)
31  : m_thread_wp(thread.shared_from_this()),
32  m_stop_id(thread.GetProcess()->GetStopID()),
33  m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
34  m_description(), m_override_should_notify(eLazyBoolCalculate),
35  m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
36 
37 bool StopInfo::IsValid() const {
38  ThreadSP thread_sp(m_thread_wp.lock());
39  if (thread_sp)
40  return thread_sp->GetProcess()->GetStopID() == m_stop_id;
41  return false;
42 }
43 
45  ThreadSP thread_sp(m_thread_wp.lock());
46  if (thread_sp) {
47  m_stop_id = thread_sp->GetProcess()->GetStopID();
48  m_resume_id = thread_sp->GetProcess()->GetResumeID();
49  }
50 }
51 
53  ThreadSP thread_sp(m_thread_wp.lock());
54 
55  if (thread_sp) {
56  lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
57  if (ret_type == eStateRunning) {
58  return true;
59  } else if (ret_type == eStateStopped) {
60  // This is a little tricky. We want to count "run and stopped again
61  // before you could ask this question as a "TRUE" answer to
62  // HasTargetRunSinceMe. But we don't want to include any running of the
63  // target done for expressions. So we track both resumes, and resumes
64  // caused by expressions, and check if there are any resumes
65  // NOT caused
66  // by expressions.
67 
68  uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
69  uint32_t last_user_expression_id =
70  thread_sp->GetProcess()->GetLastUserExpressionResumeID();
71  if (curr_resume_id == m_resume_id) {
72  return false;
73  } else if (curr_resume_id > last_user_expression_id) {
74  return true;
75  }
76  }
77  }
78  return false;
79 }
80 
81 // StopInfoBreakpoint
82 
83 namespace lldb_private {
84 class StopInfoBreakpoint : public StopInfo {
85 public:
87  : StopInfo(thread, break_id), m_should_stop(false),
88  m_should_stop_is_valid(false), m_should_perform_action(true),
89  m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
90  m_was_one_shot(false) {
91  StoreBPInfo();
92  }
93 
94  StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
95  : StopInfo(thread, break_id), m_should_stop(should_stop),
96  m_should_stop_is_valid(true), m_should_perform_action(true),
97  m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
98  m_was_one_shot(false) {
99  StoreBPInfo();
100  }
101 
102  ~StopInfoBreakpoint() override = default;
103 
104  void StoreBPInfo() {
105  ThreadSP thread_sp(m_thread_wp.lock());
106  if (thread_sp) {
107  BreakpointSiteSP bp_site_sp(
108  thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
109  if (bp_site_sp) {
110  if (bp_site_sp->GetNumberOfOwners() == 1) {
111  BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
112  if (bp_loc_sp) {
113  m_break_id = bp_loc_sp->GetBreakpoint().GetID();
114  m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
115  }
116  }
117  m_address = bp_site_sp->GetLoadAddress();
118  }
119  }
120  }
121 
122  bool IsValidForOperatingSystemThread(Thread &thread) override {
123  ProcessSP process_sp(thread.GetProcess());
124  if (process_sp) {
125  BreakpointSiteSP bp_site_sp(
126  process_sp->GetBreakpointSiteList().FindByID(m_value));
127  if (bp_site_sp)
128  return bp_site_sp->ValidForThisThread(&thread);
129  }
130  return false;
131  }
132 
133  StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
134 
135  bool ShouldStopSynchronous(Event *event_ptr) override {
136  ThreadSP thread_sp(m_thread_wp.lock());
137  if (thread_sp) {
138  if (!m_should_stop_is_valid) {
139  // Only check once if we should stop at a breakpoint
140  BreakpointSiteSP bp_site_sp(
141  thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
142  if (bp_site_sp) {
143  ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
144  StoppointCallbackContext context(event_ptr, exe_ctx, true);
145  bp_site_sp->BumpHitCounts();
146  m_should_stop = bp_site_sp->ShouldStop(&context);
147  } else {
149 
150  if (log)
151  log->Printf(
152  "Process::%s could not find breakpoint site id: %" PRId64 "...",
153  __FUNCTION__, m_value);
154 
155  m_should_stop = true;
156  }
157  m_should_stop_is_valid = true;
158  }
159  return m_should_stop;
160  }
161  return false;
162  }
163 
164  bool DoShouldNotify(Event *event_ptr) override {
165  ThreadSP thread_sp(m_thread_wp.lock());
166  if (thread_sp) {
167  BreakpointSiteSP bp_site_sp(
168  thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
169  if (bp_site_sp) {
170  bool all_internal = true;
171 
172  for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
173  if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
174  all_internal = false;
175  break;
176  }
177  }
178  return !all_internal;
179  }
180  }
181  return true;
182  }
183 
184  const char *GetDescription() override {
185  if (m_description.empty()) {
186  ThreadSP thread_sp(m_thread_wp.lock());
187  if (thread_sp) {
188  BreakpointSiteSP bp_site_sp(
189  thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
190  if (bp_site_sp) {
191  StreamString strm;
192  // If we have just hit an internal breakpoint, and it has a kind
193  // description, print that instead of the full breakpoint printing:
194  if (bp_site_sp->IsInternal()) {
195  size_t num_owners = bp_site_sp->GetNumberOfOwners();
196  for (size_t idx = 0; idx < num_owners; idx++) {
197  const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
198  ->GetBreakpoint()
199  .GetBreakpointKind();
200  if (kind != nullptr) {
201  m_description.assign(kind);
202  return kind;
203  }
204  }
205  }
206 
207  strm.Printf("breakpoint ");
208  bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
209  m_description = strm.GetString();
210  } else {
211  StreamString strm;
212  if (m_break_id != LLDB_INVALID_BREAK_ID) {
213  BreakpointSP break_sp =
214  thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
215  m_break_id);
216  if (break_sp) {
217  if (break_sp->IsInternal()) {
218  const char *kind = break_sp->GetBreakpointKind();
219  if (kind)
220  strm.Printf("internal %s breakpoint(%d).", kind, m_break_id);
221  else
222  strm.Printf("internal breakpoint(%d).", m_break_id);
223  } else {
224  strm.Printf("breakpoint %d.", m_break_id);
225  }
226  } else {
227  if (m_was_one_shot)
228  strm.Printf("one-shot breakpoint %d", m_break_id);
229  else
230  strm.Printf("breakpoint %d which has been deleted.",
231  m_break_id);
232  }
233  } else if (m_address == LLDB_INVALID_ADDRESS)
234  strm.Printf("breakpoint site %" PRIi64
235  " which has been deleted - unknown address",
236  m_value);
237  else
238  strm.Printf("breakpoint site %" PRIi64
239  " which has been deleted - was at 0x%" PRIx64,
240  m_value, m_address);
241 
242  m_description = strm.GetString();
243  }
244  }
245  }
246  return m_description.c_str();
247  }
248 
249 protected:
250  bool ShouldStop(Event *event_ptr) override {
251  // This just reports the work done by PerformAction or the synchronous
252  // stop. It should only ever get called after they have had a chance to
253  // run.
254  assert(m_should_stop_is_valid);
255  return m_should_stop;
256  }
257 
258  void PerformAction(Event *event_ptr) override {
259  if (!m_should_perform_action)
260  return;
261  m_should_perform_action = false;
262  bool internal_breakpoint = true;
263 
264  ThreadSP thread_sp(m_thread_wp.lock());
265 
266  if (thread_sp) {
269 
270  if (!thread_sp->IsValid()) {
271  // This shouldn't ever happen, but just in case, don't do more harm.
272  if (log) {
273  log->Printf("PerformAction got called with an invalid thread.");
274  }
275  m_should_stop = true;
276  m_should_stop_is_valid = true;
277  return;
278  }
279 
280  BreakpointSiteSP bp_site_sp(
281  thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
282  std::unordered_set<break_id_t> precondition_breakpoints;
283 
284  if (bp_site_sp) {
285  // Let's copy the owners list out of the site and store them in a local
286  // list. That way if one of the breakpoint actions changes the site,
287  // then we won't be operating on a bad list.
288  BreakpointLocationCollection site_locations;
289  size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
290 
291  if (num_owners == 0) {
292  m_should_stop = true;
293  } else {
294  // We go through each location, and test first its precondition -
295  // this overrides everything. Note, we only do this once per
296  // breakpoint - not once per location... Then check the condition.
297  // If the condition says to stop, then we run the callback for that
298  // location. If that callback says to stop as well, then we set
299  // m_should_stop to true; we are going to stop. But we still want to
300  // give all the breakpoints whose conditions say we are going to stop
301  // a chance to run their callbacks. Of course if any callback
302  // restarts the target by putting "continue" in the callback, then
303  // we're going to restart, without running the rest of the callbacks.
304  // And in this case we will end up not stopping even if another
305  // location said we should stop. But that's better than not running
306  // all the callbacks.
307 
308  m_should_stop = false;
309 
310  // We don't select threads as we go through them testing breakpoint
311  // conditions and running commands. So we need to set the thread for
312  // expression evaluation here:
313  ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
314 
315  ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
316  Process *process = exe_ctx.GetProcessPtr();
317  if (process->GetModIDRef().IsLastResumeForUserExpression()) {
318  // If we are in the middle of evaluating an expression, don't run
319  // asynchronous breakpoint commands or expressions. That could
320  // lead to infinite recursion if the command or condition re-calls
321  // the function with this breakpoint.
322  // TODO: We can keep a list of the breakpoints we've seen while
323  // running expressions in the nested
324  // PerformAction calls that can arise when the action runs a
325  // function that hits another breakpoint, and only stop running
326  // commands when we see the same breakpoint hit a second time.
327 
328  m_should_stop_is_valid = true;
329 
330  // It is possible that the user has a breakpoint at the same site
331  // as the completed plan had (e.g. user has a breakpoint
332  // on a module entry point, and `ThreadPlanCallFunction` ends
333  // also there). We can't find an internal breakpoint in the loop
334  // later because it was already removed on the plan completion.
335  // So check if the plan was completed, and stop if so.
336  if (thread_sp->CompletedPlanOverridesBreakpoint()) {
337  m_should_stop = true;
338  thread_sp->ResetStopInfo();
339  return;
340  }
341 
342  if (log)
343  log->Printf("StopInfoBreakpoint::PerformAction - Hit a "
344  "breakpoint while running an expression,"
345  " not running commands to avoid recursion.");
346  bool ignoring_breakpoints =
347  process->GetIgnoreBreakpointsInExpressions();
348  if (ignoring_breakpoints) {
349  m_should_stop = false;
350  // Internal breakpoints will always stop.
351  for (size_t j = 0; j < num_owners; j++) {
352  lldb::BreakpointLocationSP bp_loc_sp =
353  bp_site_sp->GetOwnerAtIndex(j);
354  if (bp_loc_sp->GetBreakpoint().IsInternal()) {
355  m_should_stop = true;
356  break;
357  }
358  }
359  } else {
360  m_should_stop = true;
361  }
362  if (log)
363  log->Printf("StopInfoBreakpoint::PerformAction - in expression, "
364  "continuing: %s.",
365  m_should_stop ? "true" : "false");
366  process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
367  "Warning: hit breakpoint while running function, skipping "
368  "commands and conditions to prevent recursion.\n");
369  return;
370  }
371 
372  StoppointCallbackContext context(event_ptr, exe_ctx, false);
373 
374  // For safety's sake let's also grab an extra reference to the
375  // breakpoint owners of the locations we're going to examine, since
376  // the locations are going to have to get back to their breakpoints,
377  // and the locations don't keep their owners alive. I'm just
378  // sticking the BreakpointSP's in a vector since I'm only using it to
379  // locally increment their retain counts.
380 
381  std::vector<lldb::BreakpointSP> location_owners;
382 
383  for (size_t j = 0; j < num_owners; j++) {
384  BreakpointLocationSP loc(site_locations.GetByIndex(j));
385  location_owners.push_back(loc->GetBreakpoint().shared_from_this());
386  }
387 
388  for (size_t j = 0; j < num_owners; j++) {
389  lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
390  StreamString loc_desc;
391  if (log) {
392  bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
393  }
394  // If another action disabled this breakpoint or its location, then
395  // don't run the actions.
396  if (!bp_loc_sp->IsEnabled() ||
397  !bp_loc_sp->GetBreakpoint().IsEnabled())
398  continue;
399 
400  // The breakpoint site may have many locations associated with it,
401  // not all of them valid for this thread. Skip the ones that
402  // aren't:
403  if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
404  if (log) {
405  log->Printf("Breakpoint %s hit on thread 0x%llx but it was not "
406  "for this thread, continuing.",
407  loc_desc.GetData(), static_cast<unsigned long long>(
408  thread_sp->GetID()));
409  }
410  continue;
411  }
412 
413  internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
414 
415  // First run the precondition, but since the precondition is per
416  // breakpoint, only run it once per breakpoint.
417  std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
418  precondition_breakpoints.insert(
419  bp_loc_sp->GetBreakpoint().GetID());
420  if (!result.second)
421  continue;
422 
423  bool precondition_result =
424  bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
425  if (!precondition_result)
426  continue;
427 
428  // Next run the condition for the breakpoint. If that says we
429  // should stop, then we'll run the callback for the breakpoint. If
430  // the callback says we shouldn't stop that will win.
431 
432  if (bp_loc_sp->GetConditionText() != nullptr) {
433  Status condition_error;
434  bool condition_says_stop =
435  bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
436 
437  if (!condition_error.Success()) {
438  Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
439  StreamSP error_sp = debugger.GetAsyncErrorStream();
440  error_sp->Printf("Stopped due to an error evaluating condition "
441  "of breakpoint ");
442  bp_loc_sp->GetDescription(error_sp.get(),
444  error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
445  error_sp->EOL();
446  const char *err_str =
447  condition_error.AsCString("<Unknown Error>");
448  if (log)
449  log->Printf("Error evaluating condition: \"%s\"\n", err_str);
450 
451  error_sp->PutCString(err_str);
452  error_sp->EOL();
453  error_sp->Flush();
454  } else {
455  if (log) {
456  log->Printf("Condition evaluated for breakpoint %s on thread "
457  "0x%llx conditon_says_stop: %i.",
458  loc_desc.GetData(),
459  static_cast<unsigned long long>(
460  thread_sp->GetID()),
461  condition_says_stop);
462  }
463  if (!condition_says_stop) {
464  // We don't want to increment the hit count of breakpoints if
465  // the condition fails. We've already bumped it by the time
466  // we get here, so undo the bump:
467  bp_loc_sp->UndoBumpHitCount();
468  continue;
469  }
470  }
471  }
472 
473  // Check the auto-continue bit on the location, do this before the
474  // callback since it may change this, but that would be for the
475  // NEXT hit. Note, you might think you could check auto-continue
476  // before the condition, and not evaluate the condition if it says
477  // to continue. But failing the condition means the breakpoint was
478  // effectively NOT HIT. So these two states are different.
479  bool auto_continue_says_stop = true;
480  if (bp_loc_sp->IsAutoContinue())
481  {
482  if (log)
483  log->Printf("Continuing breakpoint %s as AutoContinue was set.",
484  loc_desc.GetData());
485  // We want this stop reported, so you will know we auto-continued
486  // but only for external breakpoints:
487  if (!internal_breakpoint)
488  thread_sp->SetShouldReportStop(eVoteYes);
489  auto_continue_says_stop = false;
490  }
491 
492  bool callback_says_stop = true;
493 
494  // FIXME: For now the callbacks have to run in async mode - the
495  // first time we restart we need
496  // to get out of there. So set it here.
497  // When we figure out how to nest breakpoint hits then this will
498  // change.
499 
500  Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
501  bool old_async = debugger.GetAsyncExecution();
502  debugger.SetAsyncExecution(true);
503 
504  callback_says_stop = bp_loc_sp->InvokeCallback(&context);
505 
506  debugger.SetAsyncExecution(old_async);
507 
508  if (callback_says_stop && auto_continue_says_stop)
509  m_should_stop = true;
510 
511  // If we are going to stop for this breakpoint, then remove the
512  // breakpoint.
513  if (callback_says_stop && bp_loc_sp &&
514  bp_loc_sp->GetBreakpoint().IsOneShot()) {
515  thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
516  bp_loc_sp->GetBreakpoint().GetID());
517  }
518  // Also make sure that the callback hasn't continued the target. If
519  // it did, when we'll set m_should_start to false and get out of
520  // here.
521  if (HasTargetRunSinceMe()) {
522  m_should_stop = false;
523  break;
524  }
525  }
526  }
527  // We've figured out what this stop wants to do, so mark it as valid so
528  // we don't compute it again.
529  m_should_stop_is_valid = true;
530  } else {
531  m_should_stop = true;
532  m_should_stop_is_valid = true;
533  Log *log_process(
535 
536  if (log_process)
537  log_process->Printf(
538  "Process::%s could not find breakpoint site id: %" PRId64 "...",
539  __FUNCTION__, m_value);
540  }
541 
542  if ((!m_should_stop || internal_breakpoint) &&
543  thread_sp->CompletedPlanOverridesBreakpoint()) {
544 
545  // Override should_stop decision when we have completed step plan
546  // additionally to the breakpoint
547  m_should_stop = true;
548 
549  // Here we clean the preset stop info so the next GetStopInfo call will
550  // find the appropriate stop info, which should be the stop info
551  // related to the completed plan
552  thread_sp->ResetStopInfo();
553  }
554 
555  if (log)
556  log->Printf("Process::%s returning from action with m_should_stop: %d.",
557  __FUNCTION__, m_should_stop);
558  }
559  }
560 
561 private:
562  bool m_should_stop;
563  bool m_should_stop_is_valid;
564  bool m_should_perform_action; // Since we are trying to preserve the "state"
565  // of the system even if we run functions
566  // etc. behind the users backs, we need to make sure we only REALLY perform
567  // the action once.
568  lldb::addr_t m_address; // We use this to capture the breakpoint site address
569  // when we create the StopInfo,
570  // in case somebody deletes it between the time the StopInfo is made and the
571  // description is asked for.
572  lldb::break_id_t m_break_id;
573  bool m_was_one_shot;
574 };
575 
576 // StopInfoWatchpoint
577 
578 class StopInfoWatchpoint : public StopInfo {
579 public:
580  // Make sure watchpoint is properly disabled and subsequently enabled while
581  // performing watchpoint actions.
583  public:
584  WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
585  watchpoint_sp(w_sp) {
586  if (process_sp && watchpoint_sp) {
587  const bool notify = false;
588  watchpoint_sp->TurnOnEphemeralMode();
589  process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
590  process_sp->AddPreResumeAction(SentryPreResumeAction, this);
591  }
592  }
593 
594  void DoReenable() {
595  if (process_sp && watchpoint_sp) {
596  bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
597  watchpoint_sp->TurnOffEphemeralMode();
598  const bool notify = false;
599  if (was_disabled) {
600  process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
601  } else {
602  process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
603  }
604  }
605  }
606 
608  DoReenable();
609  if (process_sp)
610  process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
611  }
612 
613  static bool SentryPreResumeAction(void *sentry_void) {
614  WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
615  sentry->DoReenable();
616  return true;
617  }
618 
619  private:
620  ProcessSP process_sp;
621  WatchpointSP watchpoint_sp;
622  };
623 
625  lldb::addr_t watch_hit_addr)
626  : StopInfo(thread, watch_id), m_should_stop(false),
627  m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
628 
629  ~StopInfoWatchpoint() override = default;
630 
631  StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
632 
633  const char *GetDescription() override {
634  if (m_description.empty()) {
635  StreamString strm;
636  strm.Printf("watchpoint %" PRIi64, m_value);
637  m_description = strm.GetString();
638  }
639  return m_description.c_str();
640  }
641 
642 protected:
643  bool ShouldStopSynchronous(Event *event_ptr) override {
644  // ShouldStop() method is idempotent and should not affect hit count. See
645  // Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
646  // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
647  // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
648  // StopInfoWatchpoint::ShouldStop() and
649  // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
650  // StopInfoWatchpoint::PerformAction().
651  if (m_should_stop_is_valid)
652  return m_should_stop;
653 
654  ThreadSP thread_sp(m_thread_wp.lock());
655  if (thread_sp) {
656  WatchpointSP wp_sp(
657  thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
658  GetValue()));
659  if (wp_sp) {
660  // Check if we should stop at a watchpoint.
661  ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
662  StoppointCallbackContext context(event_ptr, exe_ctx, true);
663  m_should_stop = wp_sp->ShouldStop(&context);
664  } else {
666 
667  if (log)
668  log->Printf(
669  "Process::%s could not find watchpoint location id: %" PRId64
670  "...",
671  __FUNCTION__, GetValue());
672 
673  m_should_stop = true;
674  }
675  }
676  m_should_stop_is_valid = true;
677  return m_should_stop;
678  }
679 
680  bool ShouldStop(Event *event_ptr) override {
681  // This just reports the work done by PerformAction or the synchronous
682  // stop. It should only ever get called after they have had a chance to
683  // run.
684  assert(m_should_stop_is_valid);
685  return m_should_stop;
686  }
687 
688  void PerformAction(Event *event_ptr) override {
690  // We're going to calculate if we should stop or not in some way during the
691  // course of this code. Also by default we're going to stop, so set that
692  // here.
693  m_should_stop = true;
694 
695 
696  ThreadSP thread_sp(m_thread_wp.lock());
697  if (thread_sp) {
698 
699  WatchpointSP wp_sp(
700  thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
701  GetValue()));
702  if (wp_sp) {
703  ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
704  ProcessSP process_sp = exe_ctx.GetProcessSP();
705 
706  {
707  // check if this process is running on an architecture where
708  // watchpoints trigger before the associated instruction runs. if so,
709  // disable the WP, single-step and then re-enable the watchpoint
710  if (process_sp) {
711  uint32_t num;
712  bool wp_triggers_after;
713 
714  if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
715  .Success()) {
716  if (!wp_triggers_after) {
717  // We need to preserve the watch_index before watchpoint is
718  // disable. Since Watchpoint::SetEnabled will clear the watch
719  // index. This will fix TestWatchpointIter failure
720  Watchpoint *wp = wp_sp.get();
721  uint32_t watch_index = wp->GetHardwareIndex();
722  process_sp->DisableWatchpoint(wp, false);
723  StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
724  assert(stored_stop_info_sp.get() == this);
725 
726  Status new_plan_status;
727  ThreadPlanSP new_plan_sp(
728  thread_sp->QueueThreadPlanForStepSingleInstruction(
729  false, // step-over
730  false, // abort_other_plans
731  true, // stop_other_threads
732  new_plan_status));
733  if (new_plan_sp && new_plan_status.Success()) {
734  new_plan_sp->SetIsMasterPlan(true);
735  new_plan_sp->SetOkayToDiscard(false);
736  new_plan_sp->SetPrivate(true);
737  }
738  process_sp->GetThreadList().SetSelectedThreadByID(
739  thread_sp->GetID());
740  process_sp->ResumeSynchronous(nullptr);
741  process_sp->GetThreadList().SetSelectedThreadByID(
742  thread_sp->GetID());
743  thread_sp->SetStopInfo(stored_stop_info_sp);
744  process_sp->EnableWatchpoint(wp, false);
745  wp->SetHardwareIndex(watch_index);
746  }
747  }
748  }
749  }
750 
751  // This sentry object makes sure the current watchpoint is disabled
752  // while performing watchpoint actions, and it is then enabled after we
753  // are finished.
754  WatchpointSentry sentry(process_sp, wp_sp);
755 
756  /*
757  * MIPS: Last 3bits of the watchpoint address are masked by the kernel.
758  * For example:
759  * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is
760  * set at 'm', then
761  * watch exception is generated even when 'n' is read/written. To handle
762  * this case,
763  * server emulates the instruction at PC and finds the base address of
764  * the load/store
765  * instruction and appends it in the description of the stop-info
766  * packet. If watchpoint
767  * is not set on this address by user then this do not stop.
768  */
769  if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) {
770  WatchpointSP wp_hit_sp =
771  thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
772  m_watch_hit_addr);
773  if (!wp_hit_sp) {
774  m_should_stop = false;
775  wp_sp->IncrementFalseAlarmsAndReviseHitCount();
776  }
777  }
778 
779  // TODO: This condition should be checked in the synchronous part of the
780  // watchpoint code
781  // (Watchpoint::ShouldStop), so that we avoid pulling an event even if
782  // the watchpoint fails the ignore count condition. It is moved here
783  // temporarily, because for archs with
784  // watchpoint_exceptions_received=before, the code in the previous
785  // lines takes care of moving the inferior to next PC. We have to check
786  // the ignore count condition after this is done, otherwise we will hit
787  // same watchpoint multiple times until we pass ignore condition, but
788  // we won't actually be ignoring them.
789  if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
790  m_should_stop = false;
791 
792  Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
793 
794  if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
795  // We need to make sure the user sees any parse errors in their
796  // condition, so we'll hook the constructor errors up to the
797  // debugger's Async I/O.
798  ExpressionResults result_code;
799  EvaluateExpressionOptions expr_options;
800  expr_options.SetUnwindOnError(true);
801  expr_options.SetIgnoreBreakpoints(true);
802  ValueObjectSP result_value_sp;
803  Status error;
804  result_code = UserExpression::Evaluate(
805  exe_ctx, expr_options, wp_sp->GetConditionText(),
806  llvm::StringRef(), result_value_sp, error);
807 
808  if (result_code == eExpressionCompleted) {
809  if (result_value_sp) {
810  Scalar scalar_value;
811  if (result_value_sp->ResolveValue(scalar_value)) {
812  if (scalar_value.ULongLong(1) == 0) {
813  // We have been vetoed. This takes precedence over querying
814  // the watchpoint whether it should stop (aka ignore count
815  // and friends). See also StopInfoWatchpoint::ShouldStop()
816  // as well as Process::ProcessEventData::DoOnRemoval().
817  m_should_stop = false;
818  } else
819  m_should_stop = true;
820  if (log)
821  log->Printf(
822  "Condition successfully evaluated, result is %s.\n",
823  m_should_stop ? "true" : "false");
824  } else {
825  m_should_stop = true;
826  if (log)
827  log->Printf(
828  "Failed to get an integer result from the expression.");
829  }
830  }
831  } else {
832  StreamSP error_sp = debugger.GetAsyncErrorStream();
833  error_sp->Printf(
834  "Stopped due to an error evaluating condition of watchpoint ");
835  wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief);
836  error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
837  error_sp->EOL();
838  const char *err_str = error.AsCString("<Unknown Error>");
839  if (log)
840  log->Printf("Error evaluating condition: \"%s\"\n", err_str);
841 
842  error_sp->PutCString(err_str);
843  error_sp->EOL();
844  error_sp->Flush();
845  // If the condition fails to be parsed or run, we should stop.
846  m_should_stop = true;
847  }
848  }
849 
850  // If the condition says to stop, we run the callback to further decide
851  // whether to stop.
852  if (m_should_stop) {
853  // FIXME: For now the callbacks have to run in async mode - the
854  // first time we restart we need
855  // to get out of there. So set it here.
856  // When we figure out how to nest watchpoint hits then this will
857  // change.
858 
859  bool old_async = debugger.GetAsyncExecution();
860  debugger.SetAsyncExecution(true);
861 
862  StoppointCallbackContext context(event_ptr, exe_ctx, false);
863  bool stop_requested = wp_sp->InvokeCallback(&context);
864 
865  debugger.SetAsyncExecution(old_async);
866 
867  // Also make sure that the callback hasn't continued the target. If
868  // it did, when we'll set m_should_stop to false and get out of here.
869  if (HasTargetRunSinceMe())
870  m_should_stop = false;
871 
872  if (m_should_stop && !stop_requested) {
873  // We have been vetoed by the callback mechanism.
874  m_should_stop = false;
875  }
876  }
877  // Finally, if we are going to stop, print out the new & old values:
878  if (m_should_stop) {
879  wp_sp->CaptureWatchedValue(exe_ctx);
880 
881  Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
882  StreamSP output_sp = debugger.GetAsyncOutputStream();
883  wp_sp->DumpSnapshots(output_sp.get());
884  output_sp->EOL();
885  output_sp->Flush();
886  }
887 
888  } else {
889  Log *log_process(
891 
892  if (log_process)
893  log_process->Printf(
894  "Process::%s could not find watchpoint id: %" PRId64 "...",
895  __FUNCTION__, m_value);
896  }
897  if (log)
898  log->Printf("Process::%s returning from action with m_should_stop: %d.",
899  __FUNCTION__, m_should_stop);
900 
901  m_should_stop_is_valid = true;
902  }
903  }
904 
905 private:
906  bool m_should_stop;
907  bool m_should_stop_is_valid;
908  lldb::addr_t m_watch_hit_addr;
909 };
910 
911 // StopInfoUnixSignal
912 
913 class StopInfoUnixSignal : public StopInfo {
914 public:
915  StopInfoUnixSignal(Thread &thread, int signo, const char *description)
916  : StopInfo(thread, signo) {
917  SetDescription(description);
918  }
919 
920  ~StopInfoUnixSignal() override = default;
921 
922  StopReason GetStopReason() const override { return eStopReasonSignal; }
923 
924  bool ShouldStopSynchronous(Event *event_ptr) override {
925  ThreadSP thread_sp(m_thread_wp.lock());
926  if (thread_sp)
927  return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
928  return false;
929  }
930 
931  bool ShouldStop(Event *event_ptr) override {
932  ThreadSP thread_sp(m_thread_wp.lock());
933  if (thread_sp)
934  return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
935  return false;
936  }
937 
938  // If should stop returns false, check if we should notify of this event
939  bool DoShouldNotify(Event *event_ptr) override {
940  ThreadSP thread_sp(m_thread_wp.lock());
941  if (thread_sp) {
942  bool should_notify =
943  thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
944  if (should_notify) {
945  StreamString strm;
946  strm.Printf(
947  "thread %d received signal: %s", thread_sp->GetIndexID(),
948  thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
949  m_value));
951  strm.GetData());
952  }
953  return should_notify;
954  }
955  return true;
956  }
957 
958  void WillResume(lldb::StateType resume_state) override {
959  ThreadSP thread_sp(m_thread_wp.lock());
960  if (thread_sp) {
961  if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
962  m_value))
963  thread_sp->SetResumeSignal(m_value);
964  }
965  }
966 
967  const char *GetDescription() override {
968  if (m_description.empty()) {
969  ThreadSP thread_sp(m_thread_wp.lock());
970  if (thread_sp) {
971  StreamString strm;
972  const char *signal_name =
973  thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
974  m_value);
975  if (signal_name)
976  strm.Printf("signal %s", signal_name);
977  else
978  strm.Printf("signal %" PRIi64, m_value);
979  m_description = strm.GetString();
980  }
981  }
982  return m_description.c_str();
983  }
984 };
985 
986 // StopInfoTrace
987 
988 class StopInfoTrace : public StopInfo {
989 public:
991 
992  ~StopInfoTrace() override = default;
993 
994  StopReason GetStopReason() const override { return eStopReasonTrace; }
995 
996  const char *GetDescription() override {
997  if (m_description.empty())
998  return "trace";
999  else
1000  return m_description.c_str();
1001  }
1002 };
1003 
1004 // StopInfoException
1005 
1006 class StopInfoException : public StopInfo {
1007 public:
1008  StopInfoException(Thread &thread, const char *description)
1009  : StopInfo(thread, LLDB_INVALID_UID) {
1010  if (description)
1011  SetDescription(description);
1012  }
1013 
1014  ~StopInfoException() override = default;
1015 
1016  StopReason GetStopReason() const override { return eStopReasonException; }
1017 
1018  const char *GetDescription() override {
1019  if (m_description.empty())
1020  return "exception";
1021  else
1022  return m_description.c_str();
1023  }
1024 };
1025 
1026 // StopInfoThreadPlan
1027 
1029 public:
1030  StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
1031  ExpressionVariableSP &expression_variable_sp)
1032  : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
1033  m_return_valobj_sp(return_valobj_sp),
1034  m_expression_variable_sp(expression_variable_sp) {}
1035 
1036  ~StopInfoThreadPlan() override = default;
1037 
1038  StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
1039 
1040  const char *GetDescription() override {
1041  if (m_description.empty()) {
1042  StreamString strm;
1043  m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
1044  m_description = strm.GetString();
1045  }
1046  return m_description.c_str();
1047  }
1048 
1049  ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
1050 
1051  ExpressionVariableSP GetExpressionVariable() {
1052  return m_expression_variable_sp;
1053  }
1054 
1055 protected:
1056  bool ShouldStop(Event *event_ptr) override {
1057  if (m_plan_sp)
1058  return m_plan_sp->ShouldStop(event_ptr);
1059  else
1060  return StopInfo::ShouldStop(event_ptr);
1061  }
1062 
1063 private:
1064  ThreadPlanSP m_plan_sp;
1065  ValueObjectSP m_return_valobj_sp;
1066  ExpressionVariableSP m_expression_variable_sp;
1067 };
1068 
1069 // StopInfoExec
1070 
1071 class StopInfoExec : public StopInfo {
1072 public:
1074  : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
1075 
1076  ~StopInfoExec() override = default;
1077 
1078  bool ShouldStop(Event *event_ptr) override {
1079  ThreadSP thread_sp(m_thread_wp.lock());
1080  if (thread_sp)
1081  return thread_sp->GetProcess()->GetStopOnExec();
1082  return false;
1083  }
1084 
1085  StopReason GetStopReason() const override { return eStopReasonExec; }
1086 
1087  const char *GetDescription() override { return "exec"; }
1088 
1089 protected:
1090  void PerformAction(Event *event_ptr) override {
1091  // Only perform the action once
1092  if (m_performed_action)
1093  return;
1094  m_performed_action = true;
1095  ThreadSP thread_sp(m_thread_wp.lock());
1096  if (thread_sp)
1097  thread_sp->GetProcess()->DidExec();
1098  }
1099 
1101 };
1102 
1103 } // namespace lldb_private
1104 
1106  break_id_t break_id) {
1107  return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
1108 }
1109 
1111  break_id_t break_id,
1112  bool should_stop) {
1113  return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
1114 }
1115 
1116 StopInfoSP
1118  lldb::addr_t watch_hit_addr) {
1119  return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
1120 }
1121 
1122 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
1123  const char *description) {
1124  return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
1125 }
1126 
1128  return StopInfoSP(new StopInfoTrace(thread));
1129 }
1130 
1132  ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
1133  ExpressionVariableSP expression_variable_sp) {
1134  return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
1135  expression_variable_sp));
1136 }
1137 
1139  const char *description) {
1140  return StopInfoSP(new StopInfoException(thread, description));
1141 }
1142 
1144  return StopInfoSP(new StopInfoExec(thread));
1145 }
1146 
1147 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
1148  if (stop_info_sp &&
1149  stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1150  StopInfoThreadPlan *plan_stop_info =
1151  static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1152  return plan_stop_info->GetReturnValueObject();
1153  } else
1154  return ValueObjectSP();
1155 }
1156 
1157 ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) {
1158  if (stop_info_sp &&
1159  stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1160  StopInfoThreadPlan *plan_stop_info =
1161  static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1162  return plan_stop_info->GetExpressionVariable();
1163  } else
1164  return ExpressionVariableSP();
1165 }
1166 
1167 lldb::ValueObjectSP
1168 StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp,
1169  lldb::addr_t *crashing_address) {
1170  if (!stop_info_sp) {
1171  return ValueObjectSP();
1172  }
1173 
1174  const char *description = stop_info_sp->GetDescription();
1175  if (!description) {
1176  return ValueObjectSP();
1177  }
1178 
1179  ThreadSP thread_sp = stop_info_sp->GetThread();
1180  if (!thread_sp) {
1181  return ValueObjectSP();
1182  }
1183 
1184  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
1185 
1186  if (!frame_sp) {
1187  return ValueObjectSP();
1188  }
1189 
1190  const char address_string[] = "address=";
1191 
1192  const char *address_loc = strstr(description, address_string);
1193  if (!address_loc) {
1194  return ValueObjectSP();
1195  }
1196 
1197  address_loc += (sizeof(address_string) - 1);
1198 
1199  uint64_t address = strtoull(address_loc, 0, 0);
1200  if (crashing_address) {
1201  *crashing_address = address;
1202  }
1203 
1204  return frame_sp->GuessValueForAddress(address);
1205 }
static lldb::StopInfoSP CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan, lldb::ValueObjectSP return_valobj_sp, lldb::ExpressionVariableSP expression_variable_sp)
Definition: StopInfo.cpp:1131
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:289
A class to manage flag bits.
Definition: Debugger.h:82
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1078
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
int32_t break_id_t
Definition: lldb-types.h:88
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:924
const char * GetDescription() override
Definition: StopInfo.cpp:996
StopReason GetStopReason() const override
Definition: StopInfo.cpp:922
StopInfoException(Thread &thread, const char *description)
Definition: StopInfo.cpp:1008
lldb::ThreadSP GetThread() const
Definition: StopInfo.h:34
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:1090
virtual void SetDescription(const char *desc_cstr)
Definition: StopInfo.h:70
StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
Definition: StopInfo.cpp:94
WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp)
Definition: StopInfo.cpp:584
bool IsValid() const
Definition: StopInfo.cpp:37
void SetAsyncExecution(bool async)
Definition: Debugger.cpp:875
static bool SentryPreResumeAction(void *sentry_void)
Definition: StopInfo.cpp:613
uint64_t GetValue() const
Definition: StopInfo.h:42
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:285
void WillResume(lldb::StateType resume_state) override
Definition: StopInfo.cpp:958
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb::StreamSP GetAsyncErrorStream()
Definition: Debugger.cpp:1153
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:250
Process or thread is stopped and can be examined.
const char * GetData() const
Definition: StreamString.h:43
#define LLDB_INVALID_UID
Definition: lldb-defines.h:91
#define LIBLLDB_LOG_WATCHPOINTS
Definition: Logging.h:20
static lldb::StopInfoSP CreateStopReasonWithException(Thread &thread, const char *description)
Definition: StopInfo.cpp:1138
StopReason GetStopReason() const override
Definition: StopInfo.cpp:631
const char * GetDescription() override
Definition: StopInfo.cpp:1087
static lldb::ValueObjectSP GetCrashingDereference(lldb::StopInfoSP &stop_info_sp, lldb::addr_t *crashing_address=nullptr)
Definition: StopInfo.cpp:1168
const char * GetDescription() override
Definition: StopInfo.cpp:633
StopReason GetStopReason() const override
Definition: StopInfo.cpp:133
static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread)
Definition: StopInfo.cpp:1127
bool IsValidForOperatingSystemThread(Thread &thread) override
Definition: StopInfo.cpp:122
StopReason GetStopReason() const override
Definition: StopInfo.cpp:994
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
lldb::StreamSP GetAsyncOutputStream()
Definition: Debugger.cpp:1149
ExpressionVariableSP GetExpressionVariable()
Definition: StopInfo.cpp:1051
static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread)
Definition: StopInfo.cpp:1143
static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(Thread &thread, lldb::break_id_t break_id)
Definition: StopInfo.cpp:1105
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:931
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:688
const char * GetDescription() override
Definition: StopInfo.cpp:1018
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
void SetHardwareIndex(uint32_t index)
ValueObjectSP GetReturnValueObject()
Definition: StopInfo.cpp:1049
llvm::StringRef GetString() const
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:1566
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1085
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:1056
StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp)
Definition: StopInfo.cpp:1030
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
StopInfoUnixSignal(Thread &thread, int signo, const char *description)
Definition: StopInfo.cpp:915
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
bool Success() const
Test for success condition.
Definition: Status.cpp:287
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
bool DoShouldNotify(Event *event_ptr) override
Definition: StopInfo.cpp:164
lldb::ThreadWP m_thread_wp
Definition: StopInfo.h:158
const char * GetDescription() override
Definition: StopInfo.cpp:967
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:643
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1016
StopInfoExec(Thread &thread)
Definition: StopInfo.cpp:1073
static void AddRestartedReason(Event *event_ptr, const char *reason)
Definition: Process.cpp:4165
StopReason GetStopReason() const override
Definition: StopInfo.cpp:1038
std::string m_description
Definition: StopInfo.h:163
uint64_t addr_t
Definition: lldb-types.h:83
StopInfoBreakpoint(Thread &thread, break_id_t break_id)
Definition: StopInfo.cpp:86
StopInfoTrace(Thread &thread)
Definition: StopInfo.cpp:990
StopInfoWatchpoint(Thread &thread, break_id_t watch_id, lldb::addr_t watch_hit_addr)
Definition: StopInfo.cpp:624
bool DoShouldNotify(Event *event_ptr) override
Definition: StopInfo.cpp:939
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:61
Definition: SBAddress.h:15
virtual bool ShouldStop(Event *event_ptr)
Definition: StopInfo.h:155
static lldb::ValueObjectSP GetReturnValueObject(lldb::StopInfoSP &stop_info_sp)
Definition: StopInfo.cpp:1147
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
void PerformAction(Event *event_ptr) override
Definition: StopInfo.cpp:258
static lldb::StopInfoSP CreateStopReasonWithSignal(Thread &thread, int signo, const char *description=nullptr)
Definition: StopInfo.cpp:1122
bool ShouldStop(Event *event_ptr) override
Definition: StopInfo.cpp:680
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
const char * GetDescription() override
Definition: StopInfo.cpp:184
static lldb::ExpressionVariableSP GetExpressionVariable(lldb::StopInfoSP &stop_info_sp)
Definition: StopInfo.cpp:1157
#define LIBLLDB_LOG_STEP
Definition: Logging.h:21
lldb::BreakpointLocationSP GetByIndex(size_t i)
Returns a shared pointer to the breakpoint location with index i.
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
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, lldb::ModuleSP *jit_module_sp_ptr=nullptr, ValueObject *ctx_obj=nullptr)
Evaluate one expression in the scratch context of the target passed in the exe_ctx and return its res...
bool ShouldStopSynchronous(Event *event_ptr) override
Definition: StopInfo.cpp:135
An error handling class.
Definition: Status.h:44
static lldb::StopInfoSP CreateStopReasonWithWatchpointID(Thread &thread, lldb::break_id_t watch_id, lldb::addr_t watch_hit_addr=LLDB_INVALID_ADDRESS)
Definition: StopInfo.cpp:1117
const char * GetDescription() override
Definition: StopInfo.cpp:1040
Process or thread is running and can&#39;t be examined.