1 //===-- SBWatchpoint.cpp --------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/API/SBWatchpoint.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/Log.h"
23 #include "lldb/Utility/Stream.h"
24 #include "lldb/lldb-defines.h"
25 #include "lldb/lldb-types.h"
26
27 using namespace lldb;
28 using namespace lldb_private;
29
SBWatchpoint()30 SBWatchpoint::SBWatchpoint() {}
31
SBWatchpoint(const lldb::WatchpointSP & wp_sp)32 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
33 : m_opaque_wp(wp_sp) {
34 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
35
36 if (log) {
37 SBStream sstr;
38 GetDescription(sstr, lldb::eDescriptionLevelBrief);
39 LLDB_LOG(log, "watchpoint = {0} ({1})", wp_sp.get(), sstr.GetData());
40 }
41 }
42
SBWatchpoint(const SBWatchpoint & rhs)43 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
44 : m_opaque_wp(rhs.m_opaque_wp) {}
45
operator =(const SBWatchpoint & rhs)46 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
47 m_opaque_wp = rhs.m_opaque_wp;
48 return *this;
49 }
50
~SBWatchpoint()51 SBWatchpoint::~SBWatchpoint() {}
52
GetID()53 watch_id_t SBWatchpoint::GetID() {
54 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
55
56 watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
57 lldb::WatchpointSP watchpoint_sp(GetSP());
58 if (watchpoint_sp)
59 watch_id = watchpoint_sp->GetID();
60
61 if (log) {
62 if (watch_id == LLDB_INVALID_WATCH_ID)
63 log->Printf("SBWatchpoint(%p)::GetID () => LLDB_INVALID_WATCH_ID",
64 static_cast<void *>(watchpoint_sp.get()));
65 else
66 log->Printf("SBWatchpoint(%p)::GetID () => %u",
67 static_cast<void *>(watchpoint_sp.get()), watch_id);
68 }
69
70 return watch_id;
71 }
72
IsValid() const73 bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); }
74
GetError()75 SBError SBWatchpoint::GetError() {
76 SBError sb_error;
77 lldb::WatchpointSP watchpoint_sp(GetSP());
78 if (watchpoint_sp) {
79 sb_error.SetError(watchpoint_sp->GetError());
80 }
81 return sb_error;
82 }
83
GetHardwareIndex()84 int32_t SBWatchpoint::GetHardwareIndex() {
85 int32_t hw_index = -1;
86
87 lldb::WatchpointSP watchpoint_sp(GetSP());
88 if (watchpoint_sp) {
89 std::lock_guard<std::recursive_mutex> guard(
90 watchpoint_sp->GetTarget().GetAPIMutex());
91 hw_index = watchpoint_sp->GetHardwareIndex();
92 }
93
94 return hw_index;
95 }
96
GetWatchAddress()97 addr_t SBWatchpoint::GetWatchAddress() {
98 addr_t ret_addr = LLDB_INVALID_ADDRESS;
99
100 lldb::WatchpointSP watchpoint_sp(GetSP());
101 if (watchpoint_sp) {
102 std::lock_guard<std::recursive_mutex> guard(
103 watchpoint_sp->GetTarget().GetAPIMutex());
104 ret_addr = watchpoint_sp->GetLoadAddress();
105 }
106
107 return ret_addr;
108 }
109
GetWatchSize()110 size_t SBWatchpoint::GetWatchSize() {
111 size_t watch_size = 0;
112
113 lldb::WatchpointSP watchpoint_sp(GetSP());
114 if (watchpoint_sp) {
115 std::lock_guard<std::recursive_mutex> guard(
116 watchpoint_sp->GetTarget().GetAPIMutex());
117 watch_size = watchpoint_sp->GetByteSize();
118 }
119
120 return watch_size;
121 }
122
SetEnabled(bool enabled)123 void SBWatchpoint::SetEnabled(bool enabled) {
124 lldb::WatchpointSP watchpoint_sp(GetSP());
125 if (watchpoint_sp) {
126 Target &target = watchpoint_sp->GetTarget();
127 std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
128 ProcessSP process_sp = target.GetProcessSP();
129 const bool notify = true;
130 if (process_sp) {
131 if (enabled)
132 process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
133 else
134 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
135 } else {
136 watchpoint_sp->SetEnabled(enabled, notify);
137 }
138 }
139 }
140
IsEnabled()141 bool SBWatchpoint::IsEnabled() {
142 lldb::WatchpointSP watchpoint_sp(GetSP());
143 if (watchpoint_sp) {
144 std::lock_guard<std::recursive_mutex> guard(
145 watchpoint_sp->GetTarget().GetAPIMutex());
146 return watchpoint_sp->IsEnabled();
147 } else
148 return false;
149 }
150
GetHitCount()151 uint32_t SBWatchpoint::GetHitCount() {
152 uint32_t count = 0;
153 lldb::WatchpointSP watchpoint_sp(GetSP());
154 if (watchpoint_sp) {
155 std::lock_guard<std::recursive_mutex> guard(
156 watchpoint_sp->GetTarget().GetAPIMutex());
157 count = watchpoint_sp->GetHitCount();
158 }
159
160 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
161 if (log)
162 log->Printf("SBWatchpoint(%p)::GetHitCount () => %u",
163 static_cast<void *>(watchpoint_sp.get()), count);
164
165 return count;
166 }
167
GetIgnoreCount()168 uint32_t SBWatchpoint::GetIgnoreCount() {
169 lldb::WatchpointSP watchpoint_sp(GetSP());
170 if (watchpoint_sp) {
171 std::lock_guard<std::recursive_mutex> guard(
172 watchpoint_sp->GetTarget().GetAPIMutex());
173 return watchpoint_sp->GetIgnoreCount();
174 } else
175 return 0;
176 }
177
SetIgnoreCount(uint32_t n)178 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
179 lldb::WatchpointSP watchpoint_sp(GetSP());
180 if (watchpoint_sp) {
181 std::lock_guard<std::recursive_mutex> guard(
182 watchpoint_sp->GetTarget().GetAPIMutex());
183 watchpoint_sp->SetIgnoreCount(n);
184 }
185 }
186
GetCondition()187 const char *SBWatchpoint::GetCondition() {
188 lldb::WatchpointSP watchpoint_sp(GetSP());
189 if (watchpoint_sp) {
190 std::lock_guard<std::recursive_mutex> guard(
191 watchpoint_sp->GetTarget().GetAPIMutex());
192 return watchpoint_sp->GetConditionText();
193 }
194 return NULL;
195 }
196
SetCondition(const char * condition)197 void SBWatchpoint::SetCondition(const char *condition) {
198 lldb::WatchpointSP watchpoint_sp(GetSP());
199 if (watchpoint_sp) {
200 std::lock_guard<std::recursive_mutex> guard(
201 watchpoint_sp->GetTarget().GetAPIMutex());
202 watchpoint_sp->SetCondition(condition);
203 }
204 }
205
GetDescription(SBStream & description,DescriptionLevel level)206 bool SBWatchpoint::GetDescription(SBStream &description,
207 DescriptionLevel level) {
208 Stream &strm = description.ref();
209
210 lldb::WatchpointSP watchpoint_sp(GetSP());
211 if (watchpoint_sp) {
212 std::lock_guard<std::recursive_mutex> guard(
213 watchpoint_sp->GetTarget().GetAPIMutex());
214 watchpoint_sp->GetDescription(&strm, level);
215 strm.EOL();
216 } else
217 strm.PutCString("No value");
218
219 return true;
220 }
221
Clear()222 void SBWatchpoint::Clear() { m_opaque_wp.reset(); }
223
GetSP() const224 lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); }
225
SetSP(const lldb::WatchpointSP & sp)226 void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; }
227
EventIsWatchpointEvent(const lldb::SBEvent & event)228 bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
229 return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
230 NULL;
231 }
232
233 WatchpointEventType
GetWatchpointEventTypeFromEvent(const SBEvent & event)234 SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
235 if (event.IsValid())
236 return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
237 event.GetSP());
238 return eWatchpointEventTypeInvalidType;
239 }
240
GetWatchpointFromEvent(const lldb::SBEvent & event)241 SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
242 SBWatchpoint sb_watchpoint;
243 if (event.IsValid())
244 sb_watchpoint =
245 Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
246 return sb_watchpoint;
247 }
248