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
22namespace lldb_private {
23
24class Watchpoint : public std::enable_shared_from_this<Watchpoint>,
25 public StoppointSite {
26public:
28 public:
29 WatchpointEventData(lldb::WatchpointEventType sub_type,
30 const lldb::WatchpointSP &new_watchpoint_sp);
31
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
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;
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
152
154
156
157private:
158 friend class Target;
159 friend class WatchpointList;
160 friend class StopInfoWatchpoint; // This needs to call UndoHitCount()
161
163 m_old_value_sp.reset();
164 m_new_value_sp.reset();
165 }
166
168
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;
194 Status m_error; // An error object describing errors associated with this
195 // watchpoint.
197 m_options; // Settable watchpoint options, which is a delegate to handle
198 // the callback machinery.
200
201 std::unique_ptr<UserExpression> m_condition_up; // The condition to test.
202
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
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:39
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
void Decrement(uint32_t difference=1)
lldb::break_id_t m_id
Stoppoint site ID.
Definition: StoppointSite.h:53
StoppointHitCounter m_hit_counter
Number of times this breakpoint/watchpoint has been hit.
Definition: StoppointSite.h:71
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,.
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
static lldb::WatchpointSP GetWatchpointFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:382
lldb::WatchpointEventType m_watchpoint_event
Definition: Watchpoint.h:54
lldb::WatchpointEventType GetWatchpointEventType() const
Definition: Watchpoint.cpp:354
ConstString GetFlavor() const override
Definition: Watchpoint.cpp:345
const WatchpointEventData & operator=(const WatchpointEventData &)=delete
static lldb::WatchpointEventType GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:372
void Dump(Stream *s) const override
Definition: Watchpoint.cpp:358
WatchpointEventData(const WatchpointEventData &)=delete
static const WatchpointEventData * GetEventDataFromEvent(const Event *event_sp)
Definition: Watchpoint.cpp:361
WatchpointEventData(lldb::WatchpointEventType sub_type, const lldb::WatchpointSP &new_watchpoint_sp)
bool IsWatchVariable() const
Definition: Watchpoint.cpp:104
void SetCallback(WatchpointHitCallback callback, void *callback_baton, bool is_synchronous=false)
Set the callback action invoked when the watchpoint is hit.
Definition: Watchpoint.cpp:67
bool CaptureWatchedValue(const ExecutionContext &exe_ctx)
Definition: Watchpoint.cpp:108
void DumpSnapshots(Stream *s, const char *prefix=nullptr) const
Definition: Watchpoint.cpp:159
uint32_t GetIgnoreCount() const
Definition: Watchpoint.cpp:273
bool InvokeCallback(StoppointCallbackContext *context)
Invoke the callback action when the watchpoint is hit.
Definition: Watchpoint.cpp:282
void SetIgnoreCount(uint32_t n)
Definition: Watchpoint.cpp:275
std::unique_ptr< UserExpression > m_condition_up
Definition: Watchpoint.h:201
void SetEnabled(bool enabled, bool notify=true)
Definition: Watchpoint.cpp:241
bool IsHardware() const override
Definition: Watchpoint.cpp:99
void Dump(Stream *s) const override
Definition: Watchpoint.cpp:153
Watchpoint(const Watchpoint &)=delete
void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind)
Definition: Watchpoint.cpp:312
std::string GetWatchSpec()
Definition: Watchpoint.cpp:93
void SetCallback(WatchpointHitCallback callback, const lldb::BatonSP &callback_baton_sp, bool is_synchronous=false)
lldb::ValueObjectSP m_new_value_sp
Definition: Watchpoint.h:192
lldb::ValueObjectSP m_old_value_sp
Definition: Watchpoint.h:191
bool ShouldStop(StoppointCallbackContext *context) override
Definition: Watchpoint.cpp:143
void SetWatchSpec(const std::string &str)
Definition: Watchpoint.cpp:95
void SetWatchVariable(bool val)
Definition: Watchpoint.cpp:106
void SetID(lldb::watch_id_t id)
Definition: Watchpoint.h:203
const char * GetConditionText() const
Return a pointer to the text of the condition expression.
Definition: Watchpoint.cpp:305
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Definition: Watchpoint.cpp:149
const Watchpoint & operator=(const Watchpoint &)=delete
WatchpointOptions m_options
Definition: Watchpoint.h:197
bool WatchpointRead() const
Definition: Watchpoint.cpp:269
std::string m_watch_spec_str
Definition: Watchpoint.h:190
const CompilerType & GetCompilerType()
Definition: Watchpoint.h:155
void SetCondition(const char *condition)
Set the watchpoint's condition.
Definition: Watchpoint.cpp:286
WatchpointOptions * GetOptions()
Returns the WatchpointOptions structure set for this watchpoint.
Definition: Watchpoint.h:104
void SetWatchpointType(uint32_t type, bool notify=true)
Definition: Watchpoint.cpp:259
const Status & GetError()
Definition: Watchpoint.h:98
void SetDeclInfo(const std::string &str)
Definition: Watchpoint.cpp:91
bool WatchpointWrite() const
Definition: Watchpoint.cpp:271
void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
Definition: Watchpoint.cpp:188
void IncrementFalseAlarmsAndReviseHitCount()
Definition: Watchpoint.cpp:127
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
int32_t watch_id_t
Definition: lldb-types.h:85
uint64_t addr_t
Definition: lldb-types.h:79