LLDB  mainline
ThreadPlan.h
Go to the documentation of this file.
1 //===-- ThreadPlan.h --------------------------------------------*- 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 #ifndef LLDB_TARGET_THREADPLAN_H
10 #define LLDB_TARGET_THREADPLAN_H
11 
12 #include <mutex>
13 #include <string>
14 
15 #include "lldb/Target/Process.h"
16 #include "lldb/Target/StopInfo.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Target/Thread.h"
20 #include "lldb/Utility/UserID.h"
21 #include "lldb/lldb-private.h"
22 
23 namespace lldb_private {
24 
25 // ThreadPlan:
26 //
27 // This is the pure virtual base class for thread plans.
28 //
29 // The thread plans provide the "atoms" of behavior that all the logical
30 // process control, either directly from commands or through more complex
31 // composite plans will rely on.
32 //
33 // Plan Stack:
34 //
35 // The thread maintaining a thread plan stack, and you program the actions of
36 // a particular thread by pushing plans onto the plan stack. There is always
37 // a "Current" plan, which is the top of the plan stack, though in some cases
38 // a plan may defer to plans higher in the stack for some piece of information
39 // (let us define that the plan stack grows downwards).
40 //
41 // The plan stack is never empty, there is always a Base Plan which persists
42 // through the life of the running process.
43 //
44 //
45 // Creating Plans:
46 //
47 // The thread plan is generally created and added to the plan stack through
48 // the QueueThreadPlanFor... API in lldb::Thread. Those API's will return the
49 // plan that performs the named operation in a manner appropriate for the
50 // current process. The plans in lldb/source/Target are generic
51 // implementations, but a Process plugin can override them.
52 //
53 // ValidatePlan is then called. If it returns false, the plan is unshipped.
54 // This is a little convenience which keeps us from having to error out of the
55 // constructor.
56 //
57 // Then the plan is added to the plan stack. When the plan is added to the
58 // plan stack its DidPush will get called. This is useful if a plan wants to
59 // push any additional plans as it is constructed, since you need to make sure
60 // you're already on the stack before you push additional plans.
61 //
62 // Completed Plans:
63 //
64 // When the target process stops the plans are queried, among other things,
65 // for whether their job is done. If it is they are moved from the plan stack
66 // to the Completed Plan stack in reverse order from their position on the
67 // plan stack (since multiple plans may be done at a given stop.) This is
68 // used primarily so that the lldb::Thread::StopInfo for the thread can be set
69 // properly. If one plan pushes another to achieve part of its job, but it
70 // doesn't want that sub-plan to be the one that sets the StopInfo, then call
71 // SetPrivate on the sub-plan when you create it, and the Thread will pass
72 // over that plan in reporting the reason for the stop.
73 //
74 // Discarded plans:
75 //
76 // Your plan may also get discarded, i.e. moved from the plan stack to the
77 // "discarded plan stack". This can happen, for instance, if the plan is
78 // calling a function and the function call crashes and you want to unwind the
79 // attempt to call. So don't assume that your plan will always successfully
80 // stop. Which leads to:
81 //
82 // Cleaning up after your plans:
83 //
84 // When the plan is moved from the plan stack its DidPop method is always
85 // called, no matter why. Once it is moved off the plan stack it is done, and
86 // won't get a chance to run again. So you should undo anything that affects
87 // target state in this method. But be sure to leave the plan able to
88 // correctly fill the StopInfo, however. N.B. Don't wait to do clean up
89 // target state till the destructor, since that will usually get called when
90 // the target resumes, and you want to leave the target state correct for new
91 // plans in the time between when your plan gets unshipped and the next
92 // resume.
93 //
94 // Thread State Checkpoint:
95 //
96 // Note that calling functions on target process (ThreadPlanCallFunction)
97 // changes current thread state. The function can be called either by direct
98 // user demand or internally, for example lldb allocates memory on device to
99 // calculate breakpoint condition expression - on Linux it is performed by
100 // calling mmap on device. ThreadStateCheckpoint saves Thread state (stop
101 // info and completed plan stack) to restore it after completing function
102 // call.
103 //
104 // Over the lifetime of the plan, various methods of the ThreadPlan are then
105 // called in response to changes of state in the process we are debugging as
106 // follows:
107 //
108 // Resuming:
109 //
110 // When the target process is about to be restarted, the plan's WillResume
111 // method is called, giving the plan a chance to prepare for the run. If
112 // WillResume returns false, then the process is not restarted. Be sure to
113 // set an appropriate error value in the Process if you have to do this.
114 // Note, ThreadPlans actually implement DoWillResume, WillResume wraps that
115 // call.
116 //
117 // Next the "StopOthers" method of all the threads are polled, and if one
118 // thread's Current plan returns "true" then only that thread gets to run. If
119 // more than one returns "true" the threads that want to run solo get run one
120 // by one round robin fashion. Otherwise all are let to run.
121 //
122 // Note, the way StopOthers is implemented, the base class implementation just
123 // asks the previous plan. So if your plan has no opinion about whether it
124 // should run stopping others or not, just don't implement StopOthers, and the
125 // parent will be asked.
126 //
127 // Finally, for each thread that is running, it run state is set to the return
128 // of RunState from the thread's Current plan.
129 //
130 // Responding to a stop:
131 //
132 // When the target process stops, the plan is called in the following stages:
133 //
134 // First the thread asks the Current Plan if it can handle this stop by
135 // calling PlanExplainsStop. If the Current plan answers "true" then it is
136 // asked if the stop should percolate all the way to the user by calling the
137 // ShouldStop method. If the current plan doesn't explain the stop, then we
138 // query up the plan stack for a plan that does explain the stop. The plan
139 // that does explain the stop then needs to figure out what to do about the
140 // plans below it in the stack. If the stop is recoverable, then the plan
141 // that understands it can just do what it needs to set up to restart, and
142 // then continue. Otherwise, the plan that understood the stop should call
143 // DiscardPlanStack to clean up the stack below it. Note, plans actually
144 // implement DoPlanExplainsStop, the result is cached in PlanExplainsStop so
145 // the DoPlanExplainsStop itself will only get called once per stop.
146 //
147 // Master plans:
148 //
149 // In the normal case, when we decide to stop, we will collapse the plan
150 // stack up to the point of the plan that understood the stop reason.
151 // However, if a plan wishes to stay on the stack after an event it didn't
152 // directly handle it can designate itself a "Master" plan by responding true
153 // to IsMasterPlan, and then if it wants not to be discarded, it can return
154 // false to OkayToDiscard, and it and all its dependent plans will be
155 // preserved when we resume execution.
156 //
157 // The other effect of being a master plan is that when the Master plan is
158 // done , if it has set "OkayToDiscard" to false, then it will be popped &
159 // execution will stop and return to the user. Remember that if OkayToDiscard
160 // is false, the plan will be popped and control will be given to the next
161 // plan above it on the stack So setting OkayToDiscard to false means the
162 // user will regain control when the MasterPlan is completed.
163 //
164 // Between these two controls this allows things like: a
165 // MasterPlan/DontDiscard Step Over to hit a breakpoint, stop and return
166 // control to the user, but then when the user continues, the step out
167 // succeeds. Even more tricky, when the breakpoint is hit, the user can
168 // continue to step in/step over/etc, and finally when they continue, they
169 // will finish up the Step Over.
170 //
171 // FIXME: MasterPlan & OkayToDiscard aren't really orthogonal. MasterPlan
172 // designation means that this plan controls it's fate and the fate of plans
173 // below it. OkayToDiscard tells whether the MasterPlan wants to stay on the
174 // stack. I originally thought "MasterPlan-ness" would need to be a fixed
175 // characteristic of a ThreadPlan, in which case you needed the extra control.
176 // But that doesn't seem to be true. So we should be able to convert to only
177 // MasterPlan status to mean the current "MasterPlan/DontDiscard". Then no
178 // plans would be MasterPlans by default, and you would set the ones you
179 // wanted to be "user level" in this way.
180 //
181 //
182 // Actually Stopping:
183 //
184 // If a plan says responds "true" to ShouldStop, then it is asked if it's job
185 // is complete by calling MischiefManaged. If that returns true, the plan is
186 // popped from the plan stack and added to the Completed Plan Stack. Then the
187 // next plan in the stack is asked if it ShouldStop, and it returns "true",
188 // it is asked if it is done, and if yes popped, and so on till we reach a
189 // plan that is not done.
190 //
191 // Since you often know in the ShouldStop method whether your plan is
192 // complete, as a convenience you can call SetPlanComplete and the ThreadPlan
193 // implementation of MischiefManaged will return "true", without your having
194 // to redo the calculation when your sub-classes MischiefManaged is called.
195 // If you call SetPlanComplete, you can later use IsPlanComplete to determine
196 // whether the plan is complete. This is only a convenience for sub-classes,
197 // the logic in lldb::Thread will only call MischiefManaged.
198 //
199 // One slightly tricky point is you have to be careful using SetPlanComplete
200 // in PlanExplainsStop because you are not guaranteed that PlanExplainsStop
201 // for a plan will get called before ShouldStop gets called. If your sub-plan
202 // explained the stop and then popped itself, only your ShouldStop will get
203 // called.
204 //
205 // If ShouldStop for any thread returns "true", then the WillStop method of
206 // the Current plan of all threads will be called, the stop event is placed on
207 // the Process's public broadcaster, and control returns to the upper layers
208 // of the debugger.
209 //
210 // Reporting the stop:
211 //
212 // When the process stops, the thread is given a StopReason, in the form of a
213 // StopInfo object. If there is a completed plan corresponding to the stop,
214 // then the "actual" stop reason can be suppressed, and instead a
215 // StopInfoThreadPlan object will be cons'ed up from the top completed plan in
216 // the stack. However, if the plan doesn't want to be the stop reason, then
217 // it can call SetPlanComplete and pass in "false" for the "success"
218 // parameter. In that case, the real stop reason will be used instead. One
219 // example of this is the "StepRangeStepIn" thread plan. If it stops because
220 // of a crash or breakpoint hit, it wants to unship itself, because it isn't
221 // so useful to have step in keep going after a breakpoint hit. But it can't
222 // be the reason for the stop or no-one would see that they had hit a
223 // breakpoint.
224 //
225 // Cleaning up the plan stack:
226 //
227 // One of the complications of MasterPlans is that you may get past the limits
228 // of a plan without triggering it to clean itself up. For instance, if you
229 // are doing a MasterPlan StepOver, and hit a breakpoint in a called function,
230 // then step over enough times to step out of the initial StepOver range, each
231 // of the step overs will explain the stop & take themselves off the stack,
232 // but control would never be returned to the original StepOver. Eventually,
233 // the user will continue, and when that continue stops, the old stale
234 // StepOver plan that was left on the stack will get woken up and notice it is
235 // done. But that can leave junk on the stack for a while. To avoid that, the
236 // plans implement a "IsPlanStale" method, that can check whether it is
237 // relevant anymore. On stop, after the regular plan negotiation, the
238 // remaining plan stack is consulted and if any plan says it is stale, it and
239 // the plans below it are discarded from the stack.
240 //
241 // Automatically Resuming:
242 //
243 // If ShouldStop for all threads returns "false", then the target process will
244 // resume. This then cycles back to Resuming above.
245 //
246 // Reporting eStateStopped events when the target is restarted:
247 //
248 // If a plan decides to auto-continue the target by returning "false" from
249 // ShouldStop, then it will be asked whether the Stopped event should still be
250 // reported. For instance, if you hit a breakpoint that is a User set
251 // breakpoint, but the breakpoint callback said to continue the target
252 // process, you might still want to inform the upper layers of lldb that the
253 // stop had happened. The way this works is every thread gets to vote on
254 // whether to report the stop. If all votes are eVoteNoOpinion, then the
255 // thread list will decide what to do (at present it will pretty much always
256 // suppress these stopped events.) If there is an eVoteYes, then the event
257 // will be reported regardless of the other votes. If there is an eVoteNo and
258 // no eVoteYes's, then the event won't be reported.
259 //
260 // One other little detail here, sometimes a plan will push another plan onto
261 // the plan stack to do some part of the first plan's job, and it would be
262 // convenient to tell that plan how it should respond to ShouldReportStop.
263 // You can do that by setting the report_stop_vote in the child plan when you
264 // create it.
265 //
266 // Suppressing the initial eStateRunning event:
267 //
268 // The private process running thread will take care of ensuring that only one
269 // "eStateRunning" event will be delivered to the public Process broadcaster
270 // per public eStateStopped event. However there are some cases where the
271 // public state of this process is eStateStopped, but a thread plan needs to
272 // restart the target, but doesn't want the running event to be publicly
273 // broadcast. The obvious example of this is running functions by hand as
274 // part of expression evaluation. To suppress the running event return
275 // eVoteNo from ShouldReportStop, to force a running event to be reported
276 // return eVoteYes, in general though you should return eVoteNoOpinion which
277 // will allow the ThreadList to figure out the right thing to do. The
278 // report_run_vote argument to the constructor works like report_stop_vote, and
279 // is a way for a plan to instruct a sub-plan on how to respond to
280 // ShouldReportStop.
281 
282 class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
283  public UserID {
284 public:
285  // We use these enums so that we can cast a base thread plan to it's real
286  // type without having to resort to dynamic casting.
301  };
302 
303  virtual ~ThreadPlan();
304 
305  /// Returns the name of this thread plan.
306  ///
307  /// \return
308  /// A const char * pointer to the thread plan's name.
309  const char *GetName() const { return m_name.c_str(); }
310 
311  /// Returns the Thread that is using this thread plan.
312  ///
313  /// \return
314  /// A pointer to the thread plan's owning thread.
315  Thread &GetThread();
316 
317  Target &GetTarget();
318 
319  const Target &GetTarget() const;
320 
321  /// Clear the Thread* cache.
322  ///
323  /// This is useful in situations like when a new Thread list is being
324  /// generated.
325  void ClearThreadCache();
326 
327  /// Print a description of this thread to the stream \a s.
328  /// \a thread. Don't expect that the result of GetThread is valid in
329  /// the description method. This might get called when the underlying
330  /// Thread has not been reported, so we only know the TID and not the thread.
331  ///
332  /// \param[in] s
333  /// The stream to which to print the description.
334  ///
335  /// \param[in] level
336  /// The level of description desired. Note that eDescriptionLevelBrief
337  /// will be used in the stop message printed when the plan is complete.
338  virtual void GetDescription(Stream *s, lldb::DescriptionLevel level) = 0;
339 
340  /// Returns whether this plan could be successfully created.
341  ///
342  /// \param[in] error
343  /// A stream to which to print some reason why the plan could not be
344  /// created.
345  /// Can be NULL.
346  ///
347  /// \return
348  /// \b true if the plan should be queued, \b false otherwise.
349  virtual bool ValidatePlan(Stream *error) = 0;
350 
352  if (!m_tracer_sp)
353  return false;
354  else
355  return m_tracer_sp->TracerExplainsStop();
356  }
357 
359 
360  bool PlanExplainsStop(Event *event_ptr);
361 
362  virtual bool ShouldStop(Event *event_ptr) = 0;
363 
364  /// Returns whether this thread plan overrides the `ShouldStop` of
365  /// subsequently processed plans.
366  ///
367  /// When processing the thread plan stack, this function gives plans the
368  /// ability to continue - even when subsequent plans return true from
369  /// `ShouldStop`. \see Thread::ShouldStop
370  virtual bool ShouldAutoContinue(Event *event_ptr) { return false; }
371 
372  // Whether a "stop class" event should be reported to the "outside world".
373  // In general if a thread plan is active, events should not be reported.
374 
375  virtual Vote ShouldReportStop(Event *event_ptr);
376 
377  Vote ShouldReportRun(Event *event_ptr);
378 
379  virtual void SetStopOthers(bool new_value);
380 
381  virtual bool StopOthers();
382 
383  // This is the wrapper for DoWillResume that does generic ThreadPlan logic,
384  // then calls DoWillResume.
385  bool WillResume(lldb::StateType resume_state, bool current_plan);
386 
387  virtual bool WillStop() = 0;
388 
389  bool IsMasterPlan() { return m_is_master_plan; }
390 
391  bool SetIsMasterPlan(bool value) {
392  bool old_value = m_is_master_plan;
393  m_is_master_plan = value;
394  return old_value;
395  }
396 
397  virtual bool OkayToDiscard();
398 
399  void SetOkayToDiscard(bool value) { m_okay_to_discard = value; }
400 
401  // The base class MischiefManaged does some cleanup - so you have to call it
402  // in your MischiefManaged derived class.
403  virtual bool MischiefManaged();
404 
405  virtual void ThreadDestroyed() {
406  // Any cleanup that a plan might want to do in case the thread goes away in
407  // the middle of the plan being queued on a thread can be done here.
408  }
409 
410  bool GetPrivate() { return m_plan_private; }
411 
412  void SetPrivate(bool input) { m_plan_private = input; }
413 
414  virtual void DidPush();
415 
416  virtual void DidPop();
417 
418  ThreadPlanKind GetKind() const { return m_kind; }
419 
420  bool IsPlanComplete();
421 
422  void SetPlanComplete(bool success = true);
423 
424  virtual bool IsPlanStale() { return false; }
425 
426  bool PlanSucceeded() { return m_plan_succeeded; }
427 
428  virtual bool IsBasePlan() { return false; }
429 
430  lldb::ThreadPlanTracerSP &GetThreadPlanTracer() { return m_tracer_sp; }
431 
432  void SetThreadPlanTracer(lldb::ThreadPlanTracerSP new_tracer_sp) {
433  m_tracer_sp = new_tracer_sp;
434  }
435 
436  void DoTraceLog() {
437  if (m_tracer_sp && m_tracer_sp->TracingEnabled())
438  m_tracer_sp->Log();
439  }
440 
441  // If the completion of the thread plan stepped out of a function, the return
442  // value of the function might have been captured by the thread plan
443  // (currently only ThreadPlanStepOut does this.) If so, the ReturnValueObject
444  // can be retrieved from here.
445 
446  virtual lldb::ValueObjectSP GetReturnValueObject() {
447  return lldb::ValueObjectSP();
448  }
449 
450  // If the thread plan managing the evaluation of a user expression lives
451  // longer than the command that instigated the expression (generally because
452  // the expression evaluation hit a breakpoint, and the user regained control
453  // at that point) a subsequent process control command step/continue/etc.
454  // might complete the expression evaluations. If so, the result of the
455  // expression evaluation will show up here.
456 
457  virtual lldb::ExpressionVariableSP GetExpressionVariable() {
458  return lldb::ExpressionVariableSP();
459  }
460 
461  // If a thread plan stores the state before it was run, then you might want
462  // to restore the state when it is done. This will do that job. This is
463  // mostly useful for artificial plans like CallFunction plans.
464 
465  virtual void RestoreThreadState() {}
466 
467  virtual bool IsVirtualStep() { return false; }
468 
469  bool SetIterationCount(size_t count) {
471  // Don't tell me to do something 0 times...
472  if (count == 0)
473  return false;
474  m_iteration_count = count;
475  }
477  }
478 
479 protected:
480  // Constructors and Destructors
481  ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
482  Vote report_stop_vote, Vote report_run_vote);
483 
484  // Classes that inherit from ThreadPlan can see and modify these
485 
486  virtual bool DoWillResume(lldb::StateType resume_state, bool current_plan) {
487  return true;
488  }
489 
490  virtual bool DoPlanExplainsStop(Event *event_ptr) = 0;
491 
492  // This pushes a plan onto the plan stack of the current plan's thread.
493  // Also sets the plans to private and not master plans. A plan pushed by
494  // another thread plan is never either of the above.
495  void PushPlan(lldb::ThreadPlanSP &thread_plan_sp) {
496  GetThread().PushPlan(thread_plan_sp);
497  thread_plan_sp->SetPrivate(true);
498  thread_plan_sp->SetIsMasterPlan(false);
499  }
500 
501  // This gets the previous plan to the current plan (for forwarding requests).
502  // This is mostly a formal requirement, it allows us to make the Thread's
503  // GetPreviousPlan protected, but only friend ThreadPlan to thread.
504 
506 
507  // This forwards the private Thread::GetPrivateStopInfo which is generally
508  // what ThreadPlan's need to know.
509 
510  lldb::StopInfoSP GetPrivateStopInfo() {
511  return GetThread().GetPrivateStopInfo();
512  }
513 
514  void SetStopInfo(lldb::StopInfoSP stop_reason_sp) {
515  GetThread().SetStopInfo(stop_reason_sp);
516  }
517 
518  virtual lldb::StateType GetPlanRunState() = 0;
519 
521 
529  int32_t m_iteration_count = 1;
530 
531 private:
532  void CachePlanExplainsStop(bool does_explain) {
534  }
535 
536  // For ThreadPlan only
537  static lldb::user_id_t GetNextID();
538 
539  Thread *m_thread; // Stores a cached value of the thread, which is set to
540  // nullptr when the thread resumes. Don't use this anywhere
541  // but ThreadPlan::GetThread().
544  std::recursive_mutex m_plan_complete_mutex;
551 
552  lldb::ThreadPlanTracerSP m_tracer_sp;
553 
554  ThreadPlan(const ThreadPlan &) = delete;
555  const ThreadPlan &operator=(const ThreadPlan &) = delete;
556 };
557 
558 // ThreadPlanNull:
559 // Threads are assumed to always have at least one plan on the plan stack. This
560 // is put on the plan stack when a thread is destroyed so that if you
561 // accidentally access a thread after it is destroyed you won't crash. But
562 // asking questions of the ThreadPlanNull is definitely an error.
563 
564 class ThreadPlanNull : public ThreadPlan {
565 public:
566  ThreadPlanNull(Thread &thread);
567  ~ThreadPlanNull() override;
568 
569  void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
570 
571  bool ValidatePlan(Stream *error) override;
572 
573  bool ShouldStop(Event *event_ptr) override;
574 
575  bool MischiefManaged() override;
576 
577  bool WillStop() override;
578 
579  bool IsBasePlan() override { return true; }
580 
581  bool OkayToDiscard() override { return false; }
582 
583  const Status &GetStatus() { return m_status; }
584 
585 protected:
586  bool DoPlanExplainsStop(Event *event_ptr) override;
587 
588  lldb::StateType GetPlanRunState() override;
589 
590  ThreadPlanNull(const ThreadPlanNull &) = delete;
591  const ThreadPlanNull &operator=(const ThreadPlanNull &) = delete;
592 };
593 
594 } // namespace lldb_private
595 
596 #endif // LLDB_TARGET_THREADPLAN_H
lldb_private::ThreadPlan::DidPush
virtual void DidPush()
Definition: ThreadPlan.cpp:150
lldb_private::ThreadPlan::GetThread
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:41
lldb_private::ThreadPlan::m_plan_private
bool m_plan_private
Definition: ThreadPlan.h:547
lldb_private::Event
Definition: Event.h:180
lldb_private::ThreadPlan::IsPlanComplete
bool IsPlanComplete()
Definition: ThreadPlan.cpp:60
lldb_private::ThreadPlan::eKindBase
@ eKindBase
Definition: ThreadPlan.h:290
lldb_private::ThreadPlanNull::~ThreadPlanNull
~ThreadPlanNull() override
lldb_private::ThreadPlan::ThreadDestroyed
virtual void ThreadDestroyed()
Definition: ThreadPlan.h:405
lldb_private::ThreadPlan::SetOkayToDiscard
void SetOkayToDiscard(bool value)
Definition: ThreadPlan.h:399
lldb_private::Thread::GetPrivateStopInfo
virtual lldb::StopInfoSP GetPrivateStopInfo()
Definition: Thread.cpp:370
lldb_private::ThreadPlan::m_report_run_vote
Vote m_report_run_vote
Definition: ThreadPlan.h:526
lldb_private::ThreadPlan::eKindStepOverBreakpoint
@ eKindStepOverBreakpoint
Definition: ThreadPlan.h:295
lldb_private::ThreadPlan::GetReturnValueObject
virtual lldb::ValueObjectSP GetReturnValueObject()
Definition: ThreadPlan.h:446
lldb_private::UserID
Definition: UserID.h:31
lldb_private::ThreadPlan::GetPrivate
bool GetPrivate()
Definition: ThreadPlan.h:410
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
lldb_private::ThreadPlan::GetKind
ThreadPlanKind GetKind() const
Definition: ThreadPlan.h:418
lldb_private::Process
Definition: Process.h:341
lldb_private::ThreadPlan::PlanSucceeded
bool PlanSucceeded()
Definition: ThreadPlan.h:426
lldb_private::ThreadPlan::RestoreThreadState
virtual void RestoreThreadState()
Definition: ThreadPlan.h:465
lldb_private::ThreadPlan::GetPlanRunState
virtual lldb::StateType GetPlanRunState()=0
lldb_private::ThreadPlan::m_kind
ThreadPlanKind m_kind
Definition: ThreadPlan.h:542
lldb_private::ThreadPlan::eKindNull
@ eKindNull
Definition: ThreadPlan.h:289
lldb_private::ThreadPlan::ThreadPlan
ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, Vote report_stop_vote, Vote report_run_vote)
Definition: ThreadPlan.cpp:22
lldb_private::ThreadPlanNull::IsBasePlan
bool IsBasePlan() override
Definition: ThreadPlan.h:579
lldb_private::ThreadPlanNull
Definition: ThreadPlan.h:564
lldb_private::ThreadPlan::eKindStepOverRange
@ eKindStepOverRange
Definition: ThreadPlan.h:296
lldb::StopReason
StopReason
Thread stop reasons.
Definition: lldb-enumerations.h:239
lldb_private::Thread::GetPreviousPlan
ThreadPlan * GetPreviousPlan(ThreadPlan *plan) const
Definition: Thread.cpp:1145
lldb_private::ThreadPlan::eKindStepUntil
@ eKindStepUntil
Definition: ThreadPlan.h:300
lldb_private::ThreadPlanNull::ThreadPlanNull
ThreadPlanNull(Thread &thread)
Definition: ThreadPlan.cpp:181
lldb_private::ThreadPlan::m_cached_plan_explains_stop
LazyBool m_cached_plan_explains_stop
Definition: ThreadPlan.h:545
lldb_private::ThreadPlan::ShouldStop
virtual bool ShouldStop(Event *event_ptr)=0
lldb_private::Stream
Definition: Stream.h:28
lldb_private::ThreadPlanNull::GetStatus
const Status & GetStatus()
Definition: ThreadPlan.h:583
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::ThreadPlan::m_plan_succeeded
bool m_plan_succeeded
Definition: ThreadPlan.h:550
lldb_private::Target
Definition: Target.h:451
lldb_private::ThreadPlan::CachePlanExplainsStop
void CachePlanExplainsStop(bool does_explain)
Definition: ThreadPlan.h:532
Process.h
lldb_private::ThreadPlan::SetIsMasterPlan
bool SetIsMasterPlan(bool value)
Definition: ThreadPlan.h:391
lldb_private::ThreadPlan::SetStopInfo
void SetStopInfo(lldb::StopInfoSP stop_reason_sp)
Definition: ThreadPlan.h:514
lldb_private::ThreadPlan::~ThreadPlan
virtual ~ThreadPlan()
Target.h
lldb_private::ThreadPlan::eKindStepInstruction
@ eKindStepInstruction
Definition: ThreadPlan.h:293
lldb_private::ThreadPlan::ThreadPlanKind
ThreadPlanKind
Definition: ThreadPlan.h:287
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::ThreadPlan::SetIterationCount
bool SetIterationCount(size_t count)
Definition: ThreadPlan.h:469
lldb_private::ThreadPlan::GetTarget
Target & GetTarget()
Definition: ThreadPlan.cpp:37
lldb_private::ThreadPlan
Definition: ThreadPlan.h:282
lldb_private::ThreadPlan::WillStop
virtual bool WillStop()=0
lldb_private::ThreadPlan::ShouldAutoContinue
virtual bool ShouldAutoContinue(Event *event_ptr)
Returns whether this thread plan overrides the ShouldStop of subsequently processed plans.
Definition: ThreadPlan.h:370
lldb_private::ThreadPlan::MischiefManaged
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:71
lldb_private::Thread
Definition: Thread.h:60
lldb_private::ThreadPlan::eKindRunToAddress
@ eKindRunToAddress
Definition: ThreadPlan.h:298
lldb_private::ThreadPlan::GetPreviousPlan
ThreadPlan * GetPreviousPlan()
Definition: ThreadPlan.h:505
ThreadPlanTracer.h
lldb_private::ThreadPlan::eKindStepInRange
@ eKindStepInRange
Definition: ThreadPlan.h:297
lldb_private::ThreadPlan::GetExpressionVariable
virtual lldb::ExpressionVariableSP GetExpressionVariable()
Definition: ThreadPlan.h:457
lldb_private::ThreadPlanNull::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlan.cpp:191
lldb_private::ThreadPlan::DoPlanExplainsStop
virtual bool DoPlanExplainsStop(Event *event_ptr)=0
lldb_private::ThreadPlan::operator=
const ThreadPlan & operator=(const ThreadPlan &)=delete
lldb_private::ThreadPlan::GetNextID
static lldb::user_id_t GetNextID()
Definition: ThreadPlan.cpp:145
lldb_private::Thread::SetStopInfo
void SetStopInfo(const lldb::StopInfoSP &stop_info_sp)
Definition: Thread.cpp:433
lldb_private::ThreadPlan::PlanExplainsStop
bool PlanExplainsStop(Event *event_ptr)
Definition: ThreadPlan.cpp:50
lldb_private::ThreadPlan::IsVirtualStep
virtual bool IsVirtualStep()
Definition: ThreadPlan.h:467
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::ThreadPlan::m_plan_complete
bool m_plan_complete
Definition: ThreadPlan.h:546
lldb_private::ThreadPlanNull::OkayToDiscard
bool OkayToDiscard() override
Definition: ThreadPlan.h:581
lldb_private::ThreadPlan::GetThreadPlanTracer
lldb::ThreadPlanTracerSP & GetThreadPlanTracer()
Definition: ThreadPlan.h:430
lldb_private::ThreadPlan::m_plan_complete_mutex
std::recursive_mutex m_plan_complete_mutex
Definition: ThreadPlan.h:544
Thread.h
lldb_private::ThreadPlan::eKindStepThrough
@ eKindStepThrough
Definition: ThreadPlan.h:299
UserID.h
lldb_private::ThreadPlan::OkayToDiscard
virtual bool OkayToDiscard()
Definition: ThreadPlan.cpp:154
lldb_private::ThreadPlanNull::MischiefManaged
bool MischiefManaged() override
Definition: ThreadPlan.cpp:256
lldb_private::ThreadPlan::m_status
Status m_status
Definition: ThreadPlan.h:522
lldb-private.h
lldb_private::ThreadPlan::eKindGeneric
@ eKindGeneric
Definition: ThreadPlan.h:288
lldb_private::ThreadPlan::PushPlan
void PushPlan(lldb::ThreadPlanSP &thread_plan_sp)
Definition: ThreadPlan.h:495
lldb_private::ThreadPlan::SetPrivate
void SetPrivate(bool input)
Definition: ThreadPlan.h:412
lldb_private::ThreadPlan::ValidatePlan
virtual bool ValidatePlan(Stream *error)=0
Returns whether this plan could be successfully created.
lldb_private::ThreadPlan::StopOthers
virtual bool StopOthers()
Definition: ThreadPlan.cpp:104
lldb_private::ThreadPlan::SetPlanComplete
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:65
lldb_private::Status
Definition: Status.h:44
lldb_private::ThreadPlan::eKindStepOut
@ eKindStepOut
Definition: ThreadPlan.h:294
lldb_private::ThreadPlan::IsUsuallyUnexplainedStopReason
bool IsUsuallyUnexplainedStopReason(lldb::StopReason)
Definition: ThreadPlan.cpp:165
lldb_private::Thread::PushPlan
void PushPlan(lldb::ThreadPlanSP plan_sp)
Definition: Thread.cpp:1068
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::ThreadPlan::DoWillResume
virtual bool DoWillResume(lldb::StateType resume_state, bool current_plan)
Definition: ThreadPlan.h:486
lldb_private::ThreadPlan::m_could_not_resolve_hw_bp
bool m_could_not_resolve_hw_bp
Definition: ThreadPlan.h:528
lldb_private::ThreadPlan::DidPop
virtual void DidPop()
Definition: ThreadPlan.cpp:152
lldb_private::ThreadPlan::DoTraceLog
void DoTraceLog()
Definition: ThreadPlan.h:436
lldb_private::ThreadPlan::SetStopOthers
virtual void SetStopOthers(bool new_value)
Definition: ThreadPlan.cpp:110
StopInfo.h
lldb_private::ThreadPlan::m_report_stop_vote
Vote m_report_stop_vote
Definition: ThreadPlan.h:525
lldb_private::ThreadPlan::m_iteration_count
int32_t m_iteration_count
Definition: ThreadPlan.h:529
lldb_private::Vote
Vote
Definition: lldb-private-enumerations.h:59
lldb_private::ThreadPlan::ShouldReportRun
Vote ShouldReportRun(Event *event_ptr)
Definition: ThreadPlan.cpp:93
lldb_private::ThreadPlan::m_name
std::string m_name
Definition: ThreadPlan.h:543
lldb_private::ThreadPlan::GetName
const char * GetName() const
Returns the name of this thread plan.
Definition: ThreadPlan.h:309
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private::ThreadPlan::m_okay_to_discard
bool m_okay_to_discard
Definition: ThreadPlan.h:548
lldb_private::ThreadPlan::SetThreadPlanTracer
void SetThreadPlanTracer(lldb::ThreadPlanTracerSP new_tracer_sp)
Definition: ThreadPlan.h:432
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ThreadPlanNull::GetPlanRunState
lldb::StateType GetPlanRunState() override
Definition: ThreadPlan.cpp:273
lldb_private::ThreadPlan::WillResume
bool WillResume(lldb::StateType resume_state, bool current_plan)
Definition: ThreadPlan.cpp:115
lldb_private::ThreadPlan::m_tracer_sp
lldb::ThreadPlanTracerSP m_tracer_sp
Definition: ThreadPlan.h:552
lldb_private::ThreadPlanNull::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: ThreadPlan.cpp:187
lldb_private::ThreadPlan::m_tid
lldb::tid_t m_tid
Definition: ThreadPlan.h:524
lldb_private::ThreadPlan::eKindPython
@ eKindPython
Definition: ThreadPlan.h:292
lldb_private::ThreadPlan::ShouldReportStop
virtual Vote ShouldReportStop(Event *event_ptr)
Definition: ThreadPlan.cpp:78
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::ThreadPlanNull::WillStop
bool WillStop() override
Definition: ThreadPlan.cpp:223
lldb_private::ThreadPlan::IsMasterPlan
bool IsMasterPlan()
Definition: ThreadPlan.h:389
lldb_private::ThreadPlan::m_takes_iteration_count
bool m_takes_iteration_count
Definition: ThreadPlan.h:527
lldb_private::ThreadPlan::GetPrivateStopInfo
lldb::StopInfoSP GetPrivateStopInfo()
Definition: ThreadPlan.h:510
lldb_private::ThreadPlan::ClearThreadCache
void ClearThreadCache()
Clear the Thread* cache.
Definition: ThreadPlan.cpp:102
lldb_private::ThreadPlanNull::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlan.cpp:239
lldb_private::ThreadPlanNull::operator=
const ThreadPlanNull & operator=(const ThreadPlanNull &)=delete
lldb_private::ThreadPlan::IsBasePlan
virtual bool IsBasePlan()
Definition: ThreadPlan.h:428
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:523
lldb_private::ThreadPlan::RunState
lldb::StateType RunState()
Definition: ThreadPlan.cpp:158
lldb_private::ThreadPlan::GetDescription
virtual void GetDescription(Stream *s, lldb::DescriptionLevel level)=0
Print a description of this thread to the stream s.
lldb_private::ThreadPlan::TracerExplainsStop
bool TracerExplainsStop()
Definition: ThreadPlan.h:351
lldb_private::ThreadPlan::eKindCallFunction
@ eKindCallFunction
Definition: ThreadPlan.h:291
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::ThreadPlanNull::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlan.cpp:207
lldb_private::ThreadPlan::m_is_master_plan
bool m_is_master_plan
Definition: ThreadPlan.h:549
lldb_private::ThreadPlan::IsPlanStale
virtual bool IsPlanStale()
Definition: ThreadPlan.h:424
lldb_private::ThreadPlan::m_thread
Thread * m_thread
Definition: ThreadPlan.h:539