You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
158 lines
4.5 KiB
158 lines
4.5 KiB
//===-- ThreadSpec.cpp ----------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Target/ThreadSpec.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Utility/StructuredData.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
const char *ThreadSpec::g_option_names[static_cast<uint32_t>(
|
|
ThreadSpec::OptionNames::LastOptionName)]{"Index", "ID", "Name",
|
|
"QueueName"};
|
|
|
|
ThreadSpec::ThreadSpec()
|
|
: m_index(UINT32_MAX), m_tid(LLDB_INVALID_THREAD_ID), m_name(),
|
|
m_queue_name() {}
|
|
|
|
std::unique_ptr<ThreadSpec> ThreadSpec::CreateFromStructuredData(
|
|
const StructuredData::Dictionary &spec_dict, Status &error) {
|
|
uint32_t index = UINT32_MAX;
|
|
lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
|
|
llvm::StringRef name;
|
|
llvm::StringRef queue_name;
|
|
|
|
std::unique_ptr<ThreadSpec> thread_spec_up(new ThreadSpec());
|
|
bool success = spec_dict.GetValueForKeyAsInteger(
|
|
GetKey(OptionNames::ThreadIndex), index);
|
|
if (success)
|
|
thread_spec_up->SetIndex(index);
|
|
|
|
success =
|
|
spec_dict.GetValueForKeyAsInteger(GetKey(OptionNames::ThreadID), tid);
|
|
if (success)
|
|
thread_spec_up->SetTID(tid);
|
|
|
|
success =
|
|
spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName), name);
|
|
if (success)
|
|
thread_spec_up->SetName(name);
|
|
|
|
success = spec_dict.GetValueForKeyAsString(GetKey(OptionNames::ThreadName),
|
|
queue_name);
|
|
if (success)
|
|
thread_spec_up->SetQueueName(queue_name);
|
|
|
|
return thread_spec_up;
|
|
}
|
|
|
|
StructuredData::ObjectSP ThreadSpec::SerializeToStructuredData() {
|
|
StructuredData::DictionarySP data_dict_sp(new StructuredData::Dictionary());
|
|
|
|
if (m_index != UINT32_MAX)
|
|
data_dict_sp->AddIntegerItem(GetKey(OptionNames::ThreadIndex), m_index);
|
|
if (m_tid != LLDB_INVALID_THREAD_ID)
|
|
data_dict_sp->AddIntegerItem(GetKey(OptionNames::ThreadID), m_tid);
|
|
if (!m_name.empty())
|
|
data_dict_sp->AddStringItem(GetKey(OptionNames::ThreadName), m_name);
|
|
if (!m_queue_name.empty())
|
|
data_dict_sp->AddStringItem(GetKey(OptionNames::QueueName), m_queue_name);
|
|
|
|
return data_dict_sp;
|
|
}
|
|
|
|
const char *ThreadSpec::GetName() const {
|
|
return m_name.empty() ? nullptr : m_name.c_str();
|
|
}
|
|
|
|
const char *ThreadSpec::GetQueueName() const {
|
|
return m_queue_name.empty() ? nullptr : m_queue_name.c_str();
|
|
}
|
|
|
|
bool ThreadSpec::TIDMatches(Thread &thread) const {
|
|
if (m_tid == LLDB_INVALID_THREAD_ID)
|
|
return true;
|
|
|
|
lldb::tid_t thread_id = thread.GetID();
|
|
return TIDMatches(thread_id);
|
|
}
|
|
|
|
bool ThreadSpec::IndexMatches(Thread &thread) const {
|
|
if (m_index == UINT32_MAX)
|
|
return true;
|
|
uint32_t index = thread.GetIndexID();
|
|
return IndexMatches(index);
|
|
}
|
|
|
|
bool ThreadSpec::NameMatches(Thread &thread) const {
|
|
if (m_name.empty())
|
|
return true;
|
|
|
|
const char *name = thread.GetName();
|
|
return NameMatches(name);
|
|
}
|
|
|
|
bool ThreadSpec::QueueNameMatches(Thread &thread) const {
|
|
if (m_queue_name.empty())
|
|
return true;
|
|
|
|
const char *queue_name = thread.GetQueueName();
|
|
return QueueNameMatches(queue_name);
|
|
}
|
|
|
|
bool ThreadSpec::ThreadPassesBasicTests(Thread &thread) const {
|
|
if (!HasSpecification())
|
|
return true;
|
|
|
|
if (!TIDMatches(thread))
|
|
return false;
|
|
|
|
if (!IndexMatches(thread))
|
|
return false;
|
|
|
|
if (!NameMatches(thread))
|
|
return false;
|
|
|
|
if (!QueueNameMatches(thread))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ThreadSpec::HasSpecification() const {
|
|
return (m_index != UINT32_MAX || m_tid != LLDB_INVALID_THREAD_ID ||
|
|
!m_name.empty() || !m_queue_name.empty());
|
|
}
|
|
|
|
void ThreadSpec::GetDescription(Stream *s, lldb::DescriptionLevel level) const {
|
|
if (!HasSpecification()) {
|
|
if (level == eDescriptionLevelBrief) {
|
|
s->PutCString("thread spec: no ");
|
|
}
|
|
} else {
|
|
if (level == eDescriptionLevelBrief) {
|
|
s->PutCString("thread spec: yes ");
|
|
} else {
|
|
if (GetTID() != LLDB_INVALID_THREAD_ID)
|
|
s->Printf("tid: 0x%" PRIx64 " ", GetTID());
|
|
|
|
if (GetIndex() != UINT32_MAX)
|
|
s->Printf("index: %d ", GetIndex());
|
|
|
|
const char *name = GetName();
|
|
if (name)
|
|
s->Printf("thread name: \"%s\" ", name);
|
|
|
|
const char *queue_name = GetQueueName();
|
|
if (queue_name)
|
|
s->Printf("queue name: \"%s\" ", queue_name);
|
|
}
|
|
}
|
|
}
|