1 //===-- SBWatchpoint.cpp --------------------------------*- 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 #include "lldb/API/SBWatchpoint.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBAddress.h"
12 #include "lldb/API/SBDebugger.h"
13 #include "lldb/API/SBDefines.h"
14 #include "lldb/API/SBEvent.h"
15 #include "lldb/API/SBStream.h"
16
17 #include "lldb/Breakpoint/Watchpoint.h"
18 #include "lldb/Breakpoint/WatchpointList.h"
19 #include "lldb/Core/StreamFile.h"
20 #include "lldb/Target/Process.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/Stream.h"
23 #include "lldb/lldb-defines.h"
24 #include "lldb/lldb-types.h"
25
26 using namespace lldb;
27 using namespace lldb_private;
28
SBWatchpoint()29 SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
30
SBWatchpoint(const lldb::WatchpointSP & wp_sp)31 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
32 : m_opaque_wp(wp_sp) {
33 LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
34 }
35
SBWatchpoint(const SBWatchpoint & rhs)36 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
37 : m_opaque_wp(rhs.m_opaque_wp) {
38 LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
39 }
40
operator =(const SBWatchpoint & rhs)41 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
42 LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
43 SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
44
45 m_opaque_wp = rhs.m_opaque_wp;
46 return LLDB_RECORD_RESULT(*this);
47 }
48
~SBWatchpoint()49 SBWatchpoint::~SBWatchpoint() {}
50
GetID()51 watch_id_t SBWatchpoint::GetID() {
52 LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
53
54
55 watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
56 lldb::WatchpointSP watchpoint_sp(GetSP());
57 if (watchpoint_sp)
58 watch_id = watchpoint_sp->GetID();
59
60 return watch_id;
61 }
62
IsValid() const63 bool SBWatchpoint::IsValid() const {
64 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
65 return this->operator bool();
66 }
operator bool() const67 SBWatchpoint::operator bool() const {
68 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
69
70 return bool(m_opaque_wp.lock());
71 }
72
operator ==(const SBWatchpoint & rhs) const73 bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const {
74 LLDB_RECORD_METHOD_CONST(
75 bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs);
76
77 return GetSP() == rhs.GetSP();
78 }
79
operator !=(const SBWatchpoint & rhs) const80 bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const {
81 LLDB_RECORD_METHOD_CONST(
82 bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs);
83
84 return !(*this == rhs);
85 }
86
GetError()87 SBError SBWatchpoint::GetError() {
88 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
89
90 SBError sb_error;
91 lldb::WatchpointSP watchpoint_sp(GetSP());
92 if (watchpoint_sp) {
93 sb_error.SetError(watchpoint_sp->GetError());
94 }
95 return LLDB_RECORD_RESULT(sb_error);
96 }
97
GetHardwareIndex()98 int32_t SBWatchpoint::GetHardwareIndex() {
99 LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
100
101 int32_t hw_index = -1;
102
103 lldb::WatchpointSP watchpoint_sp(GetSP());
104 if (watchpoint_sp) {
105 std::lock_guard<std::recursive_mutex> guard(
106 watchpoint_sp->GetTarget().GetAPIMutex());
107 hw_index = watchpoint_sp->GetHardwareIndex();
108 }
109
110 return hw_index;
111 }
112
GetWatchAddress()113 addr_t SBWatchpoint::GetWatchAddress() {
114 LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
115
116 addr_t ret_addr = LLDB_INVALID_ADDRESS;
117
118 lldb::WatchpointSP watchpoint_sp(GetSP());
119 if (watchpoint_sp) {
120 std::lock_guard<std::recursive_mutex> guard(
121 watchpoint_sp->GetTarget().GetAPIMutex());
122 ret_addr = watchpoint_sp->GetLoadAddress();
123 }
124
125 return ret_addr;
126 }
127
GetWatchSize()128 size_t SBWatchpoint::GetWatchSize() {
129 LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
130
131 size_t watch_size = 0;
132
133 lldb::WatchpointSP watchpoint_sp(GetSP());
134 if (watchpoint_sp) {
135 std::lock_guard<std::recursive_mutex> guard(
136 watchpoint_sp->GetTarget().GetAPIMutex());
137 watch_size = watchpoint_sp->GetByteSize();
138 }
139
140 return watch_size;
141 }
142
SetEnabled(bool enabled)143 void SBWatchpoint::SetEnabled(bool enabled) {
144 LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
145
146 lldb::WatchpointSP watchpoint_sp(GetSP());
147 if (watchpoint_sp) {
148 Target &target = watchpoint_sp->GetTarget();
149 std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
150 ProcessSP process_sp = target.GetProcessSP();
151 const bool notify = true;
152 if (process_sp) {
153 if (enabled)
154 process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
155 else
156 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
157 } else {
158 watchpoint_sp->SetEnabled(enabled, notify);
159 }
160 }
161 }
162
IsEnabled()163 bool SBWatchpoint::IsEnabled() {
164 LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
165
166 lldb::WatchpointSP watchpoint_sp(GetSP());
167 if (watchpoint_sp) {
168 std::lock_guard<std::recursive_mutex> guard(
169 watchpoint_sp->GetTarget().GetAPIMutex());
170 return watchpoint_sp->IsEnabled();
171 } else
172 return false;
173 }
174
GetHitCount()175 uint32_t SBWatchpoint::GetHitCount() {
176 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
177
178 uint32_t count = 0;
179 lldb::WatchpointSP watchpoint_sp(GetSP());
180 if (watchpoint_sp) {
181 std::lock_guard<std::recursive_mutex> guard(
182 watchpoint_sp->GetTarget().GetAPIMutex());
183 count = watchpoint_sp->GetHitCount();
184 }
185
186 return count;
187 }
188
GetIgnoreCount()189 uint32_t SBWatchpoint::GetIgnoreCount() {
190 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
191
192 lldb::WatchpointSP watchpoint_sp(GetSP());
193 if (watchpoint_sp) {
194 std::lock_guard<std::recursive_mutex> guard(
195 watchpoint_sp->GetTarget().GetAPIMutex());
196 return watchpoint_sp->GetIgnoreCount();
197 } else
198 return 0;
199 }
200
SetIgnoreCount(uint32_t n)201 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
202 LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
203
204 lldb::WatchpointSP watchpoint_sp(GetSP());
205 if (watchpoint_sp) {
206 std::lock_guard<std::recursive_mutex> guard(
207 watchpoint_sp->GetTarget().GetAPIMutex());
208 watchpoint_sp->SetIgnoreCount(n);
209 }
210 }
211
GetCondition()212 const char *SBWatchpoint::GetCondition() {
213 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
214
215 lldb::WatchpointSP watchpoint_sp(GetSP());
216 if (watchpoint_sp) {
217 std::lock_guard<std::recursive_mutex> guard(
218 watchpoint_sp->GetTarget().GetAPIMutex());
219 return watchpoint_sp->GetConditionText();
220 }
221 return nullptr;
222 }
223
SetCondition(const char * condition)224 void SBWatchpoint::SetCondition(const char *condition) {
225 LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
226 condition);
227
228 lldb::WatchpointSP watchpoint_sp(GetSP());
229 if (watchpoint_sp) {
230 std::lock_guard<std::recursive_mutex> guard(
231 watchpoint_sp->GetTarget().GetAPIMutex());
232 watchpoint_sp->SetCondition(condition);
233 }
234 }
235
GetDescription(SBStream & description,DescriptionLevel level)236 bool SBWatchpoint::GetDescription(SBStream &description,
237 DescriptionLevel level) {
238 LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
239 (lldb::SBStream &, lldb::DescriptionLevel), description,
240 level);
241
242 Stream &strm = description.ref();
243
244 lldb::WatchpointSP watchpoint_sp(GetSP());
245 if (watchpoint_sp) {
246 std::lock_guard<std::recursive_mutex> guard(
247 watchpoint_sp->GetTarget().GetAPIMutex());
248 watchpoint_sp->GetDescription(&strm, level);
249 strm.EOL();
250 } else
251 strm.PutCString("No value");
252
253 return true;
254 }
255
Clear()256 void SBWatchpoint::Clear() {
257 LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
258
259 m_opaque_wp.reset();
260 }
261
GetSP() const262 lldb::WatchpointSP SBWatchpoint::GetSP() const {
263 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
264
265 return LLDB_RECORD_RESULT(m_opaque_wp.lock());
266 }
267
SetSP(const lldb::WatchpointSP & sp)268 void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
269 LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
270 sp);
271
272 m_opaque_wp = sp;
273 }
274
EventIsWatchpointEvent(const lldb::SBEvent & event)275 bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
276 LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
277 (const lldb::SBEvent &), event);
278
279 return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
280 nullptr;
281 }
282
283 WatchpointEventType
GetWatchpointEventTypeFromEvent(const SBEvent & event)284 SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
285 LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
286 GetWatchpointEventTypeFromEvent,
287 (const lldb::SBEvent &), event);
288
289 if (event.IsValid())
290 return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
291 event.GetSP());
292 return eWatchpointEventTypeInvalidType;
293 }
294
GetWatchpointFromEvent(const lldb::SBEvent & event)295 SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
296 LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
297 GetWatchpointFromEvent, (const lldb::SBEvent &),
298 event);
299
300 SBWatchpoint sb_watchpoint;
301 if (event.IsValid())
302 sb_watchpoint =
303 Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
304 return LLDB_RECORD_RESULT(sb_watchpoint);
305 }
306
307 namespace lldb_private {
308 namespace repro {
309
310 template <>
RegisterMethods(Registry & R)311 void RegisterMethods<SBWatchpoint>(Registry &R) {
312 LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
313 LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
314 LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
315 LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
316 SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
317 LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
318 LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
319 LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
320 LLDB_REGISTER_METHOD_CONST(
321 bool, SBWatchpoint, operator==,(const lldb::SBWatchpoint &));
322 LLDB_REGISTER_METHOD_CONST(
323 bool, SBWatchpoint, operator!=,(const lldb::SBWatchpoint &));
324 LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
325 LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
326 LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
327 LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
328 LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
329 LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
330 LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
331 LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
332 LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
333 LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
334 LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
335 LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
336 (lldb::SBStream &, lldb::DescriptionLevel));
337 LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
338 LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
339 LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
340 (const lldb::WatchpointSP &));
341 LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
342 (const lldb::SBEvent &));
343 LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
344 GetWatchpointEventTypeFromEvent,
345 (const lldb::SBEvent &));
346 LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
347 GetWatchpointFromEvent,
348 (const lldb::SBEvent &));
349 }
350
351 }
352 }
353