737 lines
26 KiB
C++
737 lines
26 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2013 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include <xenia/cpu/processor.h>
|
|
|
|
#include <jansson.h>
|
|
|
|
#include <alloy/runtime/debugger.h>
|
|
#include <xenia/emulator.h>
|
|
#include <xenia/export_resolver.h>
|
|
#include <xenia/cpu/xenon_memory.h>
|
|
#include <xenia/cpu/xenon_runtime.h>
|
|
#include <xenia/cpu/xex_module.h>
|
|
|
|
|
|
using namespace alloy;
|
|
using namespace alloy::backend;
|
|
using namespace alloy::frontend::ppc;
|
|
using namespace alloy::runtime;
|
|
using namespace xe;
|
|
using namespace xe::cpu;
|
|
|
|
|
|
namespace {
|
|
void InitializeIfNeeded();
|
|
void CleanupOnShutdown();
|
|
|
|
void InitializeIfNeeded() {
|
|
static bool has_initialized = false;
|
|
if (has_initialized) {
|
|
return;
|
|
}
|
|
has_initialized = true;
|
|
|
|
//ppc::RegisterDisasmCategoryAltivec();
|
|
//ppc::RegisterDisasmCategoryALU();
|
|
//ppc::RegisterDisasmCategoryControl();
|
|
//ppc::RegisterDisasmCategoryFPU();
|
|
//ppc::RegisterDisasmCategoryMemory();
|
|
|
|
atexit(CleanupOnShutdown);
|
|
}
|
|
|
|
void CleanupOnShutdown() {
|
|
}
|
|
}
|
|
|
|
|
|
Processor::Processor(Emulator* emulator) :
|
|
emulator_(emulator), export_resolver_(emulator->export_resolver()),
|
|
runtime_(0), memory_(emulator->memory()),
|
|
interrupt_thread_lock_(NULL), interrupt_thread_state_(NULL),
|
|
interrupt_thread_block_(0),
|
|
DebugTarget(emulator->debug_server()) {
|
|
InitializeIfNeeded();
|
|
|
|
debug_client_states_lock_ = xe_mutex_alloc();
|
|
|
|
emulator_->debug_server()->AddTarget("cpu", this);
|
|
}
|
|
|
|
Processor::~Processor() {
|
|
emulator_->debug_server()->RemoveTarget("cpu");
|
|
|
|
xe_mutex_lock(debug_client_states_lock_);
|
|
for (auto it = debug_client_states_.begin();
|
|
it != debug_client_states_.end(); ++it) {
|
|
DebugClientState* client_state = it->second;
|
|
delete client_state;
|
|
}
|
|
debug_client_states_.clear();
|
|
xe_mutex_unlock(debug_client_states_lock_);
|
|
xe_mutex_free(debug_client_states_lock_);
|
|
|
|
if (interrupt_thread_block_) {
|
|
memory_->HeapFree(interrupt_thread_block_, 2048);
|
|
delete interrupt_thread_state_;
|
|
xe_mutex_free(interrupt_thread_lock_);
|
|
}
|
|
|
|
delete runtime_;
|
|
}
|
|
|
|
int Processor::Setup() {
|
|
XEASSERTNULL(runtime_);
|
|
|
|
runtime_ = new XenonRuntime(memory_, export_resolver_);
|
|
if (!runtime_) {
|
|
return 1;
|
|
}
|
|
|
|
Backend* backend = 0;
|
|
// Backend* backend = new alloy::backend::ivm::IVMBackend(
|
|
// runtime);
|
|
// Backend* backend = new alloy::backend::x64::X64Backend(
|
|
// runtime);
|
|
int result = runtime_->Initialize(backend);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
|
|
// Setup debugger events.
|
|
auto debugger = runtime_->debugger();
|
|
auto debug_server = emulator_->debug_server();
|
|
debugger->breakpoint_hit.AddListener(
|
|
[debug_server](BreakpointHitEvent& e) {
|
|
const char* breakpoint_id = e.breakpoint()->id();
|
|
if (!breakpoint_id) {
|
|
// This is not a breakpoint we know about. Ignore.
|
|
return;
|
|
}
|
|
|
|
json_t* event_json = json_object();
|
|
json_t* type_json = json_string("breakpoint");
|
|
json_object_set_new(event_json, "type", type_json);
|
|
|
|
json_t* thread_id_json = json_integer(e.thread_state()->thread_id());
|
|
json_object_set_new(event_json, "threadId", thread_id_json);
|
|
json_t* breakpoint_id_json = json_string(breakpoint_id);
|
|
json_object_set_new(event_json, "breakpointId", breakpoint_id_json);
|
|
|
|
debug_server->BroadcastEvent(event_json);
|
|
|
|
json_decref(event_json);
|
|
});
|
|
|
|
interrupt_thread_lock_ = xe_mutex_alloc(10000);
|
|
interrupt_thread_state_ = new XenonThreadState(
|
|
runtime_, 0, 16 * 1024, 0);
|
|
interrupt_thread_block_ = memory_->HeapAlloc(
|
|
0, 2048, MEMORY_FLAG_ZERO);
|
|
interrupt_thread_state_->context()->r[13] = interrupt_thread_block_;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Processor::AddRegisterAccessCallbacks(
|
|
xe::cpu::RegisterAccessCallbacks callbacks) {
|
|
runtime_->AddRegisterAccessCallbacks(callbacks);
|
|
}
|
|
|
|
int Processor::Execute(XenonThreadState* thread_state, uint64_t address) {
|
|
// Attempt to get the function.
|
|
Function* fn;
|
|
if (runtime_->ResolveFunction(address, &fn)) {
|
|
// Symbol not found in any module.
|
|
XELOGCPU("Execute(%.8X): failed to find function", address);
|
|
return 1;
|
|
}
|
|
|
|
PPCContext* context = thread_state->context();
|
|
|
|
// This could be set to anything to give us a unique identifier to track
|
|
// re-entrancy/etc.
|
|
uint32_t lr = 0xBEBEBEBE;
|
|
|
|
// Setup registers.
|
|
context->lr = lr;
|
|
|
|
// Execute the function.
|
|
fn->Call(thread_state, lr);
|
|
return 0;
|
|
}
|
|
|
|
uint64_t Processor::Execute(
|
|
XenonThreadState* thread_state, uint64_t address, uint64_t arg0) {
|
|
PPCContext* context = thread_state->context();
|
|
context->r[3] = arg0;
|
|
if (Execute(thread_state, address)) {
|
|
return 0xDEADBABE;
|
|
}
|
|
return context->r[3];
|
|
}
|
|
|
|
uint64_t Processor::Execute(
|
|
XenonThreadState* thread_state, uint64_t address, uint64_t arg0,
|
|
uint64_t arg1) {
|
|
PPCContext* context = thread_state->context();
|
|
context->r[3] = arg0;
|
|
context->r[4] = arg1;
|
|
if (Execute(thread_state, address)) {
|
|
return 0xDEADBABE;
|
|
}
|
|
return context->r[3];
|
|
}
|
|
|
|
uint64_t Processor::ExecuteInterrupt(
|
|
uint32_t cpu, uint64_t address, uint64_t arg0, uint64_t arg1) {
|
|
// Acquire lock on interrupt thread (we can only dispatch one at a time).
|
|
xe_mutex_lock(interrupt_thread_lock_);
|
|
|
|
// Set 0x10C(r13) to the current CPU ID.
|
|
uint8_t* p = memory_->membase();
|
|
XESETUINT8BE(p + interrupt_thread_block_ + 0x10C, cpu);
|
|
|
|
// Execute interrupt.
|
|
uint64_t result = Execute(interrupt_thread_state_, address, arg0, arg1);
|
|
|
|
xe_mutex_unlock(interrupt_thread_lock_);
|
|
return result;
|
|
}
|
|
|
|
void Processor::OnDebugClientConnected(uint32_t client_id) {
|
|
DebugClientState* client_state = new DebugClientState(runtime_);
|
|
xe_mutex_lock(debug_client_states_lock_);
|
|
debug_client_states_[client_id] = client_state;
|
|
xe_mutex_unlock(debug_client_states_lock_);
|
|
}
|
|
|
|
void Processor::OnDebugClientDisconnected(uint32_t client_id) {
|
|
DebugClientState* client_state = debug_client_states_[client_id];
|
|
xe_mutex_lock(debug_client_states_lock_);
|
|
debug_client_states_.erase(client_id);
|
|
xe_mutex_unlock(debug_client_states_lock_);
|
|
delete client_state;
|
|
|
|
// Whenever we support multiple clients we will need to respect pause
|
|
// settings. For now, resume until running.
|
|
runtime_->debugger()->ResumeAllThreads(true);
|
|
}
|
|
|
|
json_t* Processor::OnDebugRequest(
|
|
uint32_t client_id, const char* command, json_t* request,
|
|
bool& succeeded) {
|
|
xe_mutex_lock(debug_client_states_lock_);
|
|
DebugClientState* client_state = debug_client_states_[client_id];
|
|
xe_mutex_unlock(debug_client_states_lock_);
|
|
XEASSERTNOTNULL(client_state);
|
|
|
|
succeeded = true;
|
|
if (xestrcmpa(command, "get_module_list") == 0) {
|
|
json_t* list = json_array();
|
|
Runtime::ModuleList modules = runtime_->GetModules();
|
|
for (auto it = modules.begin(); it != modules.end(); ++it) {
|
|
XexModule* module = (XexModule*)(*it);
|
|
json_t* module_json = json_object();
|
|
json_t* module_name_json = json_string(module->name());
|
|
json_object_set_new(module_json, "name", module_name_json);
|
|
json_array_append_new(list, module_json);
|
|
}
|
|
return list;
|
|
} else if (xestrcmpa(command, "get_module") == 0) {
|
|
json_t* module_name_json = json_object_get(request, "module");
|
|
if (!module_name_json || !json_is_string(module_name_json)) {
|
|
succeeded = false;
|
|
return json_string("Module name not specified");
|
|
}
|
|
const char* module_name = json_string_value(module_name_json);
|
|
XexModule* module = (XexModule*)runtime_->GetModule(module_name);
|
|
if (!module) {
|
|
succeeded = false;
|
|
return json_string("Module not found");
|
|
}
|
|
return DumpModule(module, succeeded);
|
|
} else if (xestrcmpa(command, "get_function_list") == 0) {
|
|
json_t* module_name_json = json_object_get(request, "module");
|
|
if (!module_name_json || !json_is_string(module_name_json)) {
|
|
succeeded = false;
|
|
return json_string("Module name not specified");
|
|
}
|
|
const char* module_name = json_string_value(module_name_json);
|
|
XexModule* module = (XexModule*)runtime_->GetModule(module_name);
|
|
if (!module) {
|
|
succeeded = false;
|
|
return json_string("Module not found");
|
|
}
|
|
json_t* list = json_array();
|
|
module->ForEachFunction([&](FunctionInfo* info) {
|
|
json_t* fn_json = json_object();
|
|
const char* name = info->name();
|
|
char name_buffer[32];
|
|
if (!name) {
|
|
xesnprintfa(name_buffer, XECOUNT(name_buffer), "sub_%.8X",
|
|
info->address());
|
|
name = name_buffer;
|
|
}
|
|
json_t* name_json = json_string(name);
|
|
json_object_set_new(fn_json, "name", name_json);
|
|
json_t* address_json = json_integer(info->address());
|
|
json_object_set_new(fn_json, "address", address_json);
|
|
json_t* link_status_json = json_integer(info->status());
|
|
json_object_set_new(fn_json, "linkStatus", link_status_json);
|
|
json_array_append_new(list, fn_json);
|
|
});
|
|
return list;
|
|
} else if (xestrcmpa(command, "get_function") == 0) {
|
|
json_t* address_json = json_object_get(request, "address");
|
|
if (!address_json || !json_is_number(address_json)) {
|
|
succeeded = false;
|
|
return json_string("Function address not specified");
|
|
}
|
|
uint64_t address = (uint64_t)json_number_value(address_json);
|
|
return DumpFunction(address, succeeded);
|
|
} else if (xestrcmpa(command, "add_breakpoints") == 0) {
|
|
// breakpoints: [{}]
|
|
json_t* breakpoints_json = json_object_get(request, "breakpoints");
|
|
if (!breakpoints_json || !json_is_array(breakpoints_json)) {
|
|
succeeded = false;
|
|
return json_string("Breakpoints not specified");
|
|
}
|
|
if (!json_array_size(breakpoints_json)) {
|
|
// No-op;
|
|
return json_null();
|
|
}
|
|
for (size_t n = 0; n < json_array_size(breakpoints_json); n++) {
|
|
json_t* breakpoint_json = json_array_get(breakpoints_json, n);
|
|
if (!breakpoint_json || !json_is_object(breakpoint_json)) {
|
|
succeeded = false;
|
|
return json_string("Invalid breakpoint type");
|
|
}
|
|
|
|
json_t* breakpoint_id_json = json_object_get(breakpoint_json, "id");
|
|
json_t* type_json = json_object_get(breakpoint_json, "type");
|
|
json_t* address_json = json_object_get(breakpoint_json, "address");
|
|
if (!breakpoint_id_json || !json_is_string(breakpoint_id_json) ||
|
|
!type_json || !json_is_string(type_json) ||
|
|
!address_json || !json_is_number(address_json)) {
|
|
succeeded = false;
|
|
return json_string("Invalid breakpoint members");
|
|
}
|
|
const char* breakpoint_id = json_string_value(breakpoint_id_json);
|
|
const char* type_str = json_string_value(type_json);
|
|
uint64_t address = (uint64_t)json_number_value(address_json);
|
|
Breakpoint::Type type;
|
|
if (xestrcmpa(type_str, "temp") == 0) {
|
|
type = Breakpoint::TEMP_TYPE;
|
|
} else if (xestrcmpa(type_str, "code") == 0) {
|
|
type = Breakpoint::CODE_TYPE;
|
|
} else {
|
|
succeeded = false;
|
|
return json_string("Unknown breakpoint type");
|
|
}
|
|
|
|
Breakpoint* breakpoint = new Breakpoint(
|
|
type, address);
|
|
breakpoint->set_id(breakpoint_id);
|
|
if (client_state->AddBreakpoint(breakpoint_id, breakpoint)) {
|
|
succeeded = false;
|
|
return json_string("Error adding breakpoint");
|
|
}
|
|
}
|
|
return json_null();
|
|
} else if (xestrcmpa(command, "remove_breakpoints") == 0) {
|
|
// breakpointIds: ['id']
|
|
json_t* breakpoint_ids_json = json_object_get(request, "breakpointIds");
|
|
if (!breakpoint_ids_json || !json_is_array(breakpoint_ids_json)) {
|
|
succeeded = false;
|
|
return json_string("Breakpoint IDs not specified");
|
|
}
|
|
if (!json_array_size(breakpoint_ids_json)) {
|
|
// No-op;
|
|
return json_null();
|
|
}
|
|
for (size_t n = 0; n < json_array_size(breakpoint_ids_json); n++) {
|
|
json_t* breakpoint_id_json = json_array_get(breakpoint_ids_json, n);
|
|
if (!breakpoint_id_json || !json_is_string(breakpoint_id_json)) {
|
|
succeeded = false;
|
|
return json_string("Invalid breakpoint ID type");
|
|
}
|
|
const char* breakpoint_id = json_string_value(breakpoint_id_json);
|
|
if (client_state->RemoveBreakpoint(breakpoint_id)) {
|
|
succeeded = false;
|
|
return json_string("Unable to remove breakpoints");
|
|
}
|
|
}
|
|
return json_null();
|
|
} else if (xestrcmpa(command, "remove_all_breakpoints") == 0) {
|
|
if (client_state->RemoveAllBreakpoints()) {
|
|
succeeded = false;
|
|
return json_string("Unable to remove breakpoints");
|
|
}
|
|
return json_null();
|
|
} else if (xestrcmpa(command, "continue") == 0) {
|
|
if (runtime_->debugger()->ResumeAllThreads()) {
|
|
succeeded = false;
|
|
return json_string("Unable to resume threads");
|
|
}
|
|
return json_null();
|
|
} else if (xestrcmpa(command, "break") == 0) {
|
|
if (runtime_->debugger()->SuspendAllThreads()) {
|
|
succeeded = false;
|
|
return json_string("Unable to suspend threads");
|
|
}
|
|
return json_null();
|
|
} else if (xestrcmpa(command, "step") == 0) {
|
|
// threadId
|
|
return json_null();
|
|
} else {
|
|
succeeded = false;
|
|
return json_string("Unknown command");
|
|
}
|
|
}
|
|
|
|
json_t* json_object_set_string_new(
|
|
json_t* object, const char* key, const char* value) {
|
|
json_t* value_json = json_string(value);
|
|
json_object_set_new(object, key, value_json);
|
|
return value_json;
|
|
}
|
|
|
|
json_t* json_object_set_string_format_new(
|
|
json_t* object, const char* key, const char* format, ...) {
|
|
char buffer[1024];
|
|
va_list args;
|
|
va_start(args, format);
|
|
xevsnprintfa(buffer, XECOUNT(buffer), format, args);
|
|
va_end(args);
|
|
json_t* value_json = json_string(buffer);
|
|
json_object_set_new(object, key, value_json);
|
|
return value_json;
|
|
}
|
|
|
|
json_t* json_object_set_integer_new(
|
|
json_t* object, const char* key, json_int_t value) {
|
|
json_t* value_json = json_integer(value);
|
|
json_object_set_new(object, key, value_json);
|
|
return value_json;
|
|
}
|
|
|
|
json_t* Processor::DumpModule(XexModule* module, bool& succeeded) {
|
|
auto xex = module->xex();
|
|
auto header = xe_xex2_get_header(xex);
|
|
|
|
auto export_resolver = runtime_->export_resolver();
|
|
|
|
json_t* module_json = json_object();
|
|
|
|
json_object_set_integer_new(
|
|
module_json, "moduleFlags", header->module_flags);
|
|
json_object_set_integer_new(
|
|
module_json, "systemFlags", header->system_flags);
|
|
json_object_set_integer_new(
|
|
module_json, "exeAddress", header->exe_address);
|
|
json_object_set_integer_new(
|
|
module_json, "exeEntryPoint", header->exe_entry_point);
|
|
json_object_set_integer_new(
|
|
module_json, "exeStackSize", header->exe_stack_size);
|
|
json_object_set_integer_new(
|
|
module_json, "exeHeapSize", header->exe_heap_size);
|
|
|
|
json_t* exec_info_json = json_object();
|
|
json_object_set_integer_new(
|
|
exec_info_json, "mediaId", header->execution_info.media_id);
|
|
json_object_set_string_format_new(
|
|
exec_info_json, "version", "%d.%d.%d.%d",
|
|
header->execution_info.version.major,
|
|
header->execution_info.version.minor,
|
|
header->execution_info.version.build,
|
|
header->execution_info.version.qfe);
|
|
json_object_set_string_format_new(
|
|
exec_info_json, "baseVersion", "%d.%d.%d.%d",
|
|
header->execution_info.base_version.major,
|
|
header->execution_info.base_version.minor,
|
|
header->execution_info.base_version.build,
|
|
header->execution_info.base_version.qfe);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "titleId", header->execution_info.title_id);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "platform", header->execution_info.platform);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "executableTable", header->execution_info.executable_table);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "discNumber", header->execution_info.disc_number);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "discCount", header->execution_info.disc_count);
|
|
json_object_set_integer_new(
|
|
exec_info_json, "savegameId", header->execution_info.savegame_id);
|
|
json_object_set_new(module_json, "executionInfo", exec_info_json);
|
|
|
|
json_t* loader_info_json = json_object();
|
|
json_object_set_integer_new(
|
|
loader_info_json, "imageFlags", header->loader_info.image_flags);
|
|
json_object_set_integer_new(
|
|
loader_info_json, "gameRegions", header->loader_info.game_regions);
|
|
json_object_set_integer_new(
|
|
loader_info_json, "mediaFlags", header->loader_info.media_flags);
|
|
json_object_set_new(module_json, "loaderInfo", loader_info_json);
|
|
|
|
json_t* tls_info_json = json_object();
|
|
json_object_set_integer_new(
|
|
tls_info_json, "slotCount", header->tls_info.slot_count);
|
|
json_object_set_integer_new(
|
|
tls_info_json, "dataSize", header->tls_info.data_size);
|
|
json_object_set_integer_new(
|
|
tls_info_json, "rawDataAddress", header->tls_info.raw_data_address);
|
|
json_object_set_integer_new(
|
|
tls_info_json, "rawDataSize", header->tls_info.raw_data_size);
|
|
json_object_set_new(module_json, "tlsInfo", tls_info_json);
|
|
|
|
json_t* headers_json = json_array();
|
|
for (size_t n = 0; n < header->header_count; n++) {
|
|
auto opt_header = &header->headers[n];
|
|
json_t* header_entry_json = json_object();
|
|
json_object_set_integer_new(
|
|
header_entry_json, "key", opt_header->key);
|
|
json_object_set_integer_new(
|
|
header_entry_json, "length", opt_header->length);
|
|
json_object_set_integer_new(
|
|
header_entry_json, "value", opt_header->value);
|
|
json_array_append_new(headers_json, header_entry_json);
|
|
}
|
|
json_object_set_new(module_json, "headers", headers_json);
|
|
|
|
// TODO(benvanik): resources.
|
|
json_t* resource_info_json = json_object();
|
|
json_object_set_integer_new(
|
|
resource_info_json, "address", header->resource_info.address);
|
|
json_object_set_integer_new(
|
|
resource_info_json, "size", header->resource_info.size);
|
|
json_object_set_new(module_json, "resourceInfo", resource_info_json);
|
|
|
|
json_t* sections_json = json_array();
|
|
for (size_t n = 0, i = 0; n < header->section_count; n++) {
|
|
const xe_xex2_section_t* section = &header->sections[n];
|
|
const char* type = "unknown";
|
|
switch (section->info.type) {
|
|
case XEX_SECTION_CODE:
|
|
type = "code";
|
|
break;
|
|
case XEX_SECTION_DATA:
|
|
type = "rwdata";
|
|
break;
|
|
case XEX_SECTION_READONLY_DATA:
|
|
type = "rodata";
|
|
break;
|
|
}
|
|
const size_t start_address =
|
|
header->exe_address + (i * xe_xex2_section_length);
|
|
const size_t end_address =
|
|
start_address + (section->info.page_count * xe_xex2_section_length);
|
|
json_t* section_entry_json = json_object();
|
|
json_object_set_string_new(
|
|
section_entry_json, "type", type);
|
|
json_object_set_integer_new(
|
|
section_entry_json, "pageCount", section->info.page_count);
|
|
json_object_set_integer_new(
|
|
section_entry_json, "startAddress", start_address);
|
|
json_object_set_integer_new(
|
|
section_entry_json, "endAddress", end_address);
|
|
json_object_set_integer_new(
|
|
section_entry_json, "totalLength",
|
|
section->info.page_count * xe_xex2_section_length);
|
|
json_array_append_new(sections_json, section_entry_json);
|
|
i += section->info.page_count;
|
|
}
|
|
json_object_set_new(module_json, "sections", sections_json);
|
|
|
|
json_t* static_libraries_json = json_array();
|
|
for (size_t n = 0; n < header->static_library_count; n++) {
|
|
const xe_xex2_static_library_t *library = &header->static_libraries[n];
|
|
json_t* static_library_entry_json = json_object();
|
|
json_object_set_string_new(
|
|
static_library_entry_json, "name", library->name);
|
|
json_object_set_string_format_new(
|
|
static_library_entry_json, "version", "%d.%d.%d.%d",
|
|
library->major, library->minor, library->build, library->qfe);
|
|
json_array_append_new(static_libraries_json, static_library_entry_json);
|
|
}
|
|
json_object_set_new(module_json, "staticLibraries", static_libraries_json);
|
|
|
|
json_t* library_imports_json = json_array();
|
|
for (size_t n = 0; n < header->import_library_count; n++) {
|
|
const xe_xex2_import_library_t* library = &header->import_libraries[n];
|
|
xe_xex2_import_info_t* import_infos;
|
|
size_t import_info_count;
|
|
if (xe_xex2_get_import_infos(
|
|
xex, library, &import_infos, &import_info_count)) {
|
|
continue;
|
|
}
|
|
|
|
json_t* import_library_json = json_object();
|
|
json_object_set_string_new(
|
|
import_library_json, "name", library->name);
|
|
json_object_set_string_format_new(
|
|
import_library_json, "version", "%d.%d.%d.%d",
|
|
library->version.major, library->version.minor,
|
|
library->version.build, library->version.qfe);
|
|
json_object_set_string_format_new(
|
|
import_library_json, "minVersion", "%d.%d.%d.%d",
|
|
library->min_version.major, library->min_version.minor,
|
|
library->min_version.build, library->min_version.qfe);
|
|
|
|
json_t* imports_json = json_array();
|
|
for (size_t m = 0; m < import_info_count; m++) {
|
|
auto info = &import_infos[m];
|
|
auto kernel_export = export_resolver->GetExportByOrdinal(
|
|
library->name, info->ordinal);
|
|
json_t* import_json = json_object();
|
|
if (kernel_export) {
|
|
json_object_set_string_new(
|
|
import_json, "name", kernel_export->name);
|
|
json_object_set_new(
|
|
import_json, "implemented",
|
|
kernel_export->is_implemented ? json_true() : json_false());
|
|
} else {
|
|
json_object_set_new(import_json, "name", json_null());
|
|
json_object_set_new(import_json, "implemented", json_false());
|
|
}
|
|
json_object_set_integer_new(
|
|
import_json, "ordinal", info->ordinal);
|
|
json_object_set_integer_new(
|
|
import_json, "valueAddress", info->value_address);
|
|
if (kernel_export && kernel_export->type == KernelExport::Variable) {
|
|
json_object_set_string_new(
|
|
import_json, "type", "variable");
|
|
} else if (kernel_export) {
|
|
json_object_set_string_new(
|
|
import_json, "type", "function");
|
|
json_object_set_integer_new(
|
|
import_json, "thunkAddress", info->thunk_address);
|
|
} else {
|
|
json_object_set_string_new(
|
|
import_json, "type", "unknown");
|
|
}
|
|
json_array_append_new(imports_json, import_json);
|
|
}
|
|
json_object_set_new(import_library_json, "imports", imports_json);
|
|
|
|
json_array_append_new(library_imports_json, import_library_json);
|
|
xe_free(import_infos);
|
|
}
|
|
json_object_set_new(module_json, "libraryImports", library_imports_json);
|
|
|
|
// TODO(benvanik): exports?
|
|
|
|
return module_json;
|
|
}
|
|
|
|
json_t* Processor::DumpFunction(uint64_t address, bool& succeeded) {
|
|
FunctionInfo* info;
|
|
if (runtime_->LookupFunctionInfo(address, &info)) {
|
|
succeeded = false;
|
|
return json_string("Function not found");
|
|
}
|
|
|
|
// Demand a new function with all debug info retained.
|
|
// If we ever wanted absolute x64 addresses/etc we could
|
|
// use the x64 from the function in the symbol table.
|
|
Function* fn;
|
|
if (runtime_->frontend()->DefineFunction(info, true, &fn)) {
|
|
succeeded = false;
|
|
return json_string("Unable to resolve function");
|
|
}
|
|
DebugInfo* debug_info = fn->debug_info();
|
|
if (!debug_info) {
|
|
succeeded = false;
|
|
return json_string("No debug info present for function");
|
|
}
|
|
|
|
json_t* fn_json = json_object();
|
|
const char* name = info->name();
|
|
char name_buffer[32];
|
|
if (!name) {
|
|
xesnprintfa(name_buffer, XECOUNT(name_buffer), "sub_%.8X",
|
|
info->address());
|
|
name = name_buffer;
|
|
}
|
|
json_t* name_json = json_string(name);
|
|
json_object_set_new(fn_json, "name", name_json);
|
|
json_t* start_address_json = json_integer(info->address());
|
|
json_object_set_new(fn_json, "startAddress", start_address_json);
|
|
json_t* end_address_json = json_integer(info->end_address());
|
|
json_object_set_new(fn_json, "endAddress", end_address_json);
|
|
json_t* link_status_json = json_integer(info->status());
|
|
json_object_set_new(fn_json, "linkStatus", link_status_json);
|
|
|
|
json_t* disasm_json = json_object();
|
|
json_t* disasm_str_json;
|
|
disasm_str_json = json_loads(debug_info->source_json(), 0, NULL);
|
|
json_object_set_new(disasm_json, "source", disasm_str_json);
|
|
disasm_str_json = json_string(debug_info->raw_hir_disasm());
|
|
json_object_set_new(disasm_json, "rawHir", disasm_str_json);
|
|
disasm_str_json = json_string(debug_info->hir_disasm());
|
|
json_object_set_new(disasm_json, "hir", disasm_str_json);
|
|
disasm_str_json = json_string(debug_info->raw_lir_disasm());
|
|
json_object_set_new(disasm_json, "rawLir", disasm_str_json);
|
|
disasm_str_json = json_string(debug_info->lir_disasm());
|
|
json_object_set_new(disasm_json, "lir", disasm_str_json);
|
|
disasm_str_json = json_string(debug_info->machine_code_disasm());
|
|
json_object_set_new(disasm_json, "machineCode", disasm_str_json);
|
|
json_object_set_new(fn_json, "disasm", disasm_json);
|
|
|
|
delete fn;
|
|
|
|
succeeded = true;
|
|
return fn_json;
|
|
}
|
|
|
|
Processor::DebugClientState::DebugClientState(XenonRuntime* runtime) :
|
|
runtime_(runtime) {
|
|
breakpoints_lock_ = xe_mutex_alloc(10000);
|
|
}
|
|
|
|
Processor::DebugClientState::~DebugClientState() {
|
|
RemoveAllBreakpoints();
|
|
xe_mutex_free(breakpoints_lock_);
|
|
}
|
|
|
|
int Processor::DebugClientState::AddBreakpoint(
|
|
const char* breakpoint_id, Breakpoint* breakpoint) {
|
|
xe_mutex_lock(breakpoints_lock_);
|
|
breakpoints_[breakpoint_id] = breakpoint;
|
|
int result = runtime_->debugger()->AddBreakpoint(breakpoint);
|
|
xe_mutex_unlock(breakpoints_lock_);
|
|
return result;
|
|
}
|
|
|
|
int Processor::DebugClientState::RemoveBreakpoint(const char* breakpoint_id) {
|
|
xe_mutex_lock(breakpoints_lock_);
|
|
Breakpoint* breakpoint = breakpoints_[breakpoint_id];
|
|
if (breakpoint) {
|
|
breakpoints_.erase(breakpoint_id);
|
|
runtime_->debugger()->RemoveBreakpoint(breakpoint);
|
|
delete breakpoint;
|
|
}
|
|
xe_mutex_unlock(breakpoints_lock_);
|
|
return 0;
|
|
}
|
|
|
|
int Processor::DebugClientState::RemoveAllBreakpoints() {
|
|
xe_mutex_lock(breakpoints_lock_);
|
|
for (auto it = breakpoints_.begin(); it != breakpoints_.end(); ++it) {
|
|
Breakpoint* breakpoint = it->second;
|
|
runtime_->debugger()->RemoveBreakpoint(breakpoint);
|
|
delete breakpoint;
|
|
}
|
|
breakpoints_.clear();
|
|
xe_mutex_unlock(breakpoints_lock_);
|
|
return 0;
|
|
}
|