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 
30 SBWatchpoint::SBWatchpoint () :
31     m_opaque_sp ()
32 {
33 }
34 
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 
51 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) :
52     m_opaque_sp (rhs.m_opaque_sp)
53 {
54 }
55 
56 const SBWatchpoint &
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 
65 SBWatchpoint::~SBWatchpoint ()
66 {
67 }
68 
69 watch_id_t
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
93 SBWatchpoint::IsValid() const
94 {
95     return (bool) m_opaque_sp;
96 }
97 
98 SBError
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
111 SBWatchpoint::GetHardwareIndex ()
112 {
113     int32_t hw_index = -1;
114 
115     lldb::WatchpointSP watchpoint_sp(GetSP());
116     if (watchpoint_sp)
117     {
118         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
119         hw_index = watchpoint_sp->GetHardwareIndex();
120     }
121 
122     return hw_index;
123 }
124 
125 addr_t
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         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
134         ret_addr = watchpoint_sp->GetLoadAddress();
135     }
136 
137     return ret_addr;
138 }
139 
140 size_t
141 SBWatchpoint::GetWatchSize ()
142 {
143     size_t watch_size = 0;
144 
145     lldb::WatchpointSP watchpoint_sp(GetSP());
146     if (watchpoint_sp)
147     {
148         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
149         watch_size = watchpoint_sp->GetByteSize();
150     }
151 
152     return watch_size;
153 }
154 
155 void
156 SBWatchpoint::SetEnabled (bool enabled)
157 {
158     lldb::WatchpointSP watchpoint_sp(GetSP());
159     if (watchpoint_sp)
160     {
161         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
162         watchpoint_sp->GetTarget().DisableWatchpointByID(watchpoint_sp->GetID());
163     }
164 }
165 
166 bool
167 SBWatchpoint::IsEnabled ()
168 {
169     lldb::WatchpointSP watchpoint_sp(GetSP());
170     if (watchpoint_sp)
171     {
172         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
173         return watchpoint_sp->IsEnabled();
174     }
175     else
176         return false;
177 }
178 
179 uint32_t
180 SBWatchpoint::GetHitCount ()
181 {
182     uint32_t count = 0;
183     lldb::WatchpointSP watchpoint_sp(GetSP());
184     if (watchpoint_sp)
185     {
186         std::lock_guard<std::recursive_mutex> guard(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
199 SBWatchpoint::GetIgnoreCount ()
200 {
201     lldb::WatchpointSP watchpoint_sp(GetSP());
202     if (watchpoint_sp)
203     {
204         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
205         return watchpoint_sp->GetIgnoreCount();
206     }
207     else
208         return 0;
209 }
210 
211 void
212 SBWatchpoint::SetIgnoreCount (uint32_t n)
213 {
214     lldb::WatchpointSP watchpoint_sp(GetSP());
215     if (watchpoint_sp)
216     {
217         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
218         watchpoint_sp->SetIgnoreCount (n);
219     }
220 }
221 
222 const char *
223 SBWatchpoint::GetCondition ()
224 {
225     lldb::WatchpointSP watchpoint_sp(GetSP());
226     if (watchpoint_sp)
227     {
228         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
229         return watchpoint_sp->GetConditionText ();
230     }
231     return NULL;
232 }
233 
234 void
235 SBWatchpoint::SetCondition (const char *condition)
236 {
237     lldb::WatchpointSP watchpoint_sp(GetSP());
238     if (watchpoint_sp)
239     {
240         std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
241         watchpoint_sp->SetCondition (condition);
242     }
243 }
244 
245 bool
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         std::lock_guard<std::recursive_mutex> guard(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
264 SBWatchpoint::Clear ()
265 {
266     m_opaque_sp.reset();
267 }
268 
269 lldb::WatchpointSP
270 SBWatchpoint::GetSP () const
271 {
272     return m_opaque_sp;
273 }
274 
275 void
276 SBWatchpoint::SetSP (const lldb::WatchpointSP &sp)
277 {
278     m_opaque_sp = sp;
279 }
280 
281 bool
282 SBWatchpoint::EventIsWatchpointEvent (const lldb::SBEvent &event)
283 {
284     return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != NULL;
285 
286 }
287 
288 WatchpointEventType
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
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