129 lines
4.0 KiB
C++
129 lines
4.0 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2015 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "xenia/debug/ui/model/system.h"
|
|
|
|
#include <unordered_set>
|
|
|
|
namespace xe {
|
|
namespace debug {
|
|
namespace ui {
|
|
namespace model {
|
|
|
|
using namespace xe::debug::proto; // NOLINT(build/namespaces)
|
|
|
|
System::System(xe::ui::Loop* loop, DebugClient* client)
|
|
: loop_(loop), client_(client) {
|
|
client_->set_listener(this);
|
|
client_->set_loop(loop);
|
|
}
|
|
|
|
System::~System() { client_->set_listener(nullptr); }
|
|
|
|
ExecutionState System::execution_state() { return client_->execution_state(); }
|
|
|
|
std::vector<Module*> System::modules() {
|
|
std::vector<Module*> result;
|
|
for (auto& module : modules_) {
|
|
result.push_back(module.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::vector<Thread*> System::threads() {
|
|
std::vector<Thread*> result;
|
|
for (auto& thread : threads_) {
|
|
result.push_back(thread.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Module* System::GetModuleByHandle(uint32_t module_handle) {
|
|
auto it = modules_by_handle_.find(module_handle);
|
|
return it != modules_by_handle_.end() ? it->second : nullptr;
|
|
}
|
|
|
|
Thread* System::GetThreadByHandle(uint32_t thread_handle) {
|
|
auto it = threads_by_handle_.find(thread_handle);
|
|
return it != threads_by_handle_.end() ? it->second : nullptr;
|
|
}
|
|
|
|
void System::OnExecutionStateChanged(ExecutionState execution_state) {
|
|
on_execution_state_changed();
|
|
}
|
|
|
|
void System::OnModulesUpdated(std::vector<const ModuleListEntry*> entries) {
|
|
std::unordered_set<uint32_t> extra_modules;
|
|
for (size_t i = 0; i < modules_.size(); ++i) {
|
|
extra_modules.emplace(modules_[i]->module_handle());
|
|
}
|
|
for (auto entry : entries) {
|
|
auto existing_module = modules_by_handle_.find(entry->module_handle);
|
|
if (existing_module == modules_by_handle_.end()) {
|
|
auto module = std::make_unique<Module>(this);
|
|
module->Update(entry);
|
|
modules_by_handle_.emplace(entry->module_handle, module.get());
|
|
modules_.emplace_back(std::move(module));
|
|
} else {
|
|
existing_module->second->Update(entry);
|
|
extra_modules.erase(existing_module->first);
|
|
}
|
|
}
|
|
for (auto module_handle : extra_modules) {
|
|
auto module = modules_by_handle_.find(module_handle);
|
|
if (module != modules_by_handle_.end()) {
|
|
module->second->set_dead(true);
|
|
}
|
|
}
|
|
|
|
on_modules_updated();
|
|
}
|
|
|
|
void System::OnThreadsUpdated(std::vector<const ThreadListEntry*> entries) {
|
|
std::unordered_set<uint32_t> extra_threads;
|
|
for (size_t i = 0; i < threads_.size(); ++i) {
|
|
extra_threads.emplace(threads_[i]->thread_handle());
|
|
}
|
|
for (auto entry : entries) {
|
|
auto existing_thread = threads_by_handle_.find(entry->thread_handle);
|
|
if (existing_thread == threads_by_handle_.end()) {
|
|
auto thread = std::make_unique<Thread>(this);
|
|
thread->Update(entry);
|
|
threads_by_handle_.emplace(entry->thread_handle, thread.get());
|
|
threads_.emplace_back(std::move(thread));
|
|
} else {
|
|
existing_thread->second->Update(entry);
|
|
extra_threads.erase(existing_thread->first);
|
|
}
|
|
}
|
|
for (auto thread_handle : extra_threads) {
|
|
auto thread = threads_by_handle_.find(thread_handle);
|
|
if (thread != threads_by_handle_.end()) {
|
|
thread->second->set_dead(true);
|
|
}
|
|
}
|
|
|
|
on_threads_updated();
|
|
}
|
|
|
|
void System::OnThreadStateUpdated(
|
|
uint32_t thread_handle, const ThreadStateEntry* entry,
|
|
std::vector<const ThreadCallStackFrame*> frames) {
|
|
auto thread = threads_by_handle_[thread_handle];
|
|
if (thread != nullptr) {
|
|
thread->UpdateState(entry, std::move(frames));
|
|
on_thread_state_updated(thread);
|
|
}
|
|
}
|
|
|
|
} // namespace model
|
|
} // namespace ui
|
|
} // namespace debug
|
|
} // namespace xe
|