diff --git a/app/src/main/cpp/pcsx2/x86/microVU.cpp b/app/src/main/cpp/pcsx2/x86/microVU.cpp index d36f8c6..60bd7c4 100644 --- a/app/src/main/cpp/pcsx2/x86/microVU.cpp +++ b/app/src/main/cpp/pcsx2/x86/microVU.cpp @@ -47,12 +47,15 @@ void mVUreset(microVU& mVU, bool resetReserve) // xSetPtr(mVU.cache); armSetAsmPtr(mVU.cache, mVU.index ? HostMemoryMap::mVU1recSize : HostMemoryMap::mVU0recSize, nullptr); - + armStartBlock(); + //// mVUdispatcherAB(mVU); mVUdispatcherCD(mVU); mVUGenerateWaitMTVU(mVU); mVUGenerateCopyPipelineState(mVU); mVUGenerateCompareState(mVU); + //// + mVU.prog.x86start = armEndBlock(); mVU.regs().nextBlockCycles = 0; memset(&mVU.prog.lpState, 0, sizeof(mVU.prog.lpState)); @@ -67,7 +70,6 @@ void mVUreset(microVU& mVU, bool resetReserve) // Setup Dynarec Cache Limits for Each Program // mVU.prog.x86start = xGetAlignedCallTarget(); - armAlignAsmPtr(); mVU.prog.x86ptr = mVU.prog.x86start; u32 i, e = (mVU.progSize >> 1); // mVU.progSize / 2 diff --git a/app/src/main/cpp/pcsx2/x86/microVU_Compile.inl b/app/src/main/cpp/pcsx2/x86/microVU_Compile.inl index bcc6e10..eccb591 100644 --- a/app/src/main/cpp/pcsx2/x86/microVU_Compile.inl +++ b/app/src/main/cpp/pcsx2/x86/microVU_Compile.inl @@ -748,7 +748,15 @@ static void mvuPreloadRegisters(microVU& mVU, u32 endCount) void* mVUcompile(microVU& mVU, u32 startPC, uptr pState) { microFlagCycles mFC{}; - u8* thisPtr = armGetCurrentCodePointer(); + + u8* thisPtr; + if(armHasBlock()) { + thisPtr = armGetCurrentCodePointer(); + } else { + armSetAsmPtr(mVU.prog.x86ptr, mVU.prog.x86end - mVU.prog.x86ptr, nullptr); + thisPtr = armStartBlock(); + } + const u32 endCount = (((microRegInfo*)pState)->blockType) ? 1 : (mVU.microMemSize >> 3); // mVU.microMemSize / 8 // First Pass @@ -1075,13 +1083,17 @@ void* mVUcompile(microVU& mVU, u32 startPC, uptr pState) perf_and_return: - if (mVU.regs().start_pc == startPC) - { - if (mVU.index) - Perf::vu1.RegisterPC(thisPtr, static_cast(armGetCurrentCodePointer() - thisPtr), startPC); - else - Perf::vu0.RegisterPC(thisPtr, static_cast(armGetCurrentCodePointer() - thisPtr), startPC); - } + if(armHasBlock()) + { + if (mVU.regs().start_pc == startPC) + { + if (mVU.index) + Perf::vu1.RegisterPC(thisPtr, static_cast(armGetCurrentCodePointer() - thisPtr), startPC); + else + Perf::vu0.RegisterPC(thisPtr, static_cast(armGetCurrentCodePointer() - thisPtr), startPC); + } + mVU.prog.x86ptr = armEndBlock(); + } return thisPtr; } diff --git a/app/src/main/cpp/pcsx2/x86/microVU_Execute.inl b/app/src/main/cpp/pcsx2/x86/microVU_Execute.inl index ff11195..4390cd9 100644 --- a/app/src/main/cpp/pcsx2/x86/microVU_Execute.inl +++ b/app/src/main/cpp/pcsx2/x86/microVU_Execute.inl @@ -22,7 +22,7 @@ static bool mvuNeedsFPCRUpdate(mV) // Generates the code for entering/exit recompiled blocks void mVUdispatcherAB(mV) { - mVU.startFunct = armStartBlock(); + mVU.startFunct = armGetCurrentCodePointer(); { // xScopedStackFrame frame(false, true); armBeginStackFrame(); @@ -125,8 +125,6 @@ void mVUdispatcherAB(mV) // xRET(); armAsm->Ret(); - mVU.prog.x86start = armEndBlock(); - Perf::any.Register(mVU.startFunct, static_cast(mVU.prog.x86start - mVU.startFunct), mVU.index ? "VU1StartFunc" : "VU0StartFunc"); } @@ -134,7 +132,7 @@ void mVUdispatcherAB(mV) // Generates the code for resuming/exit xgkick void mVUdispatcherCD(mV) { - mVU.startFunctXG = armStartBlock(); + mVU.startFunctXG = armGetCurrentCodePointer(); { // xScopedStackFrame frame(false, true); armBeginStackFrame(); @@ -183,77 +181,72 @@ void mVUdispatcherCD(mV) // xRET(); armAsm->Ret(); - mVU.prog.x86start = armEndBlock(); - Perf::any.Register(mVU.startFunctXG, static_cast(mVU.prog.x86start - mVU.startFunctXG), mVU.index ? "VU1StartFuncXG" : "VU0StartFuncXG"); } static void mVUGenerateWaitMTVU(mV) { - mVU.waitMTVU = armStartBlock(); + mVU.waitMTVU = armGetCurrentCodePointer(); -// int i; -// for (i = 0; i < static_cast(iREGCNT_GPR); ++i) -// { -// if (!armIsCallerSaved(i) || i == 4) -// continue; -// -// // T1 often contains the address we're loading when waiting for VU1. -// // T2 isn't used until afterwards, so don't bother saving it. -// if (i == gprT2.GetCode()) -// continue; -// -// armAsm->Push(a64::xzr, a64::XRegister(i)); -// } - //// -// for (i = 0; i < static_cast(iREGCNT_XMM); ++i) -// { -// if (!armIsCallerSavedXmm(i)) -// continue; -// -// armAsm->Push(a64::xzr, a64::DRegister(i)); -// } + int i; + for (i = 0; i < static_cast(iREGCNT_GPR); ++i) + { + if (!armIsCallerSaved(i) || i == 4) + continue; + + // T1 often contains the address we're loading when waiting for VU1. + // T2 isn't used until afterwards, so don't bother saving it. + if (i == gprT2.GetCode()) + continue; + + armAsm->Push(a64::xzr, a64::XRegister(i)); + } + // + for (i = 0; i < static_cast(iREGCNT_XMM); ++i) + { + if (!armIsCallerSavedXmm(i)) + continue; + + armAsm->Push(a64::d31, a64::DRegister(i)); + } //// // xFastCall((void*)mVUwaitMTVU); armAsm->Push(a64::xzr, a64::lr); - armAsm->Ldr(RXVIXLSCRATCH, (uptr)mVUwaitMTVU); - armAsm->Blr(RXVIXLSCRATCH); + armEmitCall((void*)mVUwaitMTVU); armAsm->Pop(a64::lr, a64::xzr); //// -// for (i = static_cast(iREGCNT_XMM - 1); i >= 0; --i) -// { -// if (!armIsCallerSavedXmm(i)) -// continue; -// -// armAsm->Pop(a64::DRegister(i), a64::xzr); -// } - //// -// for (i = static_cast(iREGCNT_GPR - 1); i >= 0; --i) -// { -// if (!armIsCallerSaved(i) || i == 4) -// continue; -// -// if (i == gprT2.GetCode()) -// continue; -// -// armAsm->Pop(a64::XRegister(i), a64::xzr); -// } + for (i = static_cast(iREGCNT_XMM - 1); i >= 0; --i) + { + if (!armIsCallerSavedXmm(i)) + continue; + + armAsm->Pop(a64::DRegister(i), a64::d31); + } + // + for (i = static_cast(iREGCNT_GPR - 1); i >= 0; --i) + { + if (!armIsCallerSaved(i) || i == 4) + continue; + + if (i == gprT2.GetCode()) + continue; + + armAsm->Pop(a64::XRegister(i), a64::xzr); + } // xRET(); armAsm->Ret(); - mVU.prog.x86start = armEndBlock(); - Perf::any.Register(mVU.waitMTVU, static_cast(mVU.prog.x86start - mVU.waitMTVU), mVU.index ? "VU1WaitMTVU" : "VU0WaitMTVU"); } static void mVUGenerateCopyPipelineState(mV) { - mVU.copyPLState = armStartBlock(); + mVU.copyPLState = armGetCurrentCodePointer(); { auto mop_rax = a64::MemOperand(RAX); auto mop_lpState = PTR_MVU(microVU[mVU.index].prog.lpState); @@ -288,8 +281,6 @@ static void mVUGenerateCopyPipelineState(mV) // xRET(); armAsm->Ret(); - mVU.prog.x86start = armEndBlock(); - Perf::any.Register(mVU.copyPLState, static_cast(mVU.prog.x86start - mVU.copyPLState), mVU.index ? "VU1CopyPLState" : "VU0CopyPLState"); } @@ -302,7 +293,7 @@ static void mVUGenerateCopyPipelineState(mV) // Note: Structs must be 16-byte aligned! (GCC doesn't guarantee this) static void mVUGenerateCompareState(mV) { - mVU.compareStateF = armStartBlock(); + mVU.compareStateF = armGetCurrentCodePointer(); { auto mop_arg1reg = a64::MemOperand(RCX); auto mop_arg2reg = a64::MemOperand(RDX); @@ -362,8 +353,6 @@ static void mVUGenerateCompareState(mV) // xRET(); armAsm->Ret(); - - mVU.prog.x86start = armEndBlock(); } @@ -385,8 +374,6 @@ _mVUt void* mVUexecute(u32 startPC, u32 cycles) mVU.totalCycles = cycles; // xSetPtr(mVU.prog.x86ptr); // Set x86ptr to where last program left off - armSetAsmPtr(mVU.prog.x86ptr, vuIndex ? HostMemoryMap::mVU1recSize : HostMemoryMap::mVU0recSize, nullptr); - mVU.prog.x86ptr = armStartBlock(); return mVUsearchProg(startPC & vuLimit, (uptr)&mVU.prog.lpState); // Find and set correct program } @@ -400,7 +387,6 @@ _mVUt void mVUcleanUp() microVU& mVU = mVUx; // mVU.prog.x86ptr = x86Ptr; - mVU.prog.x86ptr = armEndBlock(); if ((mVU.prog.x86ptr < mVU.prog.x86start) || (mVU.prog.x86ptr >= mVU.prog.x86end)) { diff --git a/app/src/main/cpp/pcsx2/x86/microVU_IR.h b/app/src/main/cpp/pcsx2/x86/microVU_IR.h index 4907281..e77c9b3 100644 --- a/app/src/main/cpp/pcsx2/x86/microVU_IR.h +++ b/app/src/main/cpp/pcsx2/x86/microVU_IR.h @@ -520,12 +520,6 @@ public: if (clearState) clearGPR(i); } - - // Wait flush - std::thread t([]() { - std::this_thread::sleep_for(std::chrono::microseconds(2)); - }); - t.detach(); } void flushCallerSavedRegisters(bool clearNeeded = false)