ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Get rid of "module" keyword 

Workaround some intellisense problems.
This commit is contained in:
Nekotekina 2020-05-06 18:18:30 +03:00
parent a6025df7de
commit e1042bc631
17 changed files with 128 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
Utilities/JIT.cpp
View File

@ -915,10 +915,10 @@ public:
~ObjectCache() override = default; ~ObjectCache() override = default;
void notifyObjectCompiled(const llvm::Module* module, llvm::MemoryBufferRef obj) override void notifyObjectCompiled(const llvm::Module* _module, llvm::MemoryBufferRef obj) override
{ {
std::string name = m_path; std::string name = m_path;
name.append(module->getName().data()); name.append(_module->getName().data());
//fs::file(name, fs::rewrite).write(obj.getBufferStart(), obj.getBufferSize()); //fs::file(name, fs::rewrite).write(obj.getBufferStart(), obj.getBufferSize());
name.append(".gz"); name.append(".gz");
@ -948,14 +948,14 @@ public:
} }
default: default:
{ {
jit_log.error("LLVM: Failed to compress module: %s", module->getName().data()); jit_log.error("LLVM: Failed to compress module: %s", _module->getName().data());
deflateEnd(&zs); deflateEnd(&zs);
return; return;
} }
} }
fs::file(name, fs::rewrite).write(zbuf.get(), zsz - zs.avail_out); fs::file(name, fs::rewrite).write(zbuf.get(), zsz - zs.avail_out);
jit_log.notice("LLVM: Created module: %s", module->getName().data()); jit_log.notice("LLVM: Created module: %s", _module->getName().data());
} }
static std::unique_ptr<llvm::MemoryBuffer> load(const std::string& path) static std::unique_ptr<llvm::MemoryBuffer> load(const std::string& path)
@ -1033,14 +1033,14 @@ public:
return nullptr; return nullptr;
} }
std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* module) override std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* _module) override
{ {
std::string path = m_path; std::string path = m_path;
path.append(module->getName().data()); path.append(_module->getName().data());
if (auto buf = load(path)) if (auto buf = load(path))
{ {
jit_log.notice("LLVM: Loaded module: %s", module->getName().data()); jit_log.notice("LLVM: Loaded module: %s", _module->getName().data());
return buf; return buf;
} }
@ -1166,13 +1166,13 @@ jit_compiler::~jit_compiler()
{ {
} }
void jit_compiler::add(std::unique_ptr<llvm::Module> module, const std::string& path) void jit_compiler::add(std::unique_ptr<llvm::Module> _module, const std::string& path)
{ {
ObjectCache cache{path}; ObjectCache cache{path};
m_engine->setObjectCache(&cache); m_engine->setObjectCache(&cache);
const auto ptr = module.get(); const auto ptr = _module.get();
m_engine->addModule(std::move(module)); m_engine->addModule(std::move(_module));
m_engine->generateCodeForModule(ptr); m_engine->generateCodeForModule(ptr);
m_engine->setObjectCache(nullptr); m_engine->setObjectCache(nullptr);
@ -1183,10 +1183,10 @@ void jit_compiler::add(std::unique_ptr<llvm::Module> module, const std::string&
} }
} }
void jit_compiler::add(std::unique_ptr<llvm::Module> module) void jit_compiler::add(std::unique_ptr<llvm::Module> _module)
{ {
const auto ptr = module.get(); const auto ptr = _module.get();
m_engine->addModule(std::move(module)); m_engine->addModule(std::move(_module));
m_engine->generateCodeForModule(ptr); m_engine->generateCodeForModule(ptr);
for (auto& func : ptr->functions()) for (auto& func : ptr->functions())

4
Utilities/JIT.h
View File

@ -163,10 +163,10 @@ public:
} }
// Add module (path to obj cache dir) // Add module (path to obj cache dir)
void add(std::unique_ptr<llvm::Module> module, const std::string& path); void add(std::unique_ptr<llvm::Module> _module, const std::string& path);
// Add module (not cached) // Add module (not cached)
void add(std::unique_ptr<llvm::Module> module); void add(std::unique_ptr<llvm::Module> _module);
// Add object (path to obj file) // Add object (path to obj file)
void add(const std::string& path); void add(const std::string& path);

6
Utilities/Thread.cpp
View File

@ -1657,10 +1657,10 @@ static LONG exception_filter(PEXCEPTION_POINTERS pExp) noexcept
//const auto uw = (u8*)(unwind_base + rtf->UnwindData); //const auto uw = (u8*)(unwind_base + rtf->UnwindData);
} }
for (HMODULE module : modules) for (HMODULE _module : modules)
{ {
MODULEINFO info; MODULEINFO info;
if (GetModuleInformation(GetCurrentProcess(), module, &info, sizeof(info))) if (GetModuleInformation(GetCurrentProcess(), _module, &info, sizeof(info)))
{ {
const DWORD64 base = reinterpret_cast<DWORD64>(info.lpBaseOfDll); const DWORD64 base = reinterpret_cast<DWORD64>(info.lpBaseOfDll);
@ -1670,7 +1670,7 @@ static LONG exception_filter(PEXCEPTION_POINTERS pExp) noexcept
for (DWORD size = 15; module_name.size() != size;) for (DWORD size = 15; module_name.size() != size;)
{ {
module_name.resize(size); module_name.resize(size);
size = GetModuleBaseNameA(GetCurrentProcess(), module, &module_name.front(), size + 1); size = GetModuleBaseNameA(GetCurrentProcess(), _module, &module_name.front(), size + 1);
if (!size) if (!size)
{ {
module_name.clear(); module_name.clear();

4
rpcs3/Emu/CPU/CPUTranslator.cpp
View File

@ -4,9 +4,9 @@
llvm::LLVMContext g_llvm_ctx; llvm::LLVMContext g_llvm_ctx;
cpu_translator::cpu_translator(llvm::Module* module, bool is_be) cpu_translator::cpu_translator(llvm::Module* _module, bool is_be)
: m_context(g_llvm_ctx) : m_context(g_llvm_ctx)
, m_module(module) , m_module(_module)
, m_is_be(is_be) , m_is_be(is_be)
{ {
} }

28
rpcs3/Emu/CPU/CPUTranslator.h
View File

@ -1009,8 +1009,8 @@ struct llvm_fshl
static llvm::Function* get_fshl(llvm::IRBuilder<>* ir) static llvm::Function* get_fshl(llvm::IRBuilder<>* ir)
{ {
const auto module = ir->GetInsertBlock()->getParent()->getParent(); const auto _module = ir->GetInsertBlock()->getParent()->getParent();
return llvm::Intrinsic::getDeclaration(module, llvm::Intrinsic::fshl, {llvm_value_t<T>::get_type(ir->getContext())}); return llvm::Intrinsic::getDeclaration(_module, llvm::Intrinsic::fshl, {llvm_value_t<T>::get_type(ir->getContext())});
} }
static llvm::Value* fold(llvm::IRBuilder<>* ir, llvm::Value* v1, llvm::Value* v2, llvm::Value* v3) static llvm::Value* fold(llvm::IRBuilder<>* ir, llvm::Value* v1, llvm::Value* v2, llvm::Value* v3)
@ -1081,8 +1081,8 @@ struct llvm_fshr
static llvm::Function* get_fshr(llvm::IRBuilder<>* ir) static llvm::Function* get_fshr(llvm::IRBuilder<>* ir)
{ {
const auto module = ir->GetInsertBlock()->getParent()->getParent(); const auto _module = ir->GetInsertBlock()->getParent()->getParent();
return llvm::Intrinsic::getDeclaration(module, llvm::Intrinsic::fshr, {llvm_value_t<T>::get_type(ir->getContext())}); return llvm::Intrinsic::getDeclaration(_module, llvm::Intrinsic::fshr, {llvm_value_t<T>::get_type(ir->getContext())});
} }
static llvm::Value* fold(llvm::IRBuilder<>* ir, llvm::Value* v1, llvm::Value* v2, llvm::Value* v3) static llvm::Value* fold(llvm::IRBuilder<>* ir, llvm::Value* v1, llvm::Value* v2, llvm::Value* v3)
@ -1642,7 +1642,7 @@ struct llvm_bitcast
using type = U; using type = U;
llvm_expr_t<A1> a1; llvm_expr_t<A1> a1;
llvm::Module* module; llvm::Module* _module;
static constexpr uint bitsize0 = llvm_value_t<T>::is_vector ? llvm_value_t<T>::is_vector * llvm_value_t<T>::esize : llvm_value_t<T>::esize; static constexpr uint bitsize0 = llvm_value_t<T>::is_vector ? llvm_value_t<T>::is_vector * llvm_value_t<T>::esize : llvm_value_t<T>::esize;
static constexpr uint bitsize1 = llvm_value_t<U>::is_vector ? llvm_value_t<U>::is_vector * llvm_value_t<U>::esize : llvm_value_t<U>::esize; static constexpr uint bitsize1 = llvm_value_t<U>::is_vector ? llvm_value_t<U>::is_vector * llvm_value_t<U>::esize : llvm_value_t<U>::esize;
@ -1668,7 +1668,7 @@ struct llvm_bitcast
if (const auto c1 = llvm::dyn_cast<llvm::Constant>(v1)) if (const auto c1 = llvm::dyn_cast<llvm::Constant>(v1))
{ {
const auto result = llvm::ConstantFoldCastOperand(llvm::Instruction::BitCast, c1, rt, module->getDataLayout()); const auto result = llvm::ConstantFoldCastOperand(llvm::Instruction::BitCast, c1, rt, _module->getDataLayout());
if (result) if (result)
{ {
@ -1714,7 +1714,7 @@ struct llvm_bitcast
const auto target = llvm_value_t<T>::get_type(c->getContext()); const auto target = llvm_value_t<T>::get_type(c->getContext());
// Reverse bitcast on a constant // Reverse bitcast on a constant
if (llvm::Value* cv = llvm::ConstantFoldCastOperand(llvm::Instruction::BitCast, c, target, module->getDataLayout())) if (llvm::Value* cv = llvm::ConstantFoldCastOperand(llvm::Instruction::BitCast, c, target, _module->getDataLayout()))
{ {
if (auto r1 = a1.match(cv); cv) if (auto r1 = a1.match(cv); cv)
{ {
@ -2029,8 +2029,8 @@ struct llvm_add_sat
static llvm::Function* get_add_sat(llvm::IRBuilder<>* ir) static llvm::Function* get_add_sat(llvm::IRBuilder<>* ir)
{ {
const auto module = ir->GetInsertBlock()->getParent()->getParent(); const auto _module = ir->GetInsertBlock()->getParent()->getParent();
return llvm::Intrinsic::getDeclaration(module, intr, {llvm_value_t<T>::get_type(ir->getContext())}); return llvm::Intrinsic::getDeclaration(_module, intr, {llvm_value_t<T>::get_type(ir->getContext())});
} }
llvm::Value* eval(llvm::IRBuilder<>* ir) const llvm::Value* eval(llvm::IRBuilder<>* ir) const
@ -2100,8 +2100,8 @@ struct llvm_sub_sat
static llvm::Function* get_sub_sat(llvm::IRBuilder<>* ir) static llvm::Function* get_sub_sat(llvm::IRBuilder<>* ir)
{ {
const auto module = ir->GetInsertBlock()->getParent()->getParent(); const auto _module = ir->GetInsertBlock()->getParent()->getParent();
return llvm::Intrinsic::getDeclaration(module, intr, {llvm_value_t<T>::get_type(ir->getContext())}); return llvm::Intrinsic::getDeclaration(_module, intr, {llvm_value_t<T>::get_type(ir->getContext())});
} }
llvm::Value* eval(llvm::IRBuilder<>* ir) const llvm::Value* eval(llvm::IRBuilder<>* ir) const
@ -2403,7 +2403,7 @@ struct llvm_shuffle2
class cpu_translator class cpu_translator
{ {
protected: protected:
cpu_translator(llvm::Module* module, bool is_be); cpu_translator(llvm::Module* _module, bool is_be);
// LLVM context // LLVM context
std::reference_wrapper<llvm::LLVMContext> m_context; std::reference_wrapper<llvm::LLVMContext> m_context;
@ -2695,8 +2695,8 @@ public:
template <typename... Types> template <typename... Types>
llvm::Function* get_intrinsic(llvm::Intrinsic::ID id) llvm::Function* get_intrinsic(llvm::Intrinsic::ID id)
{ {
const auto module = m_ir->GetInsertBlock()->getParent()->getParent(); const auto _module = m_ir->GetInsertBlock()->getParent()->getParent();
return llvm::Intrinsic::getDeclaration(module, id, {get_type<Types>()...}); return llvm::Intrinsic::getDeclaration(_module, id, {get_type<Types>()...});
} }
template <typename T> template <typename T>

6
rpcs3/Emu/Cell/Modules/StaticHLE.cpp
View File

@ -83,7 +83,7 @@ bool statichle_handler::load_patterns()
dapat.crc16_length = ::narrow<u8>(char_to_u8(pattern[1][0], pattern[1][1]), HERE); dapat.crc16_length = ::narrow<u8>(char_to_u8(pattern[1][0], pattern[1][1]), HERE);
dapat.crc16 = (char_to_u8(pattern[2][0], pattern[2][1]) << 8) | char_to_u8(pattern[2][2], pattern[2][3]); dapat.crc16 = (char_to_u8(pattern[2][0], pattern[2][1]) << 8) | char_to_u8(pattern[2][2], pattern[2][3]);
dapat.total_length = (char_to_u8(pattern[3][0], pattern[3][1]) << 8) | char_to_u8(pattern[3][2], pattern[3][3]); dapat.total_length = (char_to_u8(pattern[3][0], pattern[3][1]) << 8) | char_to_u8(pattern[3][2], pattern[3][3]);
dapat.module = pattern[4]; dapat._module = pattern[4];
dapat.name = pattern[5]; dapat.name = pattern[5];
dapat.fnid = ppu_generate_id(dapat.name.c_str()); dapat.fnid = ppu_generate_id(dapat.name.c_str());
@ -153,11 +153,11 @@ bool statichle_handler::check_against_patterns(vm::cptr<u8>& data, u32 size, u32
static_hle.success("Found function %s at 0x%x", pat.name, addr); static_hle.success("Found function %s at 0x%x", pat.name, addr);
// patch the code // patch the code
const auto smodule = ppu_module_manager::get_module(pat.module); const auto smodule = ppu_module_manager::get_module(pat._module);
if (smodule == nullptr) if (smodule == nullptr)
{ {
static_hle.error("Couldn't find module: %s", pat.module); static_hle.error("Couldn't find module: %s", pat._module);
return false; return false;
} }

2
rpcs3/Emu/Cell/Modules/StaticHLE.h
View File

@ -11,7 +11,7 @@ struct shle_pattern
u8 crc16_length; u8 crc16_length;
u16 crc16; u16 crc16;
u16 total_length; u16 total_length;
std::string module; std::string _module;
std::string name; std::string name;
u32 fnid; u32 fnid;

2
rpcs3/Emu/Cell/Modules/cellSpurs.h
View File

@ -380,7 +380,7 @@ struct CellSpursTraceMapData
struct CellSpursTraceStartData struct CellSpursTraceStartData
{ {
char module[4]; char _module[4];
be_t<u16> level; be_t<u16> level;
be_t<u16> ls; be_t<u16> ls;
}; };

4
rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
View File

@ -904,7 +904,7 @@ void spursSysServiceMain(spu_thread& spu, u32 pollStatus)
// Trace - START: Module='SYS ' // Trace - START: Module='SYS '
CellSpursTracePacket pkt{}; CellSpursTracePacket pkt{};
pkt.header.tag = CELL_SPURS_TRACE_TAG_START; pkt.header.tag = CELL_SPURS_TRACE_TAG_START;
memcpy(pkt.data.start.module, "SYS ", 4); std::memcpy(pkt.data.start._module, "SYS ", 4);
pkt.data.start.level = 1; // Policy module pkt.data.start.level = 1; // Policy module
pkt.data.start.ls = 0xA00 >> 2; pkt.data.start.ls = 0xA00 >> 2;
cellSpursModulePutTrace(&pkt, ctxt->dmaTagId); cellSpursModulePutTrace(&pkt, ctxt->dmaTagId);
@ -1958,7 +1958,7 @@ void spursTasksetInit(spu_thread& spu, u32 pollStatus)
// Trace - START: Module='TKST' // Trace - START: Module='TKST'
CellSpursTracePacket pkt{}; CellSpursTracePacket pkt{};
pkt.header.tag = 0x52; // Its not clear what this tag means exactly but it seems similar to CELL_SPURS_TRACE_TAG_START pkt.header.tag = 0x52; // Its not clear what this tag means exactly but it seems similar to CELL_SPURS_TRACE_TAG_START
memcpy(pkt.data.start.module, "TKST", 4); std::memcpy(pkt.data.start._module, "TKST", 4);
pkt.data.start.level = 2; pkt.data.start.level = 2;
pkt.data.start.ls = 0xA00 >> 2; pkt.data.start.ls = 0xA00 >> 2;
cellSpursModulePutTrace(&pkt, ctxt->dmaTagId); cellSpursModulePutTrace(&pkt, ctxt->dmaTagId);

22
rpcs3/Emu/Cell/PPUFunction.cpp
View File

@ -640,9 +640,9 @@ extern std::string ppu_get_syscall_name(u64 code)
} }
// Get function name by FNID // Get function name by FNID
extern std::string ppu_get_function_name(const std::string& module, u32 fnid) extern std::string ppu_get_function_name(const std::string& _module, u32 fnid)
{ {
if (module.empty()) switch (fnid) if (_module.empty()) switch (fnid)
{ {
case 0x0d10fd3f: return "module_prologue"; case 0x0d10fd3f: return "module_prologue";
case 0x330f7005: return "module_epilogue"; case 0x330f7005: return "module_epilogue";
@ -652,7 +652,7 @@ extern std::string ppu_get_function_name(const std::string& module, u32 fnid)
} }
// Check known FNIDs // Check known FNIDs
if (module == "sys_libc" || module == "sys_libm") switch (fnid) if (_module == "sys_libc" || _module == "sys_libm") switch (fnid)
{ {
case 0x00acf0e5: return "spu_printf_finalize"; case 0x00acf0e5: return "spu_printf_finalize";
case 0x00fb4a6b: return "spu_thread_sprintf"; case 0x00fb4a6b: return "spu_thread_sprintf";
@ -1727,7 +1727,7 @@ extern std::string ppu_get_function_name(const std::string& module, u32 fnid)
case 0xfffe79bf: return "_LCmulcc"; case 0xfffe79bf: return "_LCmulcc";
} }
if (module == "sys_libstdcxx") switch (fnid) if (_module == "sys_libstdcxx") switch (fnid)
{ {
case 0x002c338b: return "_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRNSt5_IosbIiE8_IostateEPSt2tm"; case 0x002c338b: return "_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRNSt5_IosbIiE8_IostateEPSt2tm";
case 0x002e18d8: return "_ZNSt6locale7_LocimpD0Ev"; case 0x002e18d8: return "_ZNSt6locale7_LocimpD0Ev";
@ -2287,7 +2287,7 @@ extern std::string ppu_get_function_name(const std::string& module, u32 fnid)
case 0xfff6ef55: return "_ZNKSt7num_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE6do_getES3_S3_RSt8ios_baseRNSt5_IosbIiE8_IostateERb"; case 0xfff6ef55: return "_ZNKSt7num_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE6do_getES3_S3_RSt8ios_baseRNSt5_IosbIiE8_IostateERb";
} }
if (module == "sysPrxForUser") switch (fnid) if (_module == "sysPrxForUser") switch (fnid)
{ {
case 0x02e20ec1: return "__sys_printf_basename"; case 0x02e20ec1: return "__sys_printf_basename";
case 0x0341bb97: return "sys_prx_get_module_id_by_address"; case 0x0341bb97: return "sys_prx_get_module_id_by_address";
@ -2422,7 +2422,7 @@ extern std::string ppu_get_function_name(const std::string& module, u32 fnid)
} }
// Check registered functions // Check registered functions
if (const auto sm = ppu_module_manager::get_module(module)) if (const auto sm = ppu_module_manager::get_module(_module))
{ {
const auto found = sm->functions.find(fnid); const auto found = sm->functions.find(fnid);
@ -2436,15 +2436,15 @@ extern std::string ppu_get_function_name(const std::string& module, u32 fnid)
} }
// Get variable name by VNID // Get variable name by VNID
extern std::string ppu_get_variable_name(const std::string& module, u32 vnid) extern std::string ppu_get_variable_name(const std::string& _module, u32 vnid)
{ {
if (module.empty()) switch (vnid) if (_module.empty()) switch (vnid)
{ {
// these arent the actual hash, but its close enough // these arent the actual hash, but its close enough
case 0xd7f43016: return "module_info"; case 0xd7f43016: return "module_info";
} }
// Check known FNIDs // Check known FNIDs
if (module == "sys_libc") switch (vnid) if (_module == "sys_libc") switch (vnid)
{ {
case 0x071928b0: return "_LNan"; case 0x071928b0: return "_LNan";
case 0x0a331920: return "_Clocale"; case 0x0a331920: return "_Clocale";
@ -2496,7 +2496,7 @@ extern std::string ppu_get_variable_name(const std::string& module, u32 vnid)
case 0xff2f0cc7: return "_FEps"; case 0xff2f0cc7: return "_FEps";
} }
if (module == "sys_libm") switch (vnid) if (_module == "sys_libm") switch (vnid)
{ {
case 0x1cf745bc: return "_LErf_one"; case 0x1cf745bc: return "_LErf_one";
case 0x2259ef96: return "_LGamma_big"; case 0x2259ef96: return "_LGamma_big";
@ -2511,7 +2511,7 @@ extern std::string ppu_get_variable_name(const std::string& module, u32 vnid)
} }
// Check registered variables // Check registered variables
if (const auto sm = ppu_module_manager::get_module(module)) if (const auto sm = ppu_module_manager::get_module(_module))
{ {
const auto found = sm->variables.find(vnid); const auto found = sm->variables.find(vnid);

44
rpcs3/Emu/Cell/PPUModule.cpp
View File

@ -26,8 +26,8 @@
LOG_CHANNEL(ppu_loader); LOG_CHANNEL(ppu_loader);
extern void ppu_initialize_syscalls(); extern void ppu_initialize_syscalls();
extern std::string ppu_get_function_name(const std::string& module, u32 fnid); extern std::string ppu_get_function_name(const std::string& _module, u32 fnid);
extern std::string ppu_get_variable_name(const std::string& module, u32 vnid); extern std::string ppu_get_variable_name(const std::string& _module, u32 vnid);
extern void ppu_register_range(u32 addr, u32 size); extern void ppu_register_range(u32 addr, u32 size);
extern void ppu_register_function_at(u32 addr, u32 size, ppu_function_t ptr); extern void ppu_register_function_at(u32 addr, u32 size, ppu_function_t ptr);
extern void ppu_initialize(const ppu_module& info); extern void ppu_initialize(const ppu_module& info);
@ -68,30 +68,30 @@ std::unordered_map<std::string, ppu_static_module*>& ppu_module_manager::access(
return map; return map;
} }
void ppu_module_manager::register_module(ppu_static_module* module) void ppu_module_manager::register_module(ppu_static_module* _module)
{ {
access().emplace(module->name, module); access().emplace(_module->name, _module);
} }
ppu_static_function& ppu_module_manager::access_static_function(const char* module, u32 fnid) ppu_static_function& ppu_module_manager::access_static_function(const char* _module, u32 fnid)
{ {
auto& res = access().at(module)->functions[fnid]; auto& res = access().at(_module)->functions[fnid];
if (res.name) if (res.name)
{ {
fmt::throw_exception("PPU FNID duplication in module %s (%s, 0x%x)", module, res.name, fnid); fmt::throw_exception("PPU FNID duplication in module %s (%s, 0x%x)", _module, res.name, fnid);
} }
return res; return res;
} }
ppu_static_variable& ppu_module_manager::access_static_variable(const char* module, u32 vnid) ppu_static_variable& ppu_module_manager::access_static_variable(const char* _module, u32 vnid)
{ {
auto& res = access().at(module)->variables[vnid]; auto& res = access().at(_module)->variables[vnid];
if (res.name) if (res.name)
{ {
fmt::throw_exception("PPU VNID duplication in module %s (%s, 0x%x)", module, res.name, vnid); fmt::throw_exception("PPU VNID duplication in module %s (%s, 0x%x)", _module, res.name, vnid);
} }
return res; return res;
@ -107,7 +107,7 @@ const ppu_static_module* ppu_module_manager::get_module(const std::string& name)
// Global linkage information // Global linkage information
struct ppu_linkage_info struct ppu_linkage_info
{ {
struct module struct module_data
{ {
struct info struct info
{ {
@ -127,7 +127,7 @@ struct ppu_linkage_info
}; };
// Module map // Module map
std::unordered_map<std::string, module> modules; std::unordered_map<std::string, module_data> modules;
}; };
// Initialize static modules. // Initialize static modules.
@ -289,23 +289,23 @@ static void ppu_initialize_modules(ppu_linkage_info* link)
u32 alloc_addr = 0; u32 alloc_addr = 0;
// "Use" all the modules for correct linkage // "Use" all the modules for correct linkage
for (auto& module : registered) for (auto& _module : registered)
{ {
ppu_loader.trace("Registered static module: %s", module->name); ppu_loader.trace("Registered static module: %s", _module->name);
} }
for (auto& pair : ppu_module_manager::get()) for (auto& pair : ppu_module_manager::get())
{ {
const auto module = pair.second; const auto _module = pair.second;
auto& linkage = link->modules[module->name]; auto& linkage = link->modules[_module->name];
for (auto& function : module->functions) for (auto& function : _module->functions)
{ {
ppu_loader.trace("** 0x%08X: %s", function.first, function.second.name); ppu_loader.trace("** 0x%08X: %s", function.first, function.second.name);
if (is_first) if (is_first)
{ {
g_ppu_function_names[function.second.index] = fmt::format("%s.%s", module->name, function.second.name); g_ppu_function_names[function.second.index] = fmt::format("%s.%s", _module->name, function.second.name);
} }
if ((function.second.flags & MFF_HIDDEN) == 0) if ((function.second.flags & MFF_HIDDEN) == 0)
@ -318,7 +318,7 @@ static void ppu_initialize_modules(ppu_linkage_info* link)
} }
} }
for (auto& variable : module->variables) for (auto& variable : _module->variables)
{ {
ppu_loader.trace("** &0x%08X: %s (size=0x%x, align=0x%x)", variable.first, variable.second.name, variable.second.size, variable.second.align); ppu_loader.trace("** &0x%08X: %s (size=0x%x, align=0x%x)", variable.first, variable.second.name, variable.second.size, variable.second.align);
@ -350,7 +350,7 @@ static void ppu_initialize_modules(ppu_linkage_info* link)
variable.second.var->set(variable.second.addr); variable.second.var->set(variable.second.addr);
} }
ppu_loader.trace("Allocated HLE variable %s.%s at 0x%x", module->name, variable.second.name, variable.second.var->addr()); ppu_loader.trace("Allocated HLE variable %s.%s at 0x%x", _module->name, variable.second.name, variable.second.var->addr());
// Initialize HLE variable // Initialize HLE variable
if (variable.second.init) if (variable.second.init)
@ -996,14 +996,14 @@ void ppu_unload_prx(const lv2_prx& prx)
// Clean linkage info // Clean linkage info
for (auto& imp : prx.imports) for (auto& imp : prx.imports)
{ {
auto pinfo = static_cast<ppu_linkage_info::module::info*>(imp.second); auto pinfo = static_cast<ppu_linkage_info::module_data::info*>(imp.second);
pinfo->frefss.erase(imp.first); pinfo->frefss.erase(imp.first);
pinfo->imports.erase(imp.first); pinfo->imports.erase(imp.first);
} }
//for (auto& exp : prx.exports) //for (auto& exp : prx.exports)
//{ //{
// auto pinfo = static_cast<ppu_linkage_info::module::info*>(exp.second); // auto pinfo = static_cast<ppu_linkage_info::module_data::info*>(exp.second);
// if (pinfo->static_func) // if (pinfo->static_func)
// { // {
// pinfo->export_addr = ppu_function_manager::addr + 8 * pinfo->static_func->index; // pinfo->export_addr = ppu_function_manager::addr + 8 * pinfo->static_func->index;

24
rpcs3/Emu/Cell/PPUModule.h
View File

@ -103,11 +103,11 @@ class ppu_module_manager final
static std::unordered_map<std::string, ppu_static_module*>& access(); static std::unordered_map<std::string, ppu_static_module*>& access();
static void register_module(ppu_static_module* module); static void register_module(ppu_static_module*);
static ppu_static_function& access_static_function(const char* module, u32 fnid); static ppu_static_function& access_static_function(const char* _module, u32 fnid);
static ppu_static_variable& access_static_variable(const char* module, u32 vnid); static ppu_static_variable& access_static_variable(const char* _module, u32 vnid);
// Global variable for each registered function // Global variable for each registered function
template <auto* Func> template <auto* Func>
@ -120,9 +120,9 @@ public:
static const ppu_static_module* get_module(const std::string& name); static const ppu_static_module* get_module(const std::string& name);
template <auto* Func> template <auto* Func>
static auto& register_static_function(const char* module, const char* name, ppu_function_t func, u32 fnid) static auto& register_static_function(const char* _module, const char* name, ppu_function_t func, u32 fnid)
{ {
auto& info = access_static_function(module, fnid); auto& info = access_static_function(_module, fnid);
info.name = name; info.name = name;
info.index = ppu_function_manager::register_function<decltype(Func), Func>(func); info.index = ppu_function_manager::register_function<decltype(Func), Func>(func);
@ -141,13 +141,13 @@ public:
} }
template <auto* Var> template <auto* Var>
static auto& register_static_variable(const char* module, const char* name, u32 vnid) static auto& register_static_variable(const char* _module, const char* name, u32 vnid)
{ {
using gvar = std::decay_t<decltype(*Var)>; using gvar = std::decay_t<decltype(*Var)>;
static_assert(std::is_same<u32, typename gvar::addr_type>::value, "Static variable registration: vm::gvar<T> expected"); static_assert(std::is_same<u32, typename gvar::addr_type>::value, "Static variable registration: vm::gvar<T> expected");
auto& info = access_static_variable(module, vnid); auto& info = access_static_variable(_module, vnid);
info.name = name; info.name = name;
info.var = reinterpret_cast<vm::gvar<char>*>(Var); info.var = reinterpret_cast<vm::gvar<char>*>(Var);
@ -286,12 +286,12 @@ inline RT ppu_execute(ppu_thread& ppu, Args... args)
return func(ppu, args...); return func(ppu, args...);
} }
#define REG_FNID(module, nid, func) ppu_module_manager::register_static_function<&func>(#module, ppu_select_name(#func, nid), BIND_FUNC(func, ppu.cia = static_cast<u32>(ppu.lr) & ~3), ppu_generate_id(nid)) #define REG_FNID(_module, nid, func) ppu_module_manager::register_static_function<&func>(#_module, ppu_select_name(#func, nid), BIND_FUNC(func, ppu.cia = static_cast<u32>(ppu.lr) & ~3), ppu_generate_id(nid))
#define REG_FUNC(module, func) REG_FNID(module, #func, func) #define REG_FUNC(_module, func) REG_FNID(_module, #func, func)
#define REG_VNID(module, nid, var) ppu_module_manager::register_static_variable<&var>(#module, ppu_select_name(#var, nid), ppu_generate_id(nid)) #define REG_VNID(_module, nid, var) ppu_module_manager::register_static_variable<&var>(#_module, ppu_select_name(#var, nid), ppu_generate_id(nid))
#define REG_VAR(module, var) REG_VNID(module, #var, var) #define REG_VAR(_module, var) REG_VNID(_module, #var, var)
#define UNIMPLEMENTED_FUNC(module) module.todo("%s()", __func__) #define UNIMPLEMENTED_FUNC(_module) _module.todo("%s()", __func__)

20
rpcs3/Emu/Cell/PPUThread.cpp
View File

@ -1804,14 +1804,14 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
using namespace llvm; using namespace llvm;
// Create LLVM module // Create LLVM module
std::unique_ptr<Module> module = std::make_unique<Module>(obj_name, jit.get_context()); std::unique_ptr<Module> _module = std::make_unique<Module>(obj_name, jit.get_context());
// Initialize target // Initialize target
module->setTargetTriple(Triple::normalize(sys::getProcessTriple())); _module->setTargetTriple(Triple::normalize(sys::getProcessTriple()));
module->setDataLayout(jit.get_engine().getTargetMachine()->createDataLayout()); _module->setDataLayout(jit.get_engine().getTargetMachine()->createDataLayout());
// Initialize translator // Initialize translator
PPUTranslator translator(jit.get_context(), module.get(), module_part, jit.get_engine()); PPUTranslator translator(jit.get_context(), _module.get(), module_part, jit.get_engine());
// Define some types // Define some types
const auto _void = Type::getVoidTy(jit.get_context()); const auto _void = Type::getVoidTy(jit.get_context());
@ -1822,13 +1822,13 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
{ {
if (func.size) if (func.size)
{ {
const auto f = cast<Function>(module->getOrInsertFunction(func.name, _func).getCallee()); const auto f = cast<Function>(_module->getOrInsertFunction(func.name, _func).getCallee());
f->addAttribute(1, Attribute::NoAlias); f->addAttribute(1, Attribute::NoAlias);
} }
} }
{ {
legacy::FunctionPassManager pm(module.get()); legacy::FunctionPassManager pm(_module.get());
// Basic optimizations // Basic optimizations
//pm.add(createCFGSimplificationPass()); //pm.add(createCFGSimplificationPass());
@ -1888,12 +1888,12 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
if (g_cfg.core.llvm_logs) if (g_cfg.core.llvm_logs)
{ {
out << *module; // print IR out << *_module; // print IR
fs::file(cache_path + obj_name + ".log", fs::rewrite).write(out.str()); fs::file(cache_path + obj_name + ".log", fs::rewrite).write(out.str());
result.clear(); result.clear();
} }
if (verifyModule(*module, &out)) if (verifyModule(*_module, &out))
{ {
out.flush(); out.flush();
ppu_log.error("LLVM: Verification failed for %s:\n%s", obj_name, result); ppu_log.error("LLVM: Verification failed for %s:\n%s", obj_name, result);
@ -1901,10 +1901,10 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
return; return;
} }
ppu_log.notice("LLVM: %zu functions generated", module->getFunctionList().size()); ppu_log.notice("LLVM: %zu functions generated", _module->getFunctionList().size());
} }
// Load or compile module // Load or compile module
jit.add(std::move(module), cache_path); jit.add(std::move(_module), cache_path);
#endif // LLVM_AVAILABLE #endif // LLVM_AVAILABLE
} }

10
rpcs3/Emu/Cell/PPUTranslator.cpp
View File

@ -13,8 +13,8 @@ using namespace llvm;
constexpr ppu_decoder<PPUTranslator> s_ppu_decoder; constexpr ppu_decoder<PPUTranslator> s_ppu_decoder;
constexpr ppu_decoder<ppu_iname> s_ppu_iname; constexpr ppu_decoder<ppu_iname> s_ppu_iname;
PPUTranslator::PPUTranslator(LLVMContext& context, Module* module, const ppu_module& info, ExecutionEngine& engine) PPUTranslator::PPUTranslator(LLVMContext& context, Module* _module, const ppu_module& info, ExecutionEngine& engine)
: cpu_translator(module, false) : cpu_translator(_module, false)
, m_info(info) , m_info(info)
, m_pure_attr(AttributeList::get(m_context, AttributeList::FunctionIndex, {Attribute::NoUnwind, Attribute::ReadNone})) , m_pure_attr(AttributeList::get(m_context, AttributeList::FunctionIndex, {Attribute::NoUnwind, Attribute::ReadNone}))
{ {
@ -25,7 +25,7 @@ PPUTranslator::PPUTranslator(LLVMContext& context, Module* module, const ppu_mod
const u32 gsuffix = m_info.name.empty() ? info.funcs[0].addr : info.funcs[0].addr - m_info.segs[0].addr; const u32 gsuffix = m_info.name.empty() ? info.funcs[0].addr : info.funcs[0].addr - m_info.segs[0].addr;
// Memory base // Memory base
m_base = new GlobalVariable(*module, ArrayType::get(GetType<char>(), 0x100000000)->getPointerTo(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__mptr%x", gsuffix)); m_base = new GlobalVariable(*_module, ArrayType::get(GetType<char>(), 0x100000000)->getPointerTo(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__mptr%x", gsuffix));
m_base->setInitializer(ConstantPointerNull::get(cast<PointerType>(m_base->getType()->getPointerElementType()))); m_base->setInitializer(ConstantPointerNull::get(cast<PointerType>(m_base->getType()->getPointerElementType())));
m_base->setExternallyInitialized(true); m_base->setExternallyInitialized(true);
@ -50,7 +50,7 @@ PPUTranslator::PPUTranslator(LLVMContext& context, Module* module, const ppu_mod
m_thread_type = StructType::create(m_context, thread_struct, "context_t"); m_thread_type = StructType::create(m_context, thread_struct, "context_t");
// Callable // Callable
m_call = new GlobalVariable(*module, ArrayType::get(GetType<u32>(), 0x80000000)->getPointerTo(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__cptr%x", gsuffix)); m_call = new GlobalVariable(*_module, ArrayType::get(GetType<u32>(), 0x80000000)->getPointerTo(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__cptr%x", gsuffix));
m_call->setInitializer(ConstantPointerNull::get(cast<PointerType>(m_call->getType()->getPointerElementType()))); m_call->setInitializer(ConstantPointerNull::get(cast<PointerType>(m_call->getType()->getPointerElementType())));
m_call->setExternallyInitialized(true); m_call->setExternallyInitialized(true);
@ -65,7 +65,7 @@ PPUTranslator::PPUTranslator(LLVMContext& context, Module* module, const ppu_mod
// Create segment variables // Create segment variables
for (const auto& seg : m_info.segs) for (const auto& seg : m_info.segs)
{ {
auto gv = new GlobalVariable(*module, GetType<u64>(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__seg%u_%x", m_segs.size(), gsuffix)); auto gv = new GlobalVariable(*_module, GetType<u64>(), true, GlobalValue::ExternalLinkage, 0, fmt::format("__seg%u_%x", m_segs.size(), gsuffix));
gv->setInitializer(ConstantInt::get(GetType<u64>(), seg.addr)); gv->setInitializer(ConstantInt::get(GetType<u64>(), seg.addr));
gv->setExternallyInitialized(true); gv->setExternallyInitialized(true);
m_segs.emplace_back(gv); m_segs.emplace_back(gv);

2
rpcs3/Emu/Cell/PPUTranslator.h
View File

@ -315,7 +315,7 @@ public:
// Handle compilation errors // Handle compilation errors
void CompilationError(const std::string& error); void CompilationError(const std::string& error);
PPUTranslator(llvm::LLVMContext& context, llvm::Module* module, const ppu_module& info, llvm::ExecutionEngine& engine); PPUTranslator(llvm::LLVMContext& context, llvm::Module* _module, const ppu_module& info, llvm::ExecutionEngine& engine);
~PPUTranslator(); ~PPUTranslator();
// Get thread context struct type // Get thread context struct type

44
rpcs3/Emu/Cell/SPURecompiler.cpp
View File

@ -4261,10 +4261,10 @@ public:
m_engine->clearAllGlobalMappings(); m_engine->clearAllGlobalMappings();
// Create LLVM module // Create LLVM module
std::unique_ptr<Module> module = std::make_unique<Module>(m_hash + ".obj", m_context); std::unique_ptr<Module> _module = std::make_unique<Module>(m_hash + ".obj", m_context);
module->setTargetTriple(Triple::normalize("x86_64-unknown-linux-gnu")); _module->setTargetTriple(Triple::normalize("x86_64-unknown-linux-gnu"));
module->setDataLayout(m_jit.get_engine().getTargetMachine()->createDataLayout()); _module->setDataLayout(m_jit.get_engine().getTargetMachine()->createDataLayout());
m_module = module.get(); m_module = _module.get();
// Initialize IR Builder // Initialize IR Builder
IRBuilder<> irb(m_context); IRBuilder<> irb(m_context);
@ -4450,7 +4450,7 @@ public:
m_ir->CreateUnreachable(); m_ir->CreateUnreachable();
} }
m_dispatch = cast<Function>(module->getOrInsertFunction("spu-null", entry_chunk->chunk->getFunctionType()).getCallee()); m_dispatch = cast<Function>(_module->getOrInsertFunction("spu-null", entry_chunk->chunk->getFunctionType()).getCallee());
m_dispatch->setLinkage(llvm::GlobalValue::InternalLinkage); m_dispatch->setLinkage(llvm::GlobalValue::InternalLinkage);
m_dispatch->setCallingConv(entry_chunk->chunk->getCallingConv()); m_dispatch->setCallingConv(entry_chunk->chunk->getCallingConv());
set_function(m_dispatch); set_function(m_dispatch);
@ -4709,7 +4709,7 @@ public:
} }
// Initialize pass manager // Initialize pass manager
legacy::FunctionPassManager pm(module.get()); legacy::FunctionPassManager pm(_module.get());
// Basic optimizations // Basic optimizations
pm.add(createEarlyCSEPass()); pm.add(createEarlyCSEPass());
@ -4765,11 +4765,11 @@ public:
if (g_cfg.core.spu_debug) if (g_cfg.core.spu_debug)
{ {
fmt::append(log, "LLVM IR at 0x%x:\n", func.entry_point); fmt::append(log, "LLVM IR at 0x%x:\n", func.entry_point);
out << *module; // print IR out << *_module; // print IR
out << "\n\n"; out << "\n\n";
} }
if (verifyModule(*module, &out)) if (verifyModule(*_module, &out))
{ {
out.flush(); out.flush();
spu_log.error("LLVM: Verification failed at 0x%x:\n%s", func.entry_point, log); spu_log.error("LLVM: Verification failed at 0x%x:\n%s", func.entry_point, log);
@ -4785,11 +4785,11 @@ public:
if (g_cfg.core.spu_debug) if (g_cfg.core.spu_debug)
{ {
// Testing only // Testing only
m_jit.add(std::move(module), m_spurt->get_cache_path() + "llvm/"); m_jit.add(std::move(_module), m_spurt->get_cache_path() + "llvm/");
} }
else else
{ {
m_jit.add(std::move(module)); m_jit.add(std::move(_module));
} }
m_jit.fin(); m_jit.fin();
@ -4861,10 +4861,10 @@ public:
m_engine->clearAllGlobalMappings(); m_engine->clearAllGlobalMappings();
// Create LLVM module // Create LLVM module
std::unique_ptr<Module> module = std::make_unique<Module>("spu_interpreter.obj", m_context); std::unique_ptr<Module> _module = std::make_unique<Module>("spu_interpreter.obj", m_context);
module->setTargetTriple(Triple::normalize("x86_64-unknown-linux-gnu")); _module->setTargetTriple(Triple::normalize("x86_64-unknown-linux-gnu"));
module->setDataLayout(m_jit.get_engine().getTargetMachine()->createDataLayout()); _module->setDataLayout(m_jit.get_engine().getTargetMachine()->createDataLayout());
m_module = module.get(); m_module = _module.get();
// Initialize IR Builder // Initialize IR Builder
IRBuilder<> irb(m_context); IRBuilder<> irb(m_context);
@ -4876,7 +4876,7 @@ public:
m_function_table = new GlobalVariable(*m_module, ArrayType::get(if_type->getPointerTo(), 1ull << m_interp_magn), true, GlobalValue::InternalLinkage, nullptr); m_function_table = new GlobalVariable(*m_module, ArrayType::get(if_type->getPointerTo(), 1ull << m_interp_magn), true, GlobalValue::InternalLinkage, nullptr);
// Add return function // Add return function
const auto ret_func = cast<Function>(module->getOrInsertFunction("spu_ret", if_type).getCallee()); const auto ret_func = cast<Function>(_module->getOrInsertFunction("spu_ret", if_type).getCallee());
ret_func->setCallingConv(CallingConv::GHC); ret_func->setCallingConv(CallingConv::GHC);
ret_func->setLinkage(GlobalValue::InternalLinkage); ret_func->setLinkage(GlobalValue::InternalLinkage);
m_ir->SetInsertPoint(BasicBlock::Create(m_context, "", ret_func)); m_ir->SetInsertPoint(BasicBlock::Create(m_context, "", ret_func));
@ -4966,7 +4966,7 @@ public:
} }
// Decode instruction name, access function // Decode instruction name, access function
const auto f = cast<Function>(module->getOrInsertFunction(fname, if_type).getCallee()); const auto f = cast<Function>(_module->getOrInsertFunction(fname, if_type).getCallee());
// Build if necessary // Build if necessary
if (f->empty()) if (f->empty())
@ -5179,7 +5179,7 @@ public:
m_function_table = nullptr; m_function_table = nullptr;
// Initialize pass manager // Initialize pass manager
legacy::FunctionPassManager pm(module.get()); legacy::FunctionPassManager pm(_module.get());
// Basic optimizations // Basic optimizations
pm.add(createEarlyCSEPass()); pm.add(createEarlyCSEPass());
@ -5195,11 +5195,11 @@ public:
if (g_cfg.core.spu_debug) if (g_cfg.core.spu_debug)
{ {
fmt::append(log, "LLVM IR (interpreter):\n"); fmt::append(log, "LLVM IR (interpreter):\n");
out << *module; // print IR out << *_module; // print IR
out << "\n\n"; out << "\n\n";
} }
if (verifyModule(*module, &out)) if (verifyModule(*_module, &out))
{ {
out.flush(); out.flush();
spu_log.error("LLVM: Verification failed:\n%s", log); spu_log.error("LLVM: Verification failed:\n%s", log);
@ -5215,11 +5215,11 @@ public:
if (g_cfg.core.spu_debug) if (g_cfg.core.spu_debug)
{ {
// Testing only // Testing only
m_jit.add(std::move(module), m_spurt->get_cache_path() + "llvm/"); m_jit.add(std::move(_module), m_spurt->get_cache_path() + "llvm/");
} }
else else
{ {
m_jit.add(std::move(module)); m_jit.add(std::move(_module));
} }
m_jit.fin(); m_jit.fin();
@ -7445,7 +7445,7 @@ public:
const auto mb = eval(sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.)))); const auto mb = eval(sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.))));
const auto ca = eval(bitcast<f32[4]>(bitcast<s32[4]>(a) & mb)); const auto ca = eval(bitcast<f32[4]>(bitcast<s32[4]>(a) & mb));
const auto cb = eval(bitcast<f32[4]>(bitcast<s32[4]>(b) & ma)); const auto cb = eval(bitcast<f32[4]>(bitcast<s32[4]>(b) & ma));
// Optimization: Emit only a floating multiply if the addend is zero // Optimization: Emit only a floating multiply if the addend is zero
// This is odd since SPU code could just use the FM instruction, but it seems common enough // This is odd since SPU code could just use the FM instruction, but it seems common enough
if (auto cv = llvm::dyn_cast<llvm::Constant>(c.value)) if (auto cv = llvm::dyn_cast<llvm::Constant>(c.value))

8
rpcs3/rpcs3qt/main_window.cpp
View File

@ -784,7 +784,7 @@ void main_window::DecryptSPRXLibraries()
{ {
return; return;
} }
if (!m_gui_settings->GetBootConfirmation(this)) if (!m_gui_settings->GetBootConfirmation(this))
{ {
return; return;
@ -797,9 +797,9 @@ void main_window::DecryptSPRXLibraries()
gui_log.notice("Decrypting binaries..."); gui_log.notice("Decrypting binaries...");
for (const QString& module : modules) for (const QString& _module : modules)
{ {
const std::string old_path = sstr(module); const std::string old_path = sstr(_module);
fs::file elf_file(old_path); fs::file elf_file(old_path);
@ -809,7 +809,7 @@ void main_window::DecryptSPRXLibraries()
if (elf_file) if (elf_file)
{ {
const std::string bin_ext = module.toLower().endsWith(".sprx") ? ".prx" : ".elf"; const std::string bin_ext = _module.toLower().endsWith(".sprx") ? ".prx" : ".elf";
const std::string new_path = old_path.substr(0, old_path.find_last_of('.')) + bin_ext; const std::string new_path = old_path.substr(0, old_path.find_last_of('.')) + bin_ext;
if (fs::file new_file{new_path, fs::rewrite}) if (fs::file new_file{new_path, fs::rewrite})