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