1 //===-- SBBreakpointLocation.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/SBBreakpointLocation.h"
11 #include "lldb/API/SBDefines.h"
12 #include "lldb/API/SBAddress.h"
13 #include "lldb/API/SBDebugger.h"
14 #include "lldb/API/SBStream.h"
15 
16 #include "lldb/lldb-types.h"
17 #include "lldb/lldb-defines.h"
18 #include "lldb/Breakpoint/Breakpoint.h"
19 #include "lldb/Breakpoint/BreakpointLocation.h"
20 #include "lldb/Core/Debugger.h"
21 #include "lldb/Core/Log.h"
22 #include "lldb/Core/Stream.h"
23 #include "lldb/Core/StreamFile.h"
24 #include "lldb/Interpreter/CommandInterpreter.h"
25 #include "lldb/Interpreter/ScriptInterpreter.h"
26 #include "lldb/Target/ThreadSpec.h"
27 #include "lldb/Target/Target.h"
28 #include "lldb/Target/ThreadSpec.h"
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 
33 
34 SBBreakpointLocation::SBBreakpointLocation () :
35     m_opaque_sp ()
36 {
37 }
38 
39 SBBreakpointLocation::SBBreakpointLocation (const lldb::BreakpointLocationSP &break_loc_sp) :
40     m_opaque_sp (break_loc_sp)
41 {
42     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
43 
44     if (log)
45     {
46         SBStream sstr;
47         GetDescription (sstr, lldb::eDescriptionLevelBrief);
48         log->Printf ("SBBreakpointLocation::SBBreakpointLocaiton (const lldb::BreakpointLocationsSP &break_loc_sp"
49                      "=%p)  => this.sp = %p (%s)",
50                      static_cast<void*>(break_loc_sp.get()),
51                      static_cast<void*>(m_opaque_sp.get()), sstr.GetData());
52     }
53 }
54 
55 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
56     m_opaque_sp (rhs.m_opaque_sp)
57 {
58 }
59 
60 const SBBreakpointLocation &
61 SBBreakpointLocation::operator = (const SBBreakpointLocation &rhs)
62 {
63     if (this != &rhs)
64         m_opaque_sp = rhs.m_opaque_sp;
65     return *this;
66 }
67 
68 
69 SBBreakpointLocation::~SBBreakpointLocation ()
70 {
71 }
72 
73 bool
74 SBBreakpointLocation::IsValid() const
75 {
76     return m_opaque_sp.get() != NULL;
77 }
78 
79 SBAddress
80 SBBreakpointLocation::GetAddress ()
81 {
82     if (m_opaque_sp)
83         return SBAddress(&m_opaque_sp->GetAddress());
84     else
85         return SBAddress();
86 }
87 
88 addr_t
89 SBBreakpointLocation::GetLoadAddress ()
90 {
91     addr_t ret_addr = LLDB_INVALID_ADDRESS;
92 
93     if (m_opaque_sp)
94     {
95         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
96         ret_addr = m_opaque_sp->GetLoadAddress();
97     }
98 
99     return ret_addr;
100 }
101 
102 void
103 SBBreakpointLocation::SetEnabled (bool enabled)
104 {
105     if (m_opaque_sp)
106     {
107         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
108         m_opaque_sp->SetEnabled (enabled);
109     }
110 }
111 
112 bool
113 SBBreakpointLocation::IsEnabled ()
114 {
115     if (m_opaque_sp)
116     {
117         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
118         return m_opaque_sp->IsEnabled();
119     }
120     else
121         return false;
122 }
123 
124 uint32_t
125 SBBreakpointLocation::GetIgnoreCount ()
126 {
127     if (m_opaque_sp)
128     {
129         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
130         return m_opaque_sp->GetIgnoreCount();
131     }
132     else
133         return 0;
134 }
135 
136 void
137 SBBreakpointLocation::SetIgnoreCount (uint32_t n)
138 {
139     if (m_opaque_sp)
140     {
141         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
142         m_opaque_sp->SetIgnoreCount (n);
143     }
144 }
145 
146 void
147 SBBreakpointLocation::SetCondition (const char *condition)
148 {
149     if (m_opaque_sp)
150     {
151         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
152         m_opaque_sp->SetCondition (condition);
153     }
154 }
155 
156 const char *
157 SBBreakpointLocation::GetCondition ()
158 {
159     if (m_opaque_sp)
160     {
161         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
162         return m_opaque_sp->GetConditionText ();
163     }
164     return NULL;
165 }
166 
167 void
168 SBBreakpointLocation::SetScriptCallbackFunction (const char *callback_function_name)
169 {
170     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
171 
172     if (log)
173         log->Printf ("SBBreakpointLocation(%p)::SetScriptCallbackFunction (callback=%s)",
174                      static_cast<void*>(m_opaque_sp.get()),
175                      callback_function_name);
176 
177     if (m_opaque_sp)
178     {
179         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
180         BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
181         m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallbackFunction (bp_options,
182                                                                                                                                      callback_function_name);
183     }
184 }
185 
186 SBError
187 SBBreakpointLocation::SetScriptCallbackBody (const char *callback_body_text)
188 {
189     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
190 
191     if (log)
192         log->Printf ("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)",
193                      static_cast<void*>(m_opaque_sp.get()), callback_body_text);
194 
195     SBError sb_error;
196     if (m_opaque_sp)
197     {
198         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
199         BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
200         Error error = m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
201                                                                                                                                                            callback_body_text);
202         sb_error.SetError(error);
203     }
204     else
205         sb_error.SetErrorString("invalid breakpoint");
206 
207     return sb_error;
208 }
209 
210 void
211 SBBreakpointLocation::SetThreadID (tid_t thread_id)
212 {
213     if (m_opaque_sp)
214     {
215         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
216         m_opaque_sp->SetThreadID (thread_id);
217     }
218 }
219 
220 tid_t
221 SBBreakpointLocation::GetThreadID ()
222 {
223     tid_t tid = LLDB_INVALID_THREAD_ID;
224     if (m_opaque_sp)
225     {
226         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
227         return m_opaque_sp->GetThreadID();
228     }
229     return tid;
230 }
231 
232 void
233 SBBreakpointLocation::SetThreadIndex (uint32_t index)
234 {
235     if (m_opaque_sp)
236     {
237         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
238         m_opaque_sp->SetThreadIndex (index);
239     }
240 }
241 
242 uint32_t
243 SBBreakpointLocation::GetThreadIndex() const
244 {
245     uint32_t thread_idx = UINT32_MAX;
246     if (m_opaque_sp)
247     {
248         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
249         return m_opaque_sp->GetThreadIndex();
250     }
251     return thread_idx;
252 }
253 
254 
255 void
256 SBBreakpointLocation::SetThreadName (const char *thread_name)
257 {
258     if (m_opaque_sp)
259     {
260         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
261         m_opaque_sp->SetThreadName (thread_name);
262     }
263 }
264 
265 const char *
266 SBBreakpointLocation::GetThreadName () const
267 {
268     if (m_opaque_sp)
269     {
270         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
271         return m_opaque_sp->GetThreadName();
272     }
273     return NULL;
274 }
275 
276 void
277 SBBreakpointLocation::SetQueueName (const char *queue_name)
278 {
279     if (m_opaque_sp)
280     {
281         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
282         m_opaque_sp->SetQueueName (queue_name);
283     }
284 }
285 
286 const char *
287 SBBreakpointLocation::GetQueueName () const
288 {
289     if (m_opaque_sp)
290     {
291         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
292         m_opaque_sp->GetQueueName ();
293     }
294     return NULL;
295 }
296 
297 bool
298 SBBreakpointLocation::IsResolved ()
299 {
300     if (m_opaque_sp)
301     {
302         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
303         return m_opaque_sp->IsResolved();
304     }
305     return false;
306 }
307 
308 void
309 SBBreakpointLocation::SetLocation (const lldb::BreakpointLocationSP &break_loc_sp)
310 {
311     // Uninstall the callbacks?
312     m_opaque_sp = break_loc_sp;
313 }
314 
315 bool
316 SBBreakpointLocation::GetDescription (SBStream &description, DescriptionLevel level)
317 {
318     Stream &strm = description.ref();
319 
320     if (m_opaque_sp)
321     {
322         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
323         m_opaque_sp->GetDescription (&strm, level);
324         strm.EOL();
325     }
326     else
327         strm.PutCString ("No value");
328 
329     return true;
330 }
331 
332 break_id_t
333 SBBreakpointLocation::GetID ()
334 {
335     if (m_opaque_sp)
336     {
337         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
338         return m_opaque_sp->GetID ();
339     }
340     else
341         return LLDB_INVALID_BREAK_ID;
342 }
343 
344 SBBreakpoint
345 SBBreakpointLocation::GetBreakpoint ()
346 {
347     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
348 
349     //if (log)
350     //    log->Printf ("SBBreakpointLocation::GetBreakpoint ()");
351 
352     SBBreakpoint sb_bp;
353     if (m_opaque_sp)
354     {
355         std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
356         *sb_bp = m_opaque_sp->GetBreakpoint ().shared_from_this();
357     }
358 
359     if (log)
360     {
361         SBStream sstr;
362         sb_bp.GetDescription (sstr);
363         log->Printf ("SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s",
364                      static_cast<void*>(m_opaque_sp.get()),
365                      static_cast<void*>(sb_bp.get()), sstr.GetData());
366     }
367     return sb_bp;
368 }
369 
370