fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Converting addresses in xe::cpu to 32bit.

Browse Source
This commit is contained in:
Ben Vanik
2015-03-24 19:41:29 -07:00
parent 3279776a80
commit 281abea955
42 changed files with 415 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/xenia/cpu/backend/x64/x64_emitter.cc
View File

@@ -229,7 +229,7 @@ int X64Emitter::Emit(HIRBuilder* builder, size_t& out_stack_size) {
void X64Emitter::MarkSourceOffset(const Instr* i) {
auto entry = source_map_arena_.Alloc<SourceMapEntry>();
entry->source_offset = i->src1.offset;
entry->source_offset = static_cast<uint32_t>(i->src1.offset);
entry->hir_offset = uint32_t(i->block->ordinal << 16) | i->ordinal;
entry->code_offset = getSize();
source_map_count_++;
@@ -477,12 +477,11 @@ const int kICSlotCount = 4;
const int kICSlotSize = 23;
const uint64_t kICSlotInvalidTargetAddress = 0x0F0F0F0F0F0F0F0F;
uint64_t ResolveFunctionAddress(void* raw_context, uint64_t target_address) {
uint64_t ResolveFunctionAddress(void* raw_context, uint32_t target_address) {
// TODO(benvanik): generate this thunk at runtime? or a shim?
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
// TODO(benvanik): required?
target_address &= 0xFFFFFFFF;
assert_not_zero(target_address);
Function* fn = NULL;

5
src/xenia/cpu/backend/x64/x64_function.cc
View File

@@ -34,10 +34,11 @@ int X64Function::AddBreakpointImpl(Breakpoint* breakpoint) { return 0; }
int X64Function::RemoveBreakpointImpl(Breakpoint* breakpoint) { return 0; }
int X64Function::CallImpl(ThreadState* thread_state, uint64_t return_address) {
int X64Function::CallImpl(ThreadState* thread_state, uint32_t return_address) {
auto backend = (X64Backend*)thread_state->runtime()->backend();
auto thunk = backend->host_to_guest_thunk();
thunk(machine_code_, thread_state->raw_context(), (void*)return_address);
thunk(machine_code_, thread_state->raw_context(),
reinterpret_cast<void*>(uintptr_t(return_address)));
return 0;
}

2
src/xenia/cpu/backend/x64/x64_function.h
View File

@@ -32,7 +32,7 @@ class X64Function : public Function {
protected:
virtual int AddBreakpointImpl(Breakpoint* breakpoint);
virtual int RemoveBreakpointImpl(Breakpoint* breakpoint);
virtual int CallImpl(ThreadState* thread_state, uint64_t return_address);
virtual int CallImpl(ThreadState* thread_state, uint32_t return_address);
private:
void* machine_code_;

2
src/xenia/cpu/debug_info.cc
View File

@@ -38,7 +38,7 @@ void DebugInfo::InitializeSourceMap(size_t source_map_count,
// TODO(benvanik): ensure sorted in some way? MC offset?
}
SourceMapEntry* DebugInfo::LookupSourceOffset(uint64_t offset) {
SourceMapEntry* DebugInfo::LookupSourceOffset(uint32_t offset) {
// TODO(benvanik): binary search? We know the list is sorted by code order.
for (size_t n = 0; n < source_map_count_; n++) {
auto entry = &source_map_[n];

4
src/xenia/cpu/debug_info.h
View File

@@ -37,7 +37,7 @@ enum TraceFlags {
};
typedef struct SourceMapEntry_s {
uint64_t source_offset; // Original source address/offset.
uint32_t source_offset; // Original source address/offset.
uint64_t hir_offset; // Block ordinal (16b) | Instr ordinal (16b)
uint64_t code_offset; // Offset from emitted code start.
} SourceMapEntry;
@@ -57,7 +57,7 @@ class DebugInfo {
void set_machine_code_disasm(char* value) { machine_code_disasm_ = value; }
void InitializeSourceMap(size_t source_map_count, SourceMapEntry* source_map);
SourceMapEntry* LookupSourceOffset(uint64_t offset);
SourceMapEntry* LookupSourceOffset(uint32_t offset);
SourceMapEntry* LookupHIROffset(uint64_t offset);
SourceMapEntry* LookupCodeOffset(uint64_t offset);

8
src/xenia/cpu/debugger.cc
View File

@@ -17,7 +17,7 @@
namespace xe {
namespace cpu {
Breakpoint::Breakpoint(Type type, uint64_t address)
Breakpoint::Breakpoint(Type type, uint32_t address)
: type_(type), address_(address) {}
Breakpoint::~Breakpoint() = default;
@@ -78,7 +78,7 @@ int Debugger::AddBreakpoint(Breakpoint* breakpoint) {
{
std::lock_guard<std::mutex> guard(breakpoints_lock_);
breakpoints_.insert(
std::pair<uint64_t, Breakpoint*>(breakpoint->address(), breakpoint));
std::pair<uint32_t, Breakpoint*>(breakpoint->address(), breakpoint));
}
// Find all functions that contain the breakpoint address.
@@ -126,7 +126,7 @@ int Debugger::RemoveBreakpoint(Breakpoint* breakpoint) {
return 0;
}
void Debugger::FindBreakpoints(uint64_t address,
void Debugger::FindBreakpoints(uint32_t address,
std::vector<Breakpoint*>& out_breakpoints) {
std::lock_guard<std::mutex> guard(breakpoints_lock_);
@@ -162,7 +162,7 @@ void Debugger::OnFunctionDefined(FunctionInfo* symbol_info,
std::vector<Breakpoint*> breakpoints;
{
std::lock_guard<std::mutex> guard(breakpoints_lock_);
for (uint64_t address = symbol_info->address();
for (uint32_t address = symbol_info->address();
address <= symbol_info->end_address(); address += 4) {
auto range = breakpoints_.equal_range(address);
if (range.first == range.second) {

10
src/xenia/cpu/debugger.h
View File

@@ -34,18 +34,18 @@ class Breakpoint {
};
public:
Breakpoint(Type type, uint64_t address);
Breakpoint(Type type, uint32_t address);
~Breakpoint();
Type type() const { return type_; }
uint64_t address() const { return address_; }
uint32_t address() const { return address_; }
const char* id() const { return id_.c_str(); }
void set_id(const char* id) { id_ = std::string(id); }
private:
Type type_;
uint64_t address_;
uint32_t address_;
std::string id_;
};
@@ -91,7 +91,7 @@ class Debugger {
int AddBreakpoint(Breakpoint* breakpoint);
int RemoveBreakpoint(Breakpoint* breakpoint);
void FindBreakpoints(uint64_t address,
void FindBreakpoints(uint32_t address,
std::vector<Breakpoint*>& out_breakpoints);
// TODO(benvanik): utility functions for modification (make function ignored,
@@ -113,7 +113,7 @@ class Debugger {
std::unordered_map<uint32_t, ThreadState*> threads_;
std::mutex breakpoints_lock_;
std::multimap<uint64_t, Breakpoint*> breakpoints_;
std::multimap<uint32_t, Breakpoint*> breakpoints_;
};
} // namespace cpu

6
src/xenia/cpu/entry_table.cc
View File

@@ -25,7 +25,7 @@ EntryTable::~EntryTable() {
}
}
Entry* EntryTable::Get(uint64_t address) {
Entry* EntryTable::Get(uint32_t address) {
std::lock_guard<std::mutex> guard(lock_);
const auto& it = map_.find(address);
Entry* entry = it != map_.end() ? it->second : nullptr;
@@ -38,7 +38,7 @@ Entry* EntryTable::Get(uint64_t address) {
return entry;
}
Entry::Status EntryTable::GetOrCreate(uint64_t address, Entry** out_entry) {
Entry::Status EntryTable::GetOrCreate(uint32_t address, Entry** out_entry) {
// TODO(benvanik): replace with a map with wait-free for find.
// https://github.com/facebook/folly/blob/master/folly/AtomicHashMap.h
@@ -73,7 +73,7 @@ Entry::Status EntryTable::GetOrCreate(uint64_t address, Entry** out_entry) {
return status;
}
std::vector<Function*> EntryTable::FindWithAddress(uint64_t address) {
std::vector<Function*> EntryTable::FindWithAddress(uint32_t address) {
std::lock_guard<std::mutex> guard(lock_);
std::vector<Function*> fns;
for (auto& it : map_) {

12
src/xenia/cpu/entry_table.h
View File

@@ -27,8 +27,8 @@ typedef struct Entry_t {
STATUS_FAILED,
} Status;
uint64_t address;
uint64_t end_address;
uint32_t address;
uint32_t end_address;
Status status;
Function* function;
} Entry;
@@ -38,15 +38,15 @@ class EntryTable {
EntryTable();
~EntryTable();
Entry* Get(uint64_t address);
Entry::Status GetOrCreate(uint64_t address, Entry** out_entry);
Entry* Get(uint32_t address);
Entry::Status GetOrCreate(uint32_t address, Entry** out_entry);
std::vector<Function*> FindWithAddress(uint64_t address);
std::vector<Function*> FindWithAddress(uint32_t address);
private:
// TODO(benvanik): replace with a better data structure.
std::mutex lock_;
std::unordered_map<uint64_t, Entry*> map_;
std::unordered_map<uint32_t, Entry*> map_;
};
} // namespace cpu

2
src/xenia/cpu/frontend/ppc_emit_control.cc
View File

@@ -50,7 +50,7 @@ int InstrEmit_branch(PPCHIRBuilder& f, const char* src, uint64_t cia,
// If it's a block inside of ourself, setup a fast jump.
// Unless it's to ourselves directly, in which case it's
// recursion.
uint64_t nia_value = nia->AsUint64() & 0xFFFFFFFF;
uint32_t nia_value = nia->AsUint64() & 0xFFFFFFFF;
bool is_recursion = false;
if (nia_value == f.symbol_info()->address() && lk) {
is_recursion = true;

15
src/xenia/cpu/frontend/ppc_hir_builder.cc
View File

@@ -74,10 +74,10 @@ int PPCHIRBuilder::Emit(FunctionInfo* symbol_info, uint32_t flags) {
// Always mark entry with label.
label_list_[0] = NewLabel();
uint64_t start_address = symbol_info->address();
uint64_t end_address = symbol_info->end_address();
uint32_t start_address = symbol_info->address();
uint32_t end_address = symbol_info->end_address();
InstrData i;
for (uint64_t address = start_address, offset = 0; address <= end_address;
for (uint32_t address = start_address, offset = 0; address <= end_address;
address += 4, offset++) {
i.address = address;
i.code = poly::load_and_swap<uint32_t>(p + address);
@@ -166,15 +166,14 @@ int PPCHIRBuilder::Emit(FunctionInfo* symbol_info, uint32_t flags) {
return Finalize();
}
void PPCHIRBuilder::AnnotateLabel(uint64_t address, Label* label) {
void PPCHIRBuilder::AnnotateLabel(uint32_t address, Label* label) {
char name_buffer[13];
snprintf(name_buffer, poly::countof(name_buffer), "loc_%.8X",
(uint32_t)address);
snprintf(name_buffer, poly::countof(name_buffer), "loc_%.8X", address);
label->name = (char*)arena_->Alloc(sizeof(name_buffer));
memcpy(label->name, name_buffer, sizeof(name_buffer));
}
FunctionInfo* PPCHIRBuilder::LookupFunction(uint64_t address) {
FunctionInfo* PPCHIRBuilder::LookupFunction(uint32_t address) {
Runtime* runtime = frontend_->runtime();
FunctionInfo* symbol_info;
if (runtime->LookupFunctionInfo(address, &symbol_info)) {
@@ -183,7 +182,7 @@ FunctionInfo* PPCHIRBuilder::LookupFunction(uint64_t address) {
return symbol_info;
}
Label* PPCHIRBuilder::LookupLabel(uint64_t address) {
Label* PPCHIRBuilder::LookupLabel(uint32_t address) {
if (address < start_address_) {
return NULL;
}

6
src/xenia/cpu/frontend/ppc_hir_builder.h
View File

@@ -43,8 +43,8 @@ class PPCHIRBuilder : public hir::HIRBuilder {
int Emit(FunctionInfo* symbol_info, uint32_t flags);
FunctionInfo* symbol_info() const { return symbol_info_; }
FunctionInfo* LookupFunction(uint64_t address);
Label* LookupLabel(uint64_t address);
FunctionInfo* LookupFunction(uint32_t address);
Label* LookupLabel(uint32_t address);
Value* LoadLR();
void StoreLR(Value* value);
@@ -85,7 +85,7 @@ class PPCHIRBuilder : public hir::HIRBuilder {
Value* StoreRelease(Value* address, Value* value, uint32_t store_flags = 0);
private:
void AnnotateLabel(uint64_t address, Label* label);
void AnnotateLabel(uint32_t address, Label* label);
private:
PPCFrontend* frontend_;

12
src/xenia/cpu/frontend/ppc_scanner.cc
View File

@@ -33,7 +33,7 @@ PPCScanner::PPCScanner(PPCFrontend* frontend) : frontend_(frontend) {}
PPCScanner::~PPCScanner() {}
bool PPCScanner::IsRestGprLr(uint64_t address) {
bool PPCScanner::IsRestGprLr(uint32_t address) {
FunctionInfo* symbol_info;
if (frontend_->runtime()->LookupFunctionInfo(address, &symbol_info)) {
return false;
@@ -283,14 +283,14 @@ std::vector<BlockInfo> PPCScanner::FindBlocks(FunctionInfo* symbol_info) {
Memory* memory = frontend_->memory();
const uint8_t* p = memory->membase();
std::map<uint64_t, BlockInfo> block_map;
std::map<uint32_t, BlockInfo> block_map;
uint64_t start_address = symbol_info->address();
uint64_t end_address = symbol_info->end_address();
uint32_t start_address = symbol_info->address();
uint32_t end_address = symbol_info->end_address();
bool in_block = false;
uint64_t block_start = 0;
uint32_t block_start = 0;
InstrData i;
for (uint64_t address = start_address; address <= end_address; address += 4) {
for (uint32_t address = start_address; address <= end_address; address += 4) {
i.address = address;
i.code = poly::load_and_swap<uint32_t>(p + address);
if (!i.code) {

6
src/xenia/cpu/frontend/ppc_scanner.h
View File

@@ -21,8 +21,8 @@ namespace frontend {
class PPCFrontend;
typedef struct BlockInfo_t {
uint64_t start_address;
uint64_t end_address;
uint32_t start_address;
uint32_t end_address;
} BlockInfo;
class PPCScanner {
@@ -35,7 +35,7 @@ class PPCScanner {
std::vector<BlockInfo> FindBlocks(FunctionInfo* symbol_info);
private:
bool IsRestGprLr(uint64_t address);
bool IsRestGprLr(uint32_t address);
private:
PPCFrontend* frontend_;

15
src/xenia/cpu/frontend/test/xe-cpu-ppc-test.cc
View File

@@ -37,9 +37,9 @@ typedef std::vector<std::pair<std::string, std::string>> AnnotationList;
const uint32_t START_ADDRESS = 0x100000;
struct TestCase {
TestCase(uint64_t address, std::string& name)
TestCase(uint32_t address, std::string& name)
: address(address), name(name) {}
uint64_t address;
uint32_t address;
std::string name;
AnnotationList annotations;
};
@@ -111,8 +111,7 @@ class TestSuite {
}
std::string address(line_buffer, t_test_ - line_buffer);
std::string name(t_test_ + strlen(" t test_"));
test_cases.emplace_back(START_ADDRESS + std::stoull(address, 0, 16),
name);
test_cases.emplace_back(START_ADDRESS + std::stoul(address, 0, 16), name);
}
fclose(f);
return true;
@@ -195,9 +194,9 @@ class TestRunner {
runtime->AddModule(std::move(module));
// Simulate a thread.
uint64_t stack_size = 64 * 1024;
uint64_t stack_address = START_ADDRESS - stack_size;
uint64_t thread_state_address = stack_address - 0x1000;
uint32_t stack_size = 64 * 1024;
uint32_t stack_address = START_ADDRESS - stack_size;
uint32_t thread_state_address = stack_address - 0x1000;
thread_state.reset(new ThreadState(runtime.get(), 0x100, stack_address,
stack_size, thread_state_address));
@@ -221,7 +220,7 @@ class TestRunner {
auto ctx = thread_state->context();
ctx->lr = 0xBEBEBEBE;
fn->Call(thread_state.get(), ctx->lr);
fn->Call(thread_state.get(), uint32_t(ctx->lr));
// Assert test state expectations.
bool result = CheckTestResults(test_case);

4
src/xenia/cpu/function.cc
View File

@@ -53,7 +53,7 @@ int Function::RemoveBreakpoint(Breakpoint* breakpoint) {
return found ? 0 : 1;
}
Breakpoint* Function::FindBreakpoint(uint64_t address) {
Breakpoint* Function::FindBreakpoint(uint32_t address) {
std::lock_guard<std::mutex> guard(lock_);
Breakpoint* result = nullptr;
for (auto breakpoint : breakpoints_) {
@@ -65,7 +65,7 @@ Breakpoint* Function::FindBreakpoint(uint64_t address) {
return result;
}
int Function::Call(ThreadState* thread_state, uint64_t return_address) {
int Function::Call(ThreadState* thread_state, uint32_t return_address) {
// SCOPE_profile_cpu_f("cpu");
ThreadState* original_thread_state = ThreadState::Get();

10
src/xenia/cpu/function.h
View File

@@ -28,7 +28,7 @@ class Function {
Function(FunctionInfo* symbol_info);
virtual ~Function();
uint64_t address() const { return address_; }
uint32_t address() const { return address_; }
FunctionInfo* symbol_info() const { return symbol_info_; }
DebugInfo* debug_info() const { return debug_info_.get(); }
@@ -39,16 +39,16 @@ class Function {
int AddBreakpoint(Breakpoint* breakpoint);
int RemoveBreakpoint(Breakpoint* breakpoint);
int Call(ThreadState* thread_state, uint64_t return_address);
int Call(ThreadState* thread_state, uint32_t return_address);
protected:
Breakpoint* FindBreakpoint(uint64_t address);
Breakpoint* FindBreakpoint(uint32_t address);
virtual int AddBreakpointImpl(Breakpoint* breakpoint) { return 0; }
virtual int RemoveBreakpointImpl(Breakpoint* breakpoint) { return 0; }
virtual int CallImpl(ThreadState* thread_state, uint64_t return_address) = 0;
virtual int CallImpl(ThreadState* thread_state, uint32_t return_address) = 0;
protected:
uint64_t address_;
uint32_t address_;
FunctionInfo* symbol_info_;
std::unique_ptr<DebugInfo> debug_info_;

6
src/xenia/cpu/instrument.cc
View File

@@ -78,8 +78,8 @@ void FunctionInstrument::Exit(ThreadState* thread_state) {
//
}
MemoryInstrument::MemoryInstrument(Runtime* runtime, uint64_t address,
uint64_t end_address)
MemoryInstrument::MemoryInstrument(Runtime* runtime, uint32_t address,
uint32_t end_address)
: Instrument(runtime), address_(address), end_address_(end_address) {}
bool MemoryInstrument::Attach() {
@@ -103,7 +103,7 @@ bool MemoryInstrument::Detach() {
return true;
}
void MemoryInstrument::Access(ThreadState* thread_state, uint64_t address,
void MemoryInstrument::Access(ThreadState* thread_state, uint32_t address,
AccessType type) {
// TODO(benvanik): get thread local instance
}

10
src/xenia/cpu/instrument.h
View File

@@ -86,7 +86,7 @@ class FunctionInstrument : public Instrument {
class MemoryInstrument : public Instrument {
public:
MemoryInstrument(Runtime* runtime, uint64_t address, uint64_t end_address);
MemoryInstrument(Runtime* runtime, uint32_t address, uint32_t end_address);
virtual ~MemoryInstrument() {}
uint64_t address() const { return address_; }
@@ -100,7 +100,7 @@ class MemoryInstrument : public Instrument {
ACCESS_READ = (1 << 1),
ACCESS_WRITE = (1 << 2),
};
void Access(ThreadState* thread_state, uint64_t address, AccessType type);
void Access(ThreadState* thread_state, uint32_t address, AccessType type);
protected:
class Instance {
@@ -110,7 +110,7 @@ class MemoryInstrument : public Instrument {
MemoryInstrument* instrument() const { return instrument_; }
virtual void OnAccess(ThreadState* thread_state, uint64_t address,
virtual void OnAccess(ThreadState* thread_state, uint32_t address,
AccessType type) = 0;
private:
@@ -118,8 +118,8 @@ class MemoryInstrument : public Instrument {
};
private:
uint64_t address_;
uint64_t end_address_;
uint32_t address_;
uint32_t end_address_;
};
// ThreadInstrument

10
src/xenia/cpu/module.cc
View File

@@ -24,9 +24,9 @@ Module::Module(Runtime* runtime)
Module::~Module() = default;
bool Module::ContainsAddress(uint64_t address) { return true; }
bool Module::ContainsAddress(uint32_t address) { return true; }
SymbolInfo* Module::LookupSymbol(uint64_t address, bool wait) {
SymbolInfo* Module::LookupSymbol(uint32_t address, bool wait) {
lock_.lock();
const auto it = map_.find(address);
SymbolInfo* symbol_info = it != map_.end() ? it->second : nullptr;
@@ -51,7 +51,7 @@ SymbolInfo* Module::LookupSymbol(uint64_t address, bool wait) {
}
SymbolInfo::Status Module::DeclareSymbol(SymbolInfo::Type type,
uint64_t address,
uint32_t address,
SymbolInfo** out_symbol_info) {
*out_symbol_info = nullptr;
lock_.lock();
@@ -100,7 +100,7 @@ SymbolInfo::Status Module::DeclareSymbol(SymbolInfo::Type type,
return status;
}
SymbolInfo::Status Module::DeclareFunction(uint64_t address,
SymbolInfo::Status Module::DeclareFunction(uint32_t address,
FunctionInfo** out_symbol_info) {
SymbolInfo* symbol_info;
SymbolInfo::Status status =
@@ -109,7 +109,7 @@ SymbolInfo::Status Module::DeclareFunction(uint64_t address,
return status;
}
SymbolInfo::Status Module::DeclareVariable(uint64_t address,
SymbolInfo::Status Module::DeclareVariable(uint32_t address,
VariableInfo** out_symbol_info) {
SymbolInfo* symbol_info;
SymbolInfo::Status status =

12
src/xenia/cpu/module.h
View File

@@ -34,12 +34,12 @@ class Module {
virtual const std::string& name() const = 0;
virtual bool ContainsAddress(uint64_t address);
virtual bool ContainsAddress(uint32_t address);
SymbolInfo* LookupSymbol(uint64_t address, bool wait = true);
virtual SymbolInfo::Status DeclareFunction(uint64_t address,
SymbolInfo* LookupSymbol(uint32_t address, bool wait = true);
virtual SymbolInfo::Status DeclareFunction(uint32_t address,
FunctionInfo** out_symbol_info);
virtual SymbolInfo::Status DeclareVariable(uint64_t address,
virtual SymbolInfo::Status DeclareVariable(uint32_t address,
VariableInfo** out_symbol_info);
SymbolInfo::Status DefineFunction(FunctionInfo* symbol_info);
@@ -52,7 +52,7 @@ class Module {
int ReadMap(const char* file_name);
private:
SymbolInfo::Status DeclareSymbol(SymbolInfo::Type type, uint64_t address,
SymbolInfo::Status DeclareSymbol(SymbolInfo::Type type, uint32_t address,
SymbolInfo** out_symbol_info);
SymbolInfo::Status DefineSymbol(SymbolInfo* symbol_info);
@@ -63,7 +63,7 @@ class Module {
private:
// TODO(benvanik): replace with a better data structure.
std::mutex lock_;
std::unordered_map<uint64_t, SymbolInfo*> map_;
std::unordered_map<uint32_t, SymbolInfo*> map_;
std::vector<std::unique_ptr<SymbolInfo>> list_;
};

6
src/xenia/cpu/processor.cc
View File

@@ -104,7 +104,7 @@ int Processor::Setup() {
return 0;
}
int Processor::Execute(ThreadState* thread_state, uint64_t address) {
int Processor::Execute(ThreadState* thread_state, uint32_t address) {
SCOPE_profile_cpu_f("cpu");
// Attempt to get the function.
@@ -129,7 +129,7 @@ int Processor::Execute(ThreadState* thread_state, uint64_t address) {
return 0;
}
uint64_t Processor::Execute(ThreadState* thread_state, uint64_t address,
uint64_t Processor::Execute(ThreadState* thread_state, uint32_t address,
uint64_t args[], size_t arg_count) {
SCOPE_profile_cpu_f("cpu");
@@ -155,7 +155,7 @@ void Processor::LowerIrql(Irql old_value) {
reinterpret_cast<volatile uint32_t*>(&irql_));
}
uint64_t Processor::ExecuteInterrupt(uint32_t cpu, uint64_t address,
uint64_t Processor::ExecuteInterrupt(uint32_t cpu, uint32_t address,
uint64_t args[], size_t arg_count) {
SCOPE_profile_cpu_f("cpu");

8
src/xenia/cpu/processor.h
View File

@@ -42,14 +42,14 @@ class Processor {
int Setup();
int Execute(ThreadState* thread_state, uint64_t address);
uint64_t Execute(ThreadState* thread_state, uint64_t address, uint64_t args[],
int Execute(ThreadState* thread_state, uint32_t address);
uint64_t Execute(ThreadState* thread_state, uint32_t address, uint64_t args[],
size_t arg_count);
Irql RaiseIrql(Irql new_value);
void LowerIrql(Irql old_value);
uint64_t ExecuteInterrupt(uint32_t cpu, uint64_t address, uint64_t args[],
uint64_t ExecuteInterrupt(uint32_t cpu, uint32_t address, uint64_t args[],
size_t arg_count);
private:
@@ -61,7 +61,7 @@ class Processor {
Irql irql_;
std::mutex interrupt_thread_lock_;
ThreadState* interrupt_thread_state_;
uint64_t interrupt_thread_block_;
uint32_t interrupt_thread_block_;
};
} // namespace cpu

6
src/xenia/cpu/raw_module.cc
View File

@@ -20,11 +20,11 @@ RawModule::RawModule(Runtime* runtime)
RawModule::~RawModule() {}
int RawModule::LoadFile(uint64_t base_address, const std::wstring& path) {
int RawModule::LoadFile(uint32_t base_address, const std::wstring& path) {
auto fixed_path = poly::to_string(poly::fix_path_separators(path));
FILE* file = fopen(fixed_path.c_str(), "rb");
fseek(file, 0, SEEK_END);
size_t file_length = ftell(file);
uint32_t file_length = static_cast<uint32_t>(ftell(file));
fseek(file, 0, SEEK_SET);
// Allocate memory.
@@ -52,7 +52,7 @@ int RawModule::LoadFile(uint64_t base_address, const std::wstring& path) {
return 0;
}
bool RawModule::ContainsAddress(uint64_t address) {
bool RawModule::ContainsAddress(uint32_t address) {
return address >= low_address_ && address < high_address_;
}

10
src/xenia/cpu/raw_module.h
View File

@@ -22,17 +22,17 @@ class RawModule : public Module {
RawModule(Runtime* runtime);
~RawModule() override;
int LoadFile(uint64_t base_address, const std::wstring& path);
int LoadFile(uint32_t base_address, const std::wstring& path);
const std::string& name() const override { return name_; }
bool ContainsAddress(uint64_t address) override;
bool ContainsAddress(uint32_t address) override;
private:
std::string name_;
uint64_t base_address_;
uint64_t low_address_;
uint64_t high_address_;
uint32_t base_address_;
uint32_t low_address_;
uint32_t high_address_;
};
} // namespace cpu

14
src/xenia/cpu/runtime.cc
View File

@@ -29,7 +29,7 @@ class BuiltinModule : public Module {
public:
BuiltinModule(Runtime* runtime) : Module(runtime), name_("builtin") {}
const std::string& name() const override { return name_; }
bool ContainsAddress(uint64_t address) override {
bool ContainsAddress(uint32_t address) override {
return (address & 0x1FFFFFFF0) == 0x100000000;
}
@@ -43,7 +43,7 @@ Runtime::Runtime(Memory* memory, ExportResolver* export_resolver,
debug_info_flags_(debug_info_flags),
trace_flags_(trace_flags),
builtin_module_(nullptr),
next_builtin_address_(0x100000000ull),
next_builtin_address_(0xFFFF0000ul),
export_resolver_(export_resolver) {}
Runtime::~Runtime() {
@@ -138,7 +138,7 @@ std::vector<Module*> Runtime::GetModules() {
FunctionInfo* Runtime::DefineBuiltin(const std::string& name,
FunctionInfo::ExternHandler handler,
void* arg0, void* arg1) {
uint64_t address = next_builtin_address_;
uint32_t address = next_builtin_address_;
next_builtin_address_ += 4;
FunctionInfo* fn_info;
@@ -151,11 +151,11 @@ FunctionInfo* Runtime::DefineBuiltin(const std::string& name,
return fn_info;
}
std::vector<Function*> Runtime::FindFunctionsWithAddress(uint64_t address) {
std::vector<Function*> Runtime::FindFunctionsWithAddress(uint32_t address) {
return entry_table_.FindWithAddress(address);
}
int Runtime::ResolveFunction(uint64_t address, Function** out_function) {
int Runtime::ResolveFunction(uint32_t address, Function** out_function) {
*out_function = nullptr;
Entry* entry;
Entry::Status status = entry_table_.GetOrCreate(address, &entry);
@@ -187,7 +187,7 @@ int Runtime::ResolveFunction(uint64_t address, Function** out_function) {
}
}
int Runtime::LookupFunctionInfo(uint64_t address,
int Runtime::LookupFunctionInfo(uint32_t address,
FunctionInfo** out_symbol_info) {
*out_symbol_info = nullptr;
@@ -214,7 +214,7 @@ int Runtime::LookupFunctionInfo(uint64_t address,
return LookupFunctionInfo(code_module, address, out_symbol_info);
}
int Runtime::LookupFunctionInfo(Module* module, uint64_t address,
int Runtime::LookupFunctionInfo(Module* module, uint32_t address,
FunctionInfo** out_symbol_info) {
// Atomic create/lookup symbol in module.
// If we get back the NEW flag we must declare it now.

10
src/xenia/cpu/runtime.h
View File

@@ -48,12 +48,12 @@ class Runtime {
FunctionInfo::ExternHandler handler, void* arg0,
void* arg1);
std::vector<Function*> FindFunctionsWithAddress(uint64_t address);
std::vector<Function*> FindFunctionsWithAddress(uint32_t address);
int LookupFunctionInfo(uint64_t address, FunctionInfo** out_symbol_info);
int LookupFunctionInfo(Module* module, uint64_t address,
int LookupFunctionInfo(uint32_t address, FunctionInfo** out_symbol_info);
int LookupFunctionInfo(Module* module, uint32_t address,
FunctionInfo** out_symbol_info);
int ResolveFunction(uint64_t address, Function** out_function);
int ResolveFunction(uint32_t address, Function** out_function);
// uint32_t CreateCallback(void (*callback)(void* data), void* data);
@@ -75,7 +75,7 @@ class Runtime {
std::mutex modules_lock_;
std::vector<std::unique_ptr<Module>> modules_;
Module* builtin_module_;
uint64_t next_builtin_address_;
uint32_t next_builtin_address_;
};
} // namespace cpu

6
src/xenia/cpu/symbol_info.cc
View File

@@ -12,7 +12,7 @@
namespace xe {
namespace cpu {
SymbolInfo::SymbolInfo(Type type, Module* module, uint64_t address)
SymbolInfo::SymbolInfo(Type type, Module* module, uint32_t address)
: type_(type),
module_(module),
status_(STATUS_DEFINING),
@@ -21,7 +21,7 @@ SymbolInfo::SymbolInfo(Type type, Module* module, uint64_t address)
SymbolInfo::~SymbolInfo() = default;
FunctionInfo::FunctionInfo(Module* module, uint64_t address)
FunctionInfo::FunctionInfo(Module* module, uint32_t address)
: SymbolInfo(SymbolInfo::TYPE_FUNCTION, module, address),
end_address_(0),
behavior_(BEHAVIOR_DEFAULT),
@@ -38,7 +38,7 @@ void FunctionInfo::SetupExtern(ExternHandler handler, void* arg0, void* arg1) {
extern_info_.arg1 = arg1;
}
VariableInfo::VariableInfo(Module* module, uint64_t address)
VariableInfo::VariableInfo(Module* module, uint32_t address)
: SymbolInfo(SymbolInfo::TYPE_VARIABLE, module, address) {}
VariableInfo::~VariableInfo() = default;

16
src/xenia/cpu/symbol_info.h
View File

@@ -35,14 +35,14 @@ class SymbolInfo {
};
public:
SymbolInfo(Type type, Module* module, uint64_t address);
SymbolInfo(Type type, Module* module, uint32_t address);
virtual ~SymbolInfo();
Type type() const { return type_; }
Module* module() const { return module_; }
Status status() const { return status_; }
void set_status(Status value) { status_ = value; }
uint64_t address() const { return address_; }
uint32_t address() const { return address_; }
const std::string& name() const { return name_; }
void set_name(const std::string& value) { name_ = value; }
@@ -51,7 +51,7 @@ class SymbolInfo {
Type type_;
Module* module_;
Status status_;
uint64_t address_;
uint32_t address_;
std::string name_;
};
@@ -67,12 +67,12 @@ class FunctionInfo : public SymbolInfo {
};
public:
FunctionInfo(Module* module, uint64_t address);
FunctionInfo(Module* module, uint32_t address);
~FunctionInfo() override;
bool has_end_address() const { return end_address_ > 0; }
uint64_t end_address() const { return end_address_; }
void set_end_address(uint64_t value) { end_address_ = value; }
uint32_t end_address() const { return end_address_; }
void set_end_address(uint32_t value) { end_address_ = value; }
Behavior behavior() const { return behavior_; }
void set_behavior(Behavior value) { behavior_ = value; }
@@ -87,7 +87,7 @@ class FunctionInfo : public SymbolInfo {
void* extern_arg1() const { return extern_info_.arg1; }
private:
uint64_t end_address_;
uint32_t end_address_;
Behavior behavior_;
Function* function_;
struct {
@@ -99,7 +99,7 @@ class FunctionInfo : public SymbolInfo {
class VariableInfo : public SymbolInfo {
public:
VariableInfo(Module* module, uint64_t address);
VariableInfo(Module* module, uint32_t address);
~VariableInfo() override;
};

10
src/xenia/cpu/test/util.h
View File

@@ -72,9 +72,9 @@ class TestFunction {
xe::cpu::Function* fn;
runtime->ResolveFunction(0x1000, &fn);
uint64_t stack_size = 64 * 1024;
uint64_t stack_address = memory_size - stack_size;
uint64_t thread_state_address = stack_address - 0x1000;
uint32_t stack_size = 64 * 1024;
uint32_t stack_address = memory_size - stack_size;
uint32_t thread_state_address = stack_address - 0x1000;
auto thread_state =
std::make_unique<ThreadState>(runtime.get(), 0x100, stack_address,
stack_size, thread_state_address);
@@ -83,13 +83,13 @@ class TestFunction {
pre_call(ctx);
fn->Call(thread_state.get(), ctx->lr);
fn->Call(thread_state.get(), uint32_t(ctx->lr));
post_call(ctx);
}
}
size_t memory_size;
uint32_t memory_size;
std::unique_ptr<Memory> memory;
std::vector<std::unique_ptr<Runtime>> runtimes;
};

6
src/xenia/cpu/test_module.cc
View File

@@ -24,7 +24,7 @@ using xe::cpu::hir::HIRBuilder;
namespace passes = xe::cpu::compiler::passes;
TestModule::TestModule(Runtime* runtime, const std::string& name,
std::function<bool(uint64_t)> contains_address,
std::function<bool(uint32_t)> contains_address,
std::function<bool(hir::HIRBuilder&)> generate)
: Module(runtime),
name_(name),
@@ -66,11 +66,11 @@ TestModule::TestModule(Runtime* runtime, const std::string& name,
TestModule::~TestModule() = default;
bool TestModule::ContainsAddress(uint64_t address) {
bool TestModule::ContainsAddress(uint32_t address) {
return contains_address_(address);
}
SymbolInfo::Status TestModule::DeclareFunction(uint64_t address,
SymbolInfo::Status TestModule::DeclareFunction(uint32_t address,
FunctionInfo** out_symbol_info) {
SymbolInfo::Status status = Module::DeclareFunction(address, out_symbol_info);
if (status == SymbolInfo::STATUS_NEW) {

8
src/xenia/cpu/test_module.h
View File

@@ -25,20 +25,20 @@ namespace cpu {
class TestModule : public Module {
public:
TestModule(Runtime* runtime, const std::string& name,
std::function<bool(uint64_t)> contains_address,
std::function<bool(uint32_t)> contains_address,
std::function<bool(hir::HIRBuilder&)> generate);
~TestModule() override;
const std::string& name() const override { return name_; }
bool ContainsAddress(uint64_t address) override;
bool ContainsAddress(uint32_t address) override;
SymbolInfo::Status DeclareFunction(uint64_t address,
SymbolInfo::Status DeclareFunction(uint32_t address,
FunctionInfo** out_symbol_info) override;
private:
std::string name_;
std::function<bool(uint64_t)> contains_address_;
std::function<bool(uint32_t)> contains_address_;
std::function<bool(hir::HIRBuilder&)> generate_;
std::unique_ptr<hir::HIRBuilder> builder_;

4
src/xenia/cpu/thread_state.cc
View File

@@ -22,8 +22,8 @@ using PPCContext = xe::cpu::frontend::PPCContext;
thread_local ThreadState* thread_state_ = nullptr;
ThreadState::ThreadState(Runtime* runtime, uint32_t thread_id,
uint64_t stack_address, size_t stack_size,
uint64_t thread_state_address)
uint32_t stack_address, uint32_t stack_size,
uint32_t thread_state_address)
: runtime_(runtime),
memory_(runtime->memory()),
thread_id_(thread_id),

14
src/xenia/cpu/thread_state.h
View File

@@ -28,8 +28,8 @@ class Runtime;
class ThreadState {
public:
ThreadState(Runtime* runtime, uint32_t thread_id, uint64_t stack_address,
size_t stack_size, uint64_t thread_state_address);
ThreadState(Runtime* runtime, uint32_t thread_id, uint32_t stack_address,
uint32_t stack_size, uint32_t thread_state_address);
~ThreadState();
Runtime* runtime() const { return runtime_; }
@@ -39,9 +39,9 @@ class ThreadState {
void set_name(const std::string& value) { name_ = value; }
void* backend_data() const { return backend_data_; }
void* raw_context() const { return raw_context_; }
uint64_t stack_address() const { return stack_address_; }
uint32_t stack_address() const { return stack_address_; }
size_t stack_size() const { return stack_size_; }
uint64_t thread_state_address() const { return thread_state_address_; }
uint32_t thread_state_address() const { return thread_state_address_; }
xe::cpu::frontend::PPCContext* context() const { return context_; }
int Suspend() { return Suspend(~0); }
@@ -61,10 +61,10 @@ class ThreadState {
std::string name_;
void* backend_data_;
void* raw_context_;
uint64_t stack_address_;
uint32_t stack_address_;
bool stack_allocated_;
size_t stack_size_;
uint64_t thread_state_address_;
uint32_t stack_size_;
uint32_t thread_state_address_;
// NOTE: must be 64b aligned for SSE ops.
xe::cpu::frontend::PPCContext* context_;

349
src/xenia/cpu/xex_module.cc
View File

@@ -35,11 +35,10 @@ XexModule::XexModule(Runtime* runtime)
low_address_(0),
high_address_(0) {}
XexModule::~XexModule() {
xe_xex2_dealloc(xex_);
}
XexModule::~XexModule() { xe_xex2_dealloc(xex_); }
int XexModule::Load(const std::string& name, const std::string& path, xe_xex2_ref xex) {
int XexModule::Load(const std::string& name, const std::string& path,
xe_xex2_ref xex) {
int result;
xex_ = xex;
@@ -49,16 +48,15 @@ int XexModule::Load(const std::string& name, const std::string& path, xe_xex2_re
// All code sections are continuous, so this should be easy.
low_address_ = UINT_MAX;
high_address_ = 0;
for (size_t n = 0, i = 0; n < header->section_count; n++) {
for (uint32_t n = 0, i = 0; n < header->section_count; n++) {
const xe_xex2_section_t* section = &header->sections[n];
const size_t start_address = header->exe_address + (i * section->page_size);
const size_t end_address =
const uint32_t start_address =
header->exe_address + (i * section->page_size);
const uint32_t end_address =
start_address + (section->info.page_count * section->page_size);
if (section->info.type == XEX_SECTION_CODE) {
low_address_ =
static_cast<uint32_t>(std::min(low_address_, start_address));
high_address_ =
static_cast<uint32_t>(std::max(high_address_, end_address));
low_address_ = std::min(low_address_, start_address);
high_address_ = std::max(high_address_, end_address);
}
i += section->info.page_count;
}
@@ -96,8 +94,8 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
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)) {
if (xe_xex2_get_import_infos(xex_, library, &import_infos,
&import_info_count)) {
return 1;
}
@@ -107,8 +105,8 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
for (size_t n = 0; n < import_info_count; n++) {
const xe_xex2_import_info_t* info = &import_infos[n];
KernelExport* kernel_export = export_resolver->GetExportByOrdinal(
library->name, info->ordinal);
KernelExport* kernel_export =
export_resolver->GetExportByOrdinal(library->name, info->ordinal);
if (kernel_export) {
if (info->thunk_address) {
@@ -118,15 +116,15 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
}
} else {
snprintf(name, poly::countof(name), "__imp_%s_%.3X", library->name,
info->ordinal);
info->ordinal);
}
VariableInfo* var_info;
DeclareVariable(info->value_address, &var_info);
//var->set_name(name);
// var->set_name(name);
var_info->set_status(SymbolInfo::STATUS_DECLARED);
DefineVariable(var_info);
//var->kernel_export = kernel_export;
// var->kernel_export = kernel_export;
var_info->set_status(SymbolInfo::STATUS_DEFINED);
// Grab, if available.
@@ -148,7 +146,8 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
poly::store_and_swap<uint32_t>(slot, kernel_export->variable_ptr);
} else {
// Not implemented - write with a dummy value.
poly::store_and_swap<uint32_t>(slot, 0xD000BEEF | (kernel_export->ordinal & 0xFFF) << 16);
poly::store_and_swap<uint32_t>(
slot, 0xD000BEEF | (kernel_export->ordinal & 0xFFF) << 16);
XELOGCPU("WARNING: imported a variable with no value: %s",
kernel_export->name);
}
@@ -186,7 +185,8 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
FunctionInfo::ExternHandler handler = 0;
void* handler_data = 0;
if (kernel_export) {
handler = (FunctionInfo::ExternHandler)kernel_export->function_data.shim;
handler =
(FunctionInfo::ExternHandler)kernel_export->function_data.shim;
handler_data = kernel_export->function_data.shim_data;
} else {
handler = (FunctionInfo::ExternHandler)UndefinedImport;
@@ -205,7 +205,7 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
return 0;
}
bool XexModule::ContainsAddress(uint64_t address) {
bool XexModule::ContainsAddress(uint32_t address) {
return address >= low_address_ && address < high_address_;
}
@@ -217,180 +217,173 @@ int XexModule::FindSaveRest() {
// __savegprlr_14 to __savegprlr_31
// __restgprlr_14 to __restgprlr_31
static const uint32_t gprlr_code_values[] = {
0x68FFC1F9, // __savegprlr_14
0x70FFE1F9, // __savegprlr_15
0x78FF01FA, // __savegprlr_16
0x80FF21FA, // __savegprlr_17
0x88FF41FA, // __savegprlr_18
0x90FF61FA, // __savegprlr_19
0x98FF81FA, // __savegprlr_20
0xA0FFA1FA, // __savegprlr_21
0xA8FFC1FA, // __savegprlr_22
0xB0FFE1FA, // __savegprlr_23
0xB8FF01FB, // __savegprlr_24
0xC0FF21FB, // __savegprlr_25
0xC8FF41FB, // __savegprlr_26
0xD0FF61FB, // __savegprlr_27
0xD8FF81FB, // __savegprlr_28
0xE0FFA1FB, // __savegprlr_29
0xE8FFC1FB, // __savegprlr_30
0xF0FFE1FB, // __savegprlr_31
0xF8FF8191,
0x2000804E,
0x68FFC1E9, // __restgprlr_14
0x70FFE1E9, // __restgprlr_15
0x78FF01EA, // __restgprlr_16
0x80FF21EA, // __restgprlr_17
0x88FF41EA, // __restgprlr_18
0x90FF61EA, // __restgprlr_19
0x98FF81EA, // __restgprlr_20
0xA0FFA1EA, // __restgprlr_21
0xA8FFC1EA, // __restgprlr_22
0xB0FFE1EA, // __restgprlr_23
0xB8FF01EB, // __restgprlr_24
0xC0FF21EB, // __restgprlr_25
0xC8FF41EB, // __restgprlr_26
0xD0FF61EB, // __restgprlr_27
0xD8FF81EB, // __restgprlr_28
0xE0FFA1EB, // __restgprlr_29
0xE8FFC1EB, // __restgprlr_30
0xF0FFE1EB, // __restgprlr_31
0xF8FF8181,
0xA603887D,
0x2000804E,
0x68FFC1F9, // __savegprlr_14
0x70FFE1F9, // __savegprlr_15
0x78FF01FA, // __savegprlr_16
0x80FF21FA, // __savegprlr_17
0x88FF41FA, // __savegprlr_18
0x90FF61FA, // __savegprlr_19
0x98FF81FA, // __savegprlr_20
0xA0FFA1FA, // __savegprlr_21
0xA8FFC1FA, // __savegprlr_22
0xB0FFE1FA, // __savegprlr_23
0xB8FF01FB, // __savegprlr_24
0xC0FF21FB, // __savegprlr_25
0xC8FF41FB, // __savegprlr_26
0xD0FF61FB, // __savegprlr_27
0xD8FF81FB, // __savegprlr_28
0xE0FFA1FB, // __savegprlr_29
0xE8FFC1FB, // __savegprlr_30
0xF0FFE1FB, // __savegprlr_31
0xF8FF8191, 0x2000804E,
0x68FFC1E9, // __restgprlr_14
0x70FFE1E9, // __restgprlr_15
0x78FF01EA, // __restgprlr_16
0x80FF21EA, // __restgprlr_17
0x88FF41EA, // __restgprlr_18
0x90FF61EA, // __restgprlr_19
0x98FF81EA, // __restgprlr_20
0xA0FFA1EA, // __restgprlr_21
0xA8FFC1EA, // __restgprlr_22
0xB0FFE1EA, // __restgprlr_23
0xB8FF01EB, // __restgprlr_24
0xC0FF21EB, // __restgprlr_25
0xC8FF41EB, // __restgprlr_26
0xD0FF61EB, // __restgprlr_27
0xD8FF81EB, // __restgprlr_28
0xE0FFA1EB, // __restgprlr_29
0xE8FFC1EB, // __restgprlr_30
0xF0FFE1EB, // __restgprlr_31
0xF8FF8181, 0xA603887D, 0x2000804E,
};
// __savefpr_14 to __savefpr_31
// __restfpr_14 to __restfpr_31
static const uint32_t fpr_code_values[] = {
0x70FFCCD9, // __savefpr_14
0x78FFECD9, // __savefpr_15
0x80FF0CDA, // __savefpr_16
0x88FF2CDA, // __savefpr_17
0x90FF4CDA, // __savefpr_18
0x98FF6CDA, // __savefpr_19
0xA0FF8CDA, // __savefpr_20
0xA8FFACDA, // __savefpr_21
0xB0FFCCDA, // __savefpr_22
0xB8FFECDA, // __savefpr_23
0xC0FF0CDB, // __savefpr_24
0xC8FF2CDB, // __savefpr_25
0xD0FF4CDB, // __savefpr_26
0xD8FF6CDB, // __savefpr_27
0xE0FF8CDB, // __savefpr_28
0xE8FFACDB, // __savefpr_29
0xF0FFCCDB, // __savefpr_30
0xF8FFECDB, // __savefpr_31
0x2000804E,
0x70FFCCC9, // __restfpr_14
0x78FFECC9, // __restfpr_15
0x80FF0CCA, // __restfpr_16
0x88FF2CCA, // __restfpr_17
0x90FF4CCA, // __restfpr_18
0x98FF6CCA, // __restfpr_19
0xA0FF8CCA, // __restfpr_20
0xA8FFACCA, // __restfpr_21
0xB0FFCCCA, // __restfpr_22
0xB8FFECCA, // __restfpr_23
0xC0FF0CCB, // __restfpr_24
0xC8FF2CCB, // __restfpr_25
0xD0FF4CCB, // __restfpr_26
0xD8FF6CCB, // __restfpr_27
0xE0FF8CCB, // __restfpr_28
0xE8FFACCB, // __restfpr_29
0xF0FFCCCB, // __restfpr_30
0xF8FFECCB, // __restfpr_31
0x2000804E,
0x70FFCCD9, // __savefpr_14
0x78FFECD9, // __savefpr_15
0x80FF0CDA, // __savefpr_16
0x88FF2CDA, // __savefpr_17
0x90FF4CDA, // __savefpr_18
0x98FF6CDA, // __savefpr_19
0xA0FF8CDA, // __savefpr_20
0xA8FFACDA, // __savefpr_21
0xB0FFCCDA, // __savefpr_22
0xB8FFECDA, // __savefpr_23
0xC0FF0CDB, // __savefpr_24
0xC8FF2CDB, // __savefpr_25
0xD0FF4CDB, // __savefpr_26
0xD8FF6CDB, // __savefpr_27
0xE0FF8CDB, // __savefpr_28
0xE8FFACDB, // __savefpr_29
0xF0FFCCDB, // __savefpr_30
0xF8FFECDB, // __savefpr_31
0x2000804E,
0x70FFCCC9, // __restfpr_14
0x78FFECC9, // __restfpr_15
0x80FF0CCA, // __restfpr_16
0x88FF2CCA, // __restfpr_17
0x90FF4CCA, // __restfpr_18
0x98FF6CCA, // __restfpr_19
0xA0FF8CCA, // __restfpr_20
0xA8FFACCA, // __restfpr_21
0xB0FFCCCA, // __restfpr_22
0xB8FFECCA, // __restfpr_23
0xC0FF0CCB, // __restfpr_24
0xC8FF2CCB, // __restfpr_25
0xD0FF4CCB, // __restfpr_26
0xD8FF6CCB, // __restfpr_27
0xE0FF8CCB, // __restfpr_28
0xE8FFACCB, // __restfpr_29
0xF0FFCCCB, // __restfpr_30
0xF8FFECCB, // __restfpr_31
0x2000804E,
};
// __savevmx_14 to __savevmx_31
// __savevmx_64 to __savevmx_127
// __restvmx_14 to __restvmx_31
// __restvmx_64 to __restvmx_127
static const uint32_t vmx_code_values[] = {
0xE0FE6039, // __savevmx_14
0xCE61CB7D, 0xF0FE6039, 0xCE61EB7D, 0x00FF6039, 0xCE610B7E, 0x10FF6039,
0xCE612B7E, 0x20FF6039, 0xCE614B7E, 0x30FF6039, 0xCE616B7E, 0x40FF6039,
0xCE618B7E, 0x50FF6039, 0xCE61AB7E, 0x60FF6039, 0xCE61CB7E, 0x70FF6039,
0xCE61EB7E, 0x80FF6039, 0xCE610B7F, 0x90FF6039, 0xCE612B7F, 0xA0FF6039,
0xCE614B7F, 0xB0FF6039, 0xCE616B7F, 0xC0FF6039, 0xCE618B7F, 0xD0FF6039,
0xCE61AB7F, 0xE0FF6039, 0xCE61CB7F,
0xF0FF6039, // __savevmx_31
0xCE61EB7F,
0x2000804E,
0xE0FE6039, // __savevmx_14
0xCE61CB7D, 0xF0FE6039, 0xCE61EB7D, 0x00FF6039, 0xCE610B7E, 0x10FF6039,
0xCE612B7E, 0x20FF6039, 0xCE614B7E, 0x30FF6039, 0xCE616B7E, 0x40FF6039,
0xCE618B7E, 0x50FF6039, 0xCE61AB7E, 0x60FF6039, 0xCE61CB7E, 0x70FF6039,
0xCE61EB7E, 0x80FF6039, 0xCE610B7F, 0x90FF6039, 0xCE612B7F, 0xA0FF6039,
0xCE614B7F, 0xB0FF6039, 0xCE616B7F, 0xC0FF6039, 0xCE618B7F, 0xD0FF6039,
0xCE61AB7F, 0xE0FF6039, 0xCE61CB7F, 0xF0FF6039, // __savevmx_31
0xCE61EB7F, 0x2000804E,
0x00FC6039, // __savevmx_64
0xCB610B10, 0x10FC6039, 0xCB612B10, 0x20FC6039, 0xCB614B10, 0x30FC6039,
0xCB616B10, 0x40FC6039, 0xCB618B10, 0x50FC6039, 0xCB61AB10, 0x60FC6039,
0xCB61CB10, 0x70FC6039, 0xCB61EB10, 0x80FC6039, 0xCB610B11, 0x90FC6039,
0xCB612B11, 0xA0FC6039, 0xCB614B11, 0xB0FC6039, 0xCB616B11, 0xC0FC6039,
0xCB618B11, 0xD0FC6039, 0xCB61AB11, 0xE0FC6039, 0xCB61CB11, 0xF0FC6039,
0xCB61EB11, 0x00FD6039, 0xCB610B12, 0x10FD6039, 0xCB612B12, 0x20FD6039,
0xCB614B12, 0x30FD6039, 0xCB616B12, 0x40FD6039, 0xCB618B12, 0x50FD6039,
0xCB61AB12, 0x60FD6039, 0xCB61CB12, 0x70FD6039, 0xCB61EB12, 0x80FD6039,
0xCB610B13, 0x90FD6039, 0xCB612B13, 0xA0FD6039, 0xCB614B13, 0xB0FD6039,
0xCB616B13, 0xC0FD6039, 0xCB618B13, 0xD0FD6039, 0xCB61AB13, 0xE0FD6039,
0xCB61CB13, 0xF0FD6039, 0xCB61EB13, 0x00FE6039, 0xCF610B10, 0x10FE6039,
0xCF612B10, 0x20FE6039, 0xCF614B10, 0x30FE6039, 0xCF616B10, 0x40FE6039,
0xCF618B10, 0x50FE6039, 0xCF61AB10, 0x60FE6039, 0xCF61CB10, 0x70FE6039,
0xCF61EB10, 0x80FE6039, 0xCF610B11, 0x90FE6039, 0xCF612B11, 0xA0FE6039,
0xCF614B11, 0xB0FE6039, 0xCF616B11, 0xC0FE6039, 0xCF618B11, 0xD0FE6039,
0xCF61AB11, 0xE0FE6039, 0xCF61CB11, 0xF0FE6039, 0xCF61EB11, 0x00FF6039,
0xCF610B12, 0x10FF6039, 0xCF612B12, 0x20FF6039, 0xCF614B12, 0x30FF6039,
0xCF616B12, 0x40FF6039, 0xCF618B12, 0x50FF6039, 0xCF61AB12, 0x60FF6039,
0xCF61CB12, 0x70FF6039, 0xCF61EB12, 0x80FF6039, 0xCF610B13, 0x90FF6039,
0xCF612B13, 0xA0FF6039, 0xCF614B13, 0xB0FF6039, 0xCF616B13, 0xC0FF6039,
0xCF618B13, 0xD0FF6039, 0xCF61AB13, 0xE0FF6039, 0xCF61CB13,
0xF0FF6039, // __savevmx_127
0xCF61EB13,
0x2000804E,
0x00FC6039, // __savevmx_64
0xCB610B10, 0x10FC6039, 0xCB612B10, 0x20FC6039, 0xCB614B10, 0x30FC6039,
0xCB616B10, 0x40FC6039, 0xCB618B10, 0x50FC6039, 0xCB61AB10, 0x60FC6039,
0xCB61CB10, 0x70FC6039, 0xCB61EB10, 0x80FC6039, 0xCB610B11, 0x90FC6039,
0xCB612B11, 0xA0FC6039, 0xCB614B11, 0xB0FC6039, 0xCB616B11, 0xC0FC6039,
0xCB618B11, 0xD0FC6039, 0xCB61AB11, 0xE0FC6039, 0xCB61CB11, 0xF0FC6039,
0xCB61EB11, 0x00FD6039, 0xCB610B12, 0x10FD6039, 0xCB612B12, 0x20FD6039,
0xCB614B12, 0x30FD6039, 0xCB616B12, 0x40FD6039, 0xCB618B12, 0x50FD6039,
0xCB61AB12, 0x60FD6039, 0xCB61CB12, 0x70FD6039, 0xCB61EB12, 0x80FD6039,
0xCB610B13, 0x90FD6039, 0xCB612B13, 0xA0FD6039, 0xCB614B13, 0xB0FD6039,
0xCB616B13, 0xC0FD6039, 0xCB618B13, 0xD0FD6039, 0xCB61AB13, 0xE0FD6039,
0xCB61CB13, 0xF0FD6039, 0xCB61EB13, 0x00FE6039, 0xCF610B10, 0x10FE6039,
0xCF612B10, 0x20FE6039, 0xCF614B10, 0x30FE6039, 0xCF616B10, 0x40FE6039,
0xCF618B10, 0x50FE6039, 0xCF61AB10, 0x60FE6039, 0xCF61CB10, 0x70FE6039,
0xCF61EB10, 0x80FE6039, 0xCF610B11, 0x90FE6039, 0xCF612B11, 0xA0FE6039,
0xCF614B11, 0xB0FE6039, 0xCF616B11, 0xC0FE6039, 0xCF618B11, 0xD0FE6039,
0xCF61AB11, 0xE0FE6039, 0xCF61CB11, 0xF0FE6039, 0xCF61EB11, 0x00FF6039,
0xCF610B12, 0x10FF6039, 0xCF612B12, 0x20FF6039, 0xCF614B12, 0x30FF6039,
0xCF616B12, 0x40FF6039, 0xCF618B12, 0x50FF6039, 0xCF61AB12, 0x60FF6039,
0xCF61CB12, 0x70FF6039, 0xCF61EB12, 0x80FF6039, 0xCF610B13, 0x90FF6039,
0xCF612B13, 0xA0FF6039, 0xCF614B13, 0xB0FF6039, 0xCF616B13, 0xC0FF6039,
0xCF618B13, 0xD0FF6039, 0xCF61AB13, 0xE0FF6039, 0xCF61CB13,
0xF0FF6039, // __savevmx_127
0xCF61EB13, 0x2000804E,
0xE0FE6039, // __restvmx_14
0xCE60CB7D, 0xF0FE6039, 0xCE60EB7D, 0x00FF6039, 0xCE600B7E, 0x10FF6039,
0xCE602B7E, 0x20FF6039, 0xCE604B7E, 0x30FF6039, 0xCE606B7E, 0x40FF6039,
0xCE608B7E, 0x50FF6039, 0xCE60AB7E, 0x60FF6039, 0xCE60CB7E, 0x70FF6039,
0xCE60EB7E, 0x80FF6039, 0xCE600B7F, 0x90FF6039, 0xCE602B7F, 0xA0FF6039,
0xCE604B7F, 0xB0FF6039, 0xCE606B7F, 0xC0FF6039, 0xCE608B7F, 0xD0FF6039,
0xCE60AB7F, 0xE0FF6039, 0xCE60CB7F, 0xF0FF6039, // __restvmx_31
0xCE60EB7F,
0x2000804E,
0xE0FE6039, // __restvmx_14
0xCE60CB7D, 0xF0FE6039, 0xCE60EB7D, 0x00FF6039, 0xCE600B7E, 0x10FF6039,
0xCE602B7E, 0x20FF6039, 0xCE604B7E, 0x30FF6039, 0xCE606B7E, 0x40FF6039,
0xCE608B7E, 0x50FF6039, 0xCE60AB7E, 0x60FF6039, 0xCE60CB7E, 0x70FF6039,
0xCE60EB7E, 0x80FF6039, 0xCE600B7F, 0x90FF6039, 0xCE602B7F, 0xA0FF6039,
0xCE604B7F, 0xB0FF6039, 0xCE606B7F, 0xC0FF6039, 0xCE608B7F, 0xD0FF6039,
0xCE60AB7F, 0xE0FF6039, 0xCE60CB7F, 0xF0FF6039, // __restvmx_31
0xCE60EB7F, 0x2000804E,
0x00FC6039, // __restvmx_64
0xCB600B10, 0x10FC6039, 0xCB602B10, 0x20FC6039, 0xCB604B10, 0x30FC6039,
0xCB606B10, 0x40FC6039, 0xCB608B10, 0x50FC6039, 0xCB60AB10, 0x60FC6039,
0xCB60CB10, 0x70FC6039, 0xCB60EB10, 0x80FC6039, 0xCB600B11, 0x90FC6039,
0xCB602B11, 0xA0FC6039, 0xCB604B11, 0xB0FC6039, 0xCB606B11, 0xC0FC6039,
0xCB608B11, 0xD0FC6039, 0xCB60AB11, 0xE0FC6039, 0xCB60CB11, 0xF0FC6039,
0xCB60EB11, 0x00FD6039, 0xCB600B12, 0x10FD6039, 0xCB602B12, 0x20FD6039,
0xCB604B12, 0x30FD6039, 0xCB606B12, 0x40FD6039, 0xCB608B12, 0x50FD6039,
0xCB60AB12, 0x60FD6039, 0xCB60CB12, 0x70FD6039, 0xCB60EB12, 0x80FD6039,
0xCB600B13, 0x90FD6039, 0xCB602B13, 0xA0FD6039, 0xCB604B13, 0xB0FD6039,
0xCB606B13, 0xC0FD6039, 0xCB608B13, 0xD0FD6039, 0xCB60AB13, 0xE0FD6039,
0xCB60CB13, 0xF0FD6039, 0xCB60EB13, 0x00FE6039, 0xCF600B10, 0x10FE6039,
0xCF602B10, 0x20FE6039, 0xCF604B10, 0x30FE6039, 0xCF606B10, 0x40FE6039,
0xCF608B10, 0x50FE6039, 0xCF60AB10, 0x60FE6039, 0xCF60CB10, 0x70FE6039,
0xCF60EB10, 0x80FE6039, 0xCF600B11, 0x90FE6039, 0xCF602B11, 0xA0FE6039,
0xCF604B11, 0xB0FE6039, 0xCF606B11, 0xC0FE6039, 0xCF608B11, 0xD0FE6039,
0xCF60AB11, 0xE0FE6039, 0xCF60CB11, 0xF0FE6039, 0xCF60EB11, 0x00FF6039,
0xCF600B12, 0x10FF6039, 0xCF602B12, 0x20FF6039, 0xCF604B12, 0x30FF6039,
0xCF606B12, 0x40FF6039, 0xCF608B12, 0x50FF6039, 0xCF60AB12, 0x60FF6039,
0xCF60CB12, 0x70FF6039, 0xCF60EB12, 0x80FF6039, 0xCF600B13, 0x90FF6039,
0xCF602B13, 0xA0FF6039, 0xCF604B13, 0xB0FF6039, 0xCF606B13, 0xC0FF6039,
0xCF608B13, 0xD0FF6039, 0xCF60AB13, 0xE0FF6039, 0xCF60CB13,
0xF0FF6039, // __restvmx_127
0xCF60EB13,
0x2000804E,
0x00FC6039, // __restvmx_64
0xCB600B10, 0x10FC6039, 0xCB602B10, 0x20FC6039, 0xCB604B10, 0x30FC6039,
0xCB606B10, 0x40FC6039, 0xCB608B10, 0x50FC6039, 0xCB60AB10, 0x60FC6039,
0xCB60CB10, 0x70FC6039, 0xCB60EB10, 0x80FC6039, 0xCB600B11, 0x90FC6039,
0xCB602B11, 0xA0FC6039, 0xCB604B11, 0xB0FC6039, 0xCB606B11, 0xC0FC6039,
0xCB608B11, 0xD0FC6039, 0xCB60AB11, 0xE0FC6039, 0xCB60CB11, 0xF0FC6039,
0xCB60EB11, 0x00FD6039, 0xCB600B12, 0x10FD6039, 0xCB602B12, 0x20FD6039,
0xCB604B12, 0x30FD6039, 0xCB606B12, 0x40FD6039, 0xCB608B12, 0x50FD6039,
0xCB60AB12, 0x60FD6039, 0xCB60CB12, 0x70FD6039, 0xCB60EB12, 0x80FD6039,
0xCB600B13, 0x90FD6039, 0xCB602B13, 0xA0FD6039, 0xCB604B13, 0xB0FD6039,
0xCB606B13, 0xC0FD6039, 0xCB608B13, 0xD0FD6039, 0xCB60AB13, 0xE0FD6039,
0xCB60CB13, 0xF0FD6039, 0xCB60EB13, 0x00FE6039, 0xCF600B10, 0x10FE6039,
0xCF602B10, 0x20FE6039, 0xCF604B10, 0x30FE6039, 0xCF606B10, 0x40FE6039,
0xCF608B10, 0x50FE6039, 0xCF60AB10, 0x60FE6039, 0xCF60CB10, 0x70FE6039,
0xCF60EB10, 0x80FE6039, 0xCF600B11, 0x90FE6039, 0xCF602B11, 0xA0FE6039,
0xCF604B11, 0xB0FE6039, 0xCF606B11, 0xC0FE6039, 0xCF608B11, 0xD0FE6039,
0xCF60AB11, 0xE0FE6039, 0xCF60CB11, 0xF0FE6039, 0xCF60EB11, 0x00FF6039,
0xCF600B12, 0x10FF6039, 0xCF602B12, 0x20FF6039, 0xCF604B12, 0x30FF6039,
0xCF606B12, 0x40FF6039, 0xCF608B12, 0x50FF6039, 0xCF60AB12, 0x60FF6039,
0xCF60CB12, 0x70FF6039, 0xCF60EB12, 0x80FF6039, 0xCF600B13, 0x90FF6039,
0xCF602B13, 0xA0FF6039, 0xCF604B13, 0xB0FF6039, 0xCF606B13, 0xC0FF6039,
0xCF608B13, 0xD0FF6039, 0xCF60AB13, 0xE0FF6039, 0xCF60CB13,
0xF0FF6039, // __restvmx_127
0xCF60EB13, 0x2000804E,
};
// TODO(benvanik): these are almost always sequential, if present.
// It'd be smarter to search around the other ones to prevent
// 3 full module scans.
uint64_t gplr_start = 0;
uint64_t fpr_start = 0;
uint64_t vmx_start = 0;
uint32_t gplr_start = 0;
uint32_t fpr_start = 0;
uint32_t vmx_start = 0;
const xe_xex2_header_t* header = xe_xex2_get_header(xex_);
for (size_t n = 0, i = 0; n < header->section_count; n++) {
for (uint32_t n = 0, i = 0; n < header->section_count; n++) {
const xe_xex2_section_t* section = &header->sections[n];
const size_t start_address = header->exe_address + (i * section->page_size);
const size_t end_address =
const uint32_t start_address =
header->exe_address + (i * section->page_size);
const uint32_t end_address =
start_address + (section->info.page_count * section->page_size);
if (section->info.type == XEX_SECTION_CODE) {
if (!gplr_start) {
@@ -418,7 +411,7 @@ int XexModule::FindSaveRest() {
// Add function stubs.
char name[32];
if (gplr_start) {
uint64_t address = gplr_start;
uint32_t address = gplr_start;
for (int n = 14; n <= 31; n++) {
snprintf(name, poly::countof(name), "__savegprlr_%d", n);
FunctionInfo* symbol_info;
@@ -446,7 +439,7 @@ int XexModule::FindSaveRest() {
}
}
if (fpr_start) {
uint64_t address = fpr_start;
uint32_t address = fpr_start;
for (int n = 14; n <= 31; n++) {
snprintf(name, poly::countof(name), "__savefpr_%d", n);
FunctionInfo* symbol_info;
@@ -479,7 +472,7 @@ int XexModule::FindSaveRest() {
// 64-127 save
// 14-31 rest
// 64-127 rest
uint64_t address = vmx_start;
uint32_t address = vmx_start;
for (int n = 14; n <= 31; n++) {
snprintf(name, poly::countof(name), "__savevmx_%d", n);
FunctionInfo* symbol_info;

24
src/xenia/cpu/xex_module.h
View File

@@ -22,8 +22,8 @@ namespace cpu {
class Runtime;
class XexModule : public xe::cpu::Module {
public:
XexModule(Runtime* runtime);
public:
XexModule(Runtime* runtime);
virtual ~XexModule();
xe_xex2_ref xex() const { return xex_; }
@@ -32,22 +32,22 @@ public:
const std::string& name() const override { return name_; }
bool ContainsAddress(uint64_t address) override;
bool ContainsAddress(uint32_t address) override;
private:
private:
int SetupImports(xe_xex2_ref xex);
int SetupLibraryImports(const xe_xex2_import_library_t* library);
int FindSaveRest();
private:
Runtime* runtime_;
std::string name_;
std::string path_;
xe_xex2_ref xex_;
private:
Runtime* runtime_;
std::string name_;
std::string path_;
xe_xex2_ref xex_;
uint64_t base_address_;
uint64_t low_address_;
uint64_t high_address_;
uint32_t base_address_;
uint32_t low_address_;
uint32_t high_address_;
};
} // namespace cpu