1 //===-- Watchpoint.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_BREAKPOINT_WATCHPOINT_H 10 #define LLDB_BREAKPOINT_WATCHPOINT_H 11 12 #include <memory> 13 #include <string> 14 15 #include "lldb/Breakpoint/StoppointSite.h" 16 #include "lldb/Breakpoint/WatchpointOptions.h" 17 #include "lldb/Symbol/CompilerType.h" 18 #include "lldb/Target/Target.h" 19 #include "lldb/Utility/UserID.h" 20 #include "lldb/lldb-private.h" 21 22 namespace lldb_private { 23 24 class Watchpoint : public std::enable_shared_from_this<Watchpoint>, 25 public StoppointSite { 26 public: 27 class WatchpointEventData : public EventData { 28 public: 29 WatchpointEventData(lldb::WatchpointEventType sub_type, 30 const lldb::WatchpointSP &new_watchpoint_sp); 31 32 ~WatchpointEventData() override; 33 34 static ConstString GetFlavorString(); 35 36 ConstString GetFlavor() const override; 37 38 lldb::WatchpointEventType GetWatchpointEventType() const; 39 40 lldb::WatchpointSP &GetWatchpoint(); 41 42 void Dump(Stream *s) const override; 43 44 static lldb::WatchpointEventType 45 GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp); 46 47 static lldb::WatchpointSP 48 GetWatchpointFromEvent(const lldb::EventSP &event_sp); 49 50 static const WatchpointEventData * 51 GetEventDataFromEvent(const Event *event_sp); 52 53 private: 54 lldb::WatchpointEventType m_watchpoint_event; 55 lldb::WatchpointSP m_new_watchpoint_sp; 56 57 WatchpointEventData(const WatchpointEventData &) = delete; 58 const WatchpointEventData &operator=(const WatchpointEventData &) = delete; 59 }; 60 61 Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, 62 const CompilerType *type, bool hardware = true); 63 64 ~Watchpoint() override; 65 66 void IncrementFalseAlarmsAndReviseHitCount(); 67 68 bool IsEnabled() const; 69 70 // This doesn't really enable/disable the watchpoint. It is currently just 71 // for use in the Process plugin's {Enable,Disable}Watchpoint, which should 72 // be used instead. 73 void SetEnabled(bool enabled, bool notify = true); 74 75 bool IsHardware() const override; 76 77 bool ShouldStop(StoppointCallbackContext *context) override; 78 79 bool WatchpointRead() const; 80 bool WatchpointWrite() const; 81 uint32_t GetIgnoreCount() const; 82 void SetIgnoreCount(uint32_t n); 83 void SetWatchpointType(uint32_t type, bool notify = true); 84 void SetDeclInfo(const std::string &str); 85 std::string GetWatchSpec(); 86 void SetWatchSpec(const std::string &str); 87 88 // Snapshot management interface. 89 bool IsWatchVariable() const; 90 void SetWatchVariable(bool val); 91 bool CaptureWatchedValue(const ExecutionContext &exe_ctx); 92 93 void GetDescription(Stream *s, lldb::DescriptionLevel level); 94 void Dump(Stream *s) const override; 95 void DumpSnapshots(Stream *s, const char *prefix = nullptr) const; 96 void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const; 97 Target &GetTarget() { return m_target; } 98 const Status &GetError() { return m_error; } 99 100 /// Returns the WatchpointOptions structure set for this watchpoint. 101 /// 102 /// \return 103 /// A pointer to this watchpoint's WatchpointOptions. 104 WatchpointOptions *GetOptions() { return &m_options; } 105 106 /// Set the callback action invoked when the watchpoint is hit. 107 /// 108 /// \param[in] callback 109 /// The method that will get called when the watchpoint is hit. 110 /// \param[in] callback_baton 111 /// A void * pointer that will get passed back to the callback function. 112 /// \param[in] is_synchronous 113 /// If \b true the callback will be run on the private event thread 114 /// before the stop event gets reported. If false, the callback will get 115 /// handled on the public event thread after the stop has been posted. 116 void SetCallback(WatchpointHitCallback callback, void *callback_baton, 117 bool is_synchronous = false); 118 119 void SetCallback(WatchpointHitCallback callback, 120 const lldb::BatonSP &callback_baton_sp, 121 bool is_synchronous = false); 122 123 void ClearCallback(); 124 125 /// Invoke the callback action when the watchpoint is hit. 126 /// 127 /// \param[in] context 128 /// Described the watchpoint event. 129 /// 130 /// \return 131 /// \b true if the target should stop at this watchpoint and \b false not. 132 bool InvokeCallback(StoppointCallbackContext *context); 133 134 // Condition 135 /// Set the watchpoint's condition. 136 /// 137 /// \param[in] condition 138 /// The condition expression to evaluate when the watchpoint is hit. 139 /// Pass in nullptr to clear the condition. 140 void SetCondition(const char *condition); 141 142 /// Return a pointer to the text of the condition expression. 143 /// 144 /// \return 145 /// A pointer to the condition expression text, or nullptr if no 146 // condition has been set. 147 const char *GetConditionText() const; 148 149 void TurnOnEphemeralMode(); 150 151 void TurnOffEphemeralMode(); 152 153 bool IsDisabledDuringEphemeralMode(); 154 155 const CompilerType &GetCompilerType() { return m_type; } 156 157 private: 158 friend class Target; 159 friend class WatchpointList; 160 friend class StopInfoWatchpoint; // This needs to call UndoHitCount() 161 162 void ResetHistoricValues() { 163 m_old_value_sp.reset(); 164 m_new_value_sp.reset(); 165 } 166 167 void UndoHitCount() { m_hit_counter.Decrement(); } 168 169 Target &m_target; 170 bool m_enabled; // Is this watchpoint enabled 171 bool m_is_hardware; // Is this a hardware watchpoint 172 bool m_is_watch_variable; // True if set via 'watchpoint set variable'. 173 bool m_is_ephemeral; // True if the watchpoint is in the ephemeral mode, 174 // meaning that it is 175 // undergoing a pair of temporary disable/enable actions to avoid recursively 176 // triggering further watchpoint events. 177 uint32_t m_disabled_count; // Keep track of the count that the watchpoint is 178 // disabled while in ephemeral mode. 179 // At the end of the ephemeral mode when the watchpoint is to be enabled 180 // again, we check the count, if it is more than 1, it means the user- 181 // supplied actions actually want the watchpoint to be disabled! 182 uint32_t m_watch_read : 1, // 1 if we stop when the watched data is read from 183 m_watch_write : 1, // 1 if we stop when the watched data is written to 184 m_watch_was_read : 1, // Set to 1 when watchpoint is hit for a read access 185 m_watch_was_written : 1; // Set to 1 when watchpoint is hit for a write 186 // access 187 uint32_t m_ignore_count; // Number of times to ignore this watchpoint 188 uint32_t m_false_alarms; // Number of false alarms. 189 std::string m_decl_str; // Declaration information, if any. 190 std::string m_watch_spec_str; // Spec for the watchpoint. 191 lldb::ValueObjectSP m_old_value_sp; 192 lldb::ValueObjectSP m_new_value_sp; 193 CompilerType m_type; 194 Status m_error; // An error object describing errors associated with this 195 // watchpoint. 196 WatchpointOptions 197 m_options; // Settable watchpoint options, which is a delegate to handle 198 // the callback machinery. 199 bool m_being_created; 200 201 std::unique_ptr<UserExpression> m_condition_up; // The condition to test. 202 203 void SetID(lldb::watch_id_t id) { m_id = id; } 204 205 void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind); 206 207 void SendWatchpointChangedEvent(WatchpointEventData *data); 208 209 Watchpoint(const Watchpoint &) = delete; 210 const Watchpoint &operator=(const Watchpoint &) = delete; 211 }; 212 213 } // namespace lldb_private 214 215 #endif // LLDB_BREAKPOINT_WATCHPOINT_H 216