LLDB  mainline
Watchpoint.h
Go to the documentation of this file.
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 
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 StoppointLocation {
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 
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 
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 
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.
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.
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 
154 
155  const CompilerType &GetCompilerType() { return m_type; }
156 
157 private:
158  friend class Target;
159  friend class WatchpointList;
160 
161  void ResetHitCount() { m_hit_count = 0; }
162 
164  m_old_value_sp.reset();
165  m_new_value_sp.reset();
166  }
167 
169  bool m_enabled; // Is this watchpoint enabled
170  bool m_is_hardware; // Is this a hardware watchpoint
171  bool m_is_watch_variable; // True if set via 'watchpoint set variable'.
172  bool m_is_ephemeral; // True if the watchpoint is in the ephemeral mode,
173  // meaning that it is
174  // undergoing a pair of temporary disable/enable actions to avoid recursively
175  // triggering further watchpoint events.
176  uint32_t m_disabled_count; // Keep track of the count that the watchpoint is
177  // disabled while in ephemeral mode.
178  // At the end of the ephemeral mode when the watchpoint is to be enabled
179  // again, we check the count, if it is more than 1, it means the user-
180  // supplied actions actually want the watchpoint to be disabled!
181  uint32_t m_watch_read : 1, // 1 if we stop when the watched data is read from
182  m_watch_write : 1, // 1 if we stop when the watched data is written to
183  m_watch_was_read : 1, // Set to 1 when watchpoint is hit for a read access
184  m_watch_was_written : 1; // Set to 1 when watchpoint is hit for a write
185  // access
186  uint32_t m_ignore_count; // Number of times to ignore this watchpoint
187  uint32_t m_false_alarms; // Number of false alarms.
188  std::string m_decl_str; // Declaration information, if any.
189  std::string m_watch_spec_str; // Spec for the watchpoint.
190  lldb::ValueObjectSP m_old_value_sp;
191  lldb::ValueObjectSP m_new_value_sp;
193  Status m_error; // An error object describing errors associated with this
194  // watchpoint.
196  m_options; // Settable watchpoint options, which is a delegate to handle
197  // the callback machinery.
199 
200  std::unique_ptr<UserExpression> m_condition_up; // The condition to test.
201 
203 
204  void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind);
205 
207 
208  Watchpoint(const Watchpoint &) = delete;
209  const Watchpoint &operator=(const Watchpoint &) = delete;
210 };
211 
212 } // namespace lldb_private
213 
214 #endif // LLDB_BREAKPOINT_WATCHPOINT_H
void SetCondition(const char *condition)
Set the watchpoint&#39;s condition.
Definition: Watchpoint.cpp:282
A class that represents a running process on the host machine.
ConstString GetFlavor() const override
Definition: Watchpoint.cpp:342
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
This class is used by Watchpoint to manage a list of watchpoints,.
bool InvokeCallback(StoppointCallbackContext *context)
Invoke the callback action when the watchpoint is hit.
Definition: Watchpoint.cpp:278
void SetCallback(WatchpointHitCallback callback, void *callback_baton, bool is_synchronous=false)
Set the callback action invoked when the watchpoint is hit.
Definition: Watchpoint.cpp:64
void SetDeclInfo(const std::string &str)
Definition: Watchpoint.cpp:88
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb::ValueObjectSP m_new_value_sp
Definition: Watchpoint.h:191
int32_t watch_id_t
Definition: lldb-types.h:89
void DumpSnapshots(Stream *s, const char *prefix=nullptr) const
Definition: Watchpoint.cpp:155
void IncrementFalseAlarmsAndReviseHitCount()
Definition: Watchpoint.cpp:123
std::unique_ptr< UserExpression > m_condition_up
Definition: Watchpoint.h:200
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
void SetEnabled(bool enabled, bool notify=true)
Definition: Watchpoint.cpp:237
Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, const CompilerType *type, bool hardware=true)
Definition: Watchpoint.cpp:26
WatchpointOptions * GetOptions()
Returns the WatchpointOptions structure set for this watchpoint.
Definition: Watchpoint.h:104
void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
Definition: Watchpoint.cpp:184
bool IsHardware() const override
Definition: Watchpoint.cpp:98
std::string m_watch_spec_str
Definition: Watchpoint.h:189
void SetIgnoreCount(uint32_t n)
Definition: Watchpoint.cpp:271
bool IsWatchVariable() const
Definition: Watchpoint.cpp:100
void SetID(lldb::watch_id_t id)
Definition: Watchpoint.h:202
void SetWatchVariable(bool val)
Definition: Watchpoint.cpp:102
WatchpointEventData(lldb::WatchpointEventType sub_type, const lldb::WatchpointSP &new_watchpoint_sp)
void SetWatchSpec(const std::string &str)
Definition: Watchpoint.cpp:92
const CompilerType & GetCompilerType()
Definition: Watchpoint.h:155
void SetWatchpointType(uint32_t type, bool notify=true)
Definition: Watchpoint.cpp:255
WatchpointOptions m_options
Definition: Watchpoint.h:196
void Dump(Stream *s) const override
Definition: Watchpoint.cpp:355
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
bool WatchpointWrite() const
Definition: Watchpoint.cpp:267
uint64_t addr_t
Definition: lldb-types.h:83
std::string GetWatchSpec()
Definition: Watchpoint.cpp:90
A uniqued constant string class.
Definition: ConstString.h:40
const Status & GetError()
Definition: Watchpoint.h:98
static lldb::WatchpointEventType GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:369
static lldb::WatchpointSP GetWatchpointFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:379
Represents a generic type in a programming language.
Definition: CompilerType.h:33
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Definition: Watchpoint.cpp:145
const char * GetConditionText() const
Return a pointer to the text of the condition expression.
Definition: Watchpoint.cpp:301
const WatchpointEventData & operator=(const WatchpointEventData &)=delete
bool WatchpointRead() const
Definition: Watchpoint.cpp:265
bool ShouldStop(StoppointCallbackContext *context) override
Definition: Watchpoint.cpp:139
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind)
Definition: Watchpoint.cpp:308
lldb::ValueObjectSP m_old_value_sp
Definition: Watchpoint.h:190
bool CaptureWatchedValue(const ExecutionContext &exe_ctx)
Definition: Watchpoint.cpp:104
lldb::WatchpointEventType GetWatchpointEventType() const
Definition: Watchpoint.cpp:351
lldb::WatchpointEventType m_watchpoint_event
Definition: Watchpoint.h:54
uint32_t GetIgnoreCount() const
Definition: Watchpoint.cpp:269
static const WatchpointEventData * GetEventDataFromEvent(const Event *event_sp)
Definition: Watchpoint.cpp:358
An error handling class.
Definition: Status.h:44