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"
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
23namespace 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// Controlling 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 "Controlling" plan by responding
153// true to IsControllingPlan, and then if it wants not to be discarded, it can
154// return 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 controlling plan is that when the Controlling
158// plan is
159// done , if it has set "OkayToDiscard" to false, then it will be popped &
160// execution will stop and return to the user. Remember that if OkayToDiscard
161// is false, the plan will be popped and control will be given to the next
162// plan above it on the stack So setting OkayToDiscard to false means the
163// user will regain control when the ControllingPlan is completed.
164//
165// Between these two controls this allows things like: a
166// ControllingPlan/DontDiscard Step Over to hit a breakpoint, stop and return
167// control to the user, but then when the user continues, the step out
168// succeeds. Even more tricky, when the breakpoint is hit, the user can
169// continue to step in/step over/etc, and finally when they continue, they
170// will finish up the Step Over.
171//
172// FIXME: ControllingPlan & OkayToDiscard aren't really orthogonal.
173// ControllingPlan
174// designation means that this plan controls it's fate and the fate of plans
175// below it. OkayToDiscard tells whether the ControllingPlan wants to stay on
176// the stack. I originally thought "ControllingPlan-ness" would need to be a
177// fixed
178// characteristic of a ThreadPlan, in which case you needed the extra control.
179// But that doesn't seem to be true. So we should be able to convert to only
180// ControllingPlan status to mean the current "ControllingPlan/DontDiscard".
181// Then no plans would be ControllingPlans by default, and you would set the
182// ones you wanted to be "user level" in this way.
183//
184//
185// Actually Stopping:
186//
187// If a plan says responds "true" to ShouldStop, then it is asked if it's job
188// is complete by calling MischiefManaged. If that returns true, the plan is
189// popped from the plan stack and added to the Completed Plan Stack. Then the
190// next plan in the stack is asked if it ShouldStop, and it returns "true",
191// it is asked if it is done, and if yes popped, and so on till we reach a
192// plan that is not done.
193//
194// Since you often know in the ShouldStop method whether your plan is
195// complete, as a convenience you can call SetPlanComplete and the ThreadPlan
196// implementation of MischiefManaged will return "true", without your having
197// to redo the calculation when your sub-classes MischiefManaged is called.
198// If you call SetPlanComplete, you can later use IsPlanComplete to determine
199// whether the plan is complete. This is only a convenience for sub-classes,
200// the logic in lldb::Thread will only call MischiefManaged.
201//
202// One slightly tricky point is you have to be careful using SetPlanComplete
203// in PlanExplainsStop because you are not guaranteed that PlanExplainsStop
204// for a plan will get called before ShouldStop gets called. If your sub-plan
205// explained the stop and then popped itself, only your ShouldStop will get
206// called.
207//
208// If ShouldStop for any thread returns "true", then the WillStop method of
209// the Current plan of all threads will be called, the stop event is placed on
210// the Process's public broadcaster, and control returns to the upper layers
211// of the debugger.
212//
213// Reporting the stop:
214//
215// When the process stops, the thread is given a StopReason, in the form of a
216// StopInfo object. If there is a completed plan corresponding to the stop,
217// then the "actual" stop reason can be suppressed, and instead a
218// StopInfoThreadPlan object will be cons'ed up from the top completed plan in
219// the stack. However, if the plan doesn't want to be the stop reason, then
220// it can call SetPlanComplete and pass in "false" for the "success"
221// parameter. In that case, the real stop reason will be used instead. One
222// example of this is the "StepRangeStepIn" thread plan. If it stops because
223// of a crash or breakpoint hit, it wants to unship itself, because it isn't
224// so useful to have step in keep going after a breakpoint hit. But it can't
225// be the reason for the stop or no-one would see that they had hit a
226// breakpoint.
227//
228// Cleaning up the plan stack:
229//
230// One of the complications of ControllingPlans is that you may get past the
231// limits
232// of a plan without triggering it to clean itself up. For instance, if you
233// are doing a ControllingPlan StepOver, and hit a breakpoint in a called
234// function,
235// then step over enough times to step out of the initial StepOver range, each
236// of the step overs will explain the stop & take themselves off the stack,
237// but control would never be returned to the original StepOver. Eventually,
238// the user will continue, and when that continue stops, the old stale
239// StepOver plan that was left on the stack will get woken up and notice it is
240// done. But that can leave junk on the stack for a while. To avoid that, the
241// plans implement a "IsPlanStale" method, that can check whether it is
242// relevant anymore. On stop, after the regular plan negotiation, the
243// remaining plan stack is consulted and if any plan says it is stale, it and
244// the plans below it are discarded from the stack.
245//
246// Automatically Resuming:
247//
248// If ShouldStop for all threads returns "false", then the target process will
249// resume. This then cycles back to Resuming above.
250//
251// Reporting eStateStopped events when the target is restarted:
252//
253// If a plan decides to auto-continue the target by returning "false" from
254// ShouldStop, then it will be asked whether the Stopped event should still be
255// reported. For instance, if you hit a breakpoint that is a User set
256// breakpoint, but the breakpoint callback said to continue the target
257// process, you might still want to inform the upper layers of lldb that the
258// stop had happened. The way this works is every thread gets to vote on
259// whether to report the stop. If all votes are eVoteNoOpinion, then the
260// thread list will decide what to do (at present it will pretty much always
261// suppress these stopped events.) If there is an eVoteYes, then the event
262// will be reported regardless of the other votes. If there is an eVoteNo and
263// no eVoteYes's, then the event won't be reported.
264//
265// One other little detail here, sometimes a plan will push another plan onto
266// the plan stack to do some part of the first plan's job, and it would be
267// convenient to tell that plan how it should respond to ShouldReportStop.
268// You can do that by setting the report_stop_vote in the child plan when you
269// create it.
270//
271// Suppressing the initial eStateRunning event:
272//
273// The private process running thread will take care of ensuring that only one
274// "eStateRunning" event will be delivered to the public Process broadcaster
275// per public eStateStopped event. However there are some cases where the
276// public state of this process is eStateStopped, but a thread plan needs to
277// restart the target, but doesn't want the running event to be publicly
278// broadcast. The obvious example of this is running functions by hand as
279// part of expression evaluation. To suppress the running event return
280// eVoteNo from ShouldReportStop, to force a running event to be reported
281// return eVoteYes, in general though you should return eVoteNoOpinion which
282// will allow the ThreadList to figure out the right thing to do. The
283// report_run_vote argument to the constructor works like report_stop_vote, and
284// is a way for a plan to instruct a sub-plan on how to respond to
285// ShouldReportStop.
286
287class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
288 public UserID {
289public:
290 // We use these enums so that we can cast a base thread plan to it's real
291 // type without having to resort to dynamic casting.
307 };
308
309 virtual ~ThreadPlan();
310
311 /// Returns the name of this thread plan.
312 ///
313 /// \return
314 /// A const char * pointer to the thread plan's name.
315 const char *GetName() const { return m_name.c_str(); }
316
317 /// Returns the Thread that is using this thread plan.
318 ///
319 /// \return
320 /// A pointer to the thread plan's owning thread.
321 Thread &GetThread();
322
323 Target &GetTarget();
324
325 const Target &GetTarget() const;
326
327 /// Clear the Thread* cache.
328 ///
329 /// This is useful in situations like when a new Thread list is being
330 /// generated.
331 void ClearThreadCache();
332
333 /// Print a description of this thread to the stream \a s.
334 /// \a thread. Don't expect that the result of GetThread is valid in
335 /// the description method. This might get called when the underlying
336 /// Thread has not been reported, so we only know the TID and not the thread.
337 ///
338 /// \param[in] s
339 /// The stream to which to print the description.
340 ///
341 /// \param[in] level
342 /// The level of description desired. Note that eDescriptionLevelBrief
343 /// will be used in the stop message printed when the plan is complete.
344 virtual void GetDescription(Stream *s, lldb::DescriptionLevel level) = 0;
345
346 /// Returns whether this plan could be successfully created.
347 ///
348 /// \param[in] error
349 /// A stream to which to print some reason why the plan could not be
350 /// created.
351 /// Can be NULL.
352 ///
353 /// \return
354 /// \b true if the plan should be queued, \b false otherwise.
355 virtual bool ValidatePlan(Stream *error) = 0;
356
358 if (!m_tracer_sp)
359 return false;
360 else
361 return m_tracer_sp->TracerExplainsStop();
362 }
363
365
366 bool PlanExplainsStop(Event *event_ptr);
367
368 virtual bool ShouldStop(Event *event_ptr) = 0;
369
370 /// Returns whether this thread plan overrides the `ShouldStop` of
371 /// subsequently processed plans.
372 ///
373 /// When processing the thread plan stack, this function gives plans the
374 /// ability to continue - even when subsequent plans return true from
375 /// `ShouldStop`. \see Thread::ShouldStop
376 virtual bool ShouldAutoContinue(Event *event_ptr) { return false; }
377
378 // Whether a "stop class" event should be reported to the "outside world".
379 // In general if a thread plan is active, events should not be reported.
380
381 virtual Vote ShouldReportStop(Event *event_ptr);
382
383 Vote ShouldReportRun(Event *event_ptr);
384
385 virtual void SetStopOthers(bool new_value);
386
387 virtual bool StopOthers();
388
389 virtual bool ShouldRunBeforePublicStop() { return false; }
390
391 // This is the wrapper for DoWillResume that does generic ThreadPlan logic,
392 // then calls DoWillResume.
393 bool WillResume(lldb::StateType resume_state, bool current_plan);
394
395 virtual bool WillStop() = 0;
396
398
399 // Returns true if this plan is a leaf plan, meaning the plan will be popped
400 // during each stop if it does not explain the stop and re-pushed before
401 // resuming to stay at the top of the stack.
402 virtual bool IsLeafPlan() { return false; }
403
404 bool SetIsControllingPlan(bool value) {
405 bool old_value = m_is_controlling_plan;
406 m_is_controlling_plan = value;
407 return old_value;
408 }
409
410 virtual bool OkayToDiscard();
411
412 void SetOkayToDiscard(bool value) { m_okay_to_discard = value; }
413
414 // The base class MischiefManaged does some cleanup - so you have to call it
415 // in your MischiefManaged derived class.
416 virtual bool MischiefManaged();
417
418 virtual void ThreadDestroyed() {
419 // Any cleanup that a plan might want to do in case the thread goes away in
420 // the middle of the plan being queued on a thread can be done here.
421 }
422
423 bool GetPrivate() { return m_plan_private; }
424
425 void SetPrivate(bool input) { m_plan_private = input; }
426
427 virtual void DidPush();
428
429 virtual void DidPop();
430
431 ThreadPlanKind GetKind() const { return m_kind; }
432
433 bool IsPlanComplete();
434
435 void SetPlanComplete(bool success = true);
436
437 virtual bool IsPlanStale() { return false; }
438
440
441 virtual bool IsBasePlan() { return false; }
442
444
446 m_tracer_sp = new_tracer_sp;
447 }
448
449 void DoTraceLog() {
450 if (m_tracer_sp && m_tracer_sp->TracingEnabled())
451 m_tracer_sp->Log();
452 }
453
454 // If the completion of the thread plan stepped out of a function, the return
455 // value of the function might have been captured by the thread plan
456 // (currently only ThreadPlanStepOut does this.) If so, the ReturnValueObject
457 // can be retrieved from here.
458
460 return lldb::ValueObjectSP();
461 }
462
463 // If the thread plan managing the evaluation of a user expression lives
464 // longer than the command that instigated the expression (generally because
465 // the expression evaluation hit a breakpoint, and the user regained control
466 // at that point) a subsequent process control command step/continue/etc.
467 // might complete the expression evaluations. If so, the result of the
468 // expression evaluation will show up here.
469
472 }
473
474 // If a thread plan stores the state before it was run, then you might want
475 // to restore the state when it is done. This will do that job. This is
476 // mostly useful for artificial plans like CallFunction plans.
477
478 virtual void RestoreThreadState() {}
479
480 virtual bool IsVirtualStep() { return false; }
481
482 bool SetIterationCount(size_t count) {
484 // Don't tell me to do something 0 times...
485 if (count == 0)
486 return false;
487 m_iteration_count = count;
488 }
490 }
491
493
494protected:
495 // Constructors and Destructors
496 ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
497 Vote report_stop_vote, Vote report_run_vote);
498
499 // Classes that inherit from ThreadPlan can see and modify these
500
501 virtual bool DoWillResume(lldb::StateType resume_state, bool current_plan) {
502 return true;
503 }
504
505 virtual bool DoPlanExplainsStop(Event *event_ptr) = 0;
506
507 // This pushes a plan onto the plan stack of the current plan's thread.
508 // Also sets the plans to private and not controlling plans. A plan pushed by
509 // another thread plan is never either of the above.
510 void PushPlan(lldb::ThreadPlanSP &thread_plan_sp) {
511 GetThread().PushPlan(thread_plan_sp);
512 thread_plan_sp->SetPrivate(true);
513 thread_plan_sp->SetIsControllingPlan(false);
514 }
515
516 // This gets the previous plan to the current plan (for forwarding requests).
517 // This is mostly a formal requirement, it allows us to make the Thread's
518 // GetPreviousPlan protected, but only friend ThreadPlan to thread.
519
521
522 // This forwards the private Thread::GetPrivateStopInfo which is generally
523 // what ThreadPlan's need to know.
524
526 return GetThread().GetPrivateStopInfo();
527 }
528
529 void SetStopInfo(lldb::StopInfoSP stop_reason_sp) {
530 GetThread().SetStopInfo(stop_reason_sp);
531 }
532
534
542 int32_t m_iteration_count = 1;
543
544private:
545 void CachePlanExplainsStop(bool does_explain) {
547 }
548
549 // For ThreadPlan only
550 static lldb::user_id_t GetNextID();
551
552 Thread *m_thread; // Stores a cached value of the thread, which is set to
553 // nullptr when the thread resumes. Don't use this anywhere
554 // but ThreadPlan::GetThread().
556 std::string m_name;
557 std::recursive_mutex m_plan_complete_mutex;
564
566
567 ThreadPlan(const ThreadPlan &) = delete;
568 const ThreadPlan &operator=(const ThreadPlan &) = delete;
569};
570
571// ThreadPlanNull:
572// Threads are assumed to always have at least one plan on the plan stack. This
573// is put on the plan stack when a thread is destroyed so that if you
574// accidentally access a thread after it is destroyed you won't crash. But
575// asking questions of the ThreadPlanNull is definitely an error.
576
578public:
579 ThreadPlanNull(Thread &thread);
580 ~ThreadPlanNull() override;
581
582 void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
583
584 bool ValidatePlan(Stream *error) override;
585
586 bool ShouldStop(Event *event_ptr) override;
587
588 bool MischiefManaged() override;
589
590 bool WillStop() override;
591
592 bool IsBasePlan() override { return true; }
593
594 bool OkayToDiscard() override { return false; }
595
596 const Status &GetStatus() { return m_status; }
597
598protected:
599 bool DoPlanExplainsStop(Event *event_ptr) override;
600
602
604 const ThreadPlanNull &operator=(const ThreadPlanNull &) = delete;
605};
606
607} // namespace lldb_private
608
609#endif // LLDB_TARGET_THREADPLAN_H
static llvm::raw_ostream & error(Stream &strm)
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
bool MischiefManaged() override
Definition: ThreadPlan.cpp:261
lldb::StateType GetPlanRunState() override
Definition: ThreadPlan.cpp:278
bool OkayToDiscard() override
Definition: ThreadPlan.h:594
const ThreadPlanNull & operator=(const ThreadPlanNull &)=delete
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlan.cpp:244
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: ThreadPlan.cpp:192
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlan.cpp:196
const Status & GetStatus()
Definition: ThreadPlan.h:596
ThreadPlanNull(const ThreadPlanNull &)=delete
bool IsBasePlan() override
Definition: ThreadPlan.h:592
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlan.cpp:212
virtual bool IsLeafPlan()
Definition: ThreadPlan.h:402
virtual void GetDescription(Stream *s, lldb::DescriptionLevel level)=0
Print a description of this thread to the stream s.
virtual Vote ShouldReportStop(Event *event_ptr)
Definition: ThreadPlan.cpp:79
ThreadPlanKind m_kind
Definition: ThreadPlan.h:555
virtual void ThreadDestroyed()
Definition: ThreadPlan.h:418
ThreadPlan(const ThreadPlan &)=delete
virtual bool DoPlanExplainsStop(Event *event_ptr)=0
void SetPrivate(bool input)
Definition: ThreadPlan.h:425
virtual bool OkayToDiscard()
Definition: ThreadPlan.cpp:155
virtual bool DoWillResume(lldb::StateType resume_state, bool current_plan)
Definition: ThreadPlan.h:501
virtual lldb::StateType GetPlanRunState()=0
virtual bool ShouldAutoContinue(Event *event_ptr)
Returns whether this thread plan overrides the ShouldStop of subsequently processed plans.
Definition: ThreadPlan.h:376
void SetStopInfo(lldb::StopInfoSP stop_reason_sp)
Definition: ThreadPlan.h:529
virtual lldb::ValueObjectSP GetReturnValueObject()
Definition: ThreadPlan.h:459
Vote ShouldReportRun(Event *event_ptr)
Definition: ThreadPlan.cpp:94
const char * GetName() const
Returns the name of this thread plan.
Definition: ThreadPlan.h:315
bool IsUsuallyUnexplainedStopReason(lldb::StopReason)
Definition: ThreadPlan.cpp:166
ThreadPlanKind GetKind() const
Definition: ThreadPlan.h:431
LazyBool m_cached_plan_explains_stop
Definition: ThreadPlan.h:558
void PushPlan(lldb::ThreadPlanSP &thread_plan_sp)
Definition: ThreadPlan.h:510
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
virtual bool ShouldRunBeforePublicStop()
Definition: ThreadPlan.h:389
bool PlanExplainsStop(Event *event_ptr)
Definition: ThreadPlan.cpp:51
virtual bool IsVirtualStep()
Definition: ThreadPlan.h:480
virtual lldb::ExpressionVariableSP GetExpressionVariable()
Definition: ThreadPlan.h:470
virtual bool StopOthers()
Definition: ThreadPlan.cpp:105
lldb::ThreadPlanTracerSP & GetThreadPlanTracer()
Definition: ThreadPlan.h:443
const ThreadPlan & operator=(const ThreadPlan &)=delete
void SetOkayToDiscard(bool value)
Definition: ThreadPlan.h:412
bool SetIterationCount(size_t count)
Definition: ThreadPlan.h:482
static lldb::user_id_t GetNextID()
Definition: ThreadPlan.cpp:146
void SetThreadPlanTracer(lldb::ThreadPlanTracerSP new_tracer_sp)
Definition: ThreadPlan.h:445
virtual void RestoreThreadState()
Definition: ThreadPlan.h:478
virtual bool ValidatePlan(Stream *error)=0
Returns whether this plan could be successfully created.
ThreadPlan * GetPreviousPlan()
Definition: ThreadPlan.h:520
void ClearThreadCache()
Clear the Thread* cache.
Definition: ThreadPlan.cpp:103
bool WillResume(lldb::StateType resume_state, bool current_plan)
Definition: ThreadPlan.cpp:116
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:72
virtual void DidPush()
Definition: ThreadPlan.cpp:151
virtual bool IsPlanStale()
Definition: ThreadPlan.h:437
lldb::ThreadPlanTracerSP m_tracer_sp
Definition: ThreadPlan.h:565
virtual bool WillStop()=0
lldb::StateType RunState()
Definition: ThreadPlan.cpp:159
virtual void SetStopOthers(bool new_value)
Definition: ThreadPlan.cpp:111
bool SetIsControllingPlan(bool value)
Definition: ThreadPlan.h:404
void CachePlanExplainsStop(bool does_explain)
Definition: ThreadPlan.h:545
virtual bool ShouldStop(Event *event_ptr)=0
std::recursive_mutex m_plan_complete_mutex
Definition: ThreadPlan.h:557
virtual bool IsBasePlan()
Definition: ThreadPlan.h:441
lldb::StopInfoSP GetPrivateStopInfo()
Definition: ThreadPlan.h:525
virtual lldb::StopInfoSP GetPrivateStopInfo(bool calculate=true)
Definition: Thread.cpp:385
void SetStopInfo(const lldb::StopInfoSP &stop_info_sp)
Definition: Thread.cpp:463
ThreadPlan * GetPreviousPlan(ThreadPlan *plan) const
Definition: Thread.cpp:1163
void PushPlan(lldb::ThreadPlanSP plan_sp)
Definition: Thread.cpp:1086
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:448
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:479
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:348
StateType
Process and Thread States.
uint64_t user_id_t
Definition: lldb-types.h:82
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:426
StopReason
Thread stop reasons.
uint64_t tid_t
Definition: lldb-types.h:84
std::shared_ptr< lldb_private::ThreadPlanTracer > ThreadPlanTracerSP
Definition: lldb-forward.h:452
A mix in class that contains a generic user ID.
Definition: UserID.h:31