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
SBBreakpointLocation()34 SBBreakpointLocation::SBBreakpointLocation () :
35 m_opaque_sp ()
36 {
37 }
38
SBBreakpointLocation(const lldb::BreakpointLocationSP & break_loc_sp)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
SBBreakpointLocation(const SBBreakpointLocation & rhs)55 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
56 m_opaque_sp (rhs.m_opaque_sp)
57 {
58 }
59
60 const SBBreakpointLocation &
operator =(const SBBreakpointLocation & rhs)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
~SBBreakpointLocation()69 SBBreakpointLocation::~SBBreakpointLocation ()
70 {
71 }
72
73 bool
IsValid() const74 SBBreakpointLocation::IsValid() const
75 {
76 return m_opaque_sp.get() != NULL;
77 }
78
79 SBAddress
GetAddress()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
GetLoadAddress()89 SBBreakpointLocation::GetLoadAddress ()
90 {
91 addr_t ret_addr = LLDB_INVALID_ADDRESS;
92
93 if (m_opaque_sp)
94 {
95 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
96 ret_addr = m_opaque_sp->GetLoadAddress();
97 }
98
99 return ret_addr;
100 }
101
102 void
SetEnabled(bool enabled)103 SBBreakpointLocation::SetEnabled (bool enabled)
104 {
105 if (m_opaque_sp)
106 {
107 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
108 m_opaque_sp->SetEnabled (enabled);
109 }
110 }
111
112 bool
IsEnabled()113 SBBreakpointLocation::IsEnabled ()
114 {
115 if (m_opaque_sp)
116 {
117 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
118 return m_opaque_sp->IsEnabled();
119 }
120 else
121 return false;
122 }
123
124 uint32_t
GetIgnoreCount()125 SBBreakpointLocation::GetIgnoreCount ()
126 {
127 if (m_opaque_sp)
128 {
129 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
130 return m_opaque_sp->GetIgnoreCount();
131 }
132 else
133 return 0;
134 }
135
136 void
SetIgnoreCount(uint32_t n)137 SBBreakpointLocation::SetIgnoreCount (uint32_t n)
138 {
139 if (m_opaque_sp)
140 {
141 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
142 m_opaque_sp->SetIgnoreCount (n);
143 }
144 }
145
146 void
SetCondition(const char * condition)147 SBBreakpointLocation::SetCondition (const char *condition)
148 {
149 if (m_opaque_sp)
150 {
151 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
152 m_opaque_sp->SetCondition (condition);
153 }
154 }
155
156 const char *
GetCondition()157 SBBreakpointLocation::GetCondition ()
158 {
159 if (m_opaque_sp)
160 {
161 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
162 return m_opaque_sp->GetConditionText ();
163 }
164 return NULL;
165 }
166
167 void
SetScriptCallbackFunction(const char * callback_function_name)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 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().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
SetScriptCallbackBody(const char * callback_body_text)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 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().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
SetThreadID(tid_t thread_id)211 SBBreakpointLocation::SetThreadID (tid_t thread_id)
212 {
213 if (m_opaque_sp)
214 {
215 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
216 m_opaque_sp->SetThreadID (thread_id);
217 }
218 }
219
220 tid_t
GetThreadID()221 SBBreakpointLocation::GetThreadID ()
222 {
223 tid_t tid = LLDB_INVALID_THREAD_ID;
224 if (m_opaque_sp)
225 {
226 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
227 return m_opaque_sp->GetThreadID();
228 }
229 return tid;
230 }
231
232 void
SetThreadIndex(uint32_t index)233 SBBreakpointLocation::SetThreadIndex (uint32_t index)
234 {
235 if (m_opaque_sp)
236 {
237 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
238 m_opaque_sp->SetThreadIndex (index);
239 }
240 }
241
242 uint32_t
GetThreadIndex() const243 SBBreakpointLocation::GetThreadIndex() const
244 {
245 uint32_t thread_idx = UINT32_MAX;
246 if (m_opaque_sp)
247 {
248 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
249 return m_opaque_sp->GetThreadIndex();
250 }
251 return thread_idx;
252 }
253
254
255 void
SetThreadName(const char * thread_name)256 SBBreakpointLocation::SetThreadName (const char *thread_name)
257 {
258 if (m_opaque_sp)
259 {
260 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
261 m_opaque_sp->SetThreadName (thread_name);
262 }
263 }
264
265 const char *
GetThreadName() const266 SBBreakpointLocation::GetThreadName () const
267 {
268 if (m_opaque_sp)
269 {
270 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
271 return m_opaque_sp->GetThreadName();
272 }
273 return NULL;
274 }
275
276 void
SetQueueName(const char * queue_name)277 SBBreakpointLocation::SetQueueName (const char *queue_name)
278 {
279 if (m_opaque_sp)
280 {
281 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
282 m_opaque_sp->SetQueueName (queue_name);
283 }
284 }
285
286 const char *
GetQueueName() const287 SBBreakpointLocation::GetQueueName () const
288 {
289 if (m_opaque_sp)
290 {
291 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
292 m_opaque_sp->GetQueueName ();
293 }
294 return NULL;
295 }
296
297 bool
IsResolved()298 SBBreakpointLocation::IsResolved ()
299 {
300 if (m_opaque_sp)
301 {
302 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
303 return m_opaque_sp->IsResolved();
304 }
305 return false;
306 }
307
308 void
SetLocation(const lldb::BreakpointLocationSP & break_loc_sp)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
GetDescription(SBStream & description,DescriptionLevel level)316 SBBreakpointLocation::GetDescription (SBStream &description, DescriptionLevel level)
317 {
318 Stream &strm = description.ref();
319
320 if (m_opaque_sp)
321 {
322 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().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
GetID()333 SBBreakpointLocation::GetID ()
334 {
335 if (m_opaque_sp)
336 {
337 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
338 return m_opaque_sp->GetID ();
339 }
340 else
341 return LLDB_INVALID_BREAK_ID;
342 }
343
344 SBBreakpoint
GetBreakpoint()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 Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().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