clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SBThread.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/API -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/API -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API/SBThread.cpp -faddrsig
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | #include "lldb/API/SBThread.h" |
11 | |
12 | #include "lldb/API/SBFileSpec.h" |
13 | #include "lldb/API/SBStream.h" |
14 | #include "lldb/API/SBSymbolContext.h" |
15 | #include "lldb/Breakpoint/BreakpointLocation.h" |
16 | #include "lldb/Core/Debugger.h" |
17 | #include "lldb/Core/StreamFile.h" |
18 | #include "lldb/Core/ValueObject.h" |
19 | #include "lldb/Interpreter/CommandInterpreter.h" |
20 | #include "lldb/Symbol/CompileUnit.h" |
21 | #include "lldb/Symbol/SymbolContext.h" |
22 | #include "lldb/Target/Process.h" |
23 | #include "lldb/Target/Queue.h" |
24 | #include "lldb/Target/StopInfo.h" |
25 | #include "lldb/Target/SystemRuntime.h" |
26 | #include "lldb/Target/Target.h" |
27 | #include "lldb/Target/Thread.h" |
28 | #include "lldb/Target/ThreadPlan.h" |
29 | #include "lldb/Target/ThreadPlanStepInRange.h" |
30 | #include "lldb/Target/ThreadPlanStepInstruction.h" |
31 | #include "lldb/Target/ThreadPlanStepOut.h" |
32 | #include "lldb/Target/ThreadPlanStepRange.h" |
33 | #include "lldb/Target/UnixSignals.h" |
34 | #include "lldb/Utility/State.h" |
35 | #include "lldb/Utility/Stream.h" |
36 | #include "lldb/Utility/StructuredData.h" |
37 | |
38 | #include "lldb/API/SBAddress.h" |
39 | #include "lldb/API/SBDebugger.h" |
40 | #include "lldb/API/SBEvent.h" |
41 | #include "lldb/API/SBFrame.h" |
42 | #include "lldb/API/SBProcess.h" |
43 | #include "lldb/API/SBThreadCollection.h" |
44 | #include "lldb/API/SBThreadPlan.h" |
45 | #include "lldb/API/SBValue.h" |
46 | #include "lldb/lldb-enumerations.h" |
47 | |
48 | using namespace lldb; |
49 | using namespace lldb_private; |
50 | |
51 | const char *SBThread::GetBroadcasterClassName() { |
52 | return Thread::GetStaticBroadcasterClass().AsCString(); |
53 | } |
54 | |
55 | |
56 | |
57 | |
58 | SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {} |
59 | |
60 | SBThread::SBThread(const ThreadSP &lldb_object_sp) |
61 | : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {} |
62 | |
63 | SBThread::SBThread(const SBThread &rhs) |
64 | : m_opaque_sp(new ExecutionContextRef(*rhs.m_opaque_sp)) {} |
65 | |
66 | |
67 | |
68 | |
69 | |
70 | const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { |
71 | if (this != &rhs) |
72 | *m_opaque_sp = *rhs.m_opaque_sp; |
73 | return *this; |
74 | } |
75 | |
76 | |
77 | |
78 | |
79 | SBThread::~SBThread() {} |
80 | |
81 | lldb::SBQueue SBThread::GetQueue() const { |
82 | SBQueue sb_queue; |
83 | QueueSP queue_sp; |
84 | std::unique_lock<std::recursive_mutex> lock; |
85 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
86 | |
87 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
88 | if (exe_ctx.HasThreadScope()) { |
89 | Process::StopLocker stop_locker; |
90 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
91 | queue_sp = exe_ctx.GetThreadPtr()->GetQueue(); |
92 | if (queue_sp) { |
93 | sb_queue.SetQueue(queue_sp); |
94 | } |
95 | } else { |
96 | if (log) |
97 | log->Printf("SBThread(%p)::GetQueue() => error: process is running", |
98 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
99 | } |
100 | } |
101 | |
102 | if (log) |
103 | log->Printf("SBThread(%p)::GetQueue () => SBQueue(%p)", |
104 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
105 | static_cast<void *>(queue_sp.get())); |
106 | |
107 | return sb_queue; |
108 | } |
109 | |
110 | bool SBThread::IsValid() const { |
111 | std::unique_lock<std::recursive_mutex> lock; |
112 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
113 | |
114 | Target *target = exe_ctx.GetTargetPtr(); |
115 | Process *process = exe_ctx.GetProcessPtr(); |
116 | if (target && process) { |
117 | Process::StopLocker stop_locker; |
118 | if (stop_locker.TryLock(&process->GetRunLock())) |
119 | return m_opaque_sp->GetThreadSP().get() != NULL__null; |
120 | } |
121 | |
122 | return false; |
123 | } |
124 | |
125 | void SBThread::Clear() { m_opaque_sp->Clear(); } |
126 | |
127 | StopReason SBThread::GetStopReason() { |
128 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
129 | |
130 | StopReason reason = eStopReasonInvalid; |
131 | std::unique_lock<std::recursive_mutex> lock; |
132 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
133 | |
134 | if (exe_ctx.HasThreadScope()) { |
135 | Process::StopLocker stop_locker; |
136 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
137 | return exe_ctx.GetThreadPtr()->GetStopReason(); |
138 | } else { |
139 | if (log) |
140 | log->Printf( |
141 | "SBThread(%p)::GetStopReason() => error: process is running", |
142 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
143 | } |
144 | } |
145 | |
146 | if (log) |
147 | log->Printf("SBThread(%p)::GetStopReason () => %s", |
148 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
149 | Thread::StopReasonAsCString(reason)); |
150 | |
151 | return reason; |
152 | } |
153 | |
154 | size_t SBThread::GetStopReasonDataCount() { |
155 | std::unique_lock<std::recursive_mutex> lock; |
156 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
157 | |
158 | if (exe_ctx.HasThreadScope()) { |
159 | Process::StopLocker stop_locker; |
160 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
161 | StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); |
162 | if (stop_info_sp) { |
163 | StopReason reason = stop_info_sp->GetStopReason(); |
164 | switch (reason) { |
165 | case eStopReasonInvalid: |
166 | case eStopReasonNone: |
167 | case eStopReasonTrace: |
168 | case eStopReasonExec: |
169 | case eStopReasonPlanComplete: |
170 | case eStopReasonThreadExiting: |
171 | case eStopReasonInstrumentation: |
172 | |
173 | return 0; |
174 | |
175 | case eStopReasonBreakpoint: { |
176 | break_id_t site_id = stop_info_sp->GetValue(); |
177 | lldb::BreakpointSiteSP bp_site_sp( |
178 | exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( |
179 | site_id)); |
180 | if (bp_site_sp) |
181 | return bp_site_sp->GetNumberOfOwners() * 2; |
182 | else |
183 | return 0; |
184 | } break; |
185 | |
186 | case eStopReasonWatchpoint: |
187 | return 1; |
188 | |
189 | case eStopReasonSignal: |
190 | return 1; |
191 | |
192 | case eStopReasonException: |
193 | return 1; |
194 | } |
195 | } |
196 | } else { |
197 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
198 | if (log) |
199 | log->Printf("SBThread(%p)::GetStopReasonDataCount() => error: process " |
200 | "is running", |
201 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
202 | } |
203 | } |
204 | return 0; |
205 | } |
206 | |
207 | uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { |
208 | std::unique_lock<std::recursive_mutex> lock; |
209 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
210 | |
211 | if (exe_ctx.HasThreadScope()) { |
212 | Process::StopLocker stop_locker; |
213 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
214 | Thread *thread = exe_ctx.GetThreadPtr(); |
215 | StopInfoSP stop_info_sp = thread->GetStopInfo(); |
216 | if (stop_info_sp) { |
217 | StopReason reason = stop_info_sp->GetStopReason(); |
218 | switch (reason) { |
219 | case eStopReasonInvalid: |
220 | case eStopReasonNone: |
221 | case eStopReasonTrace: |
222 | case eStopReasonExec: |
223 | case eStopReasonPlanComplete: |
224 | case eStopReasonThreadExiting: |
225 | case eStopReasonInstrumentation: |
226 | |
227 | return 0; |
228 | |
229 | case eStopReasonBreakpoint: { |
230 | break_id_t site_id = stop_info_sp->GetValue(); |
231 | lldb::BreakpointSiteSP bp_site_sp( |
232 | exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( |
233 | site_id)); |
234 | if (bp_site_sp) { |
235 | uint32_t bp_index = idx / 2; |
236 | BreakpointLocationSP bp_loc_sp( |
237 | bp_site_sp->GetOwnerAtIndex(bp_index)); |
238 | if (bp_loc_sp) { |
239 | if (idx & 1) { |
240 | |
241 | return bp_loc_sp->GetID(); |
242 | } else { |
243 | |
244 | return bp_loc_sp->GetBreakpoint().GetID(); |
245 | } |
246 | } |
247 | } |
248 | return LLDB_INVALID_BREAK_ID0; |
249 | } break; |
250 | |
251 | case eStopReasonWatchpoint: |
252 | return stop_info_sp->GetValue(); |
253 | |
254 | case eStopReasonSignal: |
255 | return stop_info_sp->GetValue(); |
256 | |
257 | case eStopReasonException: |
258 | return stop_info_sp->GetValue(); |
259 | } |
260 | } |
261 | } else { |
262 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
263 | if (log) |
264 | log->Printf("SBThread(%p)::GetStopReasonDataAtIndex() => error: " |
265 | "process is running", |
266 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
267 | } |
268 | } |
269 | return 0; |
270 | } |
271 | |
272 | bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { |
273 | Stream &strm = stream.ref(); |
274 | |
275 | std::unique_lock<std::recursive_mutex> lock; |
276 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
277 | |
278 | if (!exe_ctx.HasThreadScope()) |
279 | return false; |
280 | |
281 | StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); |
282 | StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); |
283 | if (!info) |
284 | return false; |
285 | |
286 | info->Dump(strm); |
287 | |
288 | return true; |
289 | } |
290 | |
291 | SBThreadCollection |
292 | SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { |
293 | ThreadCollectionSP threads; |
294 | threads.reset(new ThreadCollection()); |
295 | |
296 | std::unique_lock<std::recursive_mutex> lock; |
297 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
298 | |
299 | if (!exe_ctx.HasThreadScope()) |
300 | return threads; |
301 | |
302 | ProcessSP process_sp = exe_ctx.GetProcessSP(); |
303 | |
304 | StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); |
305 | StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); |
306 | if (!info) |
307 | return threads; |
308 | |
309 | return process_sp->GetInstrumentationRuntime(type) |
310 | ->GetBacktracesFromExtendedStopInfo(info); |
311 | } |
312 | |
313 | size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { |
314 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
315 | |
316 | std::unique_lock<std::recursive_mutex> lock; |
317 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
318 | |
319 | if (exe_ctx.HasThreadScope()) { |
320 | Process::StopLocker stop_locker; |
321 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
322 | |
323 | StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); |
324 | if (stop_info_sp) { |
325 | const char *stop_desc = stop_info_sp->GetDescription(); |
326 | if (stop_desc) { |
327 | if (log) |
328 | log->Printf( |
329 | "SBThread(%p)::GetStopDescription (dst, dst_len) => \"%s\"", |
330 | static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc); |
331 | if (dst) |
332 | return ::snprintf(dst, dst_len, "%s", stop_desc); |
333 | else { |
334 | |
335 | |
336 | return ::strlen(stop_desc) + 1; |
337 | } |
338 | } else { |
339 | size_t stop_desc_len = 0; |
340 | switch (stop_info_sp->GetStopReason()) { |
341 | case eStopReasonTrace: |
342 | case eStopReasonPlanComplete: { |
343 | static char trace_desc[] = "step"; |
344 | stop_desc = trace_desc; |
345 | stop_desc_len = |
346 | sizeof(trace_desc); |
347 | } break; |
348 | |
349 | case eStopReasonBreakpoint: { |
350 | static char bp_desc[] = "breakpoint hit"; |
351 | stop_desc = bp_desc; |
352 | stop_desc_len = sizeof(bp_desc); |
353 | } break; |
354 | |
355 | case eStopReasonWatchpoint: { |
356 | static char wp_desc[] = "watchpoint hit"; |
357 | stop_desc = wp_desc; |
358 | stop_desc_len = sizeof(wp_desc); |
359 | } break; |
360 | |
361 | case eStopReasonSignal: { |
362 | stop_desc = |
363 | exe_ctx.GetProcessPtr()->GetUnixSignals()->GetSignalAsCString( |
364 | stop_info_sp->GetValue()); |
365 | if (stop_desc == NULL__null || stop_desc[0] == '\0') { |
366 | static char signal_desc[] = "signal"; |
367 | stop_desc = signal_desc; |
368 | stop_desc_len = |
369 | sizeof(signal_desc); |
370 | } |
371 | } break; |
372 | |
373 | case eStopReasonException: { |
374 | char exc_desc[] = "exception"; |
375 | stop_desc = exc_desc; |
376 | stop_desc_len = sizeof(exc_desc); |
377 | } break; |
378 | |
379 | case eStopReasonExec: { |
380 | char exc_desc[] = "exec"; |
381 | stop_desc = exc_desc; |
382 | stop_desc_len = sizeof(exc_desc); |
383 | } break; |
384 | |
385 | case eStopReasonThreadExiting: { |
386 | char limbo_desc[] = "thread exiting"; |
387 | stop_desc = limbo_desc; |
388 | stop_desc_len = sizeof(limbo_desc); |
389 | } break; |
390 | default: |
391 | break; |
392 | } |
393 | |
394 | if (stop_desc && stop_desc[0]) { |
395 | if (log) |
396 | log->Printf( |
397 | "SBThread(%p)::GetStopDescription (dst, dst_len) => '%s'", |
398 | static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc); |
399 | |
400 | if (dst) |
401 | return ::snprintf(dst, dst_len, "%s", stop_desc) + |
402 | 1; |
403 | |
404 | if (stop_desc_len == 0) |
405 | stop_desc_len = ::strlen(stop_desc) + 1; |
406 | |
407 | return stop_desc_len; |
408 | } |
409 | } |
410 | } |
411 | } else { |
412 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
413 | if (log) |
414 | log->Printf( |
415 | "SBThread(%p)::GetStopDescription() => error: process is running", |
416 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
417 | } |
418 | } |
419 | if (dst) |
420 | *dst = 0; |
421 | return 0; |
422 | } |
423 | |
424 | SBValue SBThread::GetStopReturnValue() { |
425 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
426 | ValueObjectSP return_valobj_sp; |
427 | std::unique_lock<std::recursive_mutex> lock; |
428 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
429 | |
430 | if (exe_ctx.HasThreadScope()) { |
431 | Process::StopLocker stop_locker; |
432 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
433 | StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); |
434 | if (stop_info_sp) { |
435 | return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp); |
436 | } |
437 | } else { |
438 | if (log) |
439 | log->Printf( |
440 | "SBThread(%p)::GetStopReturnValue() => error: process is running", |
441 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
442 | } |
443 | } |
444 | |
445 | if (log) |
446 | log->Printf("SBThread(%p)::GetStopReturnValue () => %s", |
447 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
448 | return_valobj_sp.get() ? return_valobj_sp->GetValueAsCString() |
449 | : "<no return value>"); |
450 | |
451 | return SBValue(return_valobj_sp); |
452 | } |
453 | |
454 | void SBThread::SetThread(const ThreadSP &lldb_object_sp) { |
455 | m_opaque_sp->SetThreadSP(lldb_object_sp); |
456 | } |
457 | |
458 | lldb::tid_t SBThread::GetThreadID() const { |
459 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
460 | if (thread_sp) |
461 | return thread_sp->GetID(); |
462 | return LLDB_INVALID_THREAD_ID0; |
463 | } |
464 | |
465 | uint32_t SBThread::GetIndexID() const { |
466 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
467 | if (thread_sp) |
468 | return thread_sp->GetIndexID(); |
469 | return LLDB_INVALID_INDEX32(4294967295U); |
470 | } |
471 | |
472 | const char *SBThread::GetName() const { |
473 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
474 | const char *name = NULL__null; |
475 | std::unique_lock<std::recursive_mutex> lock; |
476 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
477 | |
478 | if (exe_ctx.HasThreadScope()) { |
479 | Process::StopLocker stop_locker; |
480 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
481 | name = exe_ctx.GetThreadPtr()->GetName(); |
482 | } else { |
483 | if (log) |
484 | log->Printf("SBThread(%p)::GetName() => error: process is running", |
485 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
486 | } |
487 | } |
488 | |
489 | if (log) |
490 | log->Printf("SBThread(%p)::GetName () => %s", |
491 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
492 | name ? name : "NULL"); |
493 | |
494 | return name; |
495 | } |
496 | |
497 | const char *SBThread::GetQueueName() const { |
498 | const char *name = NULL__null; |
499 | std::unique_lock<std::recursive_mutex> lock; |
500 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
501 | |
502 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
503 | if (exe_ctx.HasThreadScope()) { |
504 | Process::StopLocker stop_locker; |
505 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
506 | name = exe_ctx.GetThreadPtr()->GetQueueName(); |
507 | } else { |
508 | if (log) |
509 | log->Printf("SBThread(%p)::GetQueueName() => error: process is running", |
510 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
511 | } |
512 | } |
513 | |
514 | if (log) |
515 | log->Printf("SBThread(%p)::GetQueueName () => %s", |
516 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
517 | name ? name : "NULL"); |
518 | |
519 | return name; |
520 | } |
521 | |
522 | lldb::queue_id_t SBThread::GetQueueID() const { |
523 | queue_id_t id = LLDB_INVALID_QUEUE_ID0; |
524 | std::unique_lock<std::recursive_mutex> lock; |
525 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
526 | |
527 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
528 | if (exe_ctx.HasThreadScope()) { |
529 | Process::StopLocker stop_locker; |
530 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
531 | id = exe_ctx.GetThreadPtr()->GetQueueID(); |
532 | } else { |
533 | if (log) |
534 | log->Printf("SBThread(%p)::GetQueueID() => error: process is running", |
535 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
536 | } |
537 | } |
538 | |
539 | if (log) |
540 | log->Printf("SBThread(%p)::GetQueueID () => 0x%" PRIx64"l" "x", |
541 | static_cast<void *>(exe_ctx.GetThreadPtr()), id); |
542 | |
543 | return id; |
544 | } |
545 | |
546 | bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { |
547 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
548 | bool success = false; |
549 | std::unique_lock<std::recursive_mutex> lock; |
550 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
551 | |
552 | if (exe_ctx.HasThreadScope()) { |
553 | Process::StopLocker stop_locker; |
554 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
555 | Thread *thread = exe_ctx.GetThreadPtr(); |
556 | StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo(); |
557 | if (info_root_sp) { |
558 | StructuredData::ObjectSP node = |
559 | info_root_sp->GetObjectForDotSeparatedPath(path); |
560 | if (node) { |
561 | if (node->GetType() == eStructuredDataTypeString) { |
562 | strm.Printf("%s", node->GetAsString()->GetValue().str().c_str()); |
563 | success = true; |
564 | } |
565 | if (node->GetType() == eStructuredDataTypeInteger) { |
566 | strm.Printf("0x%" PRIx64"l" "x", node->GetAsInteger()->GetValue()); |
567 | success = true; |
568 | } |
569 | if (node->GetType() == eStructuredDataTypeFloat) { |
570 | strm.Printf("0x%f", node->GetAsFloat()->GetValue()); |
571 | success = true; |
572 | } |
573 | if (node->GetType() == eStructuredDataTypeBoolean) { |
574 | if (node->GetAsBoolean()->GetValue() == true) |
575 | strm.Printf("true"); |
576 | else |
577 | strm.Printf("false"); |
578 | success = true; |
579 | } |
580 | if (node->GetType() == eStructuredDataTypeNull) { |
581 | strm.Printf("null"); |
582 | success = true; |
583 | } |
584 | } |
585 | } |
586 | } else { |
587 | if (log) |
588 | log->Printf("SBThread(%p)::GetInfoItemByPathAsString() => error: " |
589 | "process is running", |
590 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
591 | } |
592 | } |
593 | |
594 | if (log) |
595 | log->Printf("SBThread(%p)::GetInfoItemByPathAsString (\"%s\") => \"%s\"", |
596 | static_cast<void *>(exe_ctx.GetThreadPtr()), path, strm.GetData()); |
597 | |
598 | return success; |
599 | } |
600 | |
601 | SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx, |
602 | ThreadPlan *new_plan) { |
603 | SBError sb_error; |
604 | |
605 | Process *process = exe_ctx.GetProcessPtr(); |
606 | if (!process) { |
607 | sb_error.SetErrorString("No process in SBThread::ResumeNewPlan"); |
608 | return sb_error; |
609 | } |
610 | |
611 | Thread *thread = exe_ctx.GetThreadPtr(); |
612 | if (!thread) { |
613 | sb_error.SetErrorString("No thread in SBThread::ResumeNewPlan"); |
614 | return sb_error; |
615 | } |
616 | |
617 | |
618 | |
619 | if (new_plan != NULL__null) { |
620 | new_plan->SetIsMasterPlan(true); |
621 | new_plan->SetOkayToDiscard(false); |
622 | } |
623 | |
624 | |
625 | process->GetThreadList().SetSelectedThreadByID(thread->GetID()); |
626 | |
627 | if (process->GetTarget().GetDebugger().GetAsyncExecution()) |
628 | sb_error.ref() = process->Resume(); |
629 | else |
630 | sb_error.ref() = process->ResumeSynchronous(NULL__null); |
631 | |
632 | return sb_error; |
633 | } |
634 | |
635 | void SBThread::StepOver(lldb::RunMode stop_other_threads) { |
636 | SBError error; |
637 | StepOver(stop_other_threads, error); |
638 | } |
639 | |
640 | void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { |
641 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
642 | |
643 | std::unique_lock<std::recursive_mutex> lock; |
644 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
645 | |
646 | if (log) |
647 | log->Printf("SBThread(%p)::StepOver (stop_other_threads='%s')", |
648 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
649 | Thread::RunModeAsCString(stop_other_threads)); |
650 | |
651 | if (!exe_ctx.HasThreadScope()) { |
652 | error.SetErrorString("this SBThread object is invalid"); |
653 | return; |
654 | } |
655 | |
656 | Thread *thread = exe_ctx.GetThreadPtr(); |
657 | bool abort_other_plans = false; |
658 | StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); |
659 | |
660 | ThreadPlanSP new_plan_sp; |
661 | if (frame_sp) { |
662 | if (frame_sp->HasDebugInformation()) { |
663 | const LazyBool avoid_no_debug = eLazyBoolCalculate; |
664 | SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); |
665 | new_plan_sp = thread->QueueThreadPlanForStepOverRange( |
666 | abort_other_plans, sc.line_entry, sc, stop_other_threads, |
667 | avoid_no_debug); |
668 | } else { |
669 | new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction( |
670 | true, abort_other_plans, stop_other_threads); |
671 | } |
672 | } |
673 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
674 | } |
675 | |
676 | void SBThread::StepInto(lldb::RunMode stop_other_threads) { |
677 | StepInto(NULL__null, stop_other_threads); |
678 | } |
679 | |
680 | void SBThread::StepInto(const char *target_name, |
681 | lldb::RunMode stop_other_threads) { |
682 | SBError error; |
683 | StepInto(target_name, LLDB_INVALID_LINE_NUMBER(4294967295U), error, stop_other_threads); |
684 | } |
685 | |
686 | void SBThread::StepInto(const char *target_name, uint32_t end_line, |
687 | SBError &error, lldb::RunMode stop_other_threads) { |
688 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
689 | |
690 | std::unique_lock<std::recursive_mutex> lock; |
691 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
692 | |
693 | if (log) |
694 | log->Printf( |
695 | "SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')", |
696 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
697 | target_name ? target_name : "<NULL>", |
698 | Thread::RunModeAsCString(stop_other_threads)); |
699 | |
700 | if (!exe_ctx.HasThreadScope()) { |
701 | error.SetErrorString("this SBThread object is invalid"); |
702 | return; |
703 | } |
704 | |
705 | bool abort_other_plans = false; |
706 | |
707 | Thread *thread = exe_ctx.GetThreadPtr(); |
708 | StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); |
709 | ThreadPlanSP new_plan_sp; |
710 | |
711 | if (frame_sp && frame_sp->HasDebugInformation()) { |
712 | SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); |
713 | AddressRange range; |
714 | if (end_line == LLDB_INVALID_LINE_NUMBER(4294967295U)) |
715 | range = sc.line_entry.range; |
716 | else { |
717 | if (!sc.GetAddressRangeFromHereToEndLine(end_line, range, error.ref())) |
718 | return; |
719 | } |
720 | |
721 | const LazyBool step_out_avoids_code_without_debug_info = |
722 | eLazyBoolCalculate; |
723 | const LazyBool step_in_avoids_code_without_debug_info = |
724 | eLazyBoolCalculate; |
725 | new_plan_sp = thread->QueueThreadPlanForStepInRange( |
726 | abort_other_plans, range, sc, target_name, stop_other_threads, |
727 | step_in_avoids_code_without_debug_info, |
728 | step_out_avoids_code_without_debug_info); |
729 | } else { |
730 | new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction( |
731 | false, abort_other_plans, stop_other_threads); |
732 | } |
733 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
734 | } |
735 | |
736 | void SBThread::StepOut() { |
737 | SBError error; |
738 | StepOut(error); |
739 | } |
740 | |
741 | void SBThread::StepOut(SBError &error) { |
742 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
743 | |
744 | std::unique_lock<std::recursive_mutex> lock; |
745 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
746 | |
747 | if (log) |
748 | log->Printf("SBThread(%p)::StepOut ()", |
749 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
750 | |
751 | if (!exe_ctx.HasThreadScope()) { |
752 | error.SetErrorString("this SBThread object is invalid"); |
753 | return; |
754 | } |
755 | |
756 | bool abort_other_plans = false; |
757 | bool stop_other_threads = false; |
758 | |
759 | Thread *thread = exe_ctx.GetThreadPtr(); |
760 | |
761 | const LazyBool avoid_no_debug = eLazyBoolCalculate; |
762 | ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut( |
763 | abort_other_plans, NULL__null, false, stop_other_threads, eVoteYes, |
764 | eVoteNoOpinion, 0, avoid_no_debug)); |
765 | |
766 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
767 | } |
768 | |
769 | void SBThread::StepOutOfFrame(SBFrame &sb_frame) { |
770 | SBError error; |
771 | StepOutOfFrame(sb_frame, error); |
| 1 | Calling 'SBThread::StepOutOfFrame' | |
|
772 | } |
773 | |
774 | void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { |
775 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
| |
776 | |
777 | std::unique_lock<std::recursive_mutex> lock; |
778 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
779 | |
780 | if (!sb_frame.IsValid()) { |
| 3 | | Assuming the condition is false | |
|
| |
781 | if (log) |
782 | log->Printf( |
783 | "SBThread(%p)::StepOutOfFrame passed an invalid frame, returning.", |
784 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
785 | error.SetErrorString("passed invalid SBFrame object"); |
786 | return; |
787 | } |
788 | |
789 | StackFrameSP frame_sp(sb_frame.GetFrameSP()); |
790 | if (log) { |
| |
| 6 | | Assuming pointer value is null | |
|
| |
791 | SBStream frame_desc_strm; |
792 | sb_frame.GetDescription(frame_desc_strm); |
793 | log->Printf("SBThread(%p)::StepOutOfFrame (frame = SBFrame(%p): %s)", |
794 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
795 | static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); |
796 | } |
797 | |
798 | if (!exe_ctx.HasThreadScope()) { |
| 8 | | Assuming the condition is false | |
|
| |
799 | error.SetErrorString("this SBThread object is invalid"); |
800 | return; |
801 | } |
802 | |
803 | bool abort_other_plans = false; |
804 | bool stop_other_threads = false; |
805 | Thread *thread = exe_ctx.GetThreadPtr(); |
806 | if (sb_frame.GetThread().GetThreadID() != thread->GetID()) { |
| 10 | | Assuming the condition is true | |
|
| |
807 | log->Printf("SBThread(%p)::StepOutOfFrame passed a frame from another " |
| 12 | | Called C++ object pointer is null |
|
808 | "thread (0x%" PRIx64"l" "x" " vrs. 0x%" PRIx64"l" "x" ", returning.", |
809 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
810 | sb_frame.GetThread().GetThreadID(), thread->GetID()); |
811 | error.SetErrorString("passed a frame from another thread"); |
812 | return; |
813 | } |
814 | |
815 | ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut( |
816 | abort_other_plans, NULL__null, false, stop_other_threads, eVoteYes, |
817 | eVoteNoOpinion, frame_sp->GetFrameIndex())); |
818 | |
819 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
820 | } |
821 | |
822 | void SBThread::StepInstruction(bool step_over) { |
823 | SBError error; |
824 | StepInstruction(step_over, error); |
825 | } |
826 | |
827 | void SBThread::StepInstruction(bool step_over, SBError &error) { |
828 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
829 | |
830 | std::unique_lock<std::recursive_mutex> lock; |
831 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
832 | |
833 | if (log) |
834 | log->Printf("SBThread(%p)::StepInstruction (step_over=%i)", |
835 | static_cast<void *>(exe_ctx.GetThreadPtr()), step_over); |
836 | |
837 | if (!exe_ctx.HasThreadScope()) { |
838 | error.SetErrorString("this SBThread object is invalid"); |
839 | return; |
840 | } |
841 | |
842 | Thread *thread = exe_ctx.GetThreadPtr(); |
843 | ThreadPlanSP new_plan_sp( |
844 | thread->QueueThreadPlanForStepSingleInstruction(step_over, true, true)); |
845 | |
846 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
847 | } |
848 | |
849 | void SBThread::RunToAddress(lldb::addr_t addr) { |
850 | SBError error; |
851 | RunToAddress(addr, error); |
852 | } |
853 | |
854 | void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { |
855 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
856 | |
857 | std::unique_lock<std::recursive_mutex> lock; |
858 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
859 | |
860 | if (log) |
861 | log->Printf("SBThread(%p)::RunToAddress (addr=0x%" PRIx64"l" "x" ")", |
862 | static_cast<void *>(exe_ctx.GetThreadPtr()), addr); |
863 | |
864 | if (!exe_ctx.HasThreadScope()) { |
865 | error.SetErrorString("this SBThread object is invalid"); |
866 | return; |
867 | } |
868 | |
869 | bool abort_other_plans = false; |
870 | bool stop_other_threads = true; |
871 | |
872 | Address target_addr(addr); |
873 | |
874 | Thread *thread = exe_ctx.GetThreadPtr(); |
875 | |
876 | ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress( |
877 | abort_other_plans, target_addr, stop_other_threads)); |
878 | |
879 | error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
880 | } |
881 | |
882 | SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, |
883 | lldb::SBFileSpec &sb_file_spec, uint32_t line) { |
884 | SBError sb_error; |
885 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
886 | char path[PATH_MAX4096]; |
887 | |
888 | std::unique_lock<std::recursive_mutex> lock; |
889 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
890 | |
891 | StackFrameSP frame_sp(sb_frame.GetFrameSP()); |
892 | |
893 | if (log) { |
894 | SBStream frame_desc_strm; |
895 | sb_frame.GetDescription(frame_desc_strm); |
896 | sb_file_spec->GetPath(path, sizeof(path)); |
897 | log->Printf("SBThread(%p)::StepOverUntil (frame = SBFrame(%p): %s, " |
898 | "file+line = %s:%u)", |
899 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
900 | static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData(), |
901 | path, line); |
902 | } |
903 | |
904 | if (exe_ctx.HasThreadScope()) { |
905 | Target *target = exe_ctx.GetTargetPtr(); |
906 | Thread *thread = exe_ctx.GetThreadPtr(); |
907 | |
908 | if (line == 0) { |
909 | sb_error.SetErrorString("invalid line argument"); |
910 | return sb_error; |
911 | } |
912 | |
913 | if (!frame_sp) { |
914 | frame_sp = thread->GetSelectedFrame(); |
915 | if (!frame_sp) |
916 | frame_sp = thread->GetStackFrameAtIndex(0); |
917 | } |
918 | |
919 | SymbolContext frame_sc; |
920 | if (!frame_sp) { |
921 | sb_error.SetErrorString("no valid frames in thread to step"); |
922 | return sb_error; |
923 | } |
924 | |
925 | |
926 | frame_sc = frame_sp->GetSymbolContext( |
927 | eSymbolContextCompUnit | eSymbolContextFunction | |
928 | eSymbolContextLineEntry | eSymbolContextSymbol); |
929 | |
930 | if (frame_sc.comp_unit == NULL__null) { |
931 | sb_error.SetErrorStringWithFormat( |
932 | "frame %u doesn't have debug information", frame_sp->GetFrameIndex()); |
933 | return sb_error; |
934 | } |
935 | |
936 | FileSpec step_file_spec; |
937 | if (sb_file_spec.IsValid()) { |
938 | |
939 | step_file_spec = sb_file_spec.ref(); |
940 | } else { |
941 | if (frame_sc.line_entry.IsValid()) |
942 | step_file_spec = frame_sc.line_entry.file; |
943 | else { |
944 | sb_error.SetErrorString("invalid file argument or no file for frame"); |
945 | return sb_error; |
946 | } |
947 | } |
948 | |
949 | |
950 | |
951 | |
952 | |
953 | |
954 | bool all_in_function = true; |
955 | AddressRange fun_range = frame_sc.function->GetAddressRange(); |
956 | |
957 | std::vector<addr_t> step_over_until_addrs; |
958 | const bool abort_other_plans = false; |
959 | const bool stop_other_threads = false; |
960 | const bool check_inlines = true; |
961 | const bool exact = false; |
962 | |
963 | SymbolContextList sc_list; |
964 | const uint32_t num_matches = frame_sc.comp_unit->ResolveSymbolContext( |
965 | step_file_spec, line, check_inlines, exact, eSymbolContextLineEntry, |
966 | sc_list); |
967 | if (num_matches > 0) { |
968 | SymbolContext sc; |
969 | for (uint32_t i = 0; i < num_matches; ++i) { |
970 | if (sc_list.GetContextAtIndex(i, sc)) { |
971 | addr_t step_addr = |
972 | sc.line_entry.range.GetBaseAddress().GetLoadAddress(target); |
973 | if (step_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) { |
974 | if (fun_range.ContainsLoadAddress(step_addr, target)) |
975 | step_over_until_addrs.push_back(step_addr); |
976 | else |
977 | all_in_function = false; |
978 | } |
979 | } |
980 | } |
981 | } |
982 | |
983 | if (step_over_until_addrs.empty()) { |
984 | if (all_in_function) { |
985 | step_file_spec.GetPath(path, sizeof(path)); |
986 | sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path, |
987 | line); |
988 | } else |
989 | sb_error.SetErrorString("step until target not in current function"); |
990 | } else { |
991 | ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil( |
992 | abort_other_plans, &step_over_until_addrs[0], |
993 | step_over_until_addrs.size(), stop_other_threads, |
994 | frame_sp->GetFrameIndex())); |
995 | |
996 | sb_error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); |
997 | } |
998 | } else { |
999 | sb_error.SetErrorString("this SBThread object is invalid"); |
1000 | } |
1001 | return sb_error; |
1002 | } |
1003 | |
1004 | SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { |
1005 | return StepUsingScriptedThreadPlan(script_class_name, true); |
1006 | } |
1007 | |
1008 | SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, |
1009 | bool resume_immediately) { |
1010 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1011 | SBError sb_error; |
1012 | |
1013 | std::unique_lock<std::recursive_mutex> lock; |
1014 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1015 | |
1016 | if (log) { |
1017 | log->Printf("SBThread(%p)::StepUsingScriptedThreadPlan: class name: %s", |
1018 | static_cast<void *>(exe_ctx.GetThreadPtr()), script_class_name); |
1019 | } |
1020 | |
1021 | if (!exe_ctx.HasThreadScope()) { |
1022 | sb_error.SetErrorString("this SBThread object is invalid"); |
1023 | return sb_error; |
1024 | } |
1025 | |
1026 | Thread *thread = exe_ctx.GetThreadPtr(); |
1027 | ThreadPlanSP thread_plan_sp = |
1028 | thread->QueueThreadPlanForStepScripted(false, script_class_name, false); |
1029 | |
1030 | if (!thread_plan_sp) { |
1031 | sb_error.SetErrorStringWithFormat( |
1032 | "Error queueing thread plan for class: %s", script_class_name); |
1033 | return sb_error; |
1034 | } |
1035 | |
1036 | if (!resume_immediately) { |
1037 | return sb_error; |
1038 | } |
1039 | |
1040 | if (thread_plan_sp) |
1041 | sb_error = ResumeNewPlan(exe_ctx, thread_plan_sp.get()); |
1042 | else { |
1043 | sb_error.SetErrorStringWithFormat( |
1044 | "Error resuming thread plan for class: %s.", script_class_name); |
1045 | if (log) |
1046 | log->Printf("SBThread(%p)::StepUsingScriptedThreadPlan: Error queuing " |
1047 | "thread plan for class: %s", |
1048 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1049 | script_class_name); |
1050 | } |
1051 | |
1052 | return sb_error; |
1053 | } |
1054 | |
1055 | SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { |
1056 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1057 | SBError sb_error; |
1058 | |
1059 | std::unique_lock<std::recursive_mutex> lock; |
1060 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1061 | |
1062 | if (log) |
1063 | log->Printf("SBThread(%p)::JumpToLine (file+line = %s:%u)", |
1064 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1065 | file_spec->GetPath().c_str(), line); |
1066 | |
1067 | if (!exe_ctx.HasThreadScope()) { |
1068 | sb_error.SetErrorString("this SBThread object is invalid"); |
1069 | return sb_error; |
1070 | } |
1071 | |
1072 | Thread *thread = exe_ctx.GetThreadPtr(); |
1073 | |
1074 | Status err = thread->JumpToLine(file_spec.get(), line, true); |
1075 | sb_error.SetError(err); |
1076 | return sb_error; |
1077 | } |
1078 | |
1079 | SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { |
1080 | SBError sb_error; |
1081 | |
1082 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1083 | |
1084 | std::unique_lock<std::recursive_mutex> lock; |
1085 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1086 | |
1087 | if (log) |
1088 | log->Printf("SBThread(%p)::ReturnFromFrame (frame=%d)", |
1089 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1090 | frame.GetFrameID()); |
1091 | |
1092 | if (exe_ctx.HasThreadScope()) { |
1093 | Thread *thread = exe_ctx.GetThreadPtr(); |
1094 | sb_error.SetError( |
1095 | thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP())); |
1096 | } |
1097 | |
1098 | return sb_error; |
1099 | } |
1100 | |
1101 | SBError SBThread::UnwindInnermostExpression() { |
1102 | SBError sb_error; |
1103 | |
1104 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1105 | |
1106 | std::unique_lock<std::recursive_mutex> lock; |
1107 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1108 | |
1109 | if (log) |
1110 | log->Printf("SBThread(%p)::UnwindExpressionEvaluation", |
1111 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1112 | |
1113 | if (exe_ctx.HasThreadScope()) { |
1114 | Thread *thread = exe_ctx.GetThreadPtr(); |
1115 | sb_error.SetError(thread->UnwindInnermostExpression()); |
1116 | if (sb_error.Success()) |
1117 | thread->SetSelectedFrameByIndex(0, false); |
1118 | } |
1119 | |
1120 | return sb_error; |
1121 | } |
1122 | |
1123 | bool SBThread::Suspend() { |
1124 | SBError error; |
1125 | return Suspend(error); |
1126 | } |
1127 | |
1128 | bool SBThread::Suspend(SBError &error) { |
1129 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1130 | std::unique_lock<std::recursive_mutex> lock; |
1131 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1132 | |
1133 | bool result = false; |
1134 | if (exe_ctx.HasThreadScope()) { |
1135 | Process::StopLocker stop_locker; |
1136 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1137 | exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended); |
1138 | result = true; |
1139 | } else { |
1140 | error.SetErrorString("process is running"); |
1141 | if (log) |
1142 | log->Printf("SBThread(%p)::Suspend() => error: process is running", |
1143 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1144 | } |
1145 | } else |
1146 | error.SetErrorString("this SBThread object is invalid"); |
1147 | if (log) |
1148 | log->Printf("SBThread(%p)::Suspend() => %i", |
1149 | static_cast<void *>(exe_ctx.GetThreadPtr()), result); |
1150 | return result; |
1151 | } |
1152 | |
1153 | bool SBThread::Resume() { |
1154 | SBError error; |
1155 | return Resume(error); |
1156 | } |
1157 | |
1158 | bool SBThread::Resume(SBError &error) { |
1159 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1160 | std::unique_lock<std::recursive_mutex> lock; |
1161 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1162 | |
1163 | bool result = false; |
1164 | if (exe_ctx.HasThreadScope()) { |
1165 | Process::StopLocker stop_locker; |
1166 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1167 | const bool override_suspend = true; |
1168 | exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); |
1169 | result = true; |
1170 | } else { |
1171 | error.SetErrorString("process is running"); |
1172 | if (log) |
1173 | log->Printf("SBThread(%p)::Resume() => error: process is running", |
1174 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1175 | } |
1176 | } else |
1177 | error.SetErrorString("this SBThread object is invalid"); |
1178 | if (log) |
1179 | log->Printf("SBThread(%p)::Resume() => %i", |
1180 | static_cast<void *>(exe_ctx.GetThreadPtr()), result); |
1181 | return result; |
1182 | } |
1183 | |
1184 | bool SBThread::IsSuspended() { |
1185 | std::unique_lock<std::recursive_mutex> lock; |
1186 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1187 | |
1188 | if (exe_ctx.HasThreadScope()) |
1189 | return exe_ctx.GetThreadPtr()->GetResumeState() == eStateSuspended; |
1190 | return false; |
1191 | } |
1192 | |
1193 | bool SBThread::IsStopped() { |
1194 | std::unique_lock<std::recursive_mutex> lock; |
1195 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1196 | |
1197 | if (exe_ctx.HasThreadScope()) |
1198 | return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true); |
1199 | return false; |
1200 | } |
1201 | |
1202 | SBProcess SBThread::GetProcess() { |
1203 | SBProcess sb_process; |
1204 | std::unique_lock<std::recursive_mutex> lock; |
1205 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1206 | |
1207 | if (exe_ctx.HasThreadScope()) { |
1208 | |
1209 | |
1210 | sb_process.SetSP(exe_ctx.GetProcessSP()); |
1211 | } |
1212 | |
1213 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1214 | if (log) { |
1215 | SBStream frame_desc_strm; |
1216 | sb_process.GetDescription(frame_desc_strm); |
1217 | log->Printf("SBThread(%p)::GetProcess () => SBProcess(%p): %s", |
1218 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1219 | static_cast<void *>(sb_process.GetSP().get()), |
1220 | frame_desc_strm.GetData()); |
1221 | } |
1222 | |
1223 | return sb_process; |
1224 | } |
1225 | |
1226 | uint32_t SBThread::GetNumFrames() { |
1227 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1228 | |
1229 | uint32_t num_frames = 0; |
1230 | std::unique_lock<std::recursive_mutex> lock; |
1231 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1232 | |
1233 | if (exe_ctx.HasThreadScope()) { |
1234 | Process::StopLocker stop_locker; |
1235 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1236 | num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); |
1237 | } else { |
1238 | if (log) |
1239 | log->Printf("SBThread(%p)::GetNumFrames() => error: process is running", |
1240 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1241 | } |
1242 | } |
1243 | |
1244 | if (log) |
1245 | log->Printf("SBThread(%p)::GetNumFrames () => %u", |
1246 | static_cast<void *>(exe_ctx.GetThreadPtr()), num_frames); |
1247 | |
1248 | return num_frames; |
1249 | } |
1250 | |
1251 | SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { |
1252 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1253 | |
1254 | SBFrame sb_frame; |
1255 | StackFrameSP frame_sp; |
1256 | std::unique_lock<std::recursive_mutex> lock; |
1257 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1258 | |
1259 | if (exe_ctx.HasThreadScope()) { |
1260 | Process::StopLocker stop_locker; |
1261 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1262 | frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx); |
1263 | sb_frame.SetFrameSP(frame_sp); |
1264 | } else { |
1265 | if (log) |
1266 | log->Printf( |
1267 | "SBThread(%p)::GetFrameAtIndex() => error: process is running", |
1268 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1269 | } |
1270 | } |
1271 | |
1272 | if (log) { |
1273 | SBStream frame_desc_strm; |
1274 | sb_frame.GetDescription(frame_desc_strm); |
1275 | log->Printf("SBThread(%p)::GetFrameAtIndex (idx=%d) => SBFrame(%p): %s", |
1276 | static_cast<void *>(exe_ctx.GetThreadPtr()), idx, |
1277 | static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); |
1278 | } |
1279 | |
1280 | return sb_frame; |
1281 | } |
1282 | |
1283 | lldb::SBFrame SBThread::GetSelectedFrame() { |
1284 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1285 | |
1286 | SBFrame sb_frame; |
1287 | StackFrameSP frame_sp; |
1288 | std::unique_lock<std::recursive_mutex> lock; |
1289 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1290 | |
1291 | if (exe_ctx.HasThreadScope()) { |
1292 | Process::StopLocker stop_locker; |
1293 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1294 | frame_sp = exe_ctx.GetThreadPtr()->GetSelectedFrame(); |
1295 | sb_frame.SetFrameSP(frame_sp); |
1296 | } else { |
1297 | if (log) |
1298 | log->Printf( |
1299 | "SBThread(%p)::GetSelectedFrame() => error: process is running", |
1300 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1301 | } |
1302 | } |
1303 | |
1304 | if (log) { |
1305 | SBStream frame_desc_strm; |
1306 | sb_frame.GetDescription(frame_desc_strm); |
1307 | log->Printf("SBThread(%p)::GetSelectedFrame () => SBFrame(%p): %s", |
1308 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1309 | static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); |
1310 | } |
1311 | |
1312 | return sb_frame; |
1313 | } |
1314 | |
1315 | lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { |
1316 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1317 | |
1318 | SBFrame sb_frame; |
1319 | StackFrameSP frame_sp; |
1320 | std::unique_lock<std::recursive_mutex> lock; |
1321 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1322 | |
1323 | if (exe_ctx.HasThreadScope()) { |
1324 | Process::StopLocker stop_locker; |
1325 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1326 | Thread *thread = exe_ctx.GetThreadPtr(); |
1327 | frame_sp = thread->GetStackFrameAtIndex(idx); |
1328 | if (frame_sp) { |
1329 | thread->SetSelectedFrame(frame_sp.get()); |
1330 | sb_frame.SetFrameSP(frame_sp); |
1331 | } |
1332 | } else { |
1333 | if (log) |
1334 | log->Printf( |
1335 | "SBThread(%p)::SetSelectedFrame() => error: process is running", |
1336 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1337 | } |
1338 | } |
1339 | |
1340 | if (log) { |
1341 | SBStream frame_desc_strm; |
1342 | sb_frame.GetDescription(frame_desc_strm); |
1343 | log->Printf("SBThread(%p)::SetSelectedFrame (idx=%u) => SBFrame(%p): %s", |
1344 | static_cast<void *>(exe_ctx.GetThreadPtr()), idx, |
1345 | static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); |
1346 | } |
1347 | return sb_frame; |
1348 | } |
1349 | |
1350 | bool SBThread::EventIsThreadEvent(const SBEvent &event) { |
1351 | return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL__null; |
1352 | } |
1353 | |
1354 | SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) { |
1355 | return Thread::ThreadEventData::GetStackFrameFromEvent(event.get()); |
1356 | } |
1357 | |
1358 | SBThread SBThread::GetThreadFromEvent(const SBEvent &event) { |
1359 | return Thread::ThreadEventData::GetThreadFromEvent(event.get()); |
1360 | } |
1361 | |
1362 | bool SBThread::operator==(const SBThread &rhs) const { |
1363 | return m_opaque_sp->GetThreadSP().get() == |
1364 | rhs.m_opaque_sp->GetThreadSP().get(); |
1365 | } |
1366 | |
1367 | bool SBThread::operator!=(const SBThread &rhs) const { |
1368 | return m_opaque_sp->GetThreadSP().get() != |
1369 | rhs.m_opaque_sp->GetThreadSP().get(); |
1370 | } |
1371 | |
1372 | bool SBThread::GetStatus(SBStream &status) const { |
1373 | Stream &strm = status.ref(); |
1374 | |
1375 | std::unique_lock<std::recursive_mutex> lock; |
1376 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1377 | |
1378 | if (exe_ctx.HasThreadScope()) { |
1379 | exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true); |
1380 | } else |
1381 | strm.PutCString("No status"); |
1382 | |
1383 | return true; |
1384 | } |
1385 | |
1386 | bool SBThread::GetDescription(SBStream &description) const { |
1387 | return GetDescription(description, false); |
1388 | } |
1389 | |
1390 | bool SBThread::GetDescription(SBStream &description, bool stop_format) const { |
1391 | Stream &strm = description.ref(); |
1392 | |
1393 | std::unique_lock<std::recursive_mutex> lock; |
1394 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1395 | |
1396 | if (exe_ctx.HasThreadScope()) { |
1397 | exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat(strm, |
1398 | LLDB_INVALID_THREAD_ID0, |
1399 | stop_format); |
1400 | |
1401 | |
1402 | } else |
1403 | strm.PutCString("No value"); |
1404 | |
1405 | return true; |
1406 | } |
1407 | |
1408 | SBThread SBThread::GetExtendedBacktraceThread(const char *type) { |
1409 | Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16))); |
1410 | std::unique_lock<std::recursive_mutex> lock; |
1411 | ExecutionContext exe_ctx(m_opaque_sp.get(), lock); |
1412 | SBThread sb_origin_thread; |
1413 | |
1414 | if (exe_ctx.HasThreadScope()) { |
1415 | Process::StopLocker stop_locker; |
1416 | if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { |
1417 | ThreadSP real_thread(exe_ctx.GetThreadSP()); |
1418 | if (real_thread) { |
1419 | ConstString type_const(type); |
1420 | Process *process = exe_ctx.GetProcessPtr(); |
1421 | if (process) { |
1422 | SystemRuntime *runtime = process->GetSystemRuntime(); |
1423 | if (runtime) { |
1424 | ThreadSP new_thread_sp( |
1425 | runtime->GetExtendedBacktraceThread(real_thread, type_const)); |
1426 | if (new_thread_sp) { |
1427 | |
1428 | |
1429 | process->GetExtendedThreadList().AddThread(new_thread_sp); |
1430 | sb_origin_thread.SetThread(new_thread_sp); |
1431 | if (log) { |
1432 | const char *queue_name = new_thread_sp->GetQueueName(); |
1433 | if (queue_name == NULL__null) |
1434 | queue_name = ""; |
1435 | log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => new " |
1436 | "extended Thread " |
1437 | "created (%p) with queue_id 0x%" PRIx64"l" "x" |
1438 | " queue name '%s'", |
1439 | static_cast<void *>(exe_ctx.GetThreadPtr()), |
1440 | static_cast<void *>(new_thread_sp.get()), |
1441 | new_thread_sp->GetQueueID(), queue_name); |
1442 | } |
1443 | } |
1444 | } |
1445 | } |
1446 | } |
1447 | } else { |
1448 | if (log) |
1449 | log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => error: " |
1450 | "process is running", |
1451 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1452 | } |
1453 | } |
1454 | |
1455 | if (log && sb_origin_thread.IsValid() == false) |
1456 | log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a " |
1457 | "Valid thread", |
1458 | static_cast<void *>(exe_ctx.GetThreadPtr())); |
1459 | return sb_origin_thread; |
1460 | } |
1461 | |
1462 | uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { |
1463 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
1464 | if (thread_sp) |
1465 | return thread_sp->GetExtendedBacktraceOriginatingIndexID(); |
1466 | return LLDB_INVALID_INDEX32(4294967295U); |
1467 | } |
1468 | |
1469 | bool SBThread::SafeToCallFunctions() { |
1470 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
1471 | if (thread_sp) |
1472 | return thread_sp->SafeToCallFunctions(); |
1473 | return true; |
1474 | } |
1475 | |
1476 | lldb_private::Thread *SBThread::operator->() { |
1477 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
1478 | if (thread_sp) |
1479 | return thread_sp.get(); |
1480 | else |
1481 | return NULL__null; |
1482 | } |
1483 | |
1484 | lldb_private::Thread *SBThread::get() { |
1485 | ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); |
1486 | if (thread_sp) |
1487 | return thread_sp.get(); |
1488 | else |
1489 | return NULL__null; |
1490 | } |