From 714da1aa7caecda992e1637c005a1ca3bc7286d0 Mon Sep 17 00:00:00 2001 From: Nekotekina Date: Mon, 22 Jun 2015 23:01:06 +0300 Subject: [PATCH] vm::var fix, vm::ptr improved GetCurrentPPUThread() removed --- rpcs3/Emu/CPU/CPUThread.cpp | 5 -- rpcs3/Emu/CPU/CPUThread.h | 2 - rpcs3/Emu/Cell/PPUThread.cpp | 9 --- rpcs3/Emu/Cell/PPUThread.h | 2 - rpcs3/Emu/Cell/RawSPUThread.h | 2 - rpcs3/Emu/Cell/SPUThread.cpp | 12 ---- rpcs3/Emu/Cell/SPUThread.h | 2 - rpcs3/Emu/Memory/vm_ptr.h | 49 ++++++++------ rpcs3/Emu/Memory/vm_var.h | 12 +++- rpcs3/Emu/SysCalls/CB_FUNC.h | 6 -- rpcs3/Emu/SysCalls/Modules/cellGame.cpp | 2 +- rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp | 16 ++--- rpcs3/Emu/SysCalls/Modules/cellResc.cpp | 6 +- rpcs3/Emu/SysCalls/Modules/cellSync.cpp | 76 +++++++++++----------- rpcs3/Emu/SysCalls/Modules/cellSync.h | 16 ++--- rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp | 6 +- rpcs3/Emu/SysCalls/lv2/sys_lwcond.h | 2 - rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp | 8 --- 18 files changed, 102 insertions(+), 131 deletions(-) diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp index a490d187d4..673c16d924 100644 --- a/rpcs3/Emu/CPU/CPUThread.cpp +++ b/rpcs3/Emu/CPU/CPUThread.cpp @@ -10,11 +10,6 @@ #include "CPUDecoder.h" #include "CPUThread.h" -CPUThread* GetCurrentCPUThread() -{ - return dynamic_cast(GetCurrentNamedThread()); -} - CPUThread::CPUThread(CPUThreadType type) : ThreadBase("CPUThread") , m_events(0) diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h index d006ace661..81bf5b07a8 100644 --- a/rpcs3/Emu/CPU/CPUThread.h +++ b/rpcs3/Emu/CPU/CPUThread.h @@ -229,8 +229,6 @@ protected: virtual void Task(); }; -CPUThread* GetCurrentCPUThread(); - class cpu_thread { protected: diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp index cdcf209efb..411ae01e49 100644 --- a/rpcs3/Emu/Cell/PPUThread.cpp +++ b/rpcs3/Emu/Cell/PPUThread.cpp @@ -489,15 +489,6 @@ void fill_ppu_exec_map(u32 addr, u32 size) } } -PPUThread& GetCurrentPPUThread() -{ - CPUThread* thread = GetCurrentCPUThread(); - - if(!thread || thread->GetType() != CPU_THREAD_PPU) throw std::string("GetCurrentPPUThread: bad thread"); - - return *(PPUThread*)thread; -} - PPUThread::PPUThread() : CPUThread(CPU_THREAD_PPU) { Reset(); diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h index d767dfb4b2..35c6611e53 100644 --- a/rpcs3/Emu/Cell/PPUThread.h +++ b/rpcs3/Emu/Cell/PPUThread.h @@ -823,8 +823,6 @@ protected: virtual void DoStop() override; }; -PPUThread& GetCurrentPPUThread(); - class ppu_thread : cpu_thread { static const u32 stack_align = 0x10; diff --git a/rpcs3/Emu/Cell/RawSPUThread.h b/rpcs3/Emu/Cell/RawSPUThread.h index f4186ae4ed..0985c50134 100644 --- a/rpcs3/Emu/Cell/RawSPUThread.h +++ b/rpcs3/Emu/Cell/RawSPUThread.h @@ -28,5 +28,3 @@ public: private: virtual void Task(); }; - -SPUThread& GetCurrentSPUThread(); diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp index 1ab0d3ca72..8a0ef10548 100644 --- a/rpcs3/Emu/Cell/SPUThread.cpp +++ b/rpcs3/Emu/Cell/SPUThread.cpp @@ -57,18 +57,6 @@ public: } g_spu_inter_func_list; -SPUThread& GetCurrentSPUThread() -{ - CPUThread* thread = GetCurrentCPUThread(); - - if(!thread || (thread->GetType() != CPU_THREAD_SPU && thread->GetType() != CPU_THREAD_RAW_SPU)) - { - throw std::string("GetCurrentSPUThread: bad thread"); - } - - return *(SPUThread*)thread; -} - SPUThread::SPUThread(CPUThreadType type) : CPUThread(type) { assert(type == CPU_THREAD_SPU || type == CPU_THREAD_RAW_SPU); diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h index 00fe179483..b06963e24c 100644 --- a/rpcs3/Emu/Cell/SPUThread.h +++ b/rpcs3/Emu/Cell/SPUThread.h @@ -698,8 +698,6 @@ protected: virtual void DoClose(); }; -SPUThread& GetCurrentSPUThread(); - class spu_thread : cpu_thread { public: diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h index 2c48f72eb7..8052ffb17a 100644 --- a/rpcs3/Emu/Memory/vm_ptr.h +++ b/rpcs3/Emu/Memory/vm_ptr.h @@ -5,10 +5,23 @@ struct ARMv7Context; namespace vm { + // helper SFINAE type for vm::_ptr_base comparison operators (enables comparison between equal types and between any type and void*) + template using if_comparable_t = std::enable_if_t< + std::is_void::value || + std::is_void::value || + std::is_same, std::remove_cv_t>::value, + RT>; + + // helper SFINAE type for vm::_ptr_base pointer arithmetic operators and indirection (disabled for void and function pointers) + template using if_arithmetical_ptr_t = std::enable_if_t< + !std::is_void::value && + !std::is_function::value, + RT>; + template struct _ptr_base { - AT m_addr; + AT m_addr; // don't access directly using type = T; @@ -19,13 +32,27 @@ namespace vm { return m_addr; } + + // get vm pointer to member + template> _ptr_base of(MT T2::*const member) const + { + const u32 offset = static_cast(reinterpret_cast(&(reinterpret_cast(0ull)->*member))); + return{ vm::cast(m_addr + offset) }; + } + + // get vm pointer to array member with array subscribtion + template> _ptr_base> of(MT T2::*const member, u32 index) const + { + const u32 offset = static_cast(reinterpret_cast(&(reinterpret_cast(0ull)->*member))); + return{ vm::cast(m_addr + offset + sizeof32(T) * index) }; + } template std::enable_if_t::value> set(const CT& value) { m_addr = value; } - template static _ptr_base make(const AT2& addr) + template static std::enable_if_t::value, _ptr_base> make(const AT2& addr) { return{ convert_le_be(addr) }; } @@ -105,15 +132,12 @@ namespace vm return{ convert_le_be(addr) }; } - // defined in CB_FUNC.h, call using specified PPU thread context + // defined in CB_FUNC.h, passing context is mandatory RT operator()(PPUThread& CPU, T... args) const; // defined in ARMv7Callback.h, passing context is mandatory RT operator()(ARMv7Context& context, T... args) const; - // defined in CB_FUNC.h, call using current PPU thread context - RT operator()(T... args) const; - // conversion to another function pointer template operator _ptr_base() const { @@ -213,19 +237,6 @@ namespace vm // vm::null is convertible to any vm::ptr type as null pointer in virtual memory static null_t null; - // helper SFINAE type for vm::_ptr_base comparison operators (enables comparison between equal types and between any type and void*) - template using if_comparable_t = std::enable_if_t< - std::is_void::value || - std::is_void::value || - std::is_same, std::remove_cv_t>::value, - RT>; - - // helper SFINAE type for vm::_ptr_base pointer arithmetic operators and indirection (disabled for void and function pointers) - template using if_arithmetical_ptr_t = std::enable_if_t< - !std::is_void::value && - !std::is_function::value, - RT>; - // perform static_cast (for example, vm::ptr to vm::ptr) template(std::declval()))> inline _ptr_base static_ptr_cast(const _ptr_base& other) { diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h index a342f7df2a..bae1f79522 100644 --- a/rpcs3/Emu/Memory/vm_var.h +++ b/rpcs3/Emu/Memory/vm_var.h @@ -539,7 +539,7 @@ namespace vm CPUThread& m_thread; public: - stackvar(CPUThread& CPU, u32 size = sizeof(T), u32 align = __alignof(T)) + stackvar(CPUThread& CPU, u32 size = sizeof32(T), u32 align = alignof32(T)) : m_data(CPU, size, align) , m_thread(CPU) { @@ -597,6 +597,16 @@ namespace vm return *m_data.ptr; } + T& operator [](u32 index) + { + return m_data.ptr[index]; + } + + const T& operator [](u32 index) const + { + return m_data.ptr[index]; + } + u32 addr() const { return m_data.addr; diff --git a/rpcs3/Emu/SysCalls/CB_FUNC.h b/rpcs3/Emu/SysCalls/CB_FUNC.h index 648d14750b..c271c4473b 100644 --- a/rpcs3/Emu/SysCalls/CB_FUNC.h +++ b/rpcs3/Emu/SysCalls/CB_FUNC.h @@ -170,12 +170,6 @@ namespace vm return cb_detail::_func_caller::call(CPU, pc, rtoc, args...); } - - template - force_inline RT _ptr_base::operator()(T... args) const - { - return operator()(GetCurrentPPUThread(), args...); - } } template diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp index 808be8b119..6a5d66a66c 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp @@ -341,7 +341,7 @@ s32 cellGameDataCheckCreate2(PPUThread& CPU, u32 version, vm::cptr dirName strcpy_trunc(cbGet->getParam.title, psf.GetString("TITLE")); // TODO: write lang titles - funcStat(cbResult, cbGet, cbSet); + funcStat(CPU, cbResult, cbGet, cbSet); if (cbSet->setParam) { diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp index bf5e8a5084..a1c160532e 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp @@ -480,7 +480,7 @@ void cellGcmSetFlipStatus() Emu.GetGSManager().GetRender().m_flip_status = 0; } -s32 cellGcmSetPrepareFlip(vm::ptr ctxt, u32 id) +s32 cellGcmSetPrepareFlip(PPUThread& CPU, vm::ptr ctxt, u32 id) { cellGcmSys.Log("cellGcmSetPrepareFlip(ctx=0x%x, id=0x%x)", ctxt.addr(), id); @@ -503,7 +503,7 @@ s32 cellGcmSetPrepareFlip(vm::ptr ctxt, u32 id) if (current + 8 >= ctxt->end) { cellGcmSys.Error("Bad flip!"); - if (s32 res = ctxt->callback(ctxt, 8 /* ??? */)) + if (s32 res = ctxt->callback(CPU, ctxt, 8 /* ??? */)) { cellGcmSys.Error("cellGcmSetPrepareFlip : callback failed (0x%08x)", res); return res; @@ -527,11 +527,11 @@ s32 cellGcmSetPrepareFlip(vm::ptr ctxt, u32 id) return id; } -s32 cellGcmSetFlip(vm::ptr ctxt, u32 id) +s32 cellGcmSetFlip(PPUThread& CPU, vm::ptr ctxt, u32 id) { cellGcmSys.Log("cellGcmSetFlip(ctx=0x%x, id=0x%x)", ctxt.addr(), id); - s32 res = cellGcmSetPrepareFlip(ctxt, id); + s32 res = cellGcmSetPrepareFlip(CPU, ctxt, id); return res < 0 ? CELL_GCM_ERROR_FAILURE : CELL_OK; } @@ -1096,19 +1096,19 @@ void cellGcmSetDefaultCommandBuffer() // Other //------------------------------------------------------------------------ -s32 _cellGcmSetFlipCommand(vm::ptr ctx, u32 id) +s32 _cellGcmSetFlipCommand(PPUThread& CPU, vm::ptr ctx, u32 id) { cellGcmSys.Log("cellGcmSetFlipCommand(ctx_addr=0x%x, id=0x%x)", ctx.addr(), id); - return cellGcmSetPrepareFlip(ctx, id); + return cellGcmSetPrepareFlip(CPU, ctx, id); } -s32 _cellGcmSetFlipCommandWithWaitLabel(vm::ptr ctx, u32 id, u32 label_index, u32 label_value) +s32 _cellGcmSetFlipCommandWithWaitLabel(PPUThread& CPU, vm::ptr ctx, u32 id, u32 label_index, u32 label_value) { cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx_addr=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)", ctx.addr(), id, label_index, label_value); - s32 res = cellGcmSetPrepareFlip(ctx, id); + s32 res = cellGcmSetPrepareFlip(CPU, ctx, id); vm::write32(gcm_info.label_addr + 0x10 * label_index, label_value); return res < 0 ? CELL_GCM_ERROR_FAILURE : CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp index 842f5da0a4..e76dccba23 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp @@ -17,7 +17,7 @@ extern void cellGcmSetFlipHandler(vm::ptr handler); extern void cellGcmSetVBlankHandler(vm::ptr handler); extern s32 cellGcmAddressToOffset(u32 address, vm::ptr offset); extern s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height); -extern s32 cellGcmSetPrepareFlip(vm::ptr ctx, u32 id); +extern s32 cellGcmSetPrepareFlip(PPUThread& CPU, vm::ptr ctx, u32 id); extern s32 cellGcmSetSecondVFrequency(u32 freq); extern u32 cellGcmGetLabelAddress(u8 index); extern u32 cellGcmGetTiledPitchSize(u32 size); @@ -984,7 +984,7 @@ int cellRescSetSrc(s32 idx, vm::ptr src) return 0; } -int cellRescSetConvertAndFlip(vm::ptr cntxt, s32 idx) +int cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr cntxt, s32 idx) { cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.addr(), idx); @@ -1017,7 +1017,7 @@ int cellRescSetConvertAndFlip(vm::ptr cntxt, s32 idx) //TODO: ? - cellGcmSetPrepareFlip(cntxt, idx); + cellGcmSetPrepareFlip(CPU, cntxt, idx); return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp index 33e2b95508..fbb93be9d2 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp @@ -1018,7 +1018,7 @@ s32 cellSyncLFQueueInitialize(vm::ptr queue, vm::ptr buffer return syncLFQueueInitialize(queue, buffer, size, depth, direction, eaSignal); } -s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPushPointer(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU) { @@ -1106,45 +1106,45 @@ s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 } } - if (s32 res = sys_event_queue_receive(GetCurrentPPUThread(), queue->m_eq_id, vm::null, 0)) + if (s32 res = sys_event_queue_receive(CPU, queue->m_eq_id, vm::null, 0)) { - assert(!"sys_event_queue_receive() failed"); + throw __FUNCTION__; } var1 = 1; } } -s32 _cellSyncLFQueueGetPushPointer(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPushPointer(PPUThread& CPU, vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) { cellSync.Warning("_cellSyncLFQueueGetPushPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue); s32 pointer_value; - s32 result = syncLFQueueGetPushPointer(queue, pointer_value, isBlocking, useEventQueue); + s32 result = syncLFQueueGetPushPointer(CPU, queue, pointer_value, isBlocking, useEventQueue); *pointer = pointer_value; return result; } -s32 syncLFQueueGetPushPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPushPointer2(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { throw __FUNCTION__; } -s32 _cellSyncLFQueueGetPushPointer2(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPushPointer2(PPUThread& CPU, vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) { // arguments copied from _cellSyncLFQueueGetPushPointer cellSync.Todo("_cellSyncLFQueueGetPushPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue); s32 pointer_value; - s32 result = syncLFQueueGetPushPointer2(queue, pointer_value, isBlocking, useEventQueue); + s32 result = syncLFQueueGetPushPointer2(CPU,queue, pointer_value, isBlocking, useEventQueue); *pointer = pointer_value; return result; } -s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, std::function fpSendSignal) +s32 syncLFQueueCompletePushPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal) { if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU) { @@ -1260,7 +1260,7 @@ s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, if (exch) { assert(fpSendSignal); - return fpSendSignal((u32)queue->m_eaSignal.addr(), var6); + return fpSendSignal(CPU, (u32)queue->m_eaSignal.addr(), var6); } } else @@ -1278,24 +1278,24 @@ s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, } } -s32 _cellSyncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal) +s32 _cellSyncLFQueueCompletePushPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, vm::ptr fpSendSignal) { cellSync.Warning("_cellSyncLFQueueCompletePushPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal); - return syncLFQueueCompletePushPointer(queue, pointer, fpSendSignal); + return syncLFQueueCompletePushPointer(CPU, queue, pointer, fpSendSignal); } -s32 syncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, std::function fpSendSignal) +s32 syncLFQueueCompletePushPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal) { throw __FUNCTION__; } -s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal) +s32 _cellSyncLFQueueCompletePushPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, vm::ptr fpSendSignal) { // arguments copied from _cellSyncLFQueueCompletePushPointer cellSync.Todo("_cellSyncLFQueueCompletePushPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal); - return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal); + return syncLFQueueCompletePushPointer2(CPU, queue, pointer, fpSendSignal); } s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm::cptr buffer, u32 isBlocking) @@ -1320,11 +1320,11 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm: if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { - res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0); + res = syncLFQueueGetPushPointer(CPU, queue, position, isBlocking, 0); } else { - res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0); + res = syncLFQueueGetPushPointer2(CPU, queue, position, isBlocking, 0); } if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) @@ -1354,17 +1354,17 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr queue, vm: if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { - res = syncLFQueueCompletePushPointer(queue, position, nullptr); + res = syncLFQueueCompletePushPointer(CPU, queue, position, nullptr); } else { - res = syncLFQueueCompletePushPointer2(queue, position, nullptr); + res = syncLFQueueCompletePushPointer2(CPU, queue, position, nullptr); } return res; } -s32 syncLFQueueGetPopPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue) +s32 syncLFQueueGetPopPointer(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue) { if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU) { @@ -1452,45 +1452,45 @@ s32 syncLFQueueGetPopPointer(vm::ptr queue, s32& pointer, u32 i } } - if (s32 res = sys_event_queue_receive(GetCurrentPPUThread(), queue->m_eq_id, vm::null, 0)) + if (s32 res = sys_event_queue_receive(CPU, queue->m_eq_id, vm::null, 0)) { - assert(!"sys_event_queue_receive() failed"); + throw __FUNCTION__; } var1 = 1; } } -s32 _cellSyncLFQueueGetPopPointer(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 arg4, u32 useEventQueue) +s32 _cellSyncLFQueueGetPopPointer(PPUThread& CPU, vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 arg4, u32 useEventQueue) { cellSync.Warning("_cellSyncLFQueueGetPopPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)", queue, pointer, isBlocking, arg4, useEventQueue); s32 pointer_value; - s32 result = syncLFQueueGetPopPointer(queue, pointer_value, isBlocking, arg4, useEventQueue); + s32 result = syncLFQueueGetPopPointer(CPU, queue, pointer_value, isBlocking, arg4, useEventQueue); *pointer = pointer_value; return result; } -s32 syncLFQueueGetPopPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPopPointer2(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { throw __FUNCTION__; } -s32 _cellSyncLFQueueGetPopPointer2(vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPopPointer2(PPUThread& CPU, vm::ptr queue, vm::ptr pointer, u32 isBlocking, u32 useEventQueue) { // arguments copied from _cellSyncLFQueueGetPopPointer cellSync.Todo("_cellSyncLFQueueGetPopPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue); s32 pointer_value; - s32 result = syncLFQueueGetPopPointer2(queue, pointer_value, isBlocking, useEventQueue); + s32 result = syncLFQueueGetPopPointer2(CPU, queue, pointer_value, isBlocking, useEventQueue); *pointer = pointer_value; return result; } -s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull) +s32 syncLFQueueCompletePopPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull) { if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU) { @@ -1605,7 +1605,7 @@ s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, s if (exch) { assert(fpSendSignal); - return fpSendSignal((u32)queue->m_eaSignal.addr(), var6); + return fpSendSignal(CPU, (u32)queue->m_eaSignal.addr(), var6); } } else @@ -1623,25 +1623,25 @@ s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, s } } -s32 _cellSyncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal, u32 noQueueFull) +s32 _cellSyncLFQueueCompletePopPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, vm::ptr fpSendSignal, u32 noQueueFull) { // arguments copied from _cellSyncLFQueueCompletePushPointer + unknown argument (noQueueFull taken from LFQueue2CompletePopPointer) cellSync.Warning("_cellSyncLFQueueCompletePopPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull); - return syncLFQueueCompletePopPointer(queue, pointer, fpSendSignal, noQueueFull); + return syncLFQueueCompletePopPointer(CPU, queue, pointer, fpSendSignal, noQueueFull); } -s32 syncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull) +s32 syncLFQueueCompletePopPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull) { throw __FUNCTION__; } -s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, vm::ptr fpSendSignal, u32 noQueueFull) +s32 _cellSyncLFQueueCompletePopPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, vm::ptr fpSendSignal, u32 noQueueFull) { // arguments copied from _cellSyncLFQueueCompletePopPointer cellSync.Todo("_cellSyncLFQueueCompletePopPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull); - return syncLFQueueCompletePopPointer2(queue, pointer, fpSendSignal, noQueueFull); + return syncLFQueueCompletePopPointer2(CPU, queue, pointer, fpSendSignal, noQueueFull); } s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm::ptr buffer, u32 isBlocking) @@ -1665,11 +1665,11 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm:: s32 res; if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { - res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0); + res = syncLFQueueGetPopPointer(CPU, queue, position, isBlocking, 0, 0); } else { - res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0); + res = syncLFQueueGetPopPointer2(CPU, queue, position, isBlocking, 0); } if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) @@ -1699,11 +1699,11 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr queue, vm:: if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) { - res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0); + res = syncLFQueueCompletePopPointer(CPU, queue, position, nullptr, 0); } else { - res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0); + res = syncLFQueueCompletePopPointer2(CPU, queue, position, nullptr, 0); } return res; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.h b/rpcs3/Emu/SysCalls/Modules/cellSync.h index 0e969416b6..f96ca6a237 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.h @@ -199,13 +199,13 @@ s32 syncRwmInitialize(vm::ptr rwm, vm::ptr buffer, u32 buffer s32 syncQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth); s32 syncLFQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal); -s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); -s32 syncLFQueueGetPushPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); -s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, std::function fpSendSignal); -s32 syncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, std::function fpSendSignal); -s32 syncLFQueueGetPopPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue); -s32 syncLFQueueGetPopPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); -s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull); -s32 syncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull); +s32 syncLFQueueGetPushPointer(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); +s32 syncLFQueueGetPushPointer2(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); +s32 syncLFQueueCompletePushPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal); +s32 syncLFQueueCompletePushPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal); +s32 syncLFQueueGetPopPointer(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue); +s32 syncLFQueueGetPopPointer2(PPUThread& CPU, vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); +s32 syncLFQueueCompletePopPointer(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull); +s32 syncLFQueueCompletePopPointer2(PPUThread& CPU, vm::ptr queue, s32 pointer, std::function fpSendSignal, u32 noQueueFull); s32 syncLFQueueAttachLv2EventQueue(vm::ptr spus, u32 num, vm::ptr queue); s32 syncLFQueueDetachLv2EventQueue(vm::ptr spus, u32 num, vm::ptr queue); diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp index cbbfcec90e..54db810420 100644 --- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp +++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp @@ -148,7 +148,7 @@ int sceNpTrophyCreateHandle(vm::ptr handle) return CELL_OK; } -int sceNpTrophyRegisterContext(u32 context, u32 handle, vm::ptr statusCb, u32 arg_addr, u64 options) +int sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr statusCb, u32 arg_addr, u64 options) { sceNpTrophy.Warning("sceNpTrophyRegisterContext(context=0x%x, handle=0x%x, statusCb_addr=0x%x, arg_addr=0x%x, options=0x%llx)", context, handle, statusCb.addr(), arg_addr, options); @@ -209,8 +209,8 @@ int sceNpTrophyRegisterContext(u32 context, u32 handle, vm::ptr attr) attr->name[0] = '\0'; } -void lwmutex_create(sys_lwmutex_t& lwmutex, bool recursive, u32 protocol, u64 name) -{ - lwmutex.lock_var = { { lwmutex::free, lwmutex::zero } }; - lwmutex.attribute = protocol | (recursive ? SYS_SYNC_RECURSIVE : SYS_SYNC_NOT_RECURSIVE); - lwmutex.recursive_count = 0; - lwmutex.sleep_queue = Emu.GetIdManager().make(protocol, name); -} - s32 _sys_lwmutex_create(vm::ptr lwmutex_id, u32 protocol, vm::ptr control, u32 arg4, u64 name, u32 arg6) { sys_lwmutex.Warning("_sys_lwmutex_create(lwmutex_id=*0x%x, protocol=0x%x, control=*0x%x, arg4=0x%x, name=0x%llx, arg6=0x%x)", lwmutex_id, protocol, control, arg4, name, arg6);