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 161 void ResetHistoricValues() { 162 m_old_value_sp.reset(); 163 m_new_value_sp.reset(); 164 } 165 166 Target &m_target; 167 bool m_enabled; // Is this watchpoint enabled 168 bool m_is_hardware; // Is this a hardware watchpoint 169 bool m_is_watch_variable; // True if set via 'watchpoint set variable'. 170 bool m_is_ephemeral; // True if the watchpoint is in the ephemeral mode, 171 // meaning that it is 172 // undergoing a pair of temporary disable/enable actions to avoid recursively 173 // triggering further watchpoint events. 174 uint32_t m_disabled_count; // Keep track of the count that the watchpoint is 175 // disabled while in ephemeral mode. 176 // At the end of the ephemeral mode when the watchpoint is to be enabled 177 // again, we check the count, if it is more than 1, it means the user- 178 // supplied actions actually want the watchpoint to be disabled! 179 uint32_t m_watch_read : 1, // 1 if we stop when the watched data is read from 180 m_watch_write : 1, // 1 if we stop when the watched data is written to 181 m_watch_was_read : 1, // Set to 1 when watchpoint is hit for a read access 182 m_watch_was_written : 1; // Set to 1 when watchpoint is hit for a write 183 // access 184 uint32_t m_ignore_count; // Number of times to ignore this watchpoint 185 uint32_t m_false_alarms; // Number of false alarms. 186 std::string m_decl_str; // Declaration information, if any. 187 std::string m_watch_spec_str; // Spec for the watchpoint. 188 lldb::ValueObjectSP m_old_value_sp; 189 lldb::ValueObjectSP m_new_value_sp; 190 CompilerType m_type; 191 Status m_error; // An error object describing errors associated with this 192 // watchpoint. 193 WatchpointOptions 194 m_options; // Settable watchpoint options, which is a delegate to handle 195 // the callback machinery. 196 bool m_being_created; 197 198 std::unique_ptr<UserExpression> m_condition_up; // The condition to test. 199 200 void SetID(lldb::watch_id_t id) { m_id = id; } 201 202 void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind); 203 204 void SendWatchpointChangedEvent(WatchpointEventData *data); 205 206 Watchpoint(const Watchpoint &) = delete; 207 const Watchpoint &operator=(const Watchpoint &) = delete; 208 }; 209 210 } // namespace lldb_private 211 212 #endif // LLDB_BREAKPOINT_WATCHPOINT_H 213