SBThread SBThread::GetExtendedBacktrace (const char *type) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); Mutex::Locker api_locker; ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); SBThread sb_origin_thread; if (exe_ctx.HasThreadScope()) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { ThreadSP real_thread(exe_ctx.GetThreadPtr()); if (real_thread) { ConstString type_const (type); SystemRuntime *runtime = exe_ctx.GetProcessPtr()->GetSystemRuntime(); if (runtime) { ThreadSP origin_thread = runtime->GetExtendedBacktrace (real_thread, type_const); sb_origin_thread.SetThread (origin_thread); } } } else { if (log) log->Printf ("SBThread(%p)::GetExtendedBacktrace() => error: process is running", exe_ctx.GetThreadPtr()); } } return sb_origin_thread; }
const char *ThreadGDBRemote::GetQueueName() { // If our cached queue info is valid, then someone called // ThreadGDBRemote::SetQueueInfo(...) with valid information that was gleaned // from the stop reply packet. In this case we trust that the info is valid // in m_dispatch_queue_name without refetching it if (CachedQueueInfoIsValid()) { if (m_dispatch_queue_name.empty()) return nullptr; else return m_dispatch_queue_name.c_str(); } // Always re-fetch the dispatch queue name since it can change if (m_associated_with_libdispatch_queue == eLazyBoolNo) return nullptr; if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp(GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); if (runtime) m_dispatch_queue_name = runtime->GetQueueNameFromThreadQAddress(m_thread_dispatch_qaddr); else m_dispatch_queue_name.clear(); if (!m_dispatch_queue_name.empty()) return m_dispatch_queue_name.c_str(); } } return nullptr; }
QueueKind ThreadGDBRemote::GetQueueKind() { // If our cached queue info is valid, then someone called // ThreadGDBRemote::SetQueueInfo(...) // with valid information that was gleaned from the stop reply packet. In this // case we trust // that the info is valid in m_dispatch_queue_name without refetching it if (CachedQueueInfoIsValid()) { return m_queue_kind; } if (m_associated_with_libdispatch_queue == eLazyBoolNo) return eQueueKindUnknown; if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp(GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); if (runtime) m_queue_kind = runtime->GetQueueKind(m_thread_dispatch_qaddr); return m_queue_kind; } } return eQueueKindUnknown; }
uint32_t SBProcess::GetNumExtendedBacktraceTypes () { ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); return runtime->GetExtendedBacktraceTypes().size(); } return 0; }
SBThread SBThread::GetExtendedBacktraceThread(const char *type) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); SBThread sb_origin_thread; if (exe_ctx.HasThreadScope()) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { ThreadSP real_thread(exe_ctx.GetThreadSP()); if (real_thread) { ConstString type_const(type); Process *process = exe_ctx.GetProcessPtr(); if (process) { SystemRuntime *runtime = process->GetSystemRuntime(); if (runtime) { ThreadSP new_thread_sp( runtime->GetExtendedBacktraceThread(real_thread, type_const)); if (new_thread_sp) { // Save this in the Process' ExtendedThreadList so a strong // pointer retains the // object. process->GetExtendedThreadList().AddThread(new_thread_sp); sb_origin_thread.SetThread(new_thread_sp); if (log) { const char *queue_name = new_thread_sp->GetQueueName(); if (queue_name == NULL) queue_name = ""; log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => new " "extended Thread " "created (%p) with queue_id 0x%" PRIx64 " queue name '%s'", static_cast<void *>(exe_ctx.GetThreadPtr()), static_cast<void *>(new_thread_sp.get()), new_thread_sp->GetQueueID(), queue_name); } } } } } } else { if (log) log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => error: " "process is running", static_cast<void *>(exe_ctx.GetThreadPtr())); } } if (log && sb_origin_thread.IsValid() == false) log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a " "Valid thread", static_cast<void *>(exe_ctx.GetThreadPtr())); return sb_origin_thread; }
void QueueItem::FetchEntireItem() { if (m_have_fetched_entire_item) return; ProcessSP process_sp = m_process_wp.lock(); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); if (runtime) { runtime->CompleteQueueItem(this, m_item_ref); m_have_fetched_entire_item = true; } } }
addr_t ThreadGDBRemote::GetQueueLibdispatchQueueAddress() { if (m_dispatch_queue_t == LLDB_INVALID_ADDRESS) { if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp(GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); if (runtime) { m_dispatch_queue_t = runtime->GetLibdispatchQueueAddressFromThreadQAddress( m_thread_dispatch_qaddr); } } } } return m_dispatch_queue_t; }
queue_id_t ThreadGDBRemote::GetQueueID () { if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp (GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime (); if (runtime) { return runtime->GetQueueIDFromThreadQAddress (m_thread_dispatch_qaddr); } } } return LLDB_INVALID_QUEUE_ID; }
const char * SBProcess::GetExtendedBacktraceTypeAtIndex (uint32_t idx) { ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); const std::vector<ConstString> &names = runtime->GetExtendedBacktraceTypes(); if (idx < names.size()) { return names[idx].AsCString(); } else { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => error: requested extended backtrace name out of bounds", process_sp.get()); } } return NULL; }
queue_id_t ThreadGDBRemote::GetQueueID() { // If our cached queue info is valid, then someone called // ThreadGDBRemote::SetQueueInfo(...) with valid information that was gleaned // from the stop reply packet. In this case we trust that the info is valid // in m_dispatch_queue_name without refetching it if (CachedQueueInfoIsValid()) return m_queue_serial_number; if (m_associated_with_libdispatch_queue == eLazyBoolNo) return LLDB_INVALID_QUEUE_ID; if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp(GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); if (runtime) { return runtime->GetQueueIDFromThreadQAddress(m_thread_dispatch_qaddr); } } } return LLDB_INVALID_QUEUE_ID; }
const char * ThreadGDBRemote::GetQueueName () { // Always re-fetch the dispatch queue name since it can change if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) { ProcessSP process_sp (GetProcess()); if (process_sp) { SystemRuntime *runtime = process_sp->GetSystemRuntime (); if (runtime) { m_dispatch_queue_name = runtime->GetQueueNameFromThreadQAddress (m_thread_dispatch_qaddr); } if (m_dispatch_queue_name.length() > 0) { return m_dispatch_queue_name.c_str(); } } } return NULL; }