1 | //===-- ThreadPlanShouldStopHere.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_THREADPLANSHOULDSTOPHERE_H |
10 | #define LLDB_TARGET_THREADPLANSHOULDSTOPHERE_H |
11 | |
12 | #include "lldb/Target/ThreadPlan.h" |
13 | |
14 | namespace lldb_private { |
15 | |
16 | // This is an interface that ThreadPlans can adopt to allow flexible |
17 | // modifications of the behavior when a thread plan comes to a place where it |
18 | // would ordinarily stop. If such modification makes sense for your plan, |
19 | // inherit from this class, and when you would be about to stop (in your |
20 | // ShouldStop method), call InvokeShouldStopHereCallback, passing in the frame |
21 | // comparison between where the step operation started and where you arrived. |
22 | // If it returns true, then QueueStepOutFromHere will queue the plan to execute |
23 | // instead of stopping. |
24 | // |
25 | // The classic example of the use of this is ThreadPlanStepInRange not stopping |
26 | // in frames that have no debug information. |
27 | // |
28 | // This class also defines a set of flags to control general aspects of this |
29 | // "ShouldStop" behavior. |
30 | // A class implementing this protocol needs to define a default set of flags, |
31 | // and can provide access to |
32 | // changing that default flag set if it wishes. |
33 | |
34 | class ThreadPlanShouldStopHere { |
35 | public: |
36 | struct ThreadPlanShouldStopHereCallbacks { |
37 | ThreadPlanShouldStopHereCallbacks() { |
38 | should_stop_here_callback = nullptr; |
39 | step_from_here_callback = nullptr; |
40 | } |
41 | |
42 | ThreadPlanShouldStopHereCallbacks( |
43 | ThreadPlanShouldStopHereCallback should_stop, |
44 | ThreadPlanStepFromHereCallback step_from_here) { |
45 | should_stop_here_callback = should_stop; |
46 | step_from_here_callback = step_from_here; |
47 | } |
48 | |
49 | void Clear() { |
50 | should_stop_here_callback = nullptr; |
51 | step_from_here_callback = nullptr; |
52 | } |
53 | |
54 | ThreadPlanShouldStopHereCallback should_stop_here_callback; |
55 | ThreadPlanStepFromHereCallback step_from_here_callback; |
56 | }; |
57 | |
58 | enum { |
59 | eNone = 0, |
60 | eAvoidInlines = (1 << 0), |
61 | eStepInAvoidNoDebug = (1 << 1), |
62 | eStepOutAvoidNoDebug = (1 << 2) |
63 | }; |
64 | |
65 | // Constructors and Destructors |
66 | ThreadPlanShouldStopHere(ThreadPlan *owner); |
67 | |
68 | ThreadPlanShouldStopHere(ThreadPlan *owner, |
69 | const ThreadPlanShouldStopHereCallbacks *callbacks, |
70 | void *baton = nullptr); |
71 | virtual ~ThreadPlanShouldStopHere(); |
72 | |
73 | // Set the ShouldStopHere callbacks. Pass in null to clear them and have no |
74 | // special behavior (though you can also call ClearShouldStopHereCallbacks |
75 | // for that purpose. If you pass in a valid pointer, it will adopt the non- |
76 | // null fields, and any null fields will be set to the default values. |
77 | |
78 | void |
79 | SetShouldStopHereCallbacks(const ThreadPlanShouldStopHereCallbacks *callbacks, |
80 | void *baton) { |
81 | if (callbacks) { |
82 | m_callbacks = *callbacks; |
83 | if (!m_callbacks.should_stop_here_callback) |
84 | m_callbacks.should_stop_here_callback = |
85 | ThreadPlanShouldStopHere::DefaultShouldStopHereCallback; |
86 | if (!m_callbacks.step_from_here_callback) |
87 | m_callbacks.step_from_here_callback = |
88 | ThreadPlanShouldStopHere::DefaultStepFromHereCallback; |
89 | } else { |
90 | ClearShouldStopHereCallbacks(); |
91 | } |
92 | m_baton = baton; |
93 | } |
94 | |
95 | void ClearShouldStopHereCallbacks() { m_callbacks.Clear(); } |
96 | |
97 | bool InvokeShouldStopHereCallback(lldb::FrameComparison operation, |
98 | Status &status); |
99 | |
100 | lldb::ThreadPlanSP |
101 | CheckShouldStopHereAndQueueStepOut(lldb::FrameComparison operation, |
102 | Status &status); |
103 | |
104 | lldb_private::Flags &GetFlags() { return m_flags; } |
105 | |
106 | const lldb_private::Flags &GetFlags() const { return m_flags; } |
107 | |
108 | protected: |
109 | static bool DefaultShouldStopHereCallback(ThreadPlan *current_plan, |
110 | Flags &flags, |
111 | lldb::FrameComparison operation, |
112 | Status &status, void *baton); |
113 | |
114 | static lldb::ThreadPlanSP |
115 | DefaultStepFromHereCallback(ThreadPlan *current_plan, Flags &flags, |
116 | lldb::FrameComparison operation, Status &status, |
117 | void *baton); |
118 | |
119 | virtual lldb::ThreadPlanSP |
120 | QueueStepOutFromHerePlan(Flags &flags, lldb::FrameComparison operation, |
121 | Status &status); |
122 | |
123 | // Implement this, and call it in the plan's constructor to set the default |
124 | // flags. |
125 | virtual void SetFlagsToDefault() = 0; |
126 | |
127 | ThreadPlanShouldStopHereCallbacks m_callbacks; |
128 | void *m_baton; |
129 | ThreadPlan *m_owner; |
130 | lldb_private::Flags m_flags; |
131 | |
132 | private: |
133 | ThreadPlanShouldStopHere(const ThreadPlanShouldStopHere &) = delete; |
134 | const ThreadPlanShouldStopHere & |
135 | operator=(const ThreadPlanShouldStopHere &) = delete; |
136 | }; |
137 | |
138 | } // namespace lldb_private |
139 | |
140 | #endif // LLDB_TARGET_THREADPLANSHOULDSTOPHERE_H |
141 | |