diff --git a/Utilities/Thread.cpp b/Utilities/Thread.cpp index a47f656695..d379528d5e 100644 --- a/Utilities/Thread.cpp +++ b/Utilities/Thread.cpp @@ -270,7 +270,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz { case 0x7f: { - if (repe && !oso) // MOVDQU xmm/m, xmm + if ((repe && !oso) || (!repe && oso)) // MOVDQU/MOVDQA xmm/m, xmm { out_op = X64OP_STORE; out_reg = get_modRM_reg_xmm(code, rex); diff --git a/Utilities/Timer.h b/Utilities/Timer.h index 6be99c9e52..39ccfc0104 100644 --- a/Utilities/Timer.h +++ b/Utilities/Timer.h @@ -28,22 +28,22 @@ public: double GetElapsedTimeInSec() const { - return GetElapsedTimeInMicroSec() / 1000000.0; + return double(GetElapsedTimeInMicroSec()) / 1000000.0; } double GetElapsedTimeInMilliSec() const { - return GetElapsedTimeInMicroSec() / 1000.0; + return double(GetElapsedTimeInMicroSec()) / 1000.0; } - double GetElapsedTimeInMicroSec() const + u64 GetElapsedTimeInMicroSec() const { std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now(); return std::chrono::duration_cast(now - m_start).count(); } - double GetElapsedTimeInNanoSec() const + u64 GetElapsedTimeInNanoSec() const { std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now(); diff --git a/rpcs3/Emu/ARMv7/ARMv7Decoder.cpp b/rpcs3/Emu/ARMv7/ARMv7Decoder.cpp index 0b62114b2b..00bffb74c4 100644 --- a/rpcs3/Emu/ARMv7/ARMv7Decoder.cpp +++ b/rpcs3/Emu/ARMv7/ARMv7Decoder.cpp @@ -1286,17 +1286,10 @@ void armv7_decoder_initialize(u32 addr, u32 end_addr, bool dump) // possibly a call to imported function: if (target >= end_addr && ((target - end_addr) % 16) == 0 && (instr & 0xfff000f0) == 0xe0700090) { - // check if implemented - if (const u32 func = (instr & 0xfff00) >> 4 | (instr & 0xf)) - { - // replace BLX with "HACK" instruction directly (in Thumb form), it can help to see where it was called from - vm::psv::write32(addr, 0xf870 | func << 16); - g_opct[0xf8700000 | func] = g_op4t.HACK(); - } - else - { - // leave as is if unimplemented - } + // replace BLX with "HACK" instruction directly (in Thumb form), it can help to see where it was called from + const u32 index = (instr & 0xfff00) >> 4 | (instr & 0xf); + vm::psv::write32(addr, 0xf870 | index << 16); + g_opct[0xf8700000 | index] = g_op4t.HACK(); } else { diff --git a/rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp b/rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp index e07bbaa00b..452da44c12 100644 --- a/rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp +++ b/rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp @@ -503,20 +503,20 @@ void ARMv7_instrs::UNK(ARMv7Context& context, const ARMv7Code code) void ARMv7_instrs::HACK(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type) { - u32 cond, func; + u32 cond, index; switch (type) { case T1: { cond = context.ITSTATE.advance(); - func = code.data & 0xffff; + index = code.data & 0xffff; break; } case A1: { cond = code.data >> 28; - func = (code.data & 0xfff00) >> 4 | (code.data & 0xf); + index = (code.data & 0xfff00) >> 4 | (code.data & 0xf); break; } default: throw __FUNCTION__; @@ -524,13 +524,30 @@ void ARMv7_instrs::HACK(ARMv7Context& context, const ARMv7Code code, const ARMv7 if (context.debug) { - if (context.debug & DF_DISASM) context.debug_str = fmt::format("hack%s %s", fmt_cond(cond), get_psv_func_by_index(func)->name); + if (context.debug & DF_DISASM) + { + if (auto func = get_psv_func_by_index(index)) + { + if (func->func) + { + context.debug_str = fmt::format("hack%s %s", fmt_cond(cond), func->name); + } + else + { + context.debug_str = fmt::format("hack%s UNIMPLEMENTED:0x%08X (%s)", fmt_cond(cond), func->nid, func->name); + } + } + else + { + context.debug_str = fmt::format("hack%s %d", fmt_cond(cond), index); + } + } if (process_debug(context)) return; } if (ConditionPassed(context, cond)) { - execute_psv_func_by_index(context, func); + execute_psv_func_by_index(context, index); } } diff --git a/rpcs3/Emu/ARMv7/PSVFuncList.cpp b/rpcs3/Emu/ARMv7/PSVFuncList.cpp index 763b36d4af..fdbad45cad 100644 --- a/rpcs3/Emu/ARMv7/PSVFuncList.cpp +++ b/rpcs3/Emu/ARMv7/PSVFuncList.cpp @@ -5,30 +5,50 @@ std::vector g_psv_func_list; std::vector g_psv_modules; -void add_psv_func(psv_func& data) +u32 add_psv_func(psv_func data) { for (auto& f : g_psv_func_list) { - if (f.nid == data.nid && &f - g_psv_func_list.data() >= 2 /* special functions count */) + if (f.nid == data.nid) { + const u32 index = (u32)(&f - g_psv_func_list.data()); + + if (index < SFI_MAX) + { + continue; + } + if (data.func) { f.func = data.func; } - return; + return index; } } g_psv_func_list.push_back(data); + return (u32)(g_psv_func_list.size() - 1); } -const psv_func* get_psv_func_by_nid(u32 nid) +psv_func* get_psv_func_by_nid(u32 nid, u32* out_index) { for (auto& f : g_psv_func_list) { - if (f.nid == nid && &f - g_psv_func_list.data() >= 2 /* special functions count */) + if (f.nid == nid && &f - g_psv_func_list.data()) { + const u32 index = (u32)(&f - g_psv_func_list.data()); + + if (index < SFI_MAX) + { + continue; + } + + if (out_index) + { + *out_index = index; + } + return &f; } } @@ -36,19 +56,7 @@ const psv_func* get_psv_func_by_nid(u32 nid) return nullptr; } -u32 get_psv_func_index(const psv_func* func) -{ - auto res = func - g_psv_func_list.data(); - - if ((size_t)res >= g_psv_func_list.size()) - { - throw __FUNCTION__; - } - - return (u32)res; -} - -const psv_func* get_psv_func_by_index(u32 index) +psv_func* get_psv_func_by_index(u32 index) { if (index >= g_psv_func_list.size()) { @@ -210,24 +218,15 @@ void initialize_psv_modules() g_psv_modules.push_back(&sceXml); // setup special functions (without NIDs) - psv_func unimplemented; - unimplemented.nid = 0; - unimplemented.name = "UNIMPLEMENTED"; - unimplemented.func.reset(new psv_func_detail::func_binder([](ARMv7Context& context) - { - context.thread.m_last_syscall = vm::psv::read32(context.thread.PC + 4); - throw "Unimplemented function"; - })); - g_psv_func_list.push_back(unimplemented); + g_psv_func_list.resize(SFI_MAX); - psv_func hle_return; - hle_return.nid = 1; + psv_func& hle_return = g_psv_func_list[SFI_HLE_RETURN]; + hle_return.nid = 0; hle_return.name = "HLE_RETURN"; hle_return.func.reset(new psv_func_detail::func_binder([](ARMv7Context& context) { context.thread.FastStop(); })); - g_psv_func_list.push_back(hle_return); // load functions for (auto module : g_psv_modules) diff --git a/rpcs3/Emu/ARMv7/PSVFuncList.h b/rpcs3/Emu/ARMv7/PSVFuncList.h index 34cd990c93..ed2d9217a8 100644 --- a/rpcs3/Emu/ARMv7/PSVFuncList.h +++ b/rpcs3/Emu/ARMv7/PSVFuncList.h @@ -478,8 +478,15 @@ struct psv_func psv_log_base* module; // Module for information }; +enum psv_special_function_index : u16 +{ + SFI_HLE_RETURN, + + SFI_MAX +}; + // Do not call directly -void add_psv_func(psv_func& data); +u32 add_psv_func(psv_func data); // Do not call directly template void reg_psv_func(u32 nid, psv_log_base* module, const char* name, RT(*func)(T...)) { @@ -491,12 +498,10 @@ template void reg_psv_func(u32 nid, psv_log_base* mo add_psv_func(f); } -// Find registered HLE function by its ID -const psv_func* get_psv_func_by_nid(u32 nid); -// Get index of registered HLE function -u32 get_psv_func_index(const psv_func* func); +// Find registered HLE function by NID +psv_func* get_psv_func_by_nid(u32 nid, u32* out_index = nullptr); // Find registered HLE function by its index -const psv_func* get_psv_func_by_index(u32 index); +psv_func* get_psv_func_by_index(u32 index); // Execute registered HLE function by its index void execute_psv_func_by_index(ARMv7Context& context, u32 index); // Register all HLE functions diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp index 08d0f15815..01b3a94b9e 100644 --- a/rpcs3/Emu/Cell/PPUThread.cpp +++ b/rpcs3/Emu/Cell/PPUThread.cpp @@ -189,7 +189,7 @@ u64 PPUThread::GetStackArg(s32 i) return vm::read64(vm::cast(GPR[1] + 0x70 + 0x8 * (i - 9))); } -u64 PPUThread::FastCall2(u32 addr, u32 rtoc) +void PPUThread::FastCall2(u32 addr, u32 rtoc) { auto old_status = m_status; auto old_PC = PC; @@ -212,8 +212,6 @@ u64 PPUThread::FastCall2(u32 addr, u32 rtoc) GPR[2] = old_rtoc; LR = old_LR; SetCurrentNamedThread(old_thread); - - return GPR[3]; } void PPUThread::FastStop() diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h index 88f1cb392c..64c11c7563 100644 --- a/rpcs3/Emu/Cell/PPUThread.h +++ b/rpcs3/Emu/Cell/PPUThread.h @@ -793,13 +793,27 @@ public: return false; } + u64 get_next_gpr_arg(u32& g_count, u32& f_count, u32& v_count) + { + assert(!f_count && !v_count); // not supported + + if (g_count < 8) + { + return GPR[g_count++ + 3]; + } + else + { + return GetStackArg(++g_count); + } + } + public: virtual void InitRegs() override; virtual void InitStack() override; virtual void CloseStack() override; virtual void Task() override; u64 GetStackArg(s32 i); - u64 FastCall2(u32 addr, u32 rtoc); + void FastCall2(u32 addr, u32 rtoc); void FastStop(); virtual void DoRun() override; diff --git a/rpcs3/Emu/SysCalls/Modules.cpp b/rpcs3/Emu/SysCalls/Modules.cpp index 7c038025ca..523f572c59 100644 --- a/rpcs3/Emu/SysCalls/Modules.cpp +++ b/rpcs3/Emu/SysCalls/Modules.cpp @@ -1,7 +1,9 @@ #include "stdafx.h" +#include "Utilities/Log.h" #include "Emu/Memory/Memory.h" #include "Emu/System.h" #include "Emu/SysCalls/Modules.h" +#include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/Static.h" #include "Emu/SysCalls/CB_FUNC.h" #include "Crypto/sha1.h" @@ -84,7 +86,8 @@ void execute_ps3_func_by_index(PPUThread& CPU, u32 index) } else { - throw "Unimplemented function"; + LOG_ERROR(HLE, "Unimplemented function %s", SysCalls::GetHLEFuncName(func->id)); + CPU.GPR[3] = 0; } CPU.m_last_syscall = old_last_syscall; diff --git a/rpcs3/Emu/SysCalls/Modules.h b/rpcs3/Emu/SysCalls/Modules.h index a2f803a95c..856430a235 100644 --- a/rpcs3/Emu/SysCalls/Modules.h +++ b/rpcs3/Emu/SysCalls/Modules.h @@ -179,4 +179,4 @@ void fix_relocs(Module* module, u32 lib, u32 start, u32 end, u32 seg2); #define REG_FUNC(module, name) module.AddFunc(get_function_id(#name), name) -#define UNIMPLEMENTED_FUNC(module) module.Fatal("%s", __FUNCTION__) +#define UNIMPLEMENTED_FUNC(module) module.Error("%s", __FUNCTION__) diff --git a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp index ed3c645231..0427de1bc3 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp @@ -7,65 +7,44 @@ extern Module cellAtrac; #include "cellAtrac.h" -#ifdef PRX_DEBUG -#include "prx_libatrac3plus.h" -u32 libatrac3plus; -u32 libatrac3plus_rtoc; -#endif - -s64 cellAtracSetDataAndGetMemSize(vm::ptr pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr puiWorkMemByte) +s32 cellAtracSetDataAndGetMemSize(vm::ptr pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr puiWorkMemByte) { cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)", pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x11F4, libatrac3plus_rtoc); -#endif *puiWorkMemByte = 0x1000; // unproved return CELL_OK; } -s64 cellAtracCreateDecoder(vm::ptr pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) +s32 cellAtracCreateDecoder(vm::ptr pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) { cellAtrac.Warning("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0FF0, libatrac3plus_rtoc); -#endif pHandle->data.pucWorkMem_addr = pucWorkMem_addr; return CELL_OK; } -s64 cellAtracCreateDecoderExt(vm::ptr pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr pExtRes) +s32 cellAtracCreateDecoderExt(vm::ptr pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr pExtRes) { cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)", pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0DB0, libatrac3plus_rtoc); -#endif pHandle->data.pucWorkMem_addr = pucWorkMem_addr; return CELL_OK; } -s64 cellAtracDeleteDecoder(vm::ptr pHandle) +s32 cellAtracDeleteDecoder(vm::ptr pHandle) { cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0D08, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracDecode(vm::ptr pHandle, u32 pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) +s32 cellAtracDecode(vm::ptr pHandle, u32 pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) { cellAtrac.Warning("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x09A8, libatrac3plus_rtoc); -#endif *puiSamples = 0; *puiFinishflag = 1; @@ -73,13 +52,10 @@ s64 cellAtracDecode(vm::ptr pHandle, u32 pfOutAddr, vm::ptr pHandle, vm::ptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) +s32 cellAtracGetStreamDataInfo(vm::ptr pHandle, vm::ptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) { cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)", pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0BE8, libatrac3plus_rtoc); -#endif *ppucWritePointer = pHandle->data.pucWorkMem_addr; *puiWritableByte = 0x1000; @@ -87,112 +63,82 @@ s64 cellAtracGetStreamDataInfo(vm::ptr pHandle, vm::ptr pp return CELL_OK; } -s64 cellAtracAddStreamData(vm::ptr pHandle, u32 uiAddByte) +s32 cellAtracAddStreamData(vm::ptr pHandle, u32 uiAddByte) { cellAtrac.Warning("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0AFC, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) +s32 cellAtracGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) { cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x092C, libatrac3plus_rtoc); -#endif *piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY; return CELL_OK; } -s64 cellAtracGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) +s32 cellAtracGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) { cellAtrac.Warning("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x08B0, libatrac3plus_rtoc); -#endif *puiVacantSize = 0x1000; return CELL_OK; } -s64 cellAtracIsSecondBufferNeeded(vm::ptr pHandle) +s32 cellAtracIsSecondBufferNeeded(vm::ptr pHandle) { cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0010, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) +s32 cellAtracGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) { cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)", pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x07E8, libatrac3plus_rtoc); -#endif *puiReadPosition = 0; *puiDataByte = 0; // write to null block will occur return CELL_OK; } -s64 cellAtracSetSecondBuffer(vm::ptr pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte) +s32 cellAtracSetSecondBuffer(vm::ptr pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte) { cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)", pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0704, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracGetChannel(vm::ptr pHandle, vm::ptr puiChannel) +s32 cellAtracGetChannel(vm::ptr pHandle, vm::ptr puiChannel) { cellAtrac.Warning("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0060, libatrac3plus_rtoc); -#endif *puiChannel = 2; return CELL_OK; } -s64 cellAtracGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) +s32 cellAtracGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) { cellAtrac.Warning("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x00AC, libatrac3plus_rtoc); -#endif *puiMaxSample = 512; return CELL_OK; } -s64 cellAtracGetNextSample(vm::ptr pHandle, vm::ptr puiNextSample) +s32 cellAtracGetNextSample(vm::ptr pHandle, vm::ptr puiNextSample) { cellAtrac.Warning("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0688, libatrac3plus_rtoc); -#endif *puiNextSample = 0; return CELL_OK; } -s64 cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) +s32 cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) { cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)", pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0104, libatrac3plus_rtoc); -#endif *piEndSample = 0; *piLoopStartSample = 0; @@ -200,60 +146,45 @@ s64 cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSa return CELL_OK; } -s64 cellAtracGetNextDecodePosition(vm::ptr pHandle, vm::ptr puiSamplePosition) +s32 cellAtracGetNextDecodePosition(vm::ptr pHandle, vm::ptr puiSamplePosition) { cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)", pHandle.addr(), puiSamplePosition.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0190, libatrac3plus_rtoc); -#endif *puiSamplePosition = 0; return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED; } -s64 cellAtracGetBitrate(vm::ptr pHandle, vm::ptr puiBitrate) +s32 cellAtracGetBitrate(vm::ptr pHandle, vm::ptr puiBitrate) { cellAtrac.Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)", pHandle.addr(), puiBitrate.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0374, libatrac3plus_rtoc); -#endif *puiBitrate = 128; return CELL_OK; } -s64 cellAtracGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) +s32 cellAtracGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) { cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)", pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x025C, libatrac3plus_rtoc); -#endif *piLoopNum = 0; *puiLoopStatus = 0; return CELL_OK; } -s64 cellAtracSetLoopNum(vm::ptr pHandle, int iLoopNum) +s32 cellAtracSetLoopNum(vm::ptr pHandle, int iLoopNum) { cellAtrac.Warning("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x1538, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) +s32 cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) { cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)", pHandle.addr(), uiSample, pBufferInfo.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x05BC, libatrac3plus_rtoc); -#endif pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr; pBufferInfo->uiWritableByte = 0x1000; @@ -262,24 +193,18 @@ s64 cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiS return CELL_OK; } -s64 cellAtracResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte) +s32 cellAtracResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte) { cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle.addr(), uiSample, uiWriteByte); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x04E4, libatrac3plus_rtoc); -#endif return CELL_OK; } -s64 cellAtracGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) +s32 cellAtracGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) { cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)", pHandle.addr(), piResult.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x02E4, libatrac3plus_rtoc); -#endif *piResult = 0; return CELL_OK; @@ -317,27 +242,4 @@ Module cellAtrac("cellAtrac", []() cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition); cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo); - -#ifdef PRX_DEBUG - CallAfter([]() - { - if (!Memory.MainMem.GetStartAddr()) return; - - libatrac3plus = (u32)Memory.MainMem.AllocAlign(sizeof(libatrac3plus_data), 0x100000); - memcpy(vm::get_ptr(libatrac3plus), libatrac3plus_data, sizeof(libatrac3plus_data)); - libatrac3plus_rtoc = libatrac3plus + 0xBED0; - - extern Module* cellAdec; - - FIX_IMPORT(cellAdec, cellAdecDecodeAu, libatrac3plus + 0x399C); - FIX_IMPORT(cellAdec, cellAdecStartSeq, libatrac3plus + 0x39BC); - FIX_IMPORT(cellAdec, cellAdecQueryAttr, libatrac3plus + 0x39DC); - FIX_IMPORT(cellAdec, cellAdecClose, libatrac3plus + 0x39FC); - FIX_IMPORT(cellAdec, cellAdecGetPcm, libatrac3plus + 0x3A1C); - FIX_IMPORT(cellAdec, cellAdecOpen, libatrac3plus + 0x3A3C); - fix_import(cellAdec, 0xDF982D2C, libatrac3plus + 0x3A5C); - - fix_relocs(cellAtrac, libatrac3plus, 0x3EF0, 0x5048, 0x3CE0); - }); -#endif }); diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp index 7607bf0236..539161c412 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp @@ -10,15 +10,7 @@ extern Module cellPngDec; -#undef PRX_DEBUG - -#ifdef PRX_DEBUG -#include "prx_libpngdec.h" -u32 libpngdec; -u32 libpngdec_rtoc; -#endif - -s64 pngDecCreate( +s32 pngDecCreate( vm::ptr mainHandle, vm::ptr param, vm::ptr ext = vm::ptr::make(0)) @@ -47,7 +39,7 @@ s64 pngDecCreate( return CELL_OK; } -s64 pngDecDestroy(CellPngDecMainHandle dec) +s32 pngDecDestroy(CellPngDecMainHandle dec) { if (!Memory.Free(dec.addr())) { @@ -57,7 +49,7 @@ s64 pngDecDestroy(CellPngDecMainHandle dec) return CELL_OK; } -s64 pngDecOpen( +s32 pngDecOpen( CellPngDecMainHandle dec, vm::ptr subHandle, vm::ptr src, @@ -117,7 +109,7 @@ s64 pngDecOpen( return CELL_OK; } -s64 pngDecClose(CellPngDecSubHandle stream) +s32 pngDecClose(CellPngDecSubHandle stream) { cellFsClose(stream->fd); if (!Memory.Free(stream.addr())) @@ -128,7 +120,7 @@ s64 pngDecClose(CellPngDecSubHandle stream) return CELL_OK; } -s64 pngReadHeader( +s32 pngReadHeader( CellPngDecSubHandle stream, vm::ptr info, vm::ptr extInfo = vm::ptr::make(0)) @@ -191,7 +183,7 @@ s64 pngReadHeader( return CELL_OK; } -s64 pngDecSetParameter( +s32 pngDecSetParameter( CellPngDecSubHandle stream, vm::ptr inParam, vm::ptr outParam, @@ -236,7 +228,7 @@ s64 pngDecSetParameter( return CELL_OK; } -s64 pngDecodeData( +s32 pngDecodeData( CellPngDecSubHandle stream, vm::ptr data, vm::ptr dataCtrlParam, @@ -365,13 +357,8 @@ s64 pngDecodeData( return CELL_OK; } -s64 cellPngDecCreate(vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam) +s32 cellPngDecCreate(vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - const_cast(*threadInParam).spuThreadEnable = CELL_PNGDEC_SPU_THREAD_DISABLE; // hack - return GetCurrentPPUThread().FastCall2(libpngdec + 0x295C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x)", mainHandle.addr(), threadInParam.addr(), threadOutParam.addr()); @@ -382,20 +369,15 @@ s64 cellPngDecCreate(vm::ptr mainHandle, vm::ptrpngCodecVersion = PNGDEC_CODEC_VERSION; return CELL_OK; -#endif } -s64 cellPngDecExtCreate( +s32 cellPngDecExtCreate( vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam, vm::ptr extThreadInParam, vm::ptr extThreadOutParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x296C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x, extThreadInParam_addr=0x%x, extThreadOutParam_addr=0x%x)", mainHandle.addr(), threadInParam.addr(), threadOutParam.addr(), extThreadInParam.addr(), extThreadOutParam.addr()); @@ -408,41 +390,30 @@ s64 cellPngDecExtCreate( extThreadOutParam->reserved = 0; return CELL_OK; -#endif } -s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle) +s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x1E6C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecDestroy(mainHandle=0x%x)", mainHandle.addr()); // destroy decoder return pngDecDestroy(mainHandle); -#endif } -s64 cellPngDecOpen( +s32 cellPngDecOpen( CellPngDecMainHandle mainHandle, vm::ptr subHandle, vm::ptr src, vm::ptr openInfo) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x3F3C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)", mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr()); // create stream handle return pngDecOpen(mainHandle, subHandle, src, openInfo); -#endif } -s64 cellPngDecExtOpen( +s32 cellPngDecExtOpen( CellPngDecMainHandle mainHandle, vm::ptr subHandle, vm::ptr src, @@ -450,78 +421,53 @@ s64 cellPngDecExtOpen( vm::ptr cbCtrlStrm, vm::ptr opnParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x3F34, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x, cbCtrlStrm_addr=0x%x, opnParam_addr=0x%x)", mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr(), cbCtrlStrm.addr(), opnParam.addr()); // create stream handle return pngDecOpen(mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam); -#endif } -s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle) +s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x066C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecClose(mainHandle=0x%x, subHandle=0x%x)", mainHandle.addr(), subHandle.addr()); return pngDecClose(subHandle); -#endif } -s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info) +s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x3A3C, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", mainHandle.addr(), subHandle.addr(), info.addr()); return pngReadHeader(subHandle, info); -#endif } -s64 cellPngDecExtReadHeader( +s32 cellPngDecExtReadHeader( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info, vm::ptr extInfo) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x3A34, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecExtReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x, extInfo_addr=0x%x)", mainHandle.addr(), subHandle.addr(), info.addr(), extInfo.addr()); return pngReadHeader(subHandle, info, extInfo); -#endif } -s64 cellPngDecSetParameter( +s32 cellPngDecSetParameter( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr inParam, vm::ptr outParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x33F4, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)", mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr()); return pngDecSetParameter(subHandle, inParam, outParam); -#endif } -s64 cellPngDecExtSetParameter( +s32 cellPngDecExtSetParameter( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr inParam, @@ -529,36 +475,26 @@ s64 cellPngDecExtSetParameter( vm::ptr extInParam, vm::ptr extOutParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x33EC, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecExtSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x, extInParam=0x%x, extOutParam=0x%x", mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr(), extInParam.addr(), extOutParam.addr()); return pngDecSetParameter(subHandle, inParam, outParam, extInParam, extOutParam); -#endif } -s64 cellPngDecDecodeData( +s32 cellPngDecDecodeData( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr data, vm::ptr dataCtrlParam, vm::ptr dataOutInfo) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x5D40, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)", mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr()); return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo); -#endif } -s64 cellPngDecExtDecodeData( +s32 cellPngDecExtDecodeData( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr data, @@ -567,210 +503,120 @@ s64 cellPngDecExtDecodeData( vm::ptr cbCtrlDisp, vm::ptr dispParam) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x5D38, libpngdec_rtoc); -#else cellPngDec.Warning("cellPngDecExtDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x, cbCtrlDisp_addr=0x%x, dispParam_addr=0x%x)", mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr(), cbCtrlDisp.addr(), dispParam.addr()); return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo, cbCtrlDisp, dispParam); -#endif } -s64 cellPngDecGetUnknownChunks( +s32 cellPngDecGetUnknownChunks( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr> unknownChunk, vm::ptr unknownChunkNumber) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x03EC, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr pcal) +s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr pcal) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0730, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr chrm) +s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr chrm) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0894, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr scal) +s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr scal) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x09EC, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr phys) +s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr phys) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0B14, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr offs) +s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr offs) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0C58, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr splt) +s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr splt) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0D9C, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr bkgd) +s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr bkgd) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x0ED0, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr time) +s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr time) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x1024, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr hist) +s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr hist) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x116C, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr trns) +s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr trns) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x12A4, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr sbit) +s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr sbit) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x1420, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr iccp) +s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr iccp) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x1574, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr srgb) +s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr srgb) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x16B4, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr gama) +s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr gama) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x17CC, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr plte) +s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr plte) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x18E4, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } -s64 cellPngDecGetTextChunk( +s32 cellPngDecGetTextChunk( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr textInfoNum, vm::ptr> textInfo) { -#ifdef PRX_DEBUG - cellPngDec.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libpngdec + 0x19FC, libpngdec_rtoc); -#else UNIMPLEMENTED_FUNC(cellPngDec); return CELL_OK; -#endif } Module cellPngDec("cellPngDec", []() @@ -804,51 +650,4 @@ Module cellPngDec("cellPngDec", []() REG_FUNC(cellPngDec, cellPngDecOpen); REG_FUNC(cellPngDec, cellPngDecExtDecodeData); REG_FUNC(cellPngDec, cellPngDecDecodeData); - -#ifdef PRX_DEBUG - CallAfter([]() - { - if (!Memory.MainMem.GetStartAddr()) return; - - libpngdec = (u32)Memory.MainMem.AllocAlign(sizeof(libpngdec_data), 0x100000); - memcpy(vm::get_ptr(libpngdec), libpngdec_data, sizeof(libpngdec_data)); - libpngdec_rtoc = libpngdec + 0x49710; - - extern Module* sysPrxForUser; - extern Module* cellSpurs; - extern Module* sys_fs; - - FIX_IMPORT(sysPrxForUser, _sys_snprintf , libpngdec + 0x1E6D0); - FIX_IMPORT(sysPrxForUser, _sys_strlen , libpngdec + 0x1E6F0); - fix_import(sysPrxForUser, 0x3EF17F8C , libpngdec + 0x1E710); - FIX_IMPORT(sysPrxForUser, _sys_memset , libpngdec + 0x1E730); - FIX_IMPORT(sysPrxForUser, _sys_memcpy , libpngdec + 0x1E750); - FIX_IMPORT(sysPrxForUser, _sys_strcpy , libpngdec + 0x1E770); - FIX_IMPORT(sysPrxForUser, _sys_strncpy , libpngdec + 0x1E790); - FIX_IMPORT(sysPrxForUser, _sys_memcmp , libpngdec + 0x1E7B0); - FIX_IMPORT(cellSpurs, cellSpursQueueDetachLv2EventQueue , libpngdec + 0x1E7D0); - FIX_IMPORT(cellSpurs, cellSpursAttributeSetNamePrefix , libpngdec + 0x1E7F0); - FIX_IMPORT(cellSpurs, _cellSpursQueueInitialize , libpngdec + 0x1E810); - FIX_IMPORT(cellSpurs, _cellSpursTasksetAttributeInitialize, libpngdec + 0x1E830); - FIX_IMPORT(cellSpurs, cellSpursTasksetAttributeSetName , libpngdec + 0x1E850); - FIX_IMPORT(cellSpurs, cellSpursTaskGetReadOnlyAreaPattern , libpngdec + 0x1E870); - FIX_IMPORT(cellSpurs, cellSpursTaskGetContextSaveAreaSize , libpngdec + 0x1E890); - FIX_IMPORT(cellSpurs, cellSpursQueuePopBody , libpngdec + 0x1E8B0); - FIX_IMPORT(cellSpurs, cellSpursQueuePushBody , libpngdec + 0x1E8D0); - FIX_IMPORT(cellSpurs, _cellSpursAttributeInitialize , libpngdec + 0x1E8F0); - FIX_IMPORT(cellSpurs, cellSpursJoinTaskset , libpngdec + 0x1E910); - FIX_IMPORT(cellSpurs, cellSpursShutdownTaskset , libpngdec + 0x1E930); - FIX_IMPORT(cellSpurs, cellSpursInitializeWithAttribute , libpngdec + 0x1E950); - FIX_IMPORT(cellSpurs, cellSpursCreateTask , libpngdec + 0x1E970); - FIX_IMPORT(cellSpurs, cellSpursCreateTasksetWithAttribute , libpngdec + 0x1E990); - FIX_IMPORT(cellSpurs, cellSpursFinalize , libpngdec + 0x1E9B0); - FIX_IMPORT(cellSpurs, cellSpursQueueAttachLv2EventQueue , libpngdec + 0x1E9D0); - FIX_IMPORT(sys_fs, cellFsClose , libpngdec + 0x1E9F0); - FIX_IMPORT(sys_fs, cellFsRead , libpngdec + 0x1EA10); - FIX_IMPORT(sys_fs, cellFsOpen , libpngdec + 0x1EA30); - FIX_IMPORT(sys_fs, cellFsLseek , libpngdec + 0x1EA50); - - fix_relocs(cellPngDec, libpngdec, 0x41C30, 0x47AB0, 0x40A00); - }); -#endif }); diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h index 86170f7508..361d83fe07 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h +++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h @@ -183,77 +183,77 @@ struct CellPngDecDataOutInfo }; // Functions -s64 cellPngDecCreate(vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam); +s32 cellPngDecCreate(vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam); -s64 cellPngDecExtCreate( +s32 cellPngDecExtCreate( vm::ptr mainHandle, vm::ptr threadInParam, vm::ptr threadOutParam, vm::ptr extThreadInParam, vm::ptr extThreadOutParam); -s64 cellPngDecOpen( +s32 cellPngDecOpen( CellPngDecMainHandle mainHandle, vm::ptr subHandle, vm::ptr src, vm::ptr openInfo); -s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info); +s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info); -s64 cellPngDecSetParameter( +s32 cellPngDecSetParameter( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr inParam, vm::ptr outParam); -s64 cellPngDecDecodeData( +s32 cellPngDecDecodeData( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr data, vm::ptr dataCtrlParam, vm::ptr dataOutInfo); -s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle); +s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle); -s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle); +s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle); -s64 cellPngDecGetTextChunk( +s32 cellPngDecGetTextChunk( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr textInfoNum, vm::ptr> textInfo); -s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr plte); +s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr plte); -s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr gama); +s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr gama); -s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr srgb); +s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr srgb); -s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr iccp); +s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr iccp); -s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr sbit); +s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr sbit); -s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr trns); +s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr trns); -s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr hist); +s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr hist); -s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr time); +s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr time); -s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr bkgd); +s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr bkgd); -s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr splt); +s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr splt); -s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr offs); +s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr offs); -s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr phys); +s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr phys); -s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr scal); +s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr scal); -s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr chrm); +s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr chrm); -s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr pcal); +s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr pcal); -s64 cellPngDecGetUnknownChunks( +s32 cellPngDecGetUnknownChunks( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr> unknownChunk, @@ -345,7 +345,7 @@ struct CellPngDecCbCtrlDisp }; // Functions -s64 cellPngDecExtOpen( +s32 cellPngDecExtOpen( CellPngDecMainHandle mainHandle, vm::ptr subHandle, vm::ptr src, @@ -353,13 +353,13 @@ s64 cellPngDecExtOpen( vm::ptr cbCtrlStrm, vm::ptr opnParam); -s64 cellPngDecExtReadHeader( +s32 cellPngDecExtReadHeader( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr info, vm::ptr extInfo); -s64 cellPngDecExtSetParameter( +s32 cellPngDecExtSetParameter( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr inParam, @@ -367,7 +367,7 @@ s64 cellPngDecExtSetParameter( vm::ptr extInParam, vm::ptr extOutParam); -s64 cellPngDecExtDecodeData( +s32 cellPngDecExtDecodeData( CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr data, diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp index 54422a30a4..86f2d01add 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp @@ -21,39 +21,26 @@ extern Module cellSpurs; -#ifdef PRX_DEBUG -extern u32 libsre; -extern u32 libsre_rtoc; -#endif - bool spursKernelEntry(SPUThread & spu); -s64 cellSpursLookUpTasksetAddress(vm::ptr spurs, vm::ptr taskset, u32 id); -s64 _cellSpursSendSignal(vm::ptr taskset, u32 taskID); +s32 cellSpursLookUpTasksetAddress(vm::ptr spurs, vm::ptr taskset, u32 id); +s32 _cellSpursSendSignal(vm::ptr taskset, u32 taskID); -s64 spursCreateLv2EventQueue(vm::ptr spurs, u32& queue_id, vm::ptr port, s32 size, u64 name_u64) +s32 spursCreateLv2EventQueue(vm::ptr spurs, u32& queue_id, vm::ptr port, s32 size, u64 name_u64) { -#ifdef PRX_DEBUG_XXX - vm::var> queue; - s32 res = cb_call, vm::ptr>, vm::ptr, s32, u32>(GetCurrentPPUThread(), libsre + 0xB14C, libsre_rtoc, - spurs, queue, port, size, vm::read32(libsre_rtoc - 0x7E2C)); - queue_id = queue.value(); - return res; -#endif - queue_id = event_queue_create(SYS_SYNC_FIFO, SYS_PPU_QUEUE, name_u64, 0, size); if (!queue_id) { return CELL_EAGAIN; // rough } - if (s32 res = (s32)spursAttachLv2EventQueue(spurs, queue_id, port, 1, true)) + if (s32 res = spursAttachLv2EventQueue(spurs, queue_id, port, 1, true)) { assert(!"spursAttachLv2EventQueue() failed"); } return CELL_OK; } -s64 spursInit( +s32 spursInit( vm::ptr spurs, const u32 revision, const u32 sdkVersion, @@ -68,11 +55,6 @@ s64 spursInit( const u32 swlMaxSpu, const u32 swlIsPreem) { -#ifdef PRX_DEBUG_XXX - return cb_call, u32, u32, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc, - spurs, revision, sdkVersion, nSpus, spuPriority, ppuPriority, flags, vm::get_addr(prefix), prefixSize, container, vm::get_addr(swlPriority), swlMaxSpu, swlIsPreem); -#endif - // SPURS initialization (asserts should actually rollback and return the error instead) if (!spurs) @@ -117,12 +99,7 @@ s64 spursInit( } // default or system workload: -#ifdef PRX_DEBUG - spurs->m.wklInfoSysSrv.addr.set(be_t::make(vm::read32(libsre_rtoc - 0x7EA4))); - spurs->m.wklInfoSysSrv.size = 0x2200; -#else spurs->m.wklInfoSysSrv.addr.set(be_t::make(SPURS_IMG_ADDR_SYS_SRV_WORKLOAD)); -#endif spurs->m.wklInfoSysSrv.arg = 0; spurs->m.wklInfoSysSrv.uniqueId.write_relaxed(0xff); u32 sem; @@ -149,15 +126,9 @@ s64 spursInit( spurs->m.unk13 = 0; spurs->m.nSpus = nSpus; spurs->m.spuPriority = spuPriority; -#ifdef PRX_DEBUG - if (s32 res = spu_image_import(spurs->m.spuImg, vm::read32(libsre_rtoc - (isSecond ? 0x7E94 : 0x7E98)), 1)) - { - assert(!"spu_image_import() failed"); - } -#else - spurs->m.spuImg.addr = (u32)Memory.Alloc(0x40000, 4096); + + spurs->m.spuImg.addr = Memory.MainMem.AllocAlign(0x40000, 4096); spurs->m.spuImg.entry_point = isSecond ? CELL_SPURS_KERNEL2_ENTRY_ADDR : CELL_SPURS_KERNEL1_ENTRY_ADDR; -#endif s32 tgt = SYS_SPU_THREAD_GROUP_TYPE_NORMAL; if (flags & SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT) @@ -181,9 +152,9 @@ s64 spursInit( for (s32 num = 0; num < nSpus; num++, name[name.size() - 1]++) { auto spu = spu_thread_initialize(tg, num, spurs->m.spuImg, name, SYS_SPU_THREAD_OPTION_DEC_SYNC_TB_ENABLE, (u64)num << 32, spurs.addr(), 0, 0); -#ifndef PRX_DEBUG_XXX + spu->RegisterHleFunction(spurs->m.spuImg.entry_point, spursKernelEntry); -#endif + spurs->m.spus[num] = spu->GetId(); } @@ -215,7 +186,7 @@ s64 spursInit( spurs->m.ppuPriority = ppuPriority; u32 queue; - if (s32 res = (s32)spursCreateLv2EventQueue(spurs, queue, vm::ptr::make(spurs.addr() + 0xc9), 0x2a, *(u64*)"_spuPrv")) + if (s32 res = spursCreateLv2EventQueue(spurs, queue, vm::ptr::make(spurs.addr() + 0xc9), 0x2a, *(u64*)"_spuPrv")) { assert(!"spursCreateLv2EventQueue() failed"); } @@ -234,10 +205,6 @@ s64 spursInit( spurs->m.ppu0 = ppu_thread_create(0, 0, ppuPriority, 0x4000, true, false, name + "SpursHdlr0", [spurs](PPUThread& CPU) { -#ifdef PRX_DEBUG_XXX - return cb_call>(CPU, libsre + 0x9214, libsre_rtoc, spurs); -#endif - if (spurs->m.flags & SAF_UNKNOWN_FLAG_30) { return; @@ -366,9 +333,7 @@ s64 spursInit( spurs->m.ppu1 = ppu_thread_create(0, 0, ppuPriority, 0x8000, true, false, name + "SpursHdlr1", [spurs](PPUThread& CPU) { -#ifdef PRX_DEBUG - return cb_call>(CPU, libsre + 0xB40C, libsre_rtoc, spurs); -#endif + // TODO })->GetId(); @@ -392,10 +357,7 @@ s64 spursInit( if (flags & SAF_SYSTEM_WORKLOAD_ENABLED) // initialize system workload (disabled) { s32 res = CELL_OK; -#ifdef PRX_DEBUG_XXX - res = cb_call, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x10428, libsre_rtoc, - spurs, vm::get_addr(swlPriority), swlMaxSpu, swlIsPreem); -#endif + // TODO assert(res == CELL_OK); } else if (flags & SAF_EXIT_IF_NO_WORK) // wakeup @@ -406,13 +368,10 @@ s64 spursInit( return CELL_OK; } -s64 cellSpursInitialize(vm::ptr spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork) +s32 cellSpursInitialize(vm::ptr spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork) { cellSpurs.Warning("cellSpursInitialize(spurs_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs.addr(), nSpus, spuPriority, ppuPriority, exitIfNoWork ? 1 : 0); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x8480, libsre_rtoc); -#endif return spursInit( spurs, @@ -430,12 +389,9 @@ s64 cellSpursInitialize(vm::ptr spurs, s32 nSpus, s32 spuPriority, s3 0); } -s64 cellSpursInitializeWithAttribute(vm::ptr spurs, vm::ptr attr) +s32 cellSpursInitializeWithAttribute(vm::ptr spurs, vm::ptr attr) { cellSpurs.Warning("cellSpursInitializeWithAttribute(spurs_addr=0x%x, attr_addr=0x%x)", spurs.addr(), attr.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x839C, libsre_rtoc); -#endif if (!attr) { @@ -466,12 +422,9 @@ s64 cellSpursInitializeWithAttribute(vm::ptr spurs, vm::ptrm.swlIsPreem); } -s64 cellSpursInitializeWithAttribute2(vm::ptr spurs, vm::ptr attr) +s32 cellSpursInitializeWithAttribute2(vm::ptr spurs, vm::ptr attr) { cellSpurs.Warning("cellSpursInitializeWithAttribute2(spurs_addr=0x%x, attr_addr=0x%x)", spurs.addr(), attr.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x82B4, libsre_rtoc); -#endif if (!attr) { @@ -502,13 +455,10 @@ s64 cellSpursInitializeWithAttribute2(vm::ptr spurs, vm::ptrm.swlIsPreem); } -s64 _cellSpursAttributeInitialize(vm::ptr attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork) +s32 _cellSpursAttributeInitialize(vm::ptr attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork) { cellSpurs.Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", attr.addr(), revision, sdkVersion, nSpus, spuPriority, ppuPriority, exitIfNoWork ? 1 : 0); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x72CC, libsre_rtoc); -#endif if (!attr) { @@ -529,12 +479,9 @@ s64 _cellSpursAttributeInitialize(vm::ptr attr, u32 revision return CELL_OK; } -s64 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr attr, u32 container) +s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr attr, u32 container) { cellSpurs.Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=%d)", attr.addr(), container); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x6FF8, libsre_rtoc); -#endif if (!attr) { @@ -555,12 +502,9 @@ s64 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr return CELL_OK; } -s64 cellSpursAttributeSetNamePrefix(vm::ptr attr, vm::ptr prefix, u32 size) +s32 cellSpursAttributeSetNamePrefix(vm::ptr attr, vm::ptr prefix, u32 size) { cellSpurs.Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=%d)", attr.addr(), prefix.addr(), size); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x7234, libsre_rtoc); -#endif if (!attr || !prefix) { @@ -581,12 +525,9 @@ s64 cellSpursAttributeSetNamePrefix(vm::ptr attr, vm::ptr attr) +s32 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr attr) { cellSpurs.Warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr_addr=0x%x)", attr.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x7150, libsre_rtoc); -#endif if (!attr) { @@ -601,12 +542,9 @@ s64 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr att return CELL_OK; } -s64 cellSpursAttributeSetSpuThreadGroupType(vm::ptr attr, s32 type) +s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr attr, s32 type) { cellSpurs.Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.addr(), type); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x70C8, libsre_rtoc); -#endif if (!attr) { @@ -636,13 +574,10 @@ s64 cellSpursAttributeSetSpuThreadGroupType(vm::ptr attr, s3 return CELL_OK; } -s64 cellSpursAttributeEnableSystemWorkload(vm::ptr attr, vm::ptr priority, u32 maxSpu, vm::ptr isPreemptible) +s32 cellSpursAttributeEnableSystemWorkload(vm::ptr attr, vm::ptr priority, u32 maxSpu, vm::ptr isPreemptible) { cellSpurs.Warning("cellSpursAttributeEnableSystemWorkload(attr_addr=0x%x, priority_addr=0x%x, maxSpu=%d, isPreemptible_addr=0x%x)", attr.addr(), priority.addr(), maxSpu, isPreemptible.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0xF410, libsre_rtoc); -#endif if (!attr) { @@ -694,12 +629,9 @@ s64 cellSpursAttributeEnableSystemWorkload(vm::ptr attr, vm: return CELL_SPURS_CORE_ERROR_INVAL; } -s64 cellSpursFinalize(vm::ptr spurs) +s32 cellSpursFinalize(vm::ptr spurs) { cellSpurs.Todo("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc); -#endif if (!spurs) { @@ -714,18 +646,13 @@ s64 cellSpursFinalize(vm::ptr spurs) return CELL_SPURS_CORE_ERROR_STAT; } - + // TODO return CELL_OK; } -s64 spursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic, bool wasCreated) +s32 spursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic, bool wasCreated) { -#ifdef PRX_DEBUG_XXX - return cb_call, u32, vm::ptr, s32, bool>(GetCurrentPPUThread(), libsre + 0xAE34, libsre_rtoc, - spurs, queue, port, isDynamic, wasCreated); -#endif - if (!spurs || !port) { return CELL_SPURS_CORE_ERROR_NULL_POINTER; @@ -784,45 +711,29 @@ s64 spursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr po return CELL_OK; } -s64 cellSpursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic) +s32 cellSpursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic) { cellSpurs.Warning("cellSpursAttachLv2EventQueue(spurs_addr=0x%x, queue=%d, port_addr=0x%x, isDynamic=%d)", spurs.addr(), queue, port.addr(), isDynamic); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0xAFE0, libsre_rtoc); -#endif return spursAttachLv2EventQueue(spurs, queue, port, isDynamic, false); } -s64 cellSpursDetachLv2EventQueue(vm::ptr spurs, u8 port) +s32 cellSpursDetachLv2EventQueue(vm::ptr spurs, u8 port) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursDetachLv2EventQueue(spurs_addr=0x%x, port=%d)", spurs.addr(), port); - return GetCurrentPPUThread().FastCall2(libsre + 0xB144, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetSpuGuid() +s32 cellSpursGetSpuGuid() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xEFB0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetSpuThreadGroupId(vm::ptr spurs, vm::ptr group) +s32 cellSpursGetSpuThreadGroupId(vm::ptr spurs, vm::ptr group) { cellSpurs.Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.addr(), group.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x8B30, libsre_rtoc); -#endif if (!spurs || !group) { @@ -837,12 +748,9 @@ s64 cellSpursGetSpuThreadGroupId(vm::ptr spurs, vm::ptr group) return CELL_OK; } -s64 cellSpursGetNumSpuThread(vm::ptr spurs, vm::ptr nThreads) +s32 cellSpursGetNumSpuThread(vm::ptr spurs, vm::ptr nThreads) { cellSpurs.Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.addr(), nThreads.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x8B78, libsre_rtoc); -#endif if (!spurs || !nThreads) { @@ -857,12 +765,9 @@ s64 cellSpursGetNumSpuThread(vm::ptr spurs, vm::ptr nThreads) return CELL_OK; } -s64 cellSpursGetSpuThreadId(vm::ptr spurs, vm::ptr thread, vm::ptr nThreads) +s32 cellSpursGetSpuThreadId(vm::ptr spurs, vm::ptr thread, vm::ptr nThreads) { cellSpurs.Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.addr(), thread.addr(), nThreads.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x8A98, libsre_rtoc); -#endif if (!spurs || !thread || !nThreads) { @@ -882,90 +787,50 @@ s64 cellSpursGetSpuThreadId(vm::ptr spurs, vm::ptr thread, vm::p return CELL_OK; } -s64 cellSpursSetMaxContention(vm::ptr spurs, u32 workloadId, u32 maxContention) +s32 cellSpursSetMaxContention(vm::ptr spurs, u32 workloadId, u32 maxContention) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursSetMaxContention(spurs_addr=0x%x, workloadId=%d, maxContention=%d)", spurs.addr(), workloadId, maxContention); - return GetCurrentPPUThread().FastCall2(libsre + 0x8E90, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursSetPriorities(vm::ptr spurs, u32 workloadId, vm::ptr priorities) +s32 cellSpursSetPriorities(vm::ptr spurs, u32 workloadId, vm::ptr priorities) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.addr(), workloadId, priorities.addr()); - return GetCurrentPPUThread().FastCall2(libsre + 0x8BC0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursSetPreemptionVictimHints(vm::ptr spurs, vm::ptr isPreemptible) +s32 cellSpursSetPreemptionVictimHints(vm::ptr spurs, vm::ptr isPreemptible) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.addr(), isPreemptible.addr()); - return GetCurrentPPUThread().FastCall2(libsre + 0xF5A4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursEnableExceptionEventHandler(vm::ptr spurs, bool flag) +s32 cellSpursEnableExceptionEventHandler(vm::ptr spurs, bool flag) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursEnableExceptionEventHandler(spurs_addr=0x%x, flag=%d)", spurs.addr(), flag); - return GetCurrentPPUThread().FastCall2(libsre + 0xDCC0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursSetGlobalExceptionEventHandler(vm::ptr spurs, u32 eaHandler_addr, u32 arg_addr) +s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr spurs, u32 eaHandler_addr, u32 arg_addr) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursSetGlobalExceptionEventHandler(spurs_addr=0x%x, eaHandler_addr=0x%x, arg_addr=0x%x)", - spurs.addr(), eaHandler_addr, arg_addr); - return GetCurrentPPUThread().FastCall2(libsre + 0xD6D0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr spurs) +s32 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr spurs) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs_addr=0x%x)", spurs.addr()); - return GetCurrentPPUThread().FastCall2(libsre + 0xD674, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetInfo(vm::ptr spurs, vm::ptr info) +s32 cellSpursGetInfo(vm::ptr spurs, vm::ptr info) { -#ifdef PRX_DEBUG - cellSpurs.Warning("cellSpursGetInfo(spurs_addr=0x%x, info_addr=0x%x)", spurs.addr(), info.addr()); - return GetCurrentPPUThread().FastCall2(libsre + 0xE540, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 spursWakeUp(PPUThread& CPU, vm::ptr spurs) +s32 spursWakeUp(PPUThread& CPU, vm::ptr spurs) { -#ifdef PRX_DEBUG_XXX - return cb_call>(GetCurrentPPUThread(), libsre + 0x84D8, libsre_rtoc, spurs); -#endif - if (!spurs) { return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER; @@ -998,7 +863,7 @@ s64 spursWakeUp(PPUThread& CPU, vm::ptr spurs) return CELL_OK; } -s64 cellSpursWakeUp(PPUThread& CPU, vm::ptr spurs) +s32 cellSpursWakeUp(PPUThread& CPU, vm::ptr spurs) { cellSpurs.Warning("%s(spurs_addr=0x%x)", __FUNCTION__, spurs.addr()); @@ -1019,12 +884,6 @@ s32 spursAddWorkload( vm::ptr hook, vm::ptr hookArg) { -#ifdef PRX_DEBUG_XXX - return cb_call, vm::ptr, vm::ptr, u32, u64, u32, u32, u32, u32, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x96EC, libsre_rtoc, - spurs, wid, pm, size, data, vm::get_addr(priorityTable), minContention, maxContention, - nameClass.addr(), nameInstance.addr(), hook.addr(), hookArg.addr()); -#endif - if (!spurs || !wid || !pm) { return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER; @@ -1176,7 +1035,7 @@ s32 spursAddWorkload( return CELL_OK; } -s64 cellSpursAddWorkload( +s32 cellSpursAddWorkload( vm::ptr spurs, vm::ptr wid, vm::ptr pm, @@ -1188,9 +1047,6 @@ s64 cellSpursAddWorkload( { cellSpurs.Warning("%s(spurs_addr=0x%x, wid_addr=0x%x, pm_addr=0x%x, size=0x%x, data=0x%llx, priorityTable_addr=0x%x, minContention=0x%x, maxContention=0x%x)", __FUNCTION__, spurs.addr(), wid.addr(), pm.addr(), size, data, priorityTable.addr(), minContention, maxContention); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x9ED0, libsre_rtoc); -#endif return spursAddWorkload( spurs, @@ -1207,7 +1063,7 @@ s64 cellSpursAddWorkload( vm::ptr::make(0)); } -s64 _cellSpursWorkloadAttributeInitialize( +s32 _cellSpursWorkloadAttributeInitialize( vm::ptr attr, u32 revision, u32 sdkVersion, @@ -1220,9 +1076,6 @@ s64 _cellSpursWorkloadAttributeInitialize( { cellSpurs.Warning("%s(attr_addr=0x%x, revision=%d, sdkVersion=0x%x, pm_addr=0x%x, size=0x%x, data=0x%llx, priorityTable_addr=0x%x, minContention=0x%x, maxContention=0x%x)", __FUNCTION__, attr.addr(), revision, sdkVersion, pm.addr(), size, data, priorityTable.addr(), minContention, maxContention); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x9F08, libsre_rtoc); -#endif if (!attr) { @@ -1257,12 +1110,9 @@ s64 _cellSpursWorkloadAttributeInitialize( return CELL_OK; } -s64 cellSpursWorkloadAttributeSetName(vm::ptr attr, vm::ptr nameClass, vm::ptr nameInstance) +s32 cellSpursWorkloadAttributeSetName(vm::ptr attr, vm::ptr nameClass, vm::ptr nameInstance) { cellSpurs.Warning("%s(attr_addr=0x%x, nameClass_addr=0x%x, nameInstance_addr=0x%x)", __FUNCTION__, attr.addr(), nameClass.addr(), nameInstance.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x9664, libsre_rtoc); -#endif if (!attr) { @@ -1278,12 +1128,9 @@ s64 cellSpursWorkloadAttributeSetName(vm::ptr attr, return CELL_OK; } -s64 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr attr, vm::ptr hook, vm::ptr arg) +s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr attr, vm::ptr hook, vm::ptr arg) { cellSpurs.Warning("%s(attr_addr=0x%x, hook_addr=0x%x, arg=0x%x)", __FUNCTION__, attr.addr(), hook.addr(), arg.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x96A4, libsre_rtoc); -#endif if (!attr || !hook) { @@ -1299,12 +1146,9 @@ s64 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr spurs, const vm::ptr wid, vm::ptr attr) +s32 cellSpursAddWorkloadWithAttribute(vm::ptr spurs, const vm::ptr wid, vm::ptr attr) { cellSpurs.Warning("%s(spurs_addr=0x%x, wid_addr=0x%x, attr_addr=0x%x)", __FUNCTION__, spurs.addr(), wid.addr(), attr.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0x9E14, libsre_rtoc); -#endif if (!attr) { @@ -1334,45 +1178,27 @@ s64 cellSpursAddWorkloadWithAttribute(vm::ptr spurs, const vm::ptr::make(attr->m.hookArg.addr())); } -s64 cellSpursRemoveWorkload() +s32 cellSpursRemoveWorkload() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xA414, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursWaitForWorkloadShutdown() +s32 cellSpursWaitForWorkloadShutdown() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xA20C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursShutdownWorkload() +s32 cellSpursShutdownWorkload() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xA060, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursWorkloadFlagReceiver(vm::ptr spurs, u32 wid, u32 is_set) +s32 _cellSpursWorkloadFlagReceiver(vm::ptr spurs, u32 wid, u32 is_set) { cellSpurs.Warning("%s(spurs_addr=0x%x, wid=%d, is_set=%d)", __FUNCTION__, spurs.addr(), wid, is_set); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0xF158, libsre_rtoc); -#endif if (!spurs) { @@ -1437,12 +1263,9 @@ s64 _cellSpursWorkloadFlagReceiver(vm::ptr spurs, u32 wid, u32 is_set return CELL_OK; } -s64 cellSpursGetWorkloadFlag(vm::ptr spurs, vm::ptr> flag) +s32 cellSpursGetWorkloadFlag(vm::ptr spurs, vm::ptr> flag) { cellSpurs.Warning("%s(spurs_addr=0x%x, flag_addr=0x%x)", __FUNCTION__, spurs.addr(), flag.addr()); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0xEC00, libsre_rtoc); -#endif if (!spurs || !flag) { @@ -1457,13 +1280,10 @@ s64 cellSpursGetWorkloadFlag(vm::ptr spurs, vm::ptr spurs, u32 workloadId) +s32 cellSpursSendWorkloadSignal(vm::ptr spurs, u32 workloadId) { cellSpurs.Warning("%s(spurs=0x%x, workloadId=0x%x)", __FUNCTION__, spurs.addr(), workloadId); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0xA658, libsre_rtoc); -#else if (spurs.addr() == 0) { return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER; @@ -1514,16 +1334,12 @@ s64 cellSpursSendWorkloadSignal(vm::ptr spurs, u32 workloadId) } return CELL_OK; -#endif } -s64 cellSpursGetWorkloadData(vm::ptr spurs, vm::ptr data, u32 workloadId) +s32 cellSpursGetWorkloadData(vm::ptr spurs, vm::ptr data, u32 workloadId) { cellSpurs.Warning("%s(spurs_addr=0x%x, data=0x%x, workloadId=%d)", __FUNCTION__, spurs.addr(), data.addr(), workloadId); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0xA78C, libsre_rtoc); -#else if (spurs.addr() == 0 || data.addr() == 0) { return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER; @@ -1559,15 +1375,11 @@ s64 cellSpursGetWorkloadData(vm::ptr spurs, vm::ptr data, u32 wo } return CELL_OK; -#endif } -s64 cellSpursReadyCountStore(vm::ptr spurs, u32 wid, u32 value) +s32 cellSpursReadyCountStore(vm::ptr spurs, u32 wid, u32 value) { cellSpurs.Warning("%s(spurs_addr=0x%x, wid=%d, value=0x%x)", __FUNCTION__, spurs.addr(), wid, value); -#ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall2(libsre + 0xAB2C, libsre_rtoc); -#endif if (!spurs) { @@ -1601,102 +1413,59 @@ s64 cellSpursReadyCountStore(vm::ptr spurs, u32 wid, u32 value) return CELL_OK; } -s64 cellSpursReadyCountAdd() +s32 cellSpursReadyCountAdd() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xA868, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursReadyCountCompareAndSwap() +s32 cellSpursReadyCountCompareAndSwap() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xA9CC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursReadyCountSwap() +s32 cellSpursReadyCountSwap() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xAC34, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursRequestIdleSpu() +s32 cellSpursRequestIdleSpu() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xAD88, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetWorkloadInfo() +s32 cellSpursGetWorkloadInfo() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xE70C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursWorkloadFlagReceiver2() +s32 _cellSpursWorkloadFlagReceiver2() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xF298, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursSetExceptionEventHandler() +s32 cellSpursSetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xDB54, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursUnsetExceptionEventHandler() +s32 cellSpursUnsetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0xD77C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursEventFlagInitialize(vm::ptr spurs, vm::ptr taskset, vm::ptr eventFlag, u32 flagClearMode, u32 flagDirection) +s32 _cellSpursEventFlagInitialize(vm::ptr spurs, vm::ptr taskset, vm::ptr eventFlag, u32 flagClearMode, u32 flagDirection) { cellSpurs.Warning("_cellSpursEventFlagInitialize(spurs_addr=0x%x, taskset_addr=0x%x, eventFlag_addr=0x%x, flagClearMode=%d, flagDirection=%d)", spurs.addr(), taskset.addr(), eventFlag.addr(), flagClearMode, flagDirection); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1564C, libsre_rtoc); -#else if (taskset.addr() == 0 && spurs.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -1738,16 +1507,12 @@ s64 _cellSpursEventFlagInitialize(vm::ptr spurs, vm::ptr eventFlag) +s32 cellSpursEventFlagAttachLv2EventQueue(vm::ptr eventFlag) { cellSpurs.Warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x157B8, libsre_rtoc); -#else if (!eventFlag) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -1818,16 +1583,12 @@ success: eventFlag->m.eventQueueId = eventQueueId; eventFlag->m.spuPort = port; return CELL_OK; -#endif } -s64 cellSpursEventFlagDetachLv2EventQueue(vm::ptr eventFlag) +s32 cellSpursEventFlagDetachLv2EventQueue(vm::ptr eventFlag) { cellSpurs.Warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15998, libsre_rtoc); -#else if (!eventFlag) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -1873,7 +1634,7 @@ s64 cellSpursEventFlagDetachLv2EventQueue(vm::ptr eventFlag) sys_event_port_destroy(eventFlag->m.eventPortId); } - s64 rc = CELL_OK; + s32 rc = CELL_OK; // TODO: Implement the following // auto rc = spursDetachLv2EventQueue(spurs, port, 1); // if (rc == CELL_OK) @@ -1888,10 +1649,9 @@ s64 cellSpursEventFlagDetachLv2EventQueue(vm::ptr eventFlag) } return CELL_OK; -#endif } -s64 _cellSpursEventFlagWait(vm::ptr eventFlag, vm::ptr mask, u32 mode, u32 block) +s32 _cellSpursEventFlagWait(vm::ptr eventFlag, vm::ptr mask, u32 mode, u32 block) { if (eventFlag.addr() == 0 || mask.addr() == 0) { @@ -2032,24 +1792,17 @@ s64 _cellSpursEventFlagWait(vm::ptr eventFlag, vm::ptr return CELL_OK; } -s64 cellSpursEventFlagWait(vm::ptr eventFlag, vm::ptr mask, u32 mode) +s32 cellSpursEventFlagWait(vm::ptr eventFlag, vm::ptr mask, u32 mode) { cellSpurs.Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.addr(), mask.addr(), mode); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15E68, libsre_rtoc); -#else return _cellSpursEventFlagWait(eventFlag, mask, mode, 1/*block*/); -#endif } -s64 cellSpursEventFlagClear(vm::ptr eventFlag, u16 bits) +s32 cellSpursEventFlagClear(vm::ptr eventFlag, u16 bits) { cellSpurs.Warning("cellSpursEventFlagClear(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.addr(), bits); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15E9C, libsre_rtoc); -#else if (eventFlag.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2062,16 +1815,12 @@ s64 cellSpursEventFlagClear(vm::ptr eventFlag, u16 bits) eventFlag->m.events &= ~bits; return CELL_OK; -#endif } -s64 cellSpursEventFlagSet(vm::ptr eventFlag, u16 bits) +s32 cellSpursEventFlagSet(vm::ptr eventFlag, u16 bits) { cellSpurs.Warning("cellSpursEventFlagSet(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.addr(), bits); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15F04, libsre_rtoc); -#else if (eventFlag.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2190,27 +1939,19 @@ s64 cellSpursEventFlagSet(vm::ptr eventFlag, u16 bits) } return CELL_OK; -#endif } -s64 cellSpursEventFlagTryWait(vm::ptr eventFlag, vm::ptr mask, u32 mode) +s32 cellSpursEventFlagTryWait(vm::ptr eventFlag, vm::ptr mask, u32 mode) { cellSpurs.Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.addr(), mask.addr(), mode); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15E70, libsre_rtoc); -#else return _cellSpursEventFlagWait(eventFlag, mask, mode, 0/*block*/); -#endif } -s64 cellSpursEventFlagGetDirection(vm::ptr eventFlag, vm::ptr direction) +s32 cellSpursEventFlagGetDirection(vm::ptr eventFlag, vm::ptr direction) { cellSpurs.Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.addr(), direction.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x162C4, libsre_rtoc); -#else if (eventFlag.addr() == 0 || direction.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2223,16 +1964,12 @@ s64 cellSpursEventFlagGetDirection(vm::ptr eventFlag, vm::pt *direction = eventFlag->m.direction; return CELL_OK; -#endif } -s64 cellSpursEventFlagGetClearMode(vm::ptr eventFlag, vm::ptr clear_mode) +s32 cellSpursEventFlagGetClearMode(vm::ptr eventFlag, vm::ptr clear_mode) { cellSpurs.Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.addr(), clear_mode.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x16310, libsre_rtoc); -#else if (eventFlag.addr() == 0 || clear_mode.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2245,16 +1982,12 @@ s64 cellSpursEventFlagGetClearMode(vm::ptr eventFlag, vm::pt *clear_mode = eventFlag->m.clearMode; return CELL_OK; -#endif } -s64 cellSpursEventFlagGetTasksetAddress(vm::ptr eventFlag, vm::ptr taskset) +s32 cellSpursEventFlagGetTasksetAddress(vm::ptr eventFlag, vm::ptr taskset) { cellSpurs.Warning("cellSpursEventFlagGetTasksetAddress(eventFlag_addr=0x%x, taskset_addr=0x%x)", eventFlag.addr(), taskset.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1635C, libsre_rtoc); -#else if (eventFlag.addr() == 0 || taskset.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2267,307 +2000,171 @@ s64 cellSpursEventFlagGetTasksetAddress(vm::ptr eventFlag, v taskset.set(eventFlag->m.isIwl ? 0 : eventFlag->m.addr); return CELL_OK; -#endif } -s64 _cellSpursLFQueueInitialize() +s32 _cellSpursLFQueueInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17028, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursLFQueuePushBody() +s32 _cellSpursLFQueuePushBody() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x170AC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursLFQueueDetachLv2EventQueue() +s32 cellSpursLFQueueDetachLv2EventQueue() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x177CC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursLFQueueAttachLv2EventQueue() +s32 cellSpursLFQueueAttachLv2EventQueue() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x173EC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursLFQueuePopBody() +s32 _cellSpursLFQueuePopBody() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17238, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursLFQueueGetTasksetAddress() +s32 cellSpursLFQueueGetTasksetAddress() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17C34, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursQueueInitialize() +s32 _cellSpursQueueInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x163B4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueuePopBody() +s32 cellSpursQueuePopBody() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x16BF0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueuePushBody() +s32 cellSpursQueuePushBody() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x168C4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueAttachLv2EventQueue() +s32 cellSpursQueueAttachLv2EventQueue() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1666C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueDetachLv2EventQueue() +s32 cellSpursQueueDetachLv2EventQueue() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x16524, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueGetTasksetAddress() +s32 cellSpursQueueGetTasksetAddress() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x16F50, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueClear() +s32 cellSpursQueueClear() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1675C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueDepth() +s32 cellSpursQueueDepth() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1687C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueGetEntrySize() +s32 cellSpursQueueGetEntrySize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x16FE0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueSize() +s32 cellSpursQueueSize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x167F0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursQueueGetDirection() +s32 cellSpursQueueGetDirection() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x16F98, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursCreateJobChainWithAttribute() +s32 cellSpursCreateJobChainWithAttribute() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1898C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursCreateJobChain() +s32 cellSpursCreateJobChain() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18B84, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJoinJobChain() +s32 cellSpursJoinJobChain() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18DB0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursKickJobChain() +s32 cellSpursKickJobChain() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18E8C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursJobChainAttributeInitialize() +s32 _cellSpursJobChainAttributeInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1845C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetJobChainId() +s32 cellSpursGetJobChainId() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x19064, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainSetExceptionEventHandler() +s32 cellSpursJobChainSetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1A5A0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainUnsetExceptionEventHandler() +s32 cellSpursJobChainUnsetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1A614, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetJobChainInfo() +s32 cellSpursGetJobChainInfo() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1A7A0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainGetSpursAddress() +s32 cellSpursJobChainGetSpursAddress() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1A900, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 spursCreateTaskset(vm::ptr spurs, vm::ptr taskset, u64 args, vm::ptr priority, +s32 spursCreateTaskset(vm::ptr spurs, vm::ptr taskset, u64 args, vm::ptr priority, u32 max_contention, vm::ptr name, u32 size, s32 enable_clear_ls) { if (!spurs || !taskset) @@ -2610,14 +2207,10 @@ s64 spursCreateTaskset(vm::ptr spurs, vm::ptr tasks return CELL_OK; } -s64 cellSpursCreateTasksetWithAttribute(vm::ptr spurs, vm::ptr taskset, vm::ptr attr) +s32 cellSpursCreateTasksetWithAttribute(vm::ptr spurs, vm::ptr taskset, vm::ptr attr) { cellSpurs.Warning("%s(spurs=0x%x, taskset=0x%x, attr=0x%x)", __FUNCTION__, spurs.addr(), taskset.addr(), attr.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14BEC, libsre_rtoc); -#endif - if (!attr) { CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2644,44 +2237,26 @@ s64 cellSpursCreateTasksetWithAttribute(vm::ptr spurs, vm::ptr spurs, vm::ptr taskset, u64 args, vm::ptr priority, u32 maxContention) +s32 cellSpursCreateTaskset(vm::ptr spurs, vm::ptr taskset, u64 args, vm::ptr priority, u32 maxContention) { cellSpurs.Warning("cellSpursCreateTaskset(spurs_addr=0x%x, taskset_addr=0x%x, args=0x%llx, priority_addr=0x%x, maxContention=%d)", spurs.addr(), taskset.addr(), args, priority.addr(), maxContention); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14CB8, libsre_rtoc); -#endif - -#if 0 - SPURSManagerTasksetAttribute *tattr = new SPURSManagerTasksetAttribute(args, priority, maxContention); - taskset->taskset = new SPURSManagerTaskset(taskset.addr(), tattr); - - return CELL_OK; -#endif - return spursCreateTaskset(spurs, taskset, args, priority, maxContention, vm::ptr::make(0), 6400/*CellSpursTaskset::size*/, 0); } -s64 cellSpursJoinTaskset(vm::ptr taskset) +s32 cellSpursJoinTaskset(vm::ptr taskset) { cellSpurs.Warning("cellSpursJoinTaskset(taskset_addr=0x%x)", taskset.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x152F8, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetTasksetId(vm::ptr taskset, vm::ptr wid) +s32 cellSpursGetTasksetId(vm::ptr taskset, vm::ptr wid) { cellSpurs.Warning("cellSpursGetTasksetId(taskset_addr=0x%x, wid=0x%x)", taskset.addr(), wid.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14EA0, libsre_rtoc); -#else if (!taskset || !wid) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2699,36 +2274,27 @@ s64 cellSpursGetTasksetId(vm::ptr taskset, vm::ptr wid) *wid = taskset->m.wid; return CELL_OK; -#endif } -s64 cellSpursShutdownTaskset(vm::ptr taskset) +s32 cellSpursShutdownTaskset(vm::ptr taskset) { - cellSpurs.Warning("cellSpursShutdownTaskset(taskset_addr=0x%x)", taskset.addr()); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14868, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } u32 _cellSpursGetSdkVersion() { - static s32 sdk_version = -2; + s32 sdk_version; - if (sdk_version == -2) + if (process_get_sdk_version(process_getpid(), sdk_version) != CELL_OK) { - vm::var> version; - sys_process_get_sdk_version(sys_process_getpid(), vm::ptr::make(version.addr())); - sdk_version = version.value(); + throw __FUNCTION__; } return sdk_version; } -s64 spursCreateTask(vm::ptr taskset, vm::ptr task_id, vm::ptr elf_addr, vm::ptr context_addr, u32 context_size, vm::ptr ls_pattern, vm::ptr arg) +s32 spursCreateTask(vm::ptr taskset, vm::ptr task_id, vm::ptr elf_addr, vm::ptr context_addr, u32 context_size, vm::ptr ls_pattern, vm::ptr arg) { if (!taskset || !elf_addr) { @@ -2825,7 +2391,7 @@ s64 spursCreateTask(vm::ptr taskset, vm::ptr task_id, vm: return CELL_OK; } -s64 spursTaskStart(vm::ptr taskset, u32 taskId) +s32 spursTaskStart(vm::ptr taskset, u32 taskId) { auto pendingReady = taskset->m.pending_ready.value(); pendingReady._bit[taskId] = true; @@ -2848,15 +2414,12 @@ s64 spursTaskStart(vm::ptr taskset, u32 taskId) return rc; } -s64 cellSpursCreateTask(vm::ptr taskset, vm::ptr taskId, u32 elf_addr, u32 context_addr, u32 context_size, vm::ptr lsPattern, +s32 cellSpursCreateTask(vm::ptr taskset, vm::ptr taskId, u32 elf_addr, u32 context_addr, u32 context_size, vm::ptr lsPattern, vm::ptr argument) { cellSpurs.Warning("cellSpursCreateTask(taskset_addr=0x%x, taskID_addr=0x%x, elf_addr_addr=0x%x, context_addr_addr=0x%x, context_size=%d, lsPattern_addr=0x%x, argument_addr=0x%x)", taskset.addr(), taskId.addr(), elf_addr, context_addr, context_size, lsPattern.addr(), argument.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x12414, libsre_rtoc); -#else if (!taskset) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2882,15 +2445,10 @@ s64 cellSpursCreateTask(vm::ptr taskset, vm::ptr taskId, *taskId = tmpTaskId; return CELL_OK; -#endif } -s64 _cellSpursSendSignal(vm::ptr taskset, u32 taskId) +s32 _cellSpursSendSignal(vm::ptr taskset, u32 taskId) { -#ifdef PRX_DEBUG - cellSpurs.Warning("_cellSpursSendSignal(taskset_addr=0x%x, taskId=%d)", taskset.addr(), taskId); - return GetCurrentPPUThread().FastCall2(libsre + 0x124CC, libsre_rtoc); -#else if (!taskset) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2936,28 +2494,18 @@ s64 _cellSpursSendSignal(vm::ptr taskset, u32 taskId) } return CELL_OK; -#endif } -s64 cellSpursCreateTaskWithAttribute() +s32 cellSpursCreateTaskWithAttribute() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x12204, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTasksetAttributeSetName(vm::ptr attr, vm::ptr name) +s32 cellSpursTasksetAttributeSetName(vm::ptr attr, vm::ptr name) { cellSpurs.Warning("%s(attr=0x%x, name=0x%x)", __FUNCTION__, attr.addr(), name.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14210, libsre_rtoc); -#else if (!attr || !name) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2970,16 +2518,12 @@ s64 cellSpursTasksetAttributeSetName(vm::ptr attr, vm attr->m.name = name; return CELL_OK; -#endif } -s64 cellSpursTasksetAttributeSetTasksetSize(vm::ptr attr, u32 size) +s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr attr, u32 size) { cellSpurs.Warning("%s(attr=0x%x, size=0x%x)", __FUNCTION__, attr.addr(), size); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14254, libsre_rtoc); -#else if (!attr) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -2997,16 +2541,12 @@ s64 cellSpursTasksetAttributeSetTasksetSize(vm::ptr a attr->m.taskset_size = size; return CELL_OK; -#endif } -s64 cellSpursTasksetAttributeEnableClearLS(vm::ptr attr, s32 enable) +s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr attr, s32 enable) { cellSpurs.Warning("%s(attr=0x%x, enable=%d)", __FUNCTION__, attr.addr(), enable); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x142AC, libsre_rtoc); -#else if (!attr) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3019,16 +2559,12 @@ s64 cellSpursTasksetAttributeEnableClearLS(vm::ptr at attr->m.enable_clear_ls = enable ? 1 : 0; return CELL_OK; -#endif } -s64 _cellSpursTasksetAttribute2Initialize(vm::ptr attribute, u32 revision) +s32 _cellSpursTasksetAttribute2Initialize(vm::ptr attribute, u32 revision) { cellSpurs.Warning("_cellSpursTasksetAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.addr(), revision); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1474C, libsre_rtoc); -#else + memset(attribute.get_ptr(), 0, CellSpursTasksetAttribute2::size); attribute->m.revision = revision; attribute->m.name.set(0); @@ -3043,112 +2579,60 @@ s64 _cellSpursTasksetAttribute2Initialize(vm::ptr at attribute->m.enable_clear_ls = 0; attribute->m.task_name_buffer.set(0); return CELL_OK; -#endif } -s64 cellSpursTaskExitCodeGet() +s32 cellSpursTaskExitCodeGet() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1397C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskExitCodeInitialize() +s32 cellSpursTaskExitCodeInitialize() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1352C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskExitCodeTryGet() +s32 cellSpursTaskExitCodeTryGet() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13974, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskGetLoadableSegmentPattern() +s32 cellSpursTaskGetLoadableSegmentPattern() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13ED4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskGetReadOnlyAreaPattern() +s32 cellSpursTaskGetReadOnlyAreaPattern() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13CFC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskGenerateLsPattern() +s32 cellSpursTaskGenerateLsPattern() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13B78, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursTaskAttributeInitialize() +s32 _cellSpursTaskAttributeInitialize() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x10C30, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTaskAttributeSetExitCodeContainer() +s32 cellSpursTaskAttributeSetExitCodeContainer() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x10A98, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursTaskAttribute2Initialize(vm::ptr attribute, u32 revision) +s32 _cellSpursTaskAttribute2Initialize(vm::ptr attribute, u32 revision) { cellSpurs.Warning("_cellSpursTaskAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.addr(), revision); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x10B00, libsre_rtoc); -#else attribute->revision = revision; attribute->sizeContext = 0; attribute->eaContext = 0; @@ -3161,28 +2645,18 @@ s64 _cellSpursTaskAttribute2Initialize(vm::ptr attribut attribute->name_addr = 0; return CELL_OK; -#endif } -s64 cellSpursTaskGetContextSaveAreaSize() +s32 cellSpursTaskGetContextSaveAreaSize() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1409C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursCreateTaskset2(vm::ptr spurs, vm::ptr taskset, vm::ptr attr) +s32 cellSpursCreateTaskset2(vm::ptr spurs, vm::ptr taskset, vm::ptr attr) { cellSpurs.Warning("%s(spurs=0x%x, taskset=0x%x, attr=0x%x)", __FUNCTION__, spurs.addr(), taskset.addr(), attr.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x15108, libsre_rtoc); -#else vm::ptr tmp_attr; if (!attr) @@ -3206,76 +2680,42 @@ s64 cellSpursCreateTaskset2(vm::ptr spurs, vm::ptr // TODO: Implement rest of the function return CELL_OK; -#endif } -s64 cellSpursCreateTask2() +s32 cellSpursCreateTask2() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x11E54, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJoinTask2() +s32 cellSpursJoinTask2() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x11378, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTryJoinTask2() +s32 cellSpursTryJoinTask2() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x11748, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursDestroyTaskset2() +s32 cellSpursDestroyTaskset2() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14EE8, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursCreateTask2WithBinInfo() +s32 cellSpursCreateTask2WithBinInfo() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x120E0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursTasksetSetExceptionEventHandler(vm::ptr taskset, vm::ptr handler, vm::ptr arg) +s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr taskset, vm::ptr handler, vm::ptr arg) { cellSpurs.Warning("%s(taskset=0x5x, handler=0x%x, arg=0x%x)", __FUNCTION__, taskset.addr(), handler.addr(), arg.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13124, libsre_rtoc); -#else if (!taskset || !handler) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3299,16 +2739,12 @@ s64 cellSpursTasksetSetExceptionEventHandler(vm::ptr taskset, taskset->m.exception_handler = handler; taskset->m.exception_handler_arg = arg; return CELL_OK; -#endif } -s64 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr taskset) +s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr taskset) { cellSpurs.Warning("%s(taskset=0x%x)", __FUNCTION__, taskset.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x13194, libsre_rtoc); -#else if (!taskset) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3327,16 +2763,12 @@ s64 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr taskset taskset->m.exception_handler.set(0); taskset->m.exception_handler_arg.set(0); return CELL_OK; -#endif } -s64 cellSpursLookUpTasksetAddress(vm::ptr spurs, vm::ptr taskset, u32 id) +s32 cellSpursLookUpTasksetAddress(vm::ptr spurs, vm::ptr taskset, u32 id) { cellSpurs.Warning("%s(spurs=0x%x, taskset=0x%x, id=0x%x)", __FUNCTION__, spurs.addr(), taskset.addr(), id); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x133AC, libsre_rtoc); -#else if (taskset.addr() == 0) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3352,16 +2784,12 @@ s64 cellSpursLookUpTasksetAddress(vm::ptr spurs, vm::ptr taskset, vm::ptr spurs) +s32 cellSpursTasksetGetSpursAddress(vm::ptr taskset, vm::ptr spurs) { cellSpurs.Warning("%s(taskset=0x%x, spurs=0x%x)", __FUNCTION__, taskset.addr(), spurs.addr()); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x14408, libsre_rtoc); -#else if (!taskset || !spurs) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3379,29 +2807,19 @@ s64 cellSpursTasksetGetSpursAddress(vm::ptr taskset, vm: *spurs = (u32)taskset->m.spurs.addr(); return CELL_OK; -#endif } -s64 cellSpursGetTasksetInfo() +s32 cellSpursGetTasksetInfo() { - cellSpurs.Warning("%s()", __FUNCTION__); - -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x1445C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursTasksetAttributeInitialize(vm::ptr attribute, u32 revision, u32 sdk_version, u64 args, vm::ptr priority, u32 max_contention) +s32 _cellSpursTasksetAttributeInitialize(vm::ptr attribute, u32 revision, u32 sdk_version, u64 args, vm::ptr priority, u32 max_contention) { cellSpurs.Warning("%s(attribute=0x%x, revision=%d, skd_version=%d, args=0x%llx, priority=0x%x, max_contention=%d)", __FUNCTION__, attribute.addr(), revision, sdk_version, args, priority.addr(), max_contention); -#ifdef PRX_DEBUG - return GetCurrentPPUThread().FastCall2(libsre + 0x142FC, libsre_rtoc); -#else if (!attribute) { return CELL_SPURS_TASK_ERROR_NULL_POINTER; @@ -3428,205 +2846,114 @@ s64 _cellSpursTasksetAttributeInitialize(vm::ptr attr attribute->m.taskset_size = 6400/*CellSpursTaskset::size*/; attribute->m.max_contention = max_contention; return CELL_OK; -#endif } -s64 cellSpursJobGuardInitialize() +s32 cellSpursJobGuardInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1807C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainAttributeSetName() +s32 cellSpursJobChainAttributeSetName() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1861C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursShutdownJobChain() +s32 cellSpursShutdownJobChain() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18D2C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainAttributeSetHaltOnError() +s32 cellSpursJobChainAttributeSetHaltOnError() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18660, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainAttributeSetJobTypeMemoryCheck() +s32 cellSpursJobChainAttributeSetJobTypeMemoryCheck() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x186A4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobGuardNotify() +s32 cellSpursJobGuardNotify() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17FA4, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobGuardReset() +s32 cellSpursJobGuardReset() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17F60, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursRunJobChain() +s32 cellSpursRunJobChain() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18F94, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobChainGetError() +s32 cellSpursJobChainGetError() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x190AC, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursGetJobPipelineInfo() +s32 cellSpursGetJobPipelineInfo() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1A954, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobSetMaxGrab() +s32 cellSpursJobSetMaxGrab() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1AC88, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursJobHeaderSetJobbin2Param() +s32 cellSpursJobHeaderSetJobbin2Param() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1AD58, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursAddUrgentCommand() +s32 cellSpursAddUrgentCommand() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x18160, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursAddUrgentCall() +s32 cellSpursAddUrgentCall() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x1823C, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursBarrierInitialize() +s32 cellSpursBarrierInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17CD8, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursBarrierGetTasksetAddress() +s32 cellSpursBarrierGetTasksetAddress() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17DB0, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 _cellSpursSemaphoreInitialize() +s32 _cellSpursSemaphoreInitialize() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17DF8, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } -s64 cellSpursSemaphoreGetTasksetAddress() +s32 cellSpursSemaphoreGetTasksetAddress() { -#ifdef PRX_DEBUG - cellSpurs.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsre + 0x17F18, libsre_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpurs); return CELL_OK; -#endif } bool spursIsLibProfLoaded() @@ -3647,7 +2974,7 @@ void spursTraceStatusUpdate(vm::ptr spurs) } } -s64 spursTraceInitialize(vm::ptr spurs, vm::ptr buffer, u32 size, u32 mode, u32 updateStatus) +s32 spursTraceInitialize(vm::ptr spurs, vm::ptr buffer, u32 size, u32 mode, u32 updateStatus) { if (!spurs || !buffer) { @@ -3697,7 +3024,7 @@ s64 spursTraceInitialize(vm::ptr spurs, vm::ptr b return CELL_OK; } -s64 cellSpursTraceInitialize(vm::ptr spurs, vm::ptr buffer, u32 size, u32 mode) +s32 cellSpursTraceInitialize(vm::ptr spurs, vm::ptr buffer, u32 size, u32 mode) { if (spursIsLibProfLoaded()) { @@ -3707,7 +3034,7 @@ s64 cellSpursTraceInitialize(vm::ptr spurs, vm::ptr spurs, u32 updateStatus) +s32 spursTraceStart(vm::ptr spurs, u32 updateStatus) { if (!spurs) { @@ -3733,7 +3060,7 @@ s64 spursTraceStart(vm::ptr spurs, u32 updateStatus) return CELL_OK; } -s64 cellSpursTraceStart(vm::ptr spurs) +s32 cellSpursTraceStart(vm::ptr spurs) { if (!spurs) { @@ -3748,7 +3075,7 @@ s64 cellSpursTraceStart(vm::ptr spurs) return spursTraceStart(spurs, spurs->m.traceMode & CELL_SPURS_TRACE_MODE_FLAG_SYNCHRONOUS_START_STOP); } -s64 spursTraceStop(vm::ptr spurs, u32 updateStatus) +s32 spursTraceStop(vm::ptr spurs, u32 updateStatus) { if (!spurs) { @@ -3774,7 +3101,7 @@ s64 spursTraceStop(vm::ptr spurs, u32 updateStatus) return CELL_OK; } -s64 cellSpursTraceStop(vm::ptr spurs) +s32 cellSpursTraceStop(vm::ptr spurs) { if (!spurs) { @@ -3789,7 +3116,7 @@ s64 cellSpursTraceStop(vm::ptr spurs) return spursTraceStop(spurs, spurs->m.traceMode & CELL_SPURS_TRACE_MODE_FLAG_SYNCHRONOUS_START_STOP); } -s64 cellSpursTraceFinalize(vm::ptr spurs) +s32 cellSpursTraceFinalize(vm::ptr spurs) { if (!spurs) { diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h index f6e96733c3..f474da8893 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h @@ -957,5 +957,5 @@ struct SpursTasksetContext static_assert(sizeof(SpursTasksetContext) == 0x900, "Incorrect size for SpursTasksetContext"); -s64 spursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic, bool wasCreated); -s64 spursWakeUp(PPUThread& CPU, vm::ptr spurs); +s32 spursAttachLv2EventQueue(vm::ptr spurs, u32 queue, vm::ptr port, s32 isDynamic, bool wasCreated); +s32 spursWakeUp(PPUThread& CPU, vm::ptr spurs); diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp index 8878858ea5..8b4c3b4f14 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp @@ -13,692 +13,376 @@ extern Module cellSpursJq; -#ifdef PRX_DEBUG -#include "prx_libspurs_jq.h" -u32 libspurs_jq; -u32 libspurs_jq_rtoc; -#endif - -s64 cellSpursJobQueueAttributeInitialize() +s32 cellSpursJobQueueAttributeInitialize() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000010, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetMaxGrab() +s32 cellSpursJobQueueAttributeSetMaxGrab() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000058, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetSubmitWithEntryLock() +s32 cellSpursJobQueueAttributeSetSubmitWithEntryLock() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000098, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetDoBusyWaiting() +s32 cellSpursJobQueueAttributeSetDoBusyWaiting() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0000BC, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetIsHaltOnError() +s32 cellSpursJobQueueAttributeSetIsHaltOnError() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0000E0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetIsJobTypeMemoryCheck() +s32 cellSpursJobQueueAttributeSetIsJobTypeMemoryCheck() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000104, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetMaxSizeJobDescriptor() +s32 cellSpursJobQueueAttributeSetMaxSizeJobDescriptor() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000128, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueAttributeSetGrabParameters() +s32 cellSpursJobQueueAttributeSetGrabParameters() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000178, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSetWaitingMode() +s32 cellSpursJobQueueSetWaitingMode() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0001C8, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursShutdownJobQueue() +s32 cellSpursShutdownJobQueue() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0002F0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursCreateJobQueueWithJobDescriptorPool() +s32 _cellSpursCreateJobQueueWithJobDescriptorPool() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0003CC, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursCreateJobQueue() +s32 _cellSpursCreateJobQueue() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000CA8, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJoinJobQueue() +s32 cellSpursJoinJobQueue() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000CF0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushJobListBody() +s32 _cellSpursJobQueuePushJobListBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001B24, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushJobBody2() +s32 _cellSpursJobQueuePushJobBody2() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001BF0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushJob2Body() +s32 _cellSpursJobQueuePushJob2Body() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001CD0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushAndReleaseJobBody() +s32 _cellSpursJobQueuePushAndReleaseJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001DC8, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushJobBody() +s32 _cellSpursJobQueuePushJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001EC8, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushBody() +s32 _cellSpursJobQueuePushBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001F90, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueueAllocateJobDescriptorBody() +s32 _cellSpursJobQueueAllocateJobDescriptorBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002434, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushSync() +s32 _cellSpursJobQueuePushSync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002498, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePushFlush() +s32 _cellSpursJobQueuePushFlush() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002528, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueGetSpurs() +s32 cellSpursJobQueueGetSpurs() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002598, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueGetHandleCount() +s32 cellSpursJobQueueGetHandleCount() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0025C4, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueGetError() +s32 cellSpursJobQueueGetError() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002600, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueGetMaxSizeJobDescriptor() +s32 cellSpursJobQueueGetMaxSizeJobDescriptor() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002668, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursGetJobQueueId() +s32 cellSpursGetJobQueueId() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0026A4, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueGetSuspendedJobSize() +s32 cellSpursJobQueueGetSuspendedJobSize() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002700, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueClose() +s32 cellSpursJobQueueClose() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002D70, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueOpen() +s32 cellSpursJobQueueOpen() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002E50, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSemaphoreTryAcquire() +s32 cellSpursJobQueueSemaphoreTryAcquire() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003370, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSemaphoreAcquire() +s32 cellSpursJobQueueSemaphoreAcquire() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003378, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSemaphoreInitialize() +s32 cellSpursJobQueueSemaphoreInitialize() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003380, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSendSignal() +s32 cellSpursJobQueueSendSignal() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0033E0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortGetJobQueue() +s32 cellSpursJobQueuePortGetJobQueue() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x00354C, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushSync() +s32 _cellSpursJobQueuePortPushSync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003554, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushFlush() +s32 _cellSpursJobQueuePortPushFlush() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0035C0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushJobListBody() +s32 _cellSpursJobQueuePortPushJobListBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003624, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushJobBody() +s32 _cellSpursJobQueuePortPushJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A88, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushJobBody2() +s32 _cellSpursJobQueuePortPushJobBody2() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A94, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortPushBody() +s32 _cellSpursJobQueuePortPushBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A98, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortTrySync() +s32 cellSpursJobQueuePortTrySync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C38, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortSync() +s32 cellSpursJobQueuePortSync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C40, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortInitialize() +s32 cellSpursJobQueuePortInitialize() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C48, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortInitializeWithDescriptorBuffer() +s32 cellSpursJobQueuePortInitializeWithDescriptorBuffer() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003D78, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePortFinalize() +s32 cellSpursJobQueuePortFinalize() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003E40, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortCopyPushJobBody() +s32 _cellSpursJobQueuePortCopyPushJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004280, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortCopyPushJobBody2() +s32 _cellSpursJobQueuePortCopyPushJobBody2() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x00428C, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePortCopyPushBody() +s32 _cellSpursJobQueuePortCopyPushBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004290, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2GetJobQueue() +s32 cellSpursJobQueuePort2GetJobQueue() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0042A4, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2PushSync() +s32 cellSpursJobQueuePort2PushSync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0042AC, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2PushFlush() +s32 cellSpursJobQueuePort2PushFlush() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004330, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePort2PushJobListBody() +s32 _cellSpursJobQueuePort2PushJobListBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0043B0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2Sync() +s32 cellSpursJobQueuePort2Sync() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0045AC, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2Create() +s32 cellSpursJobQueuePort2Create() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0046C4, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2Destroy() +s32 cellSpursJobQueuePort2Destroy() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0047E4, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueuePort2AllocateJobDescriptor() +s32 cellSpursJobQueuePort2AllocateJobDescriptor() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004928, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePort2PushAndReleaseJobBody() +s32 _cellSpursJobQueuePort2PushAndReleaseJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004D94, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePort2CopyPushJobBody() +s32 _cellSpursJobQueuePort2CopyPushJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004DD0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 _cellSpursJobQueuePort2PushJobBody() +s32 _cellSpursJobQueuePort2PushJobBody() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004E0C, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueSetExceptionEventHandler() +s32 cellSpursJobQueueSetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004E48, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } -s64 cellSpursJobQueueUnsetExceptionEventHandler() +s32 cellSpursJobQueueUnsetExceptionEventHandler() { -#ifdef PRX_DEBUG - cellSpursJq.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004EC0, libspurs_jq_rtoc); -#else UNIMPLEMENTED_FUNC(cellSpursJq); return CELL_OK; -#endif } Module cellSpursJq("cellSpursJq", []() @@ -765,43 +449,4 @@ Module cellSpursJq("cellSpursJq", []() REG_FUNC(cellSpursJq, _cellSpursJobQueuePort2PushJobBody); REG_FUNC(cellSpursJq, cellSpursJobQueueSetExceptionEventHandler); REG_FUNC(cellSpursJq, cellSpursJobQueueUnsetExceptionEventHandler); - -#ifdef PRX_DEBUG - CallAfter([]() - { - if (!Memory.MainMem.GetStartAddr()) return; - - libspurs_jq = (u32)Memory.MainMem.AllocAlign(sizeof(libspurs_jq_data), 0x100000); - memcpy(vm::get_ptr(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data)); - libspurs_jq_rtoc = libspurs_jq + 0x17E80; - - extern Module* sysPrxForUser; - extern Module* cellSpurs; - extern Module* cellFiber; - - FIX_IMPORT(cellSpurs, cellSpursSendWorkloadSignal , libspurs_jq + 0x6728); - FIX_IMPORT(cellSpurs, cellSpursWorkloadAttributeSetName , libspurs_jq + 0x6748); - FIX_IMPORT(cellSpurs, cellSpursRemoveWorkload , libspurs_jq + 0x6768); - FIX_IMPORT(cellSpurs, cellSpursWaitForWorkloadShutdown , libspurs_jq + 0x6788); - FIX_IMPORT(cellSpurs, cellSpursWakeUp , libspurs_jq + 0x67A8); - FIX_IMPORT(cellSpurs, cellSpursShutdownWorkload , libspurs_jq + 0x67C8); - FIX_IMPORT(cellSpurs, cellSpursAddWorkloadWithAttribute , libspurs_jq + 0x67E8); - FIX_IMPORT(cellSpurs, cellSpursSetExceptionEventHandler , libspurs_jq + 0x6808); - FIX_IMPORT(cellSpurs, _cellSpursWorkloadAttributeInitialize , libspurs_jq + 0x6828); - FIX_IMPORT(cellFiber, cellFiberPpuSelf , libspurs_jq + 0x6848); - FIX_IMPORT(cellFiber, cellFiberPpuWaitSignal , libspurs_jq + 0x6868); - FIX_IMPORT(sysPrxForUser, _sys_strncmp , libspurs_jq + 0x6888); - FIX_IMPORT(sysPrxForUser, _sys_snprintf , libspurs_jq + 0x68A8); - FIX_IMPORT(sysPrxForUser, sys_lwcond_destroy , libspurs_jq + 0x68C8); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libspurs_jq + 0x68E8); - FIX_IMPORT(sysPrxForUser, _sys_memset , libspurs_jq + 0x6908); - FIX_IMPORT(sysPrxForUser, _sys_printf , libspurs_jq + 0x6928); - fix_import(sysPrxForUser, 0x9FB6228E , libspurs_jq + 0x6948); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libspurs_jq + 0x6968); - FIX_IMPORT(sysPrxForUser, sys_lwcond_create , libspurs_jq + 0x6988); - fix_import(sysPrxForUser, 0xE75C40F2 , libspurs_jq + 0x69A8); - - fix_relocs(cellSpursJq, libspurs_jq, 0xFF70, 0x12370, 0xED00); - }); -#endif }); diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp index 502b51c1eb..0894a4e53b 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp @@ -13,12 +13,6 @@ extern Module cellSync; -#ifdef PRX_DEBUG -#include "prx_libsre.h" -u32 libsre; -u32 libsre_rtoc; -#endif - waiter_map_t g_sync_mutex_wm("sync_mutex_wm"); waiter_map_t g_sync_barrier_wait_wm("sync_barrier_wait_wm"); waiter_map_t g_sync_barrier_notify_wm("sync_barrier_notify_wm"); @@ -835,15 +829,6 @@ s32 cellSyncQueueClear(vm::ptr queue) // LFQueue functions -void syncLFQueueDump(vm::ptr queue) -{ - cellSync.Notice("CellSyncLFQueue dump: addr = 0x%x", queue.addr()); - for (u32 i = 0; i < sizeof(CellSyncLFQueue) / 16; i++) - { - cellSync.Notice("*** 0x%.16llx 0x%.16llx", vm::read64(queue.addr() + i * 16), vm::read64(queue.addr() + i * 16 + 8)); - } -} - void syncLFQueueInit(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal) { queue->m_size = size; @@ -886,11 +871,6 @@ void syncLFQueueInit(vm::ptr queue, vm::ptr buffer, u32 siz s32 syncLFQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal) { -#ifdef PRX_DEBUG_XXX - return cb_caller, vm::ptr, u32, u32, CellSyncQueueDirection, vm::ptr>::call(GetCurrentPPUThread(), libsre + 0x205C, libsre_rtoc, - queue, buffer, size, depth, direction, eaSignal); -#endif - if (!queue) { return CELL_SYNC_ERROR_NULL_POINTER; @@ -1112,10 +1092,7 @@ s32 _cellSyncLFQueueGetPushPointer(vm::ptr queue, vm::ptr s32 syncLFQueueGetPushPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { - // TODO - //pointer = 0; - assert(!"syncLFQueueGetPushPointer2()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueGetPushPointer2(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) @@ -1274,10 +1251,7 @@ s32 _cellSyncLFQueueCompletePushPointer(vm::ptr queue, s32 poin s32 syncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, const std::function fpSendSignal) { - // TODO - //if (fpSendSignal) return fpSendSignal(0, 0); - assert(!"syncLFQueueCompletePushPointer2()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal) @@ -1304,32 +1278,18 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm: } s32 position; -#ifdef PRX_DEBUG - vm::stackvar> position_v(CPU); -#endif + while (true) { s32 res; if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { -#ifdef PRX_DEBUG_XXX - res = cb_call, u32, u32, u64>(CPU, libsre + 0x24B0, libsre_rtoc, - queue, position_v.addr(), isBlocking, 0); - position = position_v.value(); -#else res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0); -#endif } else { -#ifdef PRX_DEBUG - res = cb_call, u32, u32, u64>(CPU, libsre + 0x3050, libsre_rtoc, - queue, position_v.addr(), isBlocking, 0); - position = position_v.value(); -#else res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0); -#endif } if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) @@ -1342,6 +1302,7 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm: } std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack + if (Emu.IsStopped()) { cellSync.Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.addr()); @@ -1355,23 +1316,14 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm: memcpy(vm::get_ptr(addr), buffer.get_ptr(), size); s32 res; + if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { -#ifdef PRX_DEBUG_XXX - res = cb_call, s32, u64>(CPU, libsre + 0x26C0, libsre_rtoc, - queue, position, 0); -#else res = syncLFQueueCompletePushPointer(queue, position, nullptr); -#endif } else { -#ifdef PRX_DEBUG - res = cb_call, s32, u64>(CPU, libsre + 0x355C, libsre_rtoc, - queue, position, 0); -#else res = syncLFQueueCompletePushPointer2(queue, position, nullptr); -#endif } return res; @@ -1491,10 +1443,7 @@ s32 _cellSyncLFQueueGetPopPointer(vm::ptr queue, vm::ptr p s32 syncLFQueueGetPopPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { - // TODO - //pointer = 0; - assert(!"syncLFQueueGetPopPointer2()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueGetPopPointer2(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) @@ -1653,10 +1602,7 @@ s32 _cellSyncLFQueueCompletePopPointer(vm::ptr queue, s32 point s32 syncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, const std::function fpSendSignal, u32 noQueueFull) { - // TODO - //if (fpSendSignal) fpSendSignal(0, 0); - assert(!"syncLFQueueCompletePopPointer2()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal, u32 noQueueFull) @@ -1683,31 +1629,17 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm:: } s32 position; -#ifdef PRX_DEBUG - vm::stackvar> position_v(CPU); -#endif + while (true) { s32 res; if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { -#ifdef PRX_DEBUG_XXX - res = cb_call, u32, u32, u64, u64>(CPU, libsre + 0x2A90, libsre_rtoc, - queue, position_v.addr(), isBlocking, 0, 0); - position = position_v.value(); -#else res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0); -#endif } else { -#ifdef PRX_DEBUG - res = cb_call, u32, u32, u64>(CPU, libsre + 0x39AC, libsre_rtoc, - queue, position_v.addr(), isBlocking, 0); - position = position_v.value(); -#else res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0); -#endif } if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) @@ -1720,6 +1652,7 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm:: } std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack + if (Emu.IsStopped()) { cellSync.Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.addr()); @@ -1733,23 +1666,14 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm:: memcpy(buffer.get_ptr(), vm::get_ptr(addr), size); s32 res; + if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { -#ifdef PRX_DEBUG_XXX - res = cb_call, s32, u64, u64>(CPU, libsre + 0x2CA8, libsre_rtoc, - queue, position, 0, 0); -#else res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0); -#endif } else { -#ifdef PRX_DEBUG - res = cb_call, s32, u64, u64>(CPU, libsre + 0x3EB8, libsre_rtoc, - queue, position, 0, 0); -#else res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0); -#endif } return res; @@ -1910,13 +1834,7 @@ s32 cellSyncLFQueueGetEntrySize(vm::ptr queue, vm::ptr spus, u32 num, vm::ptr queue) { -#ifdef PRX_DEBUG - return cb_call, u32, vm::ptr>(GetCurrentPPUThread(), libsre + 0x19A8, libsre_rtoc, - spus, num, queue); -#endif - - assert(!"syncLFQueueAttachLv2EventQueue()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr spus, u32 num, vm::ptr queue) @@ -1928,13 +1846,7 @@ s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr spus, u32 num, vm::ptr spus, u32 num, vm::ptr queue) { -#ifdef PRX_DEBUG - return cb_call, u32, vm::ptr>(GetCurrentPPUThread(), libsre + 0x1DA0, libsre_rtoc, - spus, num, queue); -#endif - - assert(!"syncLFQueueDetachLv2EventQueue()"); - return CELL_OK; + throw __FUNCTION__; } s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr spus, u32 num, vm::ptr queue) @@ -1992,53 +1904,4 @@ Module cellSync("cellSync", []() cellSync.AddFunc(0xe1bc7add, _cellSyncLFQueuePopBody); cellSync.AddFunc(0xe9bf2110, _cellSyncLFQueueGetPushPointer); cellSync.AddFunc(0xfe74e8e7, _cellSyncLFQueueCompletePopPointer); - -#ifdef PRX_DEBUG - CallAfter([]() - { - if (!Memory.MainMem.GetStartAddr()) return; - - libsre = (u32)Memory.MainMem.AllocAlign(sizeof(libsre_data), 0x100000); - memcpy(vm::get_ptr(libsre), libsre_data, sizeof(libsre_data)); - libsre_rtoc = libsre + 0x399B0; - - extern Module* sysPrxForUser; - - FIX_IMPORT(sysPrxForUser, cellUserTraceRegister , libsre + 0x1D5BC); // ??? - FIX_IMPORT(sysPrxForUser, cellUserTraceUnregister , libsre + 0x1D5DC); // ??? - - FIX_IMPORT(sysPrxForUser, _sys_strncmp , libsre + 0x1D5FC); - FIX_IMPORT(sysPrxForUser, _sys_strcat , libsre + 0x1D61C); - FIX_IMPORT(sysPrxForUser, _sys_vsnprintf , libsre + 0x1D63C); - FIX_IMPORT(sysPrxForUser, _sys_snprintf , libsre + 0x1D65C); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_lock , libsre + 0x1D67C); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_unlock , libsre + 0x1D69C); - FIX_IMPORT(sysPrxForUser, sys_lwcond_destroy , libsre + 0x1D6BC); - FIX_IMPORT(sysPrxForUser, sys_ppu_thread_create , libsre + 0x1D6DC); - FIX_IMPORT(sysPrxForUser, sys_lwcond_wait , libsre + 0x1D6FC); - FIX_IMPORT(sysPrxForUser, _sys_strlen , libsre + 0x1D71C); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libsre + 0x1D73C); - FIX_IMPORT(sysPrxForUser, _sys_spu_printf_detach_group , libsre + 0x1D75C); - FIX_IMPORT(sysPrxForUser, _sys_memset , libsre + 0x1D77C); - FIX_IMPORT(sysPrxForUser, _sys_memcpy , libsre + 0x1D79C); - FIX_IMPORT(sysPrxForUser, _sys_strncat , libsre + 0x1D7BC); - FIX_IMPORT(sysPrxForUser, _sys_strcpy , libsre + 0x1D7DC); - FIX_IMPORT(sysPrxForUser, _sys_printf , libsre + 0x1D7FC); - fix_import(sysPrxForUser, 0x9FB6228E , libsre + 0x1D81C); - FIX_IMPORT(sysPrxForUser, sys_ppu_thread_exit , libsre + 0x1D83C); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libsre + 0x1D85C); - FIX_IMPORT(sysPrxForUser, _sys_strncpy , libsre + 0x1D87C); - FIX_IMPORT(sysPrxForUser, sys_lwcond_create , libsre + 0x1D89C); - FIX_IMPORT(sysPrxForUser, _sys_spu_printf_attach_group , libsre + 0x1D8BC); - FIX_IMPORT(sysPrxForUser, sys_prx_get_module_id_by_name , libsre + 0x1D8DC); - FIX_IMPORT(sysPrxForUser, sys_spu_image_close , libsre + 0x1D8FC); - fix_import(sysPrxForUser, 0xE75C40F2 , libsre + 0x1D91C); - FIX_IMPORT(sysPrxForUser, sys_spu_image_import , libsre + 0x1D93C); - FIX_IMPORT(sysPrxForUser, sys_lwcond_signal , libsre + 0x1D95C); - FIX_IMPORT(sysPrxForUser, _sys_vprintf , libsre + 0x1D97C); - FIX_IMPORT(sysPrxForUser, _sys_memcmp , libsre + 0x1D99C); - - fix_relocs(cellSync, libsre, 0x31EE0, 0x3A4F0, 0x2DF00); - }); -#endif }); diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.h b/rpcs3/Emu/SysCalls/Modules/cellSync.h index 998418615a..ba7ab97781 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.h @@ -135,16 +135,18 @@ struct CellSyncLFQueue be_t m_h6; }; - union + union // 0x0 { - atomic_t pop1; // 0x0 + atomic_t pop1; atomic_t pop3; }; - union + + union // 0x8 { - atomic_t push1; // 0x8 + atomic_t push1; atomic_t push3; }; + be_t m_size; // 0x10 be_t m_depth; // 0x14 vm::bptr m_buffer; // 0x18 @@ -159,6 +161,23 @@ struct CellSyncLFQueue vm::bptr m_eaSignal; // 0x70 be_t m_v2; // 0x78 be_t m_eq_id; // 0x7C + + std::string dump() + { + std::string res = "CellSyncLFQueue dump:"; + + auto data = (be_t*)this; + + for (u32 i = 0; i < sizeof(CellSyncLFQueue) / sizeof(u64); i += 2) + { + res += "\n*** 0x"; + res += fmt::to_hex(data[i + 0], 16); + res += " 0x"; + res += fmt::to_hex(data[i + 1], 16); + } + + return res; + } }; static_assert(sizeof(CellSyncLFQueue) == 128, "CellSyncLFQueue: wrong size"); diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp index 0f229cf3fa..8875129728 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp @@ -7,18 +7,8 @@ extern Module cellSync2; -#ifdef PRX_DEBUG -#include "prx_libsync2.h" -u32 libsync2; -u32 libsync2_rtoc; -#endif - -s64 _cellSync2MutexAttributeInitialize(vm::ptr attr, u32 sdkVersion) +s32 _cellSync2MutexAttributeInitialize(vm::ptr attr, u32 sdkVersion) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x16A0, libsync2_rtoc); -#else cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); attr->sdkVersion = sdkVersion; @@ -30,85 +20,50 @@ s64 _cellSync2MutexAttributeInitialize(vm::ptr attr, u3 strcpy_trunc(attr->name, "CellSync2Mutex"); return CELL_OK; -#endif } -s64 cellSync2MutexEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) +s32 cellSync2MutexEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0xC3C, libsync2_rtoc); -#else cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); if (attr->maxWaiters > 32768) return CELL_SYNC2_ERROR_INVAL; return CELL_OK; -#endif } -s64 cellSync2MutexInitialize() +s32 cellSync2MutexInitialize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x1584, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2MutexFinalize() +s32 cellSync2MutexFinalize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x142C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2MutexLock() +s32 cellSync2MutexLock() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x1734, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2MutexTryLock() +s32 cellSync2MutexTryLock() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x1A2C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2MutexUnlock() +s32 cellSync2MutexUnlock() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x186C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 _cellSync2CondAttributeInitialize(vm::ptr attr, u32 sdkVersion) +s32 _cellSync2CondAttributeInitialize(vm::ptr attr, u32 sdkVersion) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x26DC, libsync2_rtoc); -#else cellSync2.Warning("_cellSync2CondAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); attr->sdkVersion = sdkVersion; @@ -116,85 +71,50 @@ s64 _cellSync2CondAttributeInitialize(vm::ptr attr, u32 strcpy_trunc(attr->name, "CellSync2Cond"); return CELL_OK; -#endif } -s64 cellSync2CondEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) +s32 cellSync2CondEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x1B90, libsync2_rtoc); -#else cellSync2.Todo("cellSync2CondEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); if (attr->maxWaiters == 0 || attr->maxWaiters > 32768) return CELL_SYNC2_ERROR_INVAL; return CELL_OK; -#endif } -s64 cellSync2CondInitialize() +s32 cellSync2CondInitialize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x25DC, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2CondFinalize() +s32 cellSync2CondFinalize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x23E0, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2CondWait() +s32 cellSync2CondWait() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x283C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2CondSignal() +s32 cellSync2CondSignal() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x2768, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2CondSignalAll() +s32 cellSync2CondSignalAll() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x2910, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 _cellSync2SemaphoreAttributeInitialize(vm::ptr attr, u32 sdkVersion) +s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr attr, u32 sdkVersion) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x5644, libsync2_rtoc); -#else cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); attr->sdkVersion = sdkVersion; @@ -205,96 +125,56 @@ s64 _cellSync2SemaphoreAttributeInitialize(vm::ptr strcpy_trunc(attr->name, "CellSync2Semaphore"); return CELL_OK; -#endif } -s64 cellSync2SemaphoreEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) +s32 cellSync2SemaphoreEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x4AC4, libsync2_rtoc); -#else cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); if (attr->maxWaiters == 0 || attr->maxWaiters > 32768) return CELL_SYNC2_ERROR_INVAL; return CELL_OK; -#endif } -s64 cellSync2SemaphoreInitialize() +s32 cellSync2SemaphoreInitialize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x54E0, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2SemaphoreFinalize() +s32 cellSync2SemaphoreFinalize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x52F0, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2SemaphoreAcquire() +s32 cellSync2SemaphoreAcquire() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x57A4, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2SemaphoreTryAcquire() +s32 cellSync2SemaphoreTryAcquire() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x56D8, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2SemaphoreRelease() +s32 cellSync2SemaphoreRelease() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x5870, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2SemaphoreGetCount() +s32 cellSync2SemaphoreGetCount() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x4B4C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 _cellSync2QueueAttributeInitialize(vm::ptr attr, u32 sdkVersion) +s32 _cellSync2QueueAttributeInitialize(vm::ptr attr, u32 sdkVersion) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x3C5C, libsync2_rtoc); -#else cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); attr->sdkVersion = sdkVersion; @@ -308,15 +188,10 @@ s64 _cellSync2QueueAttributeInitialize(vm::ptr attr, u3 strcpy_trunc(attr->name, "CellSync2Queue"); return CELL_OK; -#endif } -s64 cellSync2QueueEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) +s32 cellSync2QueueEstimateBufferSize(vm::ptr attr, vm::ptr bufferSize) { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x2A98, libsync2_rtoc); -#else cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); if (attr->elementSize == 0 || attr->elementSize > 16384 || attr->elementSize % 16 || attr->depth == 0 || attr->depth > 4294967292 || @@ -324,95 +199,54 @@ s64 cellSync2QueueEstimateBufferSize(vm::ptr attr return CELL_SYNC2_ERROR_INVAL; return CELL_OK; -#endif } -s64 cellSync2QueueInitialize() +s32 cellSync2QueueInitialize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x3F98, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueueFinalize() +s32 cellSync2QueueFinalize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x3C28, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueuePush() +s32 cellSync2QueuePush() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x478C, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueueTryPush() +s32 cellSync2QueueTryPush() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x4680, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueuePop() +s32 cellSync2QueuePop() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x4974, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueueTryPop() +s32 cellSync2QueueTryPop() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x4880, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueueGetSize() +s32 cellSync2QueueGetSize() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x2C00, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } -s64 cellSync2QueueGetDepth() +s32 cellSync2QueueGetDepth() { -#ifdef PRX_DEBUG - cellSync2.Warning("%s()", __FUNCTION__); - return GetCurrentPPUThread().FastCall2(libsync2 + 0x2B90, libsync2_rtoc); -#else UNIMPLEMENTED_FUNC(cellSync2); return CELL_OK; -#endif } Module cellSync2("cellSync2", []() @@ -452,37 +286,4 @@ Module cellSync2("cellSync2", []() cellSync2.AddFunc(0x0c9a0ea9, cellSync2QueueTryPop); cellSync2.AddFunc(0x12f0a27d, cellSync2QueueGetSize); cellSync2.AddFunc(0xf0e1471c, cellSync2QueueGetDepth); - -#ifdef PRX_DEBUG - CallAfter([]() - { - if (!Memory.MainMem.GetStartAddr()) return; - - libsync2 = (u32)Memory.MainMem.AllocAlign(sizeof(libsync2_data), 0x100000); - memcpy(vm::get_ptr(libsync2), libsync2_data, sizeof(libsync2_data)); - libsync2_rtoc = libsync2 + 0xF280; - - extern Module* sysPrxForUser; - extern Module* cellSpurs; - extern Module* cellSpursJq; - extern Module* cellFiber; - - FIX_IMPORT(cellSpurs, _cellSpursSendSignal , libsync2 + 0x61F0); - FIX_IMPORT(cellSpursJq, cellSpursJobQueueSendSignal , libsync2 + 0x6210); - FIX_IMPORT(cellFiber, cellFiberPpuUtilWorkerControlSendSignal , libsync2 + 0x6230); - FIX_IMPORT(cellFiber, cellFiberPpuSelf , libsync2 + 0x6250); - FIX_IMPORT(cellFiber, cellFiberPpuWaitSignal , libsync2 + 0x6270); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_lock , libsync2 + 0x6290); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_unlock , libsync2 + 0x62B0); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libsync2 + 0x62D0); - FIX_IMPORT(sysPrxForUser, sys_ppu_thread_get_id , libsync2 + 0x62F0); - FIX_IMPORT(sysPrxForUser, _sys_memset , libsync2 + 0x6310); - FIX_IMPORT(sysPrxForUser, _sys_printf , libsync2 + 0x6330); - fix_import(sysPrxForUser, 0x9FB6228E , libsync2 + 0x6350); - FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libsync2 + 0x6370); - FIX_IMPORT(sysPrxForUser, _sys_strncpy , libsync2 + 0x6390); - - fix_relocs(cellSync2, libsync2, 0x73A0, 0x95A0, 0x6B90); - }); -#endif }); diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp index cf3cc9f17e..70def9c4a3 100644 --- a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp +++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp @@ -126,7 +126,7 @@ s32 sys_prx_get_module_id_by_address() s32 sys_prx_get_module_id_by_name() { sys_prx.Todo("sys_prx_get_module_id_by_name()"); - return CELL_OK; + return CELL_PRX_ERROR_UNKNOWN_MODULE; } s32 sys_prx_get_module_info() diff --git a/rpcs3/Loader/ELF32.cpp b/rpcs3/Loader/ELF32.cpp index a118451126..42de280949 100644 --- a/rpcs3/Loader/ELF32.cpp +++ b/rpcs3/Loader/ELF32.cpp @@ -134,7 +134,7 @@ namespace loader auto armv7_thr_stop_data = vm::psv::ptr::make(Memory.PSV.RAM.AllocAlign(3 * 4)); armv7_thr_stop_data[0] = 0xf870; // HACK instruction (Thumb) - armv7_thr_stop_data[1] = 0x0001; // index 1 + armv7_thr_stop_data[1] = SFI_HLE_RETURN; Emu.SetCPUThreadStop(armv7_thr_stop_data.addr()); u32 entry = 0; // actual entry point (ELFs entry point is ignored) @@ -228,28 +228,34 @@ namespace loader const u32 nid = fnid[j]; const u32 addr = fstub[j]; - if (auto func = get_psv_func_by_nid(nid)) + u32 index; + + if (auto func = get_psv_func_by_nid(nid, &index)) { if (func->module) { - func->module->Notice("Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr); + LOG_NOTICE(LOADER, "Imported function '%s' in module '%s' (nid=0x%08x, addr=0x%x)", func->name, func->module->GetName(), nid, addr); } else { - LOG_NOTICE(LOADER, "Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr); + LOG_NOTICE(LOADER, "Imported function '%s' (nid=0x%08x, addr=0x%x)", func->name, nid, addr); } - - const u32 code = get_psv_func_index(func); - vm::psv::write32(addr + 0, 0xe0700090 | (code & 0xfff0) << 4 | (code & 0xf)); // HACK instruction (ARM) } else { LOG_ERROR(LOADER, "Unknown function 0x%08x (addr=0x%x)", nid, addr); - vm::psv::write32(addr + 0, 0xe0700090); // HACK instruction (ARM), unimplemented stub (code 0) - vm::psv::write32(addr + 4, nid); // nid + psv_func unimplemented; + unimplemented.nid = nid; + unimplemented.module = nullptr; + unimplemented.name = "UNKNOWN"; // TODO: set correct name if possible + unimplemented.func = nullptr; + + index = add_psv_func(unimplemented); } + vm::psv::write32(addr + 0, 0xe0700090 | (index & 0xfff0) << 4 | (index & 0xf)); // HACK instruction (ARM) + code_end = std::min(addr, code_end); } } diff --git a/rpcs3/Loader/ELF64.cpp b/rpcs3/Loader/ELF64.cpp index e3de0bb9fd..dfb12aee06 100644 --- a/rpcs3/Loader/ELF64.cpp +++ b/rpcs3/Loader/ELF64.cpp @@ -303,6 +303,7 @@ namespace loader std::vector start_funcs; std::vector stop_funcs; + std::vector exit_funcs; //load modules vfsDir lle_dir("/dev_flash/sys/external"); @@ -341,12 +342,48 @@ namespace loader { for (auto &e : m.second.exports) { + auto code = vm::ptr::make(vm::check_addr(e.second, 8) ? vm::read32(e.second) : 0); + + bool is_empty = !code || (code[0] == 0x38600000 && code[1] == BLR()); + + if (!code) + { + LOG_ERROR(LOADER, "bad OPD of special function 0x%08x in '%s' library (0x%x)", e.first, info.name.c_str(), code); + } + switch (e.first) { - case 0xbc9a0086: start_funcs.push_back(e.second); break; - case 0xab779874: stop_funcs.push_back(e.second); break; + case 0xbc9a0086: + { + if (!is_empty) + { + LOG_ERROR(LOADER, "start func found in '%s' library (0x%x)", info.name.c_str(), code); + start_funcs.push_back(e.second); + } + break; + } - default: LOG_ERROR(LOADER, "unknown special func 0x%08x in '%s' library", e.first, info.name.c_str()); break; + case 0xab779874: + { + if (!is_empty) + { + LOG_ERROR(LOADER, "stop func found in '%s' library (0x%x)", info.name.c_str(), code); + stop_funcs.push_back(e.second); + } + break; + } + + case 0x3ab9a95e: + { + if (!is_empty) + { + LOG_ERROR(LOADER, "exit func found in '%s' library (0x%x)", info.name.c_str(), code); + exit_funcs.push_back(e.second); + } + break; + } + + default: LOG_ERROR(LOADER, "unknown special func 0x%08x in '%s' library (0x%x)", e.first, info.name.c_str(), code); break; } } @@ -385,8 +422,15 @@ namespace loader LOG_NOTICE(LOADER, "Imported function '%s' (0x%x)", SysCalls::GetHLEFuncName(nid), addr); } - vm::write32(addr + 0, HACK(index)); - vm::write32(addr + 4, BLR()); + if (!vm::check_addr(addr, 8)) + { + LOG_ERROR(LOADER, "Failed to inject code for function '%s' (0x%x)", SysCalls::GetHLEFuncName(nid), addr); + } + else + { + vm::write32(addr + 0, HACK(index)); + vm::write32(addr + 4, BLR()); + } } } }