ThreadSP OperatingSystemPython::CreateThreadFromThreadInfo(
StructuredData::Dictionary &thread_dict, ThreadList &core_thread_list,
ThreadList &old_thread_list, std::vector<bool> &core_used_map,
bool *did_create_ptr) {
ThreadSP thread_sp;
tid_t tid = LLDB_INVALID_THREAD_ID;
if (!thread_dict.GetValueForKeyAsInteger("tid", tid))
return ThreadSP();
uint32_t core_number;
addr_t reg_data_addr;
llvm::StringRef name;
llvm::StringRef queue;
thread_dict.GetValueForKeyAsInteger("core", core_number, UINT32_MAX);
thread_dict.GetValueForKeyAsInteger("register_data_addr", reg_data_addr,
LLDB_INVALID_ADDRESS);
thread_dict.GetValueForKeyAsString("name", name);
thread_dict.GetValueForKeyAsString("queue", queue);
// See if a thread already exists for "tid"
thread_sp = old_thread_list.FindThreadByID(tid, false);
if (thread_sp) {
// A thread already does exist for "tid", make sure it was an operating
// system
// plug-in generated thread.
if (!IsOperatingSystemPluginThread(thread_sp)) {
// We have thread ID overlap between the protocol threads and the
// operating system threads, clear the thread so we create an operating
// system thread for this.
thread_sp.reset();
}
}
if (!thread_sp) {
if (did_create_ptr)
*did_create_ptr = true;
thread_sp = std::make_shared<ThreadMemory>(*m_process, tid, name, queue,
reg_data_addr);
}
if (core_number < core_thread_list.GetSize(false)) {
ThreadSP core_thread_sp(
core_thread_list.GetThreadAtIndex(core_number, false));
if (core_thread_sp) {
// Keep track of which cores were set as the backing thread for memory
// threads...
if (core_number < core_used_map.size())
core_used_map[core_number] = true;
ThreadSP backing_core_thread_sp(core_thread_sp->GetBackingThread());
if (backing_core_thread_sp) {
thread_sp->SetBackingThread(backing_core_thread_sp);
} else {
thread_sp->SetBackingThread(core_thread_sp);
}
}
}
return thread_sp;
}
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;
}