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/SBDefines.h"
12 #include "lldb/API/SBAddress.h"
13 #include "lldb/API/SBDebugger.h"
14 #include "lldb/API/SBEvent.h"
15 #include "lldb/API/SBStream.h"
16
17 #include "lldb/lldb-types.h"
18 #include "lldb/lldb-defines.h"
19 #include "lldb/Breakpoint/Watchpoint.h"
20 #include "lldb/Breakpoint/WatchpointList.h"
21 #include "lldb/Core/Log.h"
22 #include "lldb/Core/Stream.h"
23 #include "lldb/Core/StreamFile.h"
24 #include "lldb/Target/Target.h"
25
26 using namespace lldb;
27 using namespace lldb_private;
28
29
SBWatchpoint()30 SBWatchpoint::SBWatchpoint () :
31 m_opaque_sp ()
32 {
33 }
34
SBWatchpoint(const lldb::WatchpointSP & wp_sp)35 SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp) :
36 m_opaque_sp (wp_sp)
37 {
38 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
39
40 if (log)
41 {
42 SBStream sstr;
43 GetDescription (sstr, lldb::eDescriptionLevelBrief);
44 log->Printf ("SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp"
45 "=%p) => this.sp = %p (%s)", wp_sp.get(), m_opaque_sp.get(), sstr.GetData());
46 }
47 }
48
SBWatchpoint(const SBWatchpoint & rhs)49 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) :
50 m_opaque_sp (rhs.m_opaque_sp)
51 {
52 }
53
54 const SBWatchpoint &
operator =(const SBWatchpoint & rhs)55 SBWatchpoint::operator = (const SBWatchpoint &rhs)
56 {
57 if (this != &rhs)
58 m_opaque_sp = rhs.m_opaque_sp;
59 return *this;
60 }
61
62
~SBWatchpoint()63 SBWatchpoint::~SBWatchpoint ()
64 {
65 }
66
67 watch_id_t
GetID()68 SBWatchpoint::GetID ()
69 {
70 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
71
72 watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
73 lldb::WatchpointSP watchpoint_sp(GetSP());
74 if (watchpoint_sp)
75 watch_id = watchpoint_sp->GetID();
76
77 if (log)
78 {
79 if (watch_id == LLDB_INVALID_WATCH_ID)
80 log->Printf ("SBWatchpoint(%p)::GetID () => LLDB_INVALID_WATCH_ID", watchpoint_sp.get());
81 else
82 log->Printf ("SBWatchpoint(%p)::GetID () => %u", watchpoint_sp.get(), watch_id);
83 }
84
85 return watch_id;
86 }
87
88 bool
IsValid() const89 SBWatchpoint::IsValid() const
90 {
91 return (bool) m_opaque_sp;
92 }
93
94 SBError
GetError()95 SBWatchpoint::GetError ()
96 {
97 SBError sb_error;
98 lldb::WatchpointSP watchpoint_sp(GetSP());
99 if (watchpoint_sp)
100 {
101 sb_error.SetError(watchpoint_sp->GetError());
102 }
103 return sb_error;
104 }
105
106 int32_t
GetHardwareIndex()107 SBWatchpoint::GetHardwareIndex ()
108 {
109 int32_t hw_index = -1;
110
111 lldb::WatchpointSP watchpoint_sp(GetSP());
112 if (watchpoint_sp)
113 {
114 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
115 hw_index = watchpoint_sp->GetHardwareIndex();
116 }
117
118 return hw_index;
119 }
120
121 addr_t
GetWatchAddress()122 SBWatchpoint::GetWatchAddress ()
123 {
124 addr_t ret_addr = LLDB_INVALID_ADDRESS;
125
126 lldb::WatchpointSP watchpoint_sp(GetSP());
127 if (watchpoint_sp)
128 {
129 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
130 ret_addr = watchpoint_sp->GetLoadAddress();
131 }
132
133 return ret_addr;
134 }
135
136 size_t
GetWatchSize()137 SBWatchpoint::GetWatchSize ()
138 {
139 size_t watch_size = 0;
140
141 lldb::WatchpointSP watchpoint_sp(GetSP());
142 if (watchpoint_sp)
143 {
144 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
145 watch_size = watchpoint_sp->GetByteSize();
146 }
147
148 return watch_size;
149 }
150
151 void
SetEnabled(bool enabled)152 SBWatchpoint::SetEnabled (bool enabled)
153 {
154 lldb::WatchpointSP watchpoint_sp(GetSP());
155 if (watchpoint_sp)
156 {
157 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
158 watchpoint_sp->GetTarget().DisableWatchpointByID(watchpoint_sp->GetID());
159 }
160 }
161
162 bool
IsEnabled()163 SBWatchpoint::IsEnabled ()
164 {
165 lldb::WatchpointSP watchpoint_sp(GetSP());
166 if (watchpoint_sp)
167 {
168 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
169 return watchpoint_sp->IsEnabled();
170 }
171 else
172 return false;
173 }
174
175 uint32_t
GetHitCount()176 SBWatchpoint::GetHitCount ()
177 {
178 uint32_t count = 0;
179 lldb::WatchpointSP watchpoint_sp(GetSP());
180 if (watchpoint_sp)
181 {
182 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
183 count = watchpoint_sp->GetHitCount();
184 }
185
186 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
187 if (log)
188 log->Printf ("SBWatchpoint(%p)::GetHitCount () => %u", watchpoint_sp.get(), count);
189
190 return count;
191 }
192
193 uint32_t
GetIgnoreCount()194 SBWatchpoint::GetIgnoreCount ()
195 {
196 lldb::WatchpointSP watchpoint_sp(GetSP());
197 if (watchpoint_sp)
198 {
199 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
200 return watchpoint_sp->GetIgnoreCount();
201 }
202 else
203 return 0;
204 }
205
206 void
SetIgnoreCount(uint32_t n)207 SBWatchpoint::SetIgnoreCount (uint32_t n)
208 {
209 lldb::WatchpointSP watchpoint_sp(GetSP());
210 if (watchpoint_sp)
211 {
212 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
213 watchpoint_sp->SetIgnoreCount (n);
214 }
215 }
216
217 const char *
GetCondition()218 SBWatchpoint::GetCondition ()
219 {
220 lldb::WatchpointSP watchpoint_sp(GetSP());
221 if (watchpoint_sp)
222 {
223 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
224 return watchpoint_sp->GetConditionText ();
225 }
226 return NULL;
227 }
228
229 void
SetCondition(const char * condition)230 SBWatchpoint::SetCondition (const char *condition)
231 {
232 lldb::WatchpointSP watchpoint_sp(GetSP());
233 if (watchpoint_sp)
234 {
235 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
236 watchpoint_sp->SetCondition (condition);
237 }
238 }
239
240 bool
GetDescription(SBStream & description,DescriptionLevel level)241 SBWatchpoint::GetDescription (SBStream &description, DescriptionLevel level)
242 {
243 Stream &strm = description.ref();
244
245 lldb::WatchpointSP watchpoint_sp(GetSP());
246 if (watchpoint_sp)
247 {
248 Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
249 watchpoint_sp->GetDescription (&strm, level);
250 strm.EOL();
251 }
252 else
253 strm.PutCString ("No value");
254
255 return true;
256 }
257
258 void
Clear()259 SBWatchpoint::Clear ()
260 {
261 m_opaque_sp.reset();
262 }
263
264 lldb::WatchpointSP
GetSP() const265 SBWatchpoint::GetSP () const
266 {
267 return m_opaque_sp;
268 }
269
270 void
SetSP(const lldb::WatchpointSP & sp)271 SBWatchpoint::SetSP (const lldb::WatchpointSP &sp)
272 {
273 m_opaque_sp = sp;
274 }
275
276 bool
EventIsWatchpointEvent(const lldb::SBEvent & event)277 SBWatchpoint::EventIsWatchpointEvent (const lldb::SBEvent &event)
278 {
279 return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != NULL;
280
281 }
282
283 WatchpointEventType
GetWatchpointEventTypeFromEvent(const SBEvent & event)284 SBWatchpoint::GetWatchpointEventTypeFromEvent (const SBEvent& event)
285 {
286 if (event.IsValid())
287 return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (event.GetSP());
288 return eWatchpointEventTypeInvalidType;
289 }
290
291 SBWatchpoint
GetWatchpointFromEvent(const lldb::SBEvent & event)292 SBWatchpoint::GetWatchpointFromEvent (const lldb::SBEvent& event)
293 {
294 SBWatchpoint sb_watchpoint;
295 if (event.IsValid())
296 sb_watchpoint.m_opaque_sp = Watchpoint::WatchpointEventData::GetWatchpointFromEvent (event.GetSP());
297 return sb_watchpoint;
298 }
299