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)", wp_sp.get(), m_opaque_sp.get(), sstr.GetData());
46     }
47 }
48 
49 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) :
50     m_opaque_sp (rhs.m_opaque_sp)
51 {
52 }
53 
54 const SBWatchpoint &
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 
63 SBWatchpoint::~SBWatchpoint ()
64 {
65 }
66 
67 watch_id_t
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
89 SBWatchpoint::IsValid() const
90 {
91     return (bool) m_opaque_sp;
92 }
93 
94 SBError
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
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
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
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
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
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
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
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
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 *
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
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
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
259 SBWatchpoint::Clear ()
260 {
261     m_opaque_sp.reset();
262 }
263 
264 lldb::WatchpointSP
265 SBWatchpoint::GetSP () const
266 {
267     return m_opaque_sp;
268 }
269 
270 void
271 SBWatchpoint::SetSP (const lldb::WatchpointSP &sp)
272 {
273     m_opaque_sp = sp;
274 }
275 
276 bool
277 SBWatchpoint::EventIsWatchpointEvent (const lldb::SBEvent &event)
278 {
279     return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != NULL;
280 
281 }
282 
283 WatchpointEventType
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
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