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;
}
