saulteafarmer/XenonRecomp
1
0
Fork 0
mirror of https://github.com/hedge-dev/XenonRecomp.git synced 2025-05-23 02:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Downgrade projects to C++17.

Browse Source
This commit is contained in:
Skyth 2024-12-13 18:31:55 +03:00
parent 02d23b3463
commit 847842cd28
20 changed files with 250 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
CMakeLists.txt
View File

@ -1,6 +1,9 @@
cmake_minimum_required (VERSION 3.20) cmake_minimum_required (VERSION 3.20)
include($ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake)
set(THIRDPARTY_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty) set(THIRDPARTY_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty)
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD 17)
set(BUILD_SHARED_LIBS OFF) set(BUILD_SHARED_LIBS OFF)
# Enable Hot Reload for MSVC compilers if supported. # Enable Hot Reload for MSVC compilers if supported.
@ -12,20 +15,6 @@ endif()
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>") set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
include("cmake/bin2h.cmake") include("cmake/bin2h.cmake")
include(FetchContent)
FetchContent_Declare(
tomlplusplus
GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
GIT_TAG v3.4.0
)
FetchContent_Declare(
xxHash
GIT_REPOSITORY https://github.com/Cyan4973/xxHash.git
GIT_TAG v0.8.2
SOURCE_SUBDIR "cmake_unofficial"
)
FetchContent_MakeAvailable(tomlplusplus)
FetchContent_MakeAvailable(xxHash)
add_subdirectory(${THIRDPARTY_ROOT}/disasm) add_subdirectory(${THIRDPARTY_ROOT}/disasm)
set(POWERANALYSE_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/PowerAnalyse) set(POWERANALYSE_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/PowerAnalyse)

4
PowerAnalyse/CMakeLists.txt
View File

@ -5,7 +5,9 @@ project("PowerAnalyse")
add_executable(PowerAnalyse "main.cpp" "function.h" "function.cpp") add_executable(PowerAnalyse "main.cpp" "function.h" "function.cpp")
add_library(LibPowerAnalyse "function.h" "function.cpp") add_library(LibPowerAnalyse "function.h" "function.cpp")
find_package(fmt CONFIG REQUIRED)
target_include_directories(LibPowerAnalyse PUBLIC .) target_include_directories(LibPowerAnalyse PUBLIC .)
target_link_libraries(LibPowerAnalyse PUBLIC PowerUtils) target_link_libraries(LibPowerAnalyse PUBLIC PowerUtils)
target_link_libraries(PowerAnalyse PRIVATE PowerUtils) target_link_libraries(PowerAnalyse PRIVATE PowerUtils fmt::fmt)

37
PowerAnalyse/function.cpp
View File

