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