1 //===-- StopInfo.h ----------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef liblldb_StopInfo_h_ 11 #define liblldb_StopInfo_h_ 12 13 // C Includes 14 // C++ Includes 15 #include <string> 16 17 // Other libraries and framework includes 18 // Project includes 19 #include "lldb/lldb-public.h" 20 #include "lldb/Target/Process.h" 21 22 namespace lldb_private { 23 24 class StopInfo 25 { 26 friend class Process::ProcessEventData; 27 friend class ThreadPlanBase; 28 29 public: 30 //------------------------------------------------------------------ 31 // Constructors and Destructors 32 //------------------------------------------------------------------ 33 StopInfo (Thread &thread, uint64_t value); 34 35 virtual ~StopInfo() 36 { 37 } 38 39 40 bool 41 IsValid () const; 42 43 void 44 SetThread (const lldb::ThreadSP &thread_sp) 45 { 46 m_thread_wp = thread_sp; 47 } 48 49 lldb::ThreadSP 50 GetThread() const 51 { 52 return m_thread_wp.lock(); 53 } 54 55 // The value of the StopInfo depends on the StopReason. 56 // StopReason Meaning 57 // ---------------------------------------------- 58 // eStopReasonBreakpoint BreakpointSiteID 59 // eStopReasonSignal Signal number 60 // eStopReasonWatchpoint WatchpointLocationID 61 // eStopReasonPlanComplete No significance 62 63 uint64_t 64 GetValue() const 65 { 66 return m_value; 67 } 68 69 virtual lldb::StopReason 70 GetStopReason () const = 0; 71 72 // ShouldStopSynchronous will get called before any thread plans are consulted, and if it says we should 73 // resume the target, then we will just immediately resume. This should not run any code in or resume the 74 // target. 75 76 virtual bool 77 ShouldStopSynchronous (Event *event_ptr) 78 { 79 return true; 80 } 81 82 void 83 OverrideShouldNotify (bool override_value) 84 { 85 m_override_should_notify = override_value ? eLazyBoolYes : eLazyBoolNo; 86 } 87 88 // If should stop returns false, check if we should notify of this event 89 virtual bool 90 ShouldNotify (Event *event_ptr) 91 { 92 if (m_override_should_notify == eLazyBoolCalculate) 93 return DoShouldNotify (event_ptr); 94 else 95 return m_override_should_notify == eLazyBoolYes; 96 } 97 98 virtual void 99 WillResume (lldb::StateType resume_state) 100 { 101 // By default, don't do anything 102 } 103 104 virtual const char * 105 GetDescription () 106 { 107 return m_description.c_str(); 108 } 109 110 virtual void 111 SetDescription (const char *desc_cstr) 112 { 113 if (desc_cstr && desc_cstr[0]) 114 m_description.assign (desc_cstr); 115 else 116 m_description.clear(); 117 } 118 119 // Sometimes the thread plan logic will know that it wants a given stop to stop or not, 120 // regardless of what the ordinary logic for that StopInfo would dictate. The main example 121 // of this is the ThreadPlanCallFunction, which for instance knows - based on how that particular 122 // expression was executed - whether it wants all breakpoints to auto-continue or not. 123 // Use OverrideShouldStop on the StopInfo to implement this. 124 125 void 126 OverrideShouldStop (bool override_value) 127 { 128 m_override_should_stop = override_value ? eLazyBoolYes : eLazyBoolNo; 129 } 130 131 bool 132 GetOverrideShouldStop() 133 { 134 return m_override_should_stop != eLazyBoolCalculate; 135 } 136 137 bool 138 GetOverriddenShouldStopValue () 139 { 140 return m_override_should_stop == eLazyBoolYes; 141 } 142 143 static lldb::StopInfoSP 144 CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id); 145 146 // This creates a StopInfo for the thread where the should_stop is already set, and won't be recalculated. 147 static lldb::StopInfoSP 148 CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id, bool should_stop); 149 150 static lldb::StopInfoSP 151 CreateStopReasonWithWatchpointID (Thread &thread, lldb::break_id_t watch_id); 152 153 static lldb::StopInfoSP 154 CreateStopReasonWithSignal (Thread &thread, int signo); 155 156 static lldb::StopInfoSP 157 CreateStopReasonToTrace (Thread &thread); 158 159 static lldb::StopInfoSP 160 CreateStopReasonWithPlan (lldb::ThreadPlanSP &plan, lldb::ValueObjectSP return_valobj_sp); 161 162 static lldb::StopInfoSP 163 CreateStopReasonWithException (Thread &thread, const char *description); 164 165 static lldb::StopInfoSP 166 CreateStopReasonWithExec (Thread &thread); 167 168 static lldb::ValueObjectSP 169 GetReturnValueObject (lldb::StopInfoSP &stop_info_sp); 170 171 protected: 172 // Perform any action that is associated with this stop. This is done as the 173 // Event is removed from the event queue. ProcessEventData::DoOnRemoval does the job. 174 175 virtual void 176 PerformAction (Event *event_ptr) 177 { 178 } 179 180 virtual bool 181 DoShouldNotify (Event *event_ptr) 182 { 183 return false; 184 } 185 186 // Stop the thread by default. Subclasses can override this to allow 187 // the thread to continue if desired. The ShouldStop method should not do anything 188 // that might run code. If you need to run code when deciding whether to stop 189 // at this StopInfo, that must be done in the PerformAction. 190 // The PerformAction will always get called before the ShouldStop. This is done by the 191 // ProcessEventData::DoOnRemoval, though the ThreadPlanBase needs to consult this later on. 192 virtual bool 193 ShouldStop (Event *event_ptr) 194 { 195 return true; 196 } 197 198 //------------------------------------------------------------------ 199 // Classes that inherit from StackID can see and modify these 200 //------------------------------------------------------------------ 201 lldb::ThreadWP m_thread_wp; // The thread corresponding to the stop reason. 202 uint32_t m_stop_id; // The process stop ID for which this stop info is valid 203 uint32_t m_resume_id; // This is the resume ID when we made this stop ID. 204 uint64_t m_value; // A generic value that can be used for things pertaining to this stop info 205 std::string m_description; // A textual description describing this stop. 206 LazyBool m_override_should_notify; 207 LazyBool m_override_should_stop; 208 209 // This determines whether the target has run since this stop info. 210 // N.B. running to evaluate a user expression does not count. 211 bool HasTargetRunSinceMe (); 212 213 // MakeStopInfoValid is necessary to allow saved stop infos to resurrect themselves as valid. 214 // It should only be used by Thread::RestoreThreadStateFromCheckpoint and to make sure the one-step 215 // needed for before-the-fact watchpoints does not prevent us from stopping 216 void 217 MakeStopInfoValid (); 218 219 private: 220 friend class Thread; 221 222 DISALLOW_COPY_AND_ASSIGN (StopInfo); 223 }; 224 225 } // namespace lldb_private 226 227 #endif // liblldb_StopInfo_h_ 228