@ -4,6 +4,7 @@
#include <bit> #include <bit>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <byteswap.h>
size_t Function::SearchBlock(size_t address) const size_t Function::SearchBlock(size_t address) const
{ {
@ -63,7 +64,7 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
// TODO: Branch fallthrough // TODO: Branch fallthrough
for (; data <= dataEnd ; ++data) for (; data <= dataEnd ; ++data)
{ {
const auto addr = base + ((data - dataStart) * sizeof(*data)); const size_t addr = base + ((data - dataStart) * sizeof(*data));
if (blockStack.empty()) if (blockStack.empty())
{ {
break; // it's hideover break; // it's hideover
@ -71,11 +72,11 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
auto& curBlock = blocks[blockStack.back()]; auto& curBlock = blocks[blockStack.back()];
DEBUG(const auto blockBase = curBlock.base); DEBUG(const auto blockBase = curBlock.base);
const auto instruction = std::byteswap(*data); const uint32_t instruction = ByteSwap(*data);
const auto op = PPC_OP(instruction); const uint32_t op = PPC_OP(instruction);
const auto xop = PPC_XOP(instruction); const uint32_t xop = PPC_XOP(instruction);
const auto isLink = PPC_BL(instruction); // call const uint32_t isLink = PPC_BL(instruction); // call
ppc_insn insn; ppc_insn insn;
ppc::Disassemble(data, addr, insn); ppc::Disassemble(data, addr, insn);
@ -103,13 +104,13 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
// TODO: Handle absolute branches? // TODO: Handle absolute branches?
assert(!PPC_BA(instruction)); assert(!PPC_BA(instruction));
const auto branchDest = addr + PPC_BD(instruction); const size_t branchDest = addr + PPC_BD(instruction);
// true/false paths // true/false paths
// left block: false case // left block: false case
// right block: true case // right block: true case
const auto lBase = (addr - base) + 4; const size_t lBase = (addr - base) + 4;
const auto rBase = (addr + PPC_BD(instruction)) - base; const size_t rBase = (addr + PPC_BD(instruction)) - base;
// these will be -1 if it's our first time seeing these blocks // these will be -1 if it's our first time seeing these blocks
auto lBlock = fn.SearchBlock(base + lBase); auto lBlock = fn.SearchBlock(base + lBase);
@ -124,7 +125,7 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
blockStack.emplace_back(lBlock); blockStack.emplace_back(lBlock);
} }
auto rBlock = fn.SearchBlock(base + rBase); size_t rBlock = fn.SearchBlock(base + rBase);
if (rBlock == -1) if (rBlock == -1)
{ {
blocks.emplace_back(branchDest - base, 0); blocks.emplace_back(branchDest - base, 0);
@ -145,10 +146,10 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
if (op == PPC_OP_B) if (op == PPC_OP_B)
{ {
assert(!PPC_BA(instruction)); assert(!PPC_BA(instruction));
const auto branchDest = addr + PPC_BI(instruction); const size_t branchDest = addr + PPC_BI(instruction);
const auto branchBase = branchDest - base; const size_t branchBase = branchDest - base;
const auto branchBlock = fn.SearchBlock(branchDest); const size_t branchBlock = fn.SearchBlock(branchDest);
if (branchDest < base) if (branchDest < base)
{ {
@ -158,8 +159,8 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
} }
// carry over our projection if blocks are next to each other // carry over our projection if blocks are next to each other
const auto isContinuous = branchBase == curBlock.base + curBlock.size; const bool isContinuous = branchBase == curBlock.base + curBlock.size;
auto sizeProjection = (size_t)-1; size_t sizeProjection = (size_t)-1;
if (curBlock.projectedSize != -1 && isContinuous) if (curBlock.projectedSize != -1 && isContinuous)
{ {
@ -180,12 +181,12 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
else if (op == PPC_OP_CTR) else if (op == PPC_OP_CTR)
{ {
// 5th bit of BO tells cpu to ignore the counter, which is a blr/bctr otherwise it's conditional // 5th bit of BO tells cpu to ignore the counter, which is a blr/bctr otherwise it's conditional
const auto conditional = !(PPC_BO(instruction) & 0x10); const bool conditional = !(PPC_BO(instruction) & 0x10);
if (conditional) if (conditional)
{ {
// right block's just going to return // right block's just going to return
const auto lBase = (addr - base) + 4; const size_t lBase = (addr - base) + 4;
auto lBlock = fn.SearchBlock(lBase); size_t lBlock = fn.SearchBlock(lBase);
if (lBlock == -1) if (lBlock == -1)
{ {
blocks.emplace_back(lBase, 0); blocks.emplace_back(lBase, 0);
@ -212,7 +213,7 @@ Function Function::Analyze(const void* code, size_t size, size_t base)
// Sort and invalidate discontinuous blocks // Sort and invalidate discontinuous blocks
if (blocks.size() > 1) if (blocks.size() > 1)
{ {
std::ranges::sort(blocks, [](const Block& a, const Block& b) std::sort(blocks.begin(), blocks.end(), [](const Block& a, const Block& b)
{ {
return a.base < b.base; return a.base < b.base;
}); });

27
PowerAnalyse/function.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <vector> #include <vector>
#ifdef _DEBUG(X) #ifdef _DEBUG
#define DEBUG(X) X #define DEBUG(X) X
#else #else
#define DEBUG(X) #define DEBUG(X)
@ -13,16 +13,37 @@ struct Function
{ {
size_t base{}; size_t base{};
size_t size{}; size_t size{};
size_t projectedSize{ static_cast<size_t>(-1) }; // scratch
DEBUG(size_t parent{}); DEBUG(size_t parent{});
// scratch Block()
size_t projectedSize{ static_cast<size_t>(-1) }; {
}
Block(size_t base, size_t size)
: base(base), size(size)
{
}
Block(size_t base, size_t size, size_t projectedSize)
: base(base), size(size), projectedSize(projectedSize)
{
}
}; };
size_t base{}; size_t base{};
size_t size{}; size_t size{};
std::vector<Block> blocks{}; std::vector<Block> blocks{};
Function()
{
}
Function(size_t base, size_t size)
: base(base), size(size)
{
}
size_t SearchBlock(size_t address) const; size_t SearchBlock(size_t address) const;
static Function Analyze(const void* code, size_t size, size_t base); static Function Analyze(const void* code, size_t size, size_t base);
}; };

49
PowerAnalyse/main.cpp
View File

@ -1,10 +1,11 @@
#include <cassert> #include <cassert>
#include <iterator>
#include <file.h> #include <file.h>
#include <disasm.h> #include <disasm.h>
#include <image.h> #include <image.h>
#include "function.h"
#include <print>
#include <xbox.h> #include <xbox.h>
#include <fmt/core.h>
#include "function.h"
#define SWITCH_ABSOLUTE 0 #define SWITCH_ABSOLUTE 0
#define SWITCH_COMPUTED 1 #define SWITCH_COMPUTED 1
@ -139,7 +140,7 @@ void MakeMask(const uint32_t* instructions, size_t count)
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
{ {
ppc::Disassemble(&instructions[i], 0, insn); ppc::Disassemble(&instructions[i], 0, insn);
std::println("0x{:X}, // {}", std::byteswap(insn.opcode->opcode | (insn.instruction & insn.opcode->mask)), insn.opcode->name); fmt::println("0x{:X}, // {}", ByteSwap(insn.opcode->opcode | (insn.instruction & insn.opcode->mask)), insn.opcode->name);
} }
} }
@ -173,13 +174,13 @@ void* SearchMask(const void* source, const uint32_t* compare, size_t compareCoun
int main() int main()
{ {
const auto file = LoadFile("private/default.xex").value(); const auto file = LoadFile("private/default.xex");
auto image = Image::ParseImage(file.data(), file.size()).value(); auto image = Image::ParseImage(file.data(), file.size());
std::string out; std::string out;
auto println = [&]<class... Args>(std::format_string<Args...> fmt, Args&&... args) auto println = [&]<class... Args>(fmt::format_string<Args...> fmt, Args&&... args)
{ {
std::vformat_to(std::back_inserter(out), fmt.get(), std::make_format_args(args...)); fmt::vformat_to(std::back_inserter(out), fmt.get(), fmt::make_format_args(args...));
out += '\n'; out += '\n';
}; };
//for (const auto& section : image.sections) //for (const auto& section : image.sections)
@ -190,7 +191,7 @@ int main()
// MakeMask((uint32_t*)image.Find(0x82C40D84), 6); // MakeMask((uint32_t*)image.Find(0x82C40D84), 6);
//auto data = "\x4D\x99\x00\x20"; //auto data = "\x4D\x99\x00\x20";
//auto data2 = std::byteswap((2129)); //auto data2 = ByteSwap((2129));
//ppc_insn insn; //ppc_insn insn;
//ppc_insn insn2; //ppc_insn insn2;
//ppc::Disassemble(data, 0, insn); //ppc::Disassemble(data, 0, insn);
@ -261,7 +262,7 @@ int main()
table.type = type; table.type = type;
ScanTable((uint32_t*)data, base + (data - dataStart), table); ScanTable((uint32_t*)data, base + (data - dataStart), table);
// std::println("{:X} ; jmptable - {}", base + (data - dataStart), table.labels.size()); // fmt::println("{:X} ; jmptable - {}", base + (data - dataStart), table.labels.size());
if (table.base != 0) if (table.base != 0)
{ {
ReadTable(image, table); ReadTable(image, table);
@ -335,15 +336,15 @@ int main()
fwrite(out.data(), 1, out.size(), f); fwrite(out.data(), 1, out.size(), f);
fclose(f); fclose(f);
uint32_t cxxFrameHandler = std::byteswap(0x831B1C90); uint32_t cxxFrameHandler = ByteSwap(0x831B1C90);
uint32_t cSpecificFrameHandler = std::byteswap(0x8324B3BC); uint32_t cSpecificFrameHandler = ByteSwap(0x8324B3BC);
image.symbols.emplace("__CxxFrameHandler", 0x831B1C90, 0x38, Symbol_Function); image.symbols.emplace("__CxxFrameHandler", 0x831B1C90, 0x38, Symbol_Function);
image.symbols.emplace("__C_specific_handler", 0x8324B3BC, 0x38, Symbol_Function); image.symbols.emplace("__C_specific_handler", 0x8324B3BC, 0x38, Symbol_Function);
image.symbols.emplace("memcpy", 0x831B0ED0, 0x488, Symbol_Function); image.symbols.emplace("memcpy", 0x831B0ED0, 0x488, Symbol_Function);
image.symbols.emplace("memset", 0x831B0BA0, 0xA0, Symbol_Function); image.symbols.emplace("memset", 0x831B0BA0, 0xA0, Symbol_Function);
image.symbols.emplace("blkmov", 0x831B1358, 0xA8, Symbol_Function); image.symbols.emplace("blkmov", 0x831B1358, 0xA8, Symbol_Function);
image.symbols.emplace(std::format("sub_{:X}", 0x82EF5D78), 0x82EF5D78, 0x3F8, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", 0x82EF5D78), 0x82EF5D78, 0x3F8, Symbol_Function);
// auto fnd = Function::Analyze(image.Find(0x82C40D58), image.size, 0x82C40D58); // auto fnd = Function::Analyze(image.Find(0x82C40D58), image.size, 0x82C40D58);
@ -354,8 +355,8 @@ int main()
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
{ {
auto fn = pf[i]; auto fn = pf[i];
fn.BeginAddress = std::byteswap(fn.BeginAddress); fn.BeginAddress = ByteSwap(fn.BeginAddress);
fn.Data = std::byteswap(fn.Data); fn.Data = ByteSwap(fn.Data);
auto& f = functions.emplace_back(); auto& f = functions.emplace_back();
f.base = fn.BeginAddress; f.base = fn.BeginAddress;
@ -366,7 +367,7 @@ int main()
__debugbreak(); __debugbreak();
} }
image.symbols.emplace(std::format("sub_{:X}", f.base), f.base, f.size, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", f.base), f.base, f.size, Symbol_Function);
} }
auto sym = image.symbols.find(0x82BD7420); auto sym = image.symbols.find(0x82BD7420);
@ -413,7 +414,7 @@ int main()
base += missingFn.size; base += missingFn.size;
data += missingFn.size; data += missingFn.size;
std::println("sub_{:X}", missingFn.base); fmt::println("sub_{:X}", missingFn.base);
} }
} }
} }
@ -421,7 +422,7 @@ int main()
//ppc_insn insn; //ppc_insn insn;
//uint8_t c[4] = { 0x10, 0x00, 0x59, 0xC3 }; //uint8_t c[4] = { 0x10, 0x00, 0x59, 0xC3 };
//ppc::Disassemble(c, 0x831D6C64, insn); //ppc::Disassemble(c, 0x831D6C64, insn);
//std::println("{:20}{}", insn.opcode->name, insn.op_str); //fmt::println("{:20}{}", insn.opcode->name, insn.op_str);
const auto entrySymbol = image.symbols.find(image.entry_point); const auto entrySymbol = image.symbols.find(image.entry_point);
@ -432,21 +433,21 @@ int main()
image.symbols.emplace("_start", image.entry_point, entrySize, Symbol_Function); image.symbols.emplace("_start", image.entry_point, entrySize, Symbol_Function);
std::println("FUNCTIONS"); fmt::println("FUNCTIONS");
for (const auto& fn : functions) for (const auto& fn : functions)
{ {
std::println("\tsub_{:X}", fn.base); fmt::println("\tsub_{:X}", fn.base);
} }
std::println(""); fmt::println("");
std::println("SECTIONS"); fmt::println("SECTIONS");
for (const auto& section : image.sections) for (const auto& section : image.sections)
{ {
std::printf("Section %.8s\n", section.name.c_str()); printf("Section %.8s\n", section.name.c_str());
std::printf("\t%X-%X\n", section.base, section.base + section.size); printf("\t%X-%X\n", section.base, section.base + section.size);
} }
std::println(""); fmt::println("");
return 0; return 0;
} }

8
PowerRecomp/CMakeLists.txt
View File

@ -6,7 +6,13 @@ BIN2H(SOURCE_FILE ${POWERUTILS_ROOT}/ppc_context.h HEADER_FILE "generated/ppc_co
add_executable(PowerRecomp "main.cpp" "pch.h" "recompiler.cpp" "recompiler.h" "test_recompiler.cpp" "test_recompiler.h" "recompiler_config.h" "recompiler_config.cpp") add_executable(PowerRecomp "main.cpp" "pch.h" "recompiler.cpp" "recompiler.h" "test_recompiler.cpp" "test_recompiler.h" "recompiler_config.h" "recompiler_config.cpp")
target_precompile_headers(PowerRecomp PUBLIC "pch.h") target_precompile_headers(PowerRecomp PUBLIC "pch.h")
target_link_libraries(PowerRecomp PRIVATE LibPowerAnalyse tomlplusplus::tomlplusplus xxHash::xxhash)
find_package(fmt CONFIG REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(tomlplusplus REQUIRED IMPORTED_TARGET tomlplusplus)
find_package(xxHash CONFIG REQUIRED)
target_link_libraries(PowerRecomp PRIVATE LibPowerAnalyse fmt::fmt PkgConfig::tomlplusplus xxHash::xxhash)
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
target_compile_options(PowerRecomp PRIVATE -Wno-switch -Wno-unused-variable) target_compile_options(PowerRecomp PRIVATE -Wno-switch -Wno-unused-variable)

11
PowerRecomp/pch.h
View File

@ -1,22 +1,17 @@
#pragma once #pragma once
// Workaround for the intellisense for some reason not seeing C++23 features
#ifdef __INTELLISENSE__
#undef __cplusplus
#define __cplusplus 202302L
#endif
#include <cassert> #include <cassert>
#include <charconv>
#include <disasm.h> #include <disasm.h>
#include <file.h> #include <file.h>
#include <filesystem> #include <filesystem>
#include <format> #include <fstream>
#include <function.h> #include <function.h>
#include <image.h> #include <image.h>
#include <print>
#include <toml++/toml.hpp> #include <toml++/toml.hpp>
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <xbox.h> #include <xbox.h>
#include <xxhash.h> #include <xxhash.h>
#include <fmt/core.h>
#include "generated/ppc_context.gen.h" #include "generated/ppc_context.gen.h"

80
PowerRecomp/recompiler.cpp
View File

@ -13,8 +13,8 @@ void Recompiler::LoadConfig(const std::string_view& configFilePath)
{ {
config.Load(configFilePath); config.Load(configFilePath);
const auto file = LoadFile((config.directoryPath + config.filePath).c_str()).value(); const auto file = LoadFile((config.directoryPath + config.filePath).c_str());
image = Image::ParseImage(file.data(), file.size()).value(); image = Image::ParseImage(file.data(), file.size());
} }
void Recompiler::Analyse() void Recompiler::Analyse()
@ -26,32 +26,32 @@ void Recompiler::Analyse()
auto& restgpr = functions.emplace_back(); auto& restgpr = functions.emplace_back();
restgpr.base = config.restGpr14Address + (i - 14) * 4; restgpr.base = config.restGpr14Address + (i - 14) * 4;
restgpr.size = (32 - i) * 4 + 12; restgpr.size = (32 - i) * 4 + 12;
image.symbols.emplace(std::format("__restgprlr_{}", i), restgpr.base, restgpr.size, Symbol_Function); image.symbols.emplace(Symbol{ fmt::format("__restgprlr_{}", i), restgpr.base, restgpr.size, Symbol_Function });
auto& savegpr = functions.emplace_back(); auto& savegpr = functions.emplace_back();
savegpr.base = config.saveGpr14Address + (i - 14) * 4; savegpr.base = config.saveGpr14Address + (i - 14) * 4;
savegpr.size = (32 - i) * 4 + 8; savegpr.size = (32 - i) * 4 + 8;
image.symbols.emplace(std::format("__savegprlr_{}", i), savegpr.base, savegpr.size, Symbol_Function); image.symbols.emplace(fmt::format("__savegprlr_{}", i), savegpr.base, savegpr.size, Symbol_Function);
auto& restfpr = functions.emplace_back(); auto& restfpr = functions.emplace_back();
restfpr.base = config.restFpr14Address + (i - 14) * 4; restfpr.base = config.restFpr14Address + (i - 14) * 4;
restfpr.size = (32 - i) * 4 + 4; restfpr.size = (32 - i) * 4 + 4;
image.symbols.emplace(std::format("__restfpr_{}", i), restfpr.base, restfpr.size, Symbol_Function); image.symbols.emplace(fmt::format("__restfpr_{}", i), restfpr.base, restfpr.size, Symbol_Function);
auto& savefpr = functions.emplace_back(); auto& savefpr = functions.emplace_back();
savefpr.base = config.saveFpr14Address + (i - 14) * 4; savefpr.base = config.saveFpr14Address + (i - 14) * 4;
savefpr.size = (32 - i) * 4 + 4; savefpr.size = (32 - i) * 4 + 4;
image.symbols.emplace(std::format("__savefpr_{}", i), savefpr.base, savefpr.size, Symbol_Function); image.symbols.emplace(fmt::format("__savefpr_{}", i), savefpr.base, savefpr.size, Symbol_Function);
auto& restvmx = functions.emplace_back(); auto& restvmx = functions.emplace_back();
restvmx.base = config.restVmx14Address + (i - 14) * 8; restvmx.base = config.restVmx14Address + (i - 14) * 8;
restvmx.size = (32 - i) * 8 + 4; restvmx.size = (32 - i) * 8 + 4;
image.symbols.emplace(std::format("__restvmx_{}", i), restvmx.base, restvmx.size, Symbol_Function); image.symbols.emplace(fmt::format("__restvmx_{}", i), restvmx.base, restvmx.size, Symbol_Function);
auto& savevmx = functions.emplace_back(); auto& savevmx = functions.emplace_back();
savevmx.base = config.saveVmx14Address + (i - 14) * 8; savevmx.base = config.saveVmx14Address + (i - 14) * 8;
savevmx.size = (32 - i) * 8 + 4; savevmx.size = (32 - i) * 8 + 4;
image.symbols.emplace(std::format("__savevmx_{}", i), savevmx.base, savevmx.size, Symbol_Function); image.symbols.emplace(fmt::format("__savevmx_{}", i), savevmx.base, savevmx.size, Symbol_Function);
} }
if (i >= 64) if (i >= 64)
@ -59,19 +59,19 @@ void Recompiler::Analyse()
auto& restvmx = functions.emplace_back(); auto& restvmx = functions.emplace_back();
restvmx.base = config.restVmx64Address + (i - 64) * 8; restvmx.base = config.restVmx64Address + (i - 64) * 8;
restvmx.size = (128 - i) * 8 + 4; restvmx.size = (128 - i) * 8 + 4;
image.symbols.emplace(std::format("__restvmx_{}", i), restvmx.base, restvmx.size, Symbol_Function); image.symbols.emplace(fmt::format("__restvmx_{}", i), restvmx.base, restvmx.size, Symbol_Function);
auto& savevmx = functions.emplace_back(); auto& savevmx = functions.emplace_back();
savevmx.base = config.saveVmx64Address + (i - 64) * 8; savevmx.base = config.saveVmx64Address + (i - 64) * 8;
savevmx.size = (128 - i) * 8 + 4; savevmx.size = (128 - i) * 8 + 4;
image.symbols.emplace(std::format("__savevmx_{}", i), savevmx.base, savevmx.size, Symbol_Function); image.symbols.emplace(fmt::format("__savevmx_{}", i), savevmx.base, savevmx.size, Symbol_Function);
} }
} }
for (auto& [address, size] : config.functions) for (auto& [address, size] : config.functions)
{ {
functions.emplace_back(address, size); functions.emplace_back(address, size);
image.symbols.emplace(std::format("sub_{:X}", address), address, size, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", address), address, size, Symbol_Function);
} }
auto& pdata = *image.Find(".pdata"); auto& pdata = *image.Find(".pdata");
@ -80,8 +80,8 @@ void Recompiler::Analyse()
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
{ {
auto fn = pf[i]; auto fn = pf[i];
fn.BeginAddress = std::byteswap(fn.BeginAddress); fn.BeginAddress = ByteSwap(fn.BeginAddress);
fn.Data = std::byteswap(fn.Data); fn.Data = ByteSwap(fn.Data);
if (image.symbols.find(fn.BeginAddress) == image.symbols.end()) if (image.symbols.find(fn.BeginAddress) == image.symbols.end())
{ {
@ -89,7 +89,7 @@ void Recompiler::Analyse()
f.base = fn.BeginAddress; f.base = fn.BeginAddress;
f.size = fn.FunctionLength * 4; f.size = fn.FunctionLength * 4;
image.symbols.emplace(std::format("sub_{:X}", f.base), f.base, f.size, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", f.base), f.base, f.size, Symbol_Function);
} }
} }
@ -105,7 +105,7 @@ void Recompiler::Analyse()
while (data < dataEnd) while (data < dataEnd)
{ {
uint32_t insn = std::byteswap(*(uint32_t*)data); uint32_t insn = ByteSwap(*(uint32_t*)data);
if (PPC_OP(insn) == PPC_OP_B && PPC_BL(insn)) if (PPC_OP(insn) == PPC_OP_B && PPC_BL(insn))
{ {
size_t address = base + (data - section.data) + PPC_BI(insn); size_t address = base + (data - section.data) + PPC_BI(insn);
@ -114,7 +114,7 @@ void Recompiler::Analyse()
{ {
auto data = section.data + address - section.base; auto data = section.data + address - section.base;
auto& fn = functions.emplace_back(Function::Analyze(data, section.base + section.size - address, address)); auto& fn = functions.emplace_back(Function::Analyze(data, section.base + section.size - address, address));
image.symbols.emplace(std::format("sub_{:X}", fn.base), fn.base, fn.size, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", fn.base), fn.base, fn.size, Symbol_Function);
} }
} }
data += 4; data += 4;
@ -124,7 +124,7 @@ void Recompiler::Analyse()
while (data < dataEnd) while (data < dataEnd)
{ {
auto invalidInstr = config.invalidInstructions.find(std::byteswap(*(uint32_t*)data)); auto invalidInstr = config.invalidInstructions.find(ByteSwap(*(uint32_t*)data));
if (invalidInstr != config.invalidInstructions.end()) if (invalidInstr != config.invalidInstructions.end())
{ {
base += invalidInstr->second; base += invalidInstr->second;
@ -143,7 +143,7 @@ void Recompiler::Analyse()
else else
{ {
auto& fn = functions.emplace_back(Function::Analyze(data, dataEnd - data, base)); auto& fn = functions.emplace_back(Function::Analyze(data, dataEnd - data, base));
image.symbols.emplace(std::format("sub_{:X}", fn.base), fn.base, fn.size, Symbol_Function); image.symbols.emplace(fmt::format("sub_{:X}", fn.base), fn.base, fn.size, Symbol_Function);
base += fn.size; base += fn.size;
data += fn.size; data += fn.size;
@ -172,9 +172,9 @@ bool Recompiler::Recompile(
(config.nonVolatileRegistersAsLocalVariables && index >= 14)) (config.nonVolatileRegistersAsLocalVariables && index >= 14))
{ {
localVariables.r[index] = true; localVariables.r[index] = true;
return std::format("r{}", index); return fmt::format("r{}", index);
} }
return std::format("ctx.r{}", index); return fmt::format("ctx.r{}", index);
}; };
auto f = [&](size_t index) auto f = [&](size_t index)
@ -183,9 +183,9 @@ bool Recompiler::Recompile(
(config.nonVolatileRegistersAsLocalVariables && index >= 14)) (config.nonVolatileRegistersAsLocalVariables && index >= 14))
{ {
localVariables.f[index] = true; localVariables.f[index] = true;
return std::format("f{}", index); return fmt::format("f{}", index);
} }
return std::format("ctx.f{}", index); return fmt::format("ctx.f{}", index);
}; };
auto v = [&](size_t index) auto v = [&](size_t index)
@ -194,9 +194,9 @@ bool Recompiler::Recompile(
(config.nonVolatileRegistersAsLocalVariables && ((index >= 14 && index <= 31) || (index >= 64 && index <= 127)))) (config.nonVolatileRegistersAsLocalVariables && ((index >= 14 && index <= 31) || (index >= 64 && index <= 127))))
{ {
localVariables.v[index] = true; localVariables.v[index] = true;
return std::format("v{}", index); return fmt::format("v{}", index);
} }
return std::format("ctx.v{}", index); return fmt::format("ctx.v{}", index);
}; };
auto cr = [&](size_t index) auto cr = [&](size_t index)
@ -204,9 +204,9 @@ bool Recompiler::Recompile(
if (config.crRegistersAsLocalVariables) if (config.crRegistersAsLocalVariables)
{ {
localVariables.cr[index] = true; localVariables.cr[index] = true;
return std::format("cr{}", index); return fmt::format("cr{}", index);
} }
return std::format("ctx.cr{}", index); return fmt::format("ctx.cr{}", index);
}; };
auto ctr = [&]() auto ctr = [&]()
@ -287,7 +287,7 @@ bool Recompiler::Recompile(
if (targetSymbol != image.symbols.end() && targetSymbol->address == address && targetSymbol->type == Symbol_Function) if (targetSymbol != image.symbols.end() && targetSymbol->address == address && targetSymbol->type == Symbol_Function)
{ {
if (config.nonVolatileRegistersAsLocalVariables && (targetSymbol->name.starts_with("__rest") || targetSymbol->name.starts_with("__save"))) if (config.nonVolatileRegistersAsLocalVariables && (targetSymbol->name.find("__rest") == 0 || targetSymbol->name.find("__save") == 0))
{ {
// print nothing // print nothing
} }
@ -513,7 +513,7 @@ bool Recompiler::Recompile(
if (label < fn.base || label >= fn.base + fn.size) if (label < fn.base || label >= fn.base + fn.size)
{ {
println("\t\t// ERROR: 0x{:X}", label); println("\t\t// ERROR: 0x{:X}", label);
std::println("ERROR: Switch case at {:X} is trying to jump outside function: {:X}", base, label); fmt::println("ERROR: Switch case at {:X} is trying to jump outside function: {:X}", base, label);
println("\t\treturn;"); println("\t\treturn;");
} }
else else
@ -1897,7 +1897,7 @@ bool Recompiler::Recompile(
{ {
case 0: // D3D color case 0: // D3D color
if (insn.operands[3] != 1 || insn.operands[4] != 3) if (insn.operands[3] != 1 || insn.operands[4] != 3)
std::println("Unexpected D3D color pack instruction at {:X}", base); fmt::println("Unexpected D3D color pack instruction at {:X}", base);
for (size_t i = 0; i < 4; i++) for (size_t i = 0; i < 4; i++)
{ {
@ -2145,7 +2145,7 @@ bool Recompiler::Recompile(
{ {
int lastLine = out.find_last_of('\n', out.size() - 2); int lastLine = out.find_last_of('\n', out.size() - 2);
if (out.find("cr0", lastLine + 1) == std::string::npos && out.find("cr6", lastLine + 1) == std::string::npos) if (out.find("cr0", lastLine + 1) == std::string::npos && out.find("cr6", lastLine + 1) == std::string::npos)
std::println("{} at {:X} has RC bit enabled but no comparison was generated", insn.opcode->name, base); fmt::println("{} at {:X} has RC bit enabled but no comparison was generated", insn.opcode->name, base);
} }
#endif #endif
@ -2163,7 +2163,7 @@ bool Recompiler::Recompile(const Function& fn)
for (size_t addr = base; addr < end; addr += 4) for (size_t addr = base; addr < end; addr += 4)
{ {
const uint32_t instruction = std::byteswap(*(uint32_t*)((char*)data + addr - base)); const uint32_t instruction = ByteSwap(*(uint32_t*)((char*)data + addr - base));
if (!PPC_BL(instruction)) if (!PPC_BL(instruction))
{ {
const size_t op = PPC_OP(instruction); const size_t op = PPC_OP(instruction);
@ -2248,7 +2248,7 @@ bool Recompiler::Recompile(const Function& fn)
} }
else else
{ {
name = std::format("sub_{}", fn.base); name = fmt::format("sub_{}", fn.base);
} }
println("__attribute__((alias(\"__imp__{}\"))) PPC_WEAK_FUNC({});", name, name); println("__attribute__((alias(\"__imp__{}\"))) PPC_WEAK_FUNC({});", name, name);
@ -2268,7 +2268,7 @@ bool Recompiler::Recompile(const Function& fn)
ppc_insn insn; ppc_insn insn;
while (base < end) while (base < end)
{ {
if (labels.contains(base)) if (labels.find(base) != labels.end())
{ {
println("loc_{:X}:", base); println("loc_{:X}:", base);
@ -2286,17 +2286,17 @@ bool Recompiler::Recompile(const Function& fn)
println("\t// {}", insn.op_str); println("\t// {}", insn.op_str);
#if 1 #if 1
if (*data != 0) if (*data != 0)
std::println("Unable to decode instruction {:X} at {:X}", *data, base); fmt::println("Unable to decode instruction {:X} at {:X}", *data, base);
#endif #endif
} }
else else
{ {
if (insn.opcode->id == PPC_INST_BCTR && (*(data - 1) == 0x07008038 || *(data - 1) == 0x00000060) && switchTable == config.switchTables.end()) if (insn.opcode->id == PPC_INST_BCTR && (*(data - 1) == 0x07008038 || *(data - 1) == 0x00000060) && switchTable == config.switchTables.end())
std::println("Found a switch jump table at {:X} with no switch table entry present", base); fmt::println("Found a switch jump table at {:X} with no switch table entry present", base);
if (!Recompile(fn, base, insn, data, switchTable, localVariables, csrState)) if (!Recompile(fn, base, insn, data, switchTable, localVariables, csrState))
{ {
std::println("Unrecognized instruction at 0x{:X}: {}", base, insn.opcode->name); fmt::println("Unrecognized instruction at 0x{:X}: {}", base, insn.opcode->name);
allRecompiled = false; allRecompiled = false;
} }
} }
@ -2307,7 +2307,7 @@ bool Recompiler::Recompile(const Function& fn)
#if 0 #if 0
if (insn.opcode == nullptr || (insn.opcode->id != PPC_INST_B && insn.opcode->id != PPC_INST_BCTR && insn.opcode->id != PPC_INST_BLR)) if (insn.opcode == nullptr || (insn.opcode->id != PPC_INST_B && insn.opcode->id != PPC_INST_BCTR && insn.opcode->id != PPC_INST_BLR))
std::println("Function at {:X} ends prematurely with instruction {} at {:X}", fn.base, insn.opcode != nullptr ? insn.opcode->name : "INVALID", base - 4); fmt::println("Function at {:X} ends prematurely with instruction {} at {:X}", fn.base, insn.opcode != nullptr ? insn.opcode->name : "INVALID", base - 4);
#endif #endif
println("}}\n"); println("}}\n");
@ -2441,7 +2441,7 @@ void Recompiler::Recompile()
} }
if ((i % 2048) == 0 || (i == (functions.size() - 1))) if ((i % 2048) == 0 || (i == (functions.size() - 1)))
std::println("Recompiling functions... {}%", static_cast<float>(i + 1) / functions.size() * 100.0f); fmt::println("Recompiling functions... {}%", static_cast<float>(i + 1) / functions.size() * 100.0f);
Recompile(functions[i]); Recompile(functions[i]);
} }
@ -2457,14 +2457,14 @@ void Recompiler::SaveCurrentOutData(const std::string_view& name)
if (name.empty()) if (name.empty())
{ {
cppName = std::format("ppc_recomp.{}.cpp", cppFileIndex); cppName = fmt::format("ppc_recomp.{}.cpp", cppFileIndex);
++cppFileIndex; ++cppFileIndex;
} }
bool shouldWrite = true; bool shouldWrite = true;
// Check if an identical file already exists first to not trigger recompilation // Check if an identical file already exists first to not trigger recompilation
std::string filePath = std::format("{}/{}/{}", config.directoryPath, config.outDirectoryPath, name.empty() ? cppName : name); std::string filePath = fmt::format("{}/{}/{}", config.directoryPath, config.outDirectoryPath, name.empty() ? cppName : name);
FILE* f = fopen(filePath.c_str(), "rb"); FILE* f = fopen(filePath.c_str(), "rb");
if (f) if (f)
{ {

8
PowerRecomp/recompiler.h
View File

@ -38,15 +38,15 @@ struct Recompiler
void LoadConfig(const std::string_view& configFilePath); void LoadConfig(const std::string_view& configFilePath);
template<class... Args> template<class... Args>
void print(std::format_string<Args...> fmt, Args&&... args) void print(fmt::format_string<Args...> fmt, Args&&... args)
{ {
std::vformat_to(std::back_inserter(out), fmt.get(), std::make_format_args(args...)); fmt::vformat_to(std::back_inserter(out), fmt.get(), fmt::make_format_args(args...));
} }
template<class... Args> template<class... Args>
void println(std::format_string<Args...> fmt, Args&&... args) void println(fmt::format_string<Args...> fmt, Args&&... args)
{ {
std::vformat_to(std::back_inserter(out), fmt.get(), std::make_format_args(args...)); fmt::vformat_to(std::back_inserter(out), fmt.get(), fmt::make_format_args(args...));
out += '\n'; out += '\n';
} }

4
PowerRecomp/recompiler_config.cpp
View File

@ -100,14 +100,14 @@ void RecompilerConfig::Load(const std::string_view& configFilePath)
(midAsmHook.returnOnTrue && midAsmHook.jumpAddressOnTrue != NULL) || (midAsmHook.returnOnTrue && midAsmHook.jumpAddressOnTrue != NULL) ||
(midAsmHook.returnOnFalse && midAsmHook.jumpAddressOnFalse != NULL)) (midAsmHook.returnOnFalse && midAsmHook.jumpAddressOnFalse != NULL))
{ {
std::println("{}: can't return and jump at the same time", midAsmHook.name); fmt::println("{}: can't return and jump at the same time", midAsmHook.name);
} }
if ((midAsmHook.ret || midAsmHook.jumpAddress != NULL) && if ((midAsmHook.ret || midAsmHook.jumpAddress != NULL) &&
(midAsmHook.returnOnFalse != NULL || midAsmHook.returnOnTrue != NULL || (midAsmHook.returnOnFalse != NULL || midAsmHook.returnOnTrue != NULL ||
midAsmHook.jumpAddressOnFalse != NULL || midAsmHook.jumpAddressOnTrue != NULL)) midAsmHook.jumpAddressOnFalse != NULL || midAsmHook.jumpAddressOnTrue != NULL))
{ {
std::println("{}: can't mix direct and conditional return/jump", midAsmHook.name); fmt::println("{}: can't mix direct and conditional return/jump", midAsmHook.name);
} }
midAsmHooks.emplace(*table["address"].value<uint32_t>(), std::move(midAsmHook)); midAsmHooks.emplace(*table["address"].value<uint32_t>(), std::move(midAsmHook));

82
PowerRecomp/test_recompiler.cpp
View File

@ -22,7 +22,7 @@ void TestRecompiler::Analyse(const std::string_view& testName)
} }
auto& fn = functions.emplace_back(Function::Analyze(data, dataEnd - data, base)); auto& fn = functions.emplace_back(Function::Analyze(data, dataEnd - data, base));
image.symbols.emplace(std::format("{}_{:X}", testName, fn.base), fn.base, fn.size, Symbol_Function); image.symbols.emplace(fmt::format("{}_{:X}", testName, fn.base), fn.base, fn.size, Symbol_Function);
base += fn.size; base += fn.size;
data += fn.size; data += fn.size;
@ -40,11 +40,11 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
{ {
if (file.path().extension() == ".o") if (file.path().extension() == ".o")
{ {
const auto exeFile = LoadFile(file.path().string().c_str()).value(); const auto exeFile = LoadFile(file.path().string().c_str());
TestRecompiler recompiler; TestRecompiler recompiler;
recompiler.config.outDirectoryPath = dstDirectoryPath; recompiler.config.outDirectoryPath = dstDirectoryPath;
recompiler.image = Image::ParseImage(exeFile.data(), exeFile.size()).value(); recompiler.image = Image::ParseImage(exeFile.data(), exeFile.size());
auto stem = file.path().stem().string(); auto stem = file.path().stem().string();
recompiler.Analyse(stem); recompiler.Analyse(stem);
@ -61,7 +61,7 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
} }
else else
{ {
std::println("Function {:X} in {} has unimplemented instructions", fn.base, stem); fmt::println("Function {:X} in {} has unimplemented instructions", fn.base, stem);
} }
} }
stem += ".cpp"; stem += ".cpp";
@ -73,7 +73,7 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
for (auto& [fn, addr] : functions) for (auto& [fn, addr] : functions)
{ {
std::ifstream in(std::format("{}/{}.dis", srcDirectoryPath, fn)); std::ifstream in(fmt::format("{}/{}.dis", srcDirectoryPath, fn));
if (in.is_open()) if (in.is_open())
{ {
std::string line; std::string line;
@ -86,30 +86,30 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
size_t address = ~0; size_t address = ~0;
std::from_chars(&line[0], &line[spaceIndex], address, 16); std::from_chars(&line[0], &line[spaceIndex], address, 16);
address &= 0xFFFFF; address &= 0xFFFFF;
if (addr.contains(address)) if (addr.find(address) != addr.end())
symbols.emplace(line.substr(spaceIndex + 2, bracketIndex - spaceIndex - 2), std::format("{}_{:X}", fn, address)); symbols.emplace(line.substr(spaceIndex + 2, bracketIndex - spaceIndex - 2), fmt::format("{}_{:X}", fn, address));
} }
} }
} }
else else
{ {
std::println("Unable to locate disassembly file for {}", fn); fmt::println("Unable to locate disassembly file for {}", fn);
} }
} }
FILE* file = fopen(std::format("{}/main.cpp", dstDirectoryPath).c_str(), "w"); FILE* file = fopen(fmt::format("{}/main.cpp", dstDirectoryPath).c_str(), "w");
std::string main; std::string main;
std::println(file, "#define PPC_CONFIG_H_INCLUDED"); fmt::println(file, "#define PPC_CONFIG_H_INCLUDED");
std::println(file, "#include <ppc_context.h>"); fmt::println(file, "#include <ppc_context.h>");
std::println(file, "#include <Windows.h>"); fmt::println(file, "#include <Windows.h>");
std::println(file, "#include <print>\n"); fmt::println(file, "#include <print>\n");
std::println(file, "#define PPC_CHECK_VALUE_U(f, lhs, rhs) if (lhs != rhs) std::println(#f \" \" #lhs \" EXPECTED \" #rhs \" ACTUAL {{:X}}\", lhs)\n"); fmt::println(file, "#define PPC_CHECK_VALUE_U(f, lhs, rhs) if (lhs != rhs) fmt::println(#f \" \" #lhs \" EXPECTED \" #rhs \" ACTUAL {{:X}}\", lhs)\n");
std::println(file, "#define PPC_CHECK_VALUE_F(f, lhs, rhs) if (lhs != rhs) std::println(#f \" \" #lhs \" EXPECTED \" #rhs \" ACTUAL {{}}\", lhs)\n"); fmt::println(file, "#define PPC_CHECK_VALUE_F(f, lhs, rhs) if (lhs != rhs) fmt::println(#f \" \" #lhs \" EXPECTED \" #rhs \" ACTUAL {{}}\", lhs)\n");
for (auto& [fn, addr] : functions) for (auto& [fn, addr] : functions)
{ {
std::ifstream in(std::format("{}/../{}.s", srcDirectoryPath, fn)); std::ifstream in(fmt::format("{}/../{}.s", srcDirectoryPath, fn));
if (in.is_open()) if (in.is_open())
{ {
std::string str; std::string str;
@ -135,10 +135,10 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
auto symbol = symbols.find(name); auto symbol = symbols.find(name);
if (symbol != symbols.end()) if (symbol != symbols.end())
{ {
std::println(file, "PPC_FUNC({});\n", symbol->second); fmt::println(file, "PPC_FUNC({});\n", symbol->second);
std::println(file, "void {}(uint8_t* base) {{", name); fmt::println(file, "void {}(uint8_t* base) {{", name);
std::println(file, "\tPPCContext ctx{{}};"); fmt::println(file, "\tPPCContext ctx{{}};");
std::println(file, "\tctx.fpscr.loadFromHost();"); fmt::println(file, "\tctx.fpscr.loadFromHost();");
while (getline() && !str.empty() && str[0] == '#') while (getline() && !str.empty() && str[0] == '#')
{ {
@ -158,14 +158,14 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
int commaIndex2 = str.find(',', commaIndex1 + 1); int commaIndex2 = str.find(',', commaIndex1 + 1);
int closingBracketIndex = str.find(']', commaIndex2 + 1); int closingBracketIndex = str.find(']', commaIndex2 + 1);
std::println(file, "\tctx.{}.u32[3] = 0x{};", reg, str.substr(openingBracketIndex + 1, commaIndex0 - openingBracketIndex - 1)); fmt::println(file, "\tctx.{}.u32[3] = 0x{};", reg, str.substr(openingBracketIndex + 1, commaIndex0 - openingBracketIndex - 1));
std::println(file, "\tctx.{}.u32[2] = 0x{};", reg, str.substr(commaIndex0 + 2, commaIndex1 - commaIndex0 - 2)); fmt::println(file, "\tctx.{}.u32[2] = 0x{};", reg, str.substr(commaIndex0 + 2, commaIndex1 - commaIndex0 - 2));
std::println(file, "\tctx.{}.u32[1] = 0x{};", reg, str.substr(commaIndex1 + 2, commaIndex2 - commaIndex1 - 2)); fmt::println(file, "\tctx.{}.u32[1] = 0x{};", reg, str.substr(commaIndex1 + 2, commaIndex2 - commaIndex1 - 2));
std::println(file, "\tctx.{}.u32[0] = 0x{};", reg, str.substr(commaIndex2 + 2, closingBracketIndex - commaIndex2 - 2)); fmt::println(file, "\tctx.{}.u32[0] = 0x{};", reg, str.substr(commaIndex2 + 2, closingBracketIndex - commaIndex2 - 2));
} }
else else
{ {
std::println(file, "\tctx.{}.{}64 = {};", fmt::println(file, "\tctx.{}.{}64 = {};",
reg, reg,
str.find('.', secondSpaceIndex) != std::string::npos ? 'f' : 'u', str.find('.', secondSpaceIndex) != std::string::npos ? 'f' : 'u',
str.substr(secondSpaceIndex + 1)); str.substr(secondSpaceIndex + 1));
@ -183,7 +183,7 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
{ {
if (str[i] != ' ') if (str[i] != ' ')
{ {
std::println(file, "\tbase[0x{} + 0x{:X}] = 0x{}{};", address, j, str[i], str[i + 1]); fmt::println(file, "\tbase[0x{} + 0x{:X}] = 0x{}{};", address, j, str[i], str[i + 1]);
++i; // the loop adds another ++i; // the loop adds another
++j; ++j;
} }
@ -196,7 +196,7 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
while (getline() && (str.empty() || str[0] != '#')) while (getline() && (str.empty() || str[0] != '#'))
; ;
std::println(file, "\t{}(ctx, base);", symbol->second); fmt::println(file, "\t{}(ctx, base);", symbol->second);
do do
{ {
@ -218,14 +218,14 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
int commaIndex2 = str.find(',', commaIndex1 + 1); int commaIndex2 = str.find(',', commaIndex1 + 1);
int closingBracketIndex = str.find(']', commaIndex2 + 1); int closingBracketIndex = str.find(']', commaIndex2 + 1);
std::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[3], 0x{});", name, reg, str.substr(openingBracketIndex + 1, commaIndex0 - openingBracketIndex - 1)); fmt::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[3], 0x{});", name, reg, str.substr(openingBracketIndex + 1, commaIndex0 - openingBracketIndex - 1));
std::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[2], 0x{});", name, reg, str.substr(commaIndex0 + 2, commaIndex1 - commaIndex0 - 2)); fmt::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[2], 0x{});", name, reg, str.substr(commaIndex0 + 2, commaIndex1 - commaIndex0 - 2));
std::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[1], 0x{});", name, reg, str.substr(commaIndex1 + 2, commaIndex2 - commaIndex1 - 2)); fmt::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[1], 0x{});", name, reg, str.substr(commaIndex1 + 2, commaIndex2 - commaIndex1 - 2));
std::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[0], 0x{});", name, reg, str.substr(commaIndex2 + 2, closingBracketIndex - commaIndex2 - 2)); fmt::println(file, "\tPPC_CHECK_VALUE_U({}, ctx.{}.u32[0], 0x{});", name, reg, str.substr(commaIndex2 + 2, closingBracketIndex - commaIndex2 - 2));
} }
else else
{ {
std::println(file, "\tPPC_CHECK_VALUE_{}({}, ctx.{}.{}64, {});", fmt::println(file, "\tPPC_CHECK_VALUE_{}({}, ctx.{}.{}64, {});",
str.find('.', secondSpaceIndex) != std::string::npos ? 'F' : 'U', str.find('.', secondSpaceIndex) != std::string::npos ? 'F' : 'U',
name, name,
reg, reg,
@ -245,7 +245,7 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
{ {
if (str[i] != ' ') if (str[i] != ' ')
{ {
std::println(file, "\tPPC_CHECK_VALUE_U({}, base[0x{} + 0x{:X}], 0x{}{});", name, address, j, str[i], str[i + 1]); fmt::println(file, "\tPPC_CHECK_VALUE_U({}, base[0x{} + 0x{:X}], 0x{}{});", name, address, j, str[i], str[i + 1]);
++i; // the loop adds another ++i; // the loop adds another
++j; ++j;
} }
@ -255,13 +255,13 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
} }
} while (getline() && !str.empty() && str[0] == '#'); } while (getline() && !str.empty() && str[0] == '#');
std::println(file, "}}\n"); fmt::println(file, "}}\n");
std::format_to(std::back_inserter(main), "\t{}(base);\n", name); fmt::format_to(std::back_inserter(main), "\t{}(base);\n", name);
} }
else else
{ {
std::println("Found no symbol for {}", name); fmt::println("Found no symbol for {}", name);
} }
} }
} }
@ -269,15 +269,15 @@ void TestRecompiler::RecompileTests(const char* srcDirectoryPath, const char* ds
} }
else else
{ {
std::println("Unable to locate source file for {}", fn); fmt::println("Unable to locate source file for {}", fn);
} }
} }
std::println(file, "int main() {{"); fmt::println(file, "int main() {{");
std::println(file, "\tuint8_t* base = reinterpret_cast<uint8_t*>(VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE));"); fmt::println(file, "\tuint8_t* base = reinterpret_cast<uint8_t*>(VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE));");
fwrite(main.data(), 1, main.size(), file); fwrite(main.data(), 1, main.size(), file);
std::println(file, "\treturn 0;"); fmt::println(file, "\treturn 0;");
std::println(file, "}}"); fmt::println(file, "}}");
fclose(file); fclose(file);
} }

2
PowerUtils/CMakeLists.txt
View File

@ -1,5 +1,5 @@
project("PowerUtils") project("PowerUtils")
add_library(PowerUtils "disasm.h" "disasm.cpp" "file.h" "xex.cpp" "image.h" "image.cpp" "elf.h" "ppc_context.h" "symbol.h" "symbol_table.h" "section.h" "xdbf_wrapper.cpp") add_library(PowerUtils "disasm.h" "disasm.cpp" "file.h" "xex.cpp" "image.h" "image.cpp" "elf.h" "ppc_context.h" "symbol.h" "symbol_table.h" "section.h" "xdbf_wrapper.cpp" "byteswap.h")
target_include_directories(PowerUtils PUBLIC .) target_include_directories(PowerUtils PUBLIC .)
target_link_libraries(PowerUtils PUBLIC disasm) target_link_libraries(PowerUtils PUBLIC disasm)

25
PowerUtils/byteswap.h Normal file
View File

@ -0,0 +1,25 @@
#pragma once
#include <cassert>
template<typename T>
inline T ByteSwap(T value)
{
if constexpr (sizeof(T) == 1)
return value;
else if constexpr (sizeof(T) == 2)
return static_cast<T>(__builtin_bswap16(static_cast<uint16_t>(value)));
else if constexpr (sizeof(T) == 4)
return static_cast<T>(__builtin_bswap32(static_cast<uint32_t>(value)));
else if constexpr (sizeof(T) == 8)
return static_cast<T>(__builtin_bswap64(static_cast<uint64_t>(value)));
assert(false && "Unexpected byte size.");
return value;
}
template<typename T>
inline void ByteSwapInplace(T& value)
{
value = ByteSwap(value);
}

6
PowerUtils/file.h
View File

@ -1,14 +1,14 @@
#pragma once #pragma once
#include <expected>
#include <vector> #include <vector>
inline static std::expected<std::vector<uint8_t>, int> LoadFile(const char* path) inline std::vector<uint8_t> LoadFile(const char* path)
{ {
std::vector<uint8_t> data{}; std::vector<uint8_t> data{};
auto* stream = fopen(path, "rb"); auto* stream = fopen(path, "rb");
if (stream == nullptr) if (stream == nullptr)
{ {
return std::unexpected(1); return {};
} }
fseek(stream, 0, SEEK_END); fseek(stream, 0, SEEK_END);

36
PowerUtils/image.cpp
View File

@ -5,8 +5,8 @@
void Image::Map(const std::string_view& name, size_t base, uint32_t size, uint8_t flags, uint8_t* data) void Image::Map(const std::string_view& name, size_t base, uint32_t size, uint8_t flags, uint8_t* data)
{ {
sections.emplace(std::string(name), this->base + base, sections.insert({ std::string(name), this->base + base,
size, static_cast<SectionFlags>(flags), data); size, static_cast<SectionFlags>(flags), data });
} }
const void* Image::Find(size_t address) const const void* Image::Find(size_t address) const
@ -28,7 +28,7 @@ const Section* Image::Find(const std::string_view& name) const
return nullptr; return nullptr;
} }
std::expected<Image, int> Image::ParseImage(const uint8_t* data, size_t size) Image Image::ParseImage(const uint8_t* data, size_t size)
{ {
if (data[0] == ELFMAG0 && data[1] == ELFMAG1 && data[2] == ELFMAG2 && data[3] == ELFMAG3) if (data[0] == ELFMAG0 && data[1] == ELFMAG1 && data[2] == ELFMAG2 && data[3] == ELFMAG3)
{ {
@ -39,7 +39,7 @@ std::expected<Image, int> Image::ParseImage(const uint8_t* data, size_t size)
return Xex2LoadImage(data); return Xex2LoadImage(data);
} }
return std::unexpected(1); return {};
} }
Image ElfLoadImage(const uint8_t* data, size_t size) Image ElfLoadImage(const uint8_t* data, size_t size)
@ -50,27 +50,27 @@ Image ElfLoadImage(const uint8_t* data, size_t size)
Image image{}; Image image{};
image.size = size; image.size = size;
image.data = std::make_unique<uint8_t[]>(size); image.data = std::make_unique<uint8_t[]>(size);
image.entry_point = std::byteswap(header->e_entry); image.entry_point = ByteSwap(header->e_entry);
memcpy(image.data.get(), data, size); memcpy(image.data.get(), data, size);
auto stringTableIndex = std::byteswap(header->e_shstrndx); auto stringTableIndex = ByteSwap(header->e_shstrndx);
const auto numSections = std::byteswap(header->e_shnum); const auto numSections = ByteSwap(header->e_shnum);
const auto numpSections = std::byteswap(header->e_phnum); const auto numpSections = ByteSwap(header->e_phnum);
const auto* sections = (elf32_shdr*)(data + std::byteswap(header->e_shoff)); const auto* sections = (elf32_shdr*)(data + ByteSwap(header->e_shoff));
const auto* psections = (elf32_phdr*)(data + std::byteswap(header->e_phoff)); const auto* psections = (elf32_phdr*)(data + ByteSwap(header->e_phoff));
for (size_t i = 0; i < numpSections; i++) for (size_t i = 0; i < numpSections; i++)
{ {
if (psections[i].p_type == std::byteswap((Elf32_Word)PT_LOAD)) if (psections[i].p_type == ByteSwap((Elf32_Word)PT_LOAD))
{ {
image.base = std::byteswap(psections[i].p_vaddr); image.base = ByteSwap(psections[i].p_vaddr);
break; break;
} }
} }
auto* stringTable = reinterpret_cast<const char*>(data + std::byteswap(sections[stringTableIndex].sh_offset)); auto* stringTable = reinterpret_cast<const char*>(data + ByteSwap(sections[stringTableIndex].sh_offset));
for (size_t i = 0; i < numSections; i++) for (size_t i = 0; i < numSections; i++)
{ {
@ -82,16 +82,16 @@ Image ElfLoadImage(const uint8_t* data, size_t size)
uint8_t flags{}; uint8_t flags{};
if (section.sh_flags & std::byteswap(SHF_EXECINSTR)) if (section.sh_flags & ByteSwap(SHF_EXECINSTR))
{ {
flags |= SectionFlags_Code; flags |= SectionFlags_Code;
} }
auto* name = section.sh_name != 0 ? stringTable + std::byteswap(section.sh_name) : nullptr; auto* name = section.sh_name != 0 ? stringTable + ByteSwap(section.sh_name) : nullptr;
const auto rva = std::byteswap(section.sh_addr) - image.base; const auto rva = ByteSwap(section.sh_addr) - image.base;
const auto size = std::byteswap(section.sh_size); const auto size = ByteSwap(section.sh_size);
image.Map(name, rva, size, flags, image.data.get() + std::byteswap(section.sh_offset)); image.Map(name, rva, size, flags, image.data.get() + ByteSwap(section.sh_offset));
} }
return image; return image;

2
PowerUtils/image.h
View File

@ -44,7 +44,7 @@ struct Image
* \param size Size of data * \param size Size of data
* \return Parsed image * \return Parsed image
*/ */
static std::expected<Image, int> ParseImage(const uint8_t* data, size_t size); static Image ParseImage(const uint8_t* data, size_t size);
}; };
Image ElfLoadImage(const uint8_t* data, size_t size); Image ElfLoadImage(const uint8_t* data, size_t size);

13
PowerUtils/symbol.h
View File

@ -13,9 +13,18 @@ enum SymbolType
struct Symbol struct Symbol
{ {
mutable std::string name{}; mutable std::string name{};
uint32_t address{}; size_t address{};
uint32_t size{}; size_t size{};
mutable SymbolType type{}; mutable SymbolType type{};
Symbol()
{
}
Symbol(std::string name, size_t address, size_t size, SymbolType type)
: name(std::move(name)), address(address), size(size), type(type)
{
}
}; };
struct SymbolComparer struct SymbolComparer

10
PowerUtils/xbox.h
View File

@ -3,7 +3,7 @@
#include <type_traits> #include <type_traits>
#include <bit> #include <bit>
#include <string> #include <string>
#include "byteswap.h"
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
@ -81,22 +81,22 @@ struct be
{ {
if constexpr (std::is_same_v<T, double>) if constexpr (std::is_same_v<T, double>)
{ {
const uint64_t swapped = std::byteswap(*reinterpret_cast<uint64_t*>(&value)); const uint64_t swapped = ByteSwap(*reinterpret_cast<uint64_t*>(&value));
return *reinterpret_cast<const T*>(&swapped); return *reinterpret_cast<const T*>(&swapped);
} }
else if constexpr (std::is_same_v<T, float>) else if constexpr (std::is_same_v<T, float>)
{ {
const uint32_t swapped = std::byteswap(*reinterpret_cast<uint32_t*>(&value)); const uint32_t swapped = ByteSwap(*reinterpret_cast<uint32_t*>(&value));
return *reinterpret_cast<const T*>(&swapped); return *reinterpret_cast<const T*>(&swapped);
} }
else if constexpr (std::is_enum_v<T>) else if constexpr (std::is_enum_v<T>)
{ {
const std::underlying_type_t<T> swapped = std::byteswap(*reinterpret_cast<std::underlying_type_t<T>*>(&value)); const std::underlying_type_t<T> swapped = ByteSwap(*reinterpret_cast<std::underlying_type_t<T>*>(&value));
return *reinterpret_cast<const T*>(&swapped); return *reinterpret_cast<const T*>(&swapped);
} }
else else
{ {
return std::byteswap(value); return ByteSwap(value);
} }
} }

4
PowerUtils/xex.cpp
View File

@ -126,7 +126,7 @@ Image Xex2LoadImage(const uint8_t* data)
{ {
auto originalThunk = (XEX_THUNK_DATA*)image.Find(descriptors[im].FirstThunk); auto originalThunk = (XEX_THUNK_DATA*)image.Find(descriptors[im].FirstThunk);
auto originalData = originalThunk; auto originalData = originalThunk;
originalData->Data = std::byteswap(originalData->Data); originalData->Data = ByteSwap(originalData->Data);
if (originalData->OriginalData.Type != 0) if (originalData->OriginalData.Type != 0)
{ {
@ -134,7 +134,7 @@ Image Xex2LoadImage(const uint8_t* data)
auto name = names->find(originalData->OriginalData.Ordinal); auto name = names->find(originalData->OriginalData.Ordinal);
if (name != names->end()) if (name != names->end())
{ {
image.symbols.emplace(name->second, descriptors[im].FirstThunk, sizeof(thunk), Symbol_Function); image.symbols.insert({ name->second, descriptors[im].FirstThunk, sizeof(thunk), Symbol_Function });
} }
memcpy(originalThunk, thunk, sizeof(thunk)); memcpy(originalThunk, thunk, sizeof(thunk));

12
vcpkg.json Normal file
View File

@ -0,0 +1,12 @@
{
"builtin-baseline": "e63bd09dc0b7204467705c1c7c71d0e2a3f8860b",
"dependencies": [
{
"name": "pkgconf",
"platform": "windows"
},
"fmt",
"tomlplusplus",
"xxhash"
]
}