From c41baab7471a0b76123a5dda2f0365e2acba3f02 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Thu, 8 Oct 2015 19:58:37 +0200 Subject: [PATCH 1/4] Pregenerate code to handle rounding mode switches. This time, for all three cores. --- Core/MIPS/ARM/ArmAsm.cpp | 84 +++++++++++++++++++++++++++++++++--- Core/MIPS/ARM/ArmJit.cpp | 66 +++------------------------- Core/MIPS/ARM/ArmJit.h | 6 ++- Core/MIPS/ARM64/Arm64Asm.cpp | 83 +++++++++++++++++++++++++++++++++-- Core/MIPS/ARM64/Arm64Jit.cpp | 71 ++---------------------------- Core/MIPS/ARM64/Arm64Jit.h | 6 ++- Core/MIPS/x86/Asm.cpp | 67 +++++++++++++++++++++++++--- Core/MIPS/x86/Asm.h | 6 ++- Core/MIPS/x86/Jit.cpp | 64 ++++----------------------- Core/MIPS/x86/Jit.h | 2 +- 10 files changed, 255 insertions(+), 200 deletions(-) diff --git a/Core/MIPS/ARM/ArmAsm.cpp b/Core/MIPS/ARM/ArmAsm.cpp index 24accc8cef..73704340e2 100644 --- a/Core/MIPS/ARM/ArmAsm.cpp +++ b/Core/MIPS/ARM/ArmAsm.cpp @@ -31,6 +31,7 @@ using namespace ArmGen; //static int temp32; // unused? static const bool enableDebug = false; +static const bool disasm = false; //static bool enableStatistics = false; //unused? @@ -70,9 +71,78 @@ namespace MIPSComp { using namespace ArmJitConstants; -void ArmJit::GenerateFixedCode() -{ - enterCode = AlignCode16(); +void ArmJit::GenerateFixedCode() { + const u8 *start = GetCodePtr(); + + restoreRoundingMode = AlignCode16(); { + VMRS(SCRATCHREG2); + // Assume we're always in round-to-nearest mode beforehand. Flush-to-zero is off. + BIC(SCRATCHREG2, SCRATCHREG2, AssumeMakeOperand2((3 | 4) << 22)); + VMSR(SCRATCHREG2); + B(R_LR); + } + + applyRoundingMode = AlignCode16(); { + LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); + + TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); + AND(SCRATCHREG2, SCRATCHREG2, Operand2(3)); + SetCC(CC_NEQ); + ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4)); + SetCC(CC_AL); + // We can only skip if the rounding mode is zero and flush is not set. + CMP(SCRATCHREG2, Operand2(3)); + + // At this point, if it was zero, we can skip the rest. + FixupBranch skip = B_CC(CC_EQ); + PUSH(1, SCRATCHREG1); + + // MIPS Rounding Mode: ARM Rounding Mode + // 0: Round nearest 0 + // 1: Round to zero 3 + // 2: Round up (ceil) 1 + // 3: Round down (floor) 2 + AND(SCRATCHREG1, SCRATCHREG2, Operand2(3)); + CMP(SCRATCHREG1, Operand2(1)); + + SetCC(CC_EQ); ADD(SCRATCHREG2, SCRATCHREG2, Operand2(2)); + SetCC(CC_GT); SUB(SCRATCHREG2, SCRATCHREG2, Operand2(1)); + SetCC(CC_AL); + + VMRS(SCRATCHREG1); + // Assume we're always in round-to-nearest mode beforehand. + // But we need to clear flush to zero in this case anyway. + BIC(SCRATCHREG1, SCRATCHREG1, AssumeMakeOperand2((3 | 4) << 22)); + ORR(SCRATCHREG1, SCRATCHREG1, Operand2(SCRATCHREG2, ST_LSL, 22)); + VMSR(SCRATCHREG1); + + POP(1, SCRATCHREG1); + SetJumpTarget(skip); + B(R_LR); + } + + updateRoundingMode = AlignCode16(); { + LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); + + TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); + AND(SCRATCHREG2, SCRATCHREG2, Operand2(3)); + SetCC(CC_NEQ); + ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4)); + SetCC(CC_AL); + // We can only skip if the rounding mode is zero and flush is not set. + CMP(SCRATCHREG2, Operand2(3)); + + FixupBranch skip = B_CC(CC_EQ); + PUSH(1, SCRATCHREG1); + MOVI2R(SCRATCHREG2, 1); + MOVP2R(SCRATCHREG1, &js.hasSetRounding); + STRB(SCRATCHREG2, SCRATCHREG1, 0); + POP(1, SCRATCHREG1); + SetJumpTarget(skip); + B(R_LR); + } + + enterDispatcher = AlignCode16(); DEBUG_LOG(JIT, "Base: %08x", (u32)Memory::base); @@ -203,9 +273,11 @@ void ArmJit::GenerateFixedCode() // Uncomment if you want to see the output... - // INFO_LOG(JIT, "THE DISASM ========================"); - // DisassembleArm(enterCode, GetCodePtr() - enterCode); - // INFO_LOG(JIT, "END OF THE DISASM ========================"); + if (disasm) { + INFO_LOG(JIT, "THE DISASM ========================"); + DisassembleArm(start, GetCodePtr() - start); + INFO_LOG(JIT, "END OF THE DISASM ========================"); + } // Don't forget to zap the instruction cache! FlushLitPool(); diff --git a/Core/MIPS/ARM/ArmJit.cpp b/Core/MIPS/ARM/ArmJit.cpp index d889479e1f..7acd017a47 100644 --- a/Core/MIPS/ARM/ArmJit.cpp +++ b/Core/MIPS/ARM/ArmJit.cpp @@ -234,7 +234,7 @@ void ArmJit::Compile(u32 em_address) { void ArmJit::RunLoopUntil(u64 globalticks) { PROFILE_THIS_SCOPE("jit"); - ((void (*)())enterCode)(); + ((void (*)())enterDispatcher)(); } u32 ArmJit::GetCompilerPC() { @@ -585,77 +585,25 @@ void ArmJit::WriteDownCountR(ARMReg reg) { } } +// Destroys SCRATCHREG2. Does not destroy SCRATCHREG1. void ArmJit::RestoreRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - VMRS(SCRATCHREG2); - // Assume we're always in round-to-nearest mode beforehand. Flush-to-zero is off. - BIC(SCRATCHREG2, SCRATCHREG2, AssumeMakeOperand2((3 | 4) << 22)); - VMSR(SCRATCHREG2); + QuickCallFunction(R1, restoreRoundingMode); } } +// Does not destroy R0 (SCRATCHREG1). Destroys R1 (SCRATCHREG2). void ArmJit::ApplyRoundingMode(bool force) { - // NOTE: Must not destroy R0. // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); - - TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); - AND(SCRATCHREG2, SCRATCHREG2, Operand2(3)); - SetCC(CC_NEQ); - ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4)); - SetCC(CC_AL); - // We can only skip if the rounding mode is zero and flush is not set. - CMP(SCRATCHREG2, Operand2(3)); - - // At this point, if it was zero, we can skip the rest. - FixupBranch skip = B_CC(CC_EQ); - PUSH(1, SCRATCHREG1); - - // MIPS Rounding Mode: ARM Rounding Mode - // 0: Round nearest 0 - // 1: Round to zero 3 - // 2: Round up (ceil) 1 - // 3: Round down (floor) 2 - AND(SCRATCHREG1, SCRATCHREG2, Operand2(3)); - CMP(SCRATCHREG1, Operand2(1)); - - SetCC(CC_EQ); ADD(SCRATCHREG2, SCRATCHREG2, Operand2(2)); - SetCC(CC_GT); SUB(SCRATCHREG2, SCRATCHREG2, Operand2(1)); - SetCC(CC_AL); - - VMRS(SCRATCHREG1); - // Assume we're always in round-to-nearest mode beforehand. - // But we need to clear flush to zero in this case anyway. - BIC(SCRATCHREG1, SCRATCHREG1, AssumeMakeOperand2((3 | 4) << 22)); - ORR(SCRATCHREG1, SCRATCHREG1, Operand2(SCRATCHREG2, ST_LSL, 22)); - VMSR(SCRATCHREG1); - - POP(1, SCRATCHREG1); - SetJumpTarget(skip); + QuickCallFunction(R1, applyRoundingMode); } } +// Does (must!) not destroy R0 (SCRATCHREG1). Destroys R1 (SCRATCHREG2). void ArmJit::UpdateRoundingMode() { - // NOTE: Must not destroy R0. - LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); - - TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); - AND(SCRATCHREG2, SCRATCHREG2, Operand2(3)); - SetCC(CC_NEQ); - ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4)); - SetCC(CC_AL); - // We can only skip if the rounding mode is zero and flush is not set. - CMP(SCRATCHREG2, Operand2(3)); - - FixupBranch skip = B_CC(CC_EQ); - PUSH(1, SCRATCHREG1); - MOVI2R(SCRATCHREG2, 1); - MOVP2R(SCRATCHREG1, &js.hasSetRounding); - STRB(SCRATCHREG2, SCRATCHREG1, 0); - POP(1, SCRATCHREG1); - SetJumpTarget(skip); + QuickCallFunction(R1, updateRoundingMode); } // IDEA - could have a WriteDualExit that takes two destinations and two condition flags, diff --git a/Core/MIPS/ARM/ArmJit.h b/Core/MIPS/ARM/ArmJit.h index baf6ca587a..26859c86ab 100644 --- a/Core/MIPS/ARM/ArmJit.h +++ b/Core/MIPS/ARM/ArmJit.h @@ -287,7 +287,7 @@ private: public: // Code pointers - const u8 *enterCode; + const u8 *enterDispatcher; const u8 *outerLoop; const u8 *outerLoopPCInR0; @@ -296,6 +296,10 @@ public: const u8 *dispatcher; const u8 *dispatcherNoCheck; + const u8 *restoreRoundingMode; + const u8 *applyRoundingMode; + const u8 *updateRoundingMode; + const u8 *breakpointBailout; }; diff --git a/Core/MIPS/ARM64/Arm64Asm.cpp b/Core/MIPS/ARM64/Arm64Asm.cpp index ba59e64fb5..5b8e7aba2c 100644 --- a/Core/MIPS/ARM64/Arm64Asm.cpp +++ b/Core/MIPS/ARM64/Arm64Asm.cpp @@ -94,7 +94,7 @@ namespace MIPSComp { using namespace Arm64JitConstants; void Arm64Jit::GenerateFixedCode(const JitOptions &jo) { - const u8 *start = nullptr; + const u8 *start = AlignCode16(); if (jo.useStaticAlloc) { saveStaticRegisters = AlignCode16(); STR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount)); @@ -112,9 +112,84 @@ void Arm64Jit::GenerateFixedCode(const JitOptions &jo) { loadStaticRegisters = nullptr; } - enterCode = AlignCode16(); - if (!start) - start = enterCode; + restoreRoundingMode = AlignCode16(); { + MRS(SCRATCH2_64, FIELD_FPCR); + // We are not in flush-to-zero mode outside the JIT, so let's turn it off. + uint32_t mask = ~(4 << 22); + // Assume we're always in round-to-nearest mode beforehand. + mask &= ~(3 << 22); + ANDI2R(SCRATCH2, SCRATCH2, mask); + _MSR(FIELD_FPCR, SCRATCH2_64); + RET(); + } + + applyRoundingMode = AlignCode16(); { + LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31)); + TSTI2R(SCRATCH2, 1 << 24); + ANDI2R(SCRATCH2, SCRATCH2, 3); + FixupBranch skip1 = B(CC_EQ); + ADDI2R(SCRATCH2, SCRATCH2, 4); + SetJumpTarget(skip1); + // We can only skip if the rounding mode is zero and flush is set. + CMPI2R(SCRATCH2, 4); + // At this point, if it was zero, we can skip the rest. + FixupBranch skip = B(CC_EQ); + + // MIPS Rounding Mode: ARM Rounding Mode + // 0: Round nearest 0 + // 1: Round to zero 3 + // 2: Round up (ceil) 1 + // 3: Round down (floor) 2 + ANDI2R(SCRATCH1, SCRATCH2, 3); + CMPI2R(SCRATCH1, 1); + + FixupBranch skipadd = B(CC_NEQ); + ADDI2R(SCRATCH2, SCRATCH2, 2); + SetJumpTarget(skipadd); + FixupBranch skipsub = B(CC_LE); + SUBI2R(SCRATCH2, SCRATCH2, 1); + SetJumpTarget(skipsub); + + MRS(SCRATCH1_64, FIELD_FPCR); + + // Clear both flush-to-zero and rounding before re-setting them. + ANDI2R(SCRATCH1, SCRATCH1, ~((4 | 3) << 22)); + + ORR(SCRATCH1, SCRATCH1, SCRATCH2, ArithOption(SCRATCH2, ST_LSL, 22)); + _MSR(FIELD_FPCR, SCRATCH1_64); + + // Let's update js.currentRoundingFunc with the right convertS0ToSCRATCH1 func. + MOVP2R(SCRATCH1_64, convertS0ToSCRATCH1); + // We already index this array including the FZ bit. Easy. + LSL(SCRATCH2, SCRATCH2, 3); + LDR(SCRATCH2_64, SCRATCH1_64, SCRATCH2); + MOVP2R(SCRATCH1_64, &js.currentRoundingFunc); + STR(INDEX_UNSIGNED, SCRATCH2_64, SCRATCH1_64, 0); + + SetJumpTarget(skip); + RET(); + } + + updateRoundingMode = AlignCode16(); { + LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31)); + + TSTI2R(SCRATCH2, 1 << 24); + ANDI2R(SCRATCH2, SCRATCH2, 3); + FixupBranch skip = B(CC_EQ); + ADDI2R(SCRATCH2, SCRATCH2, 4); + SetJumpTarget(skip); + + // We can only skip if the rounding mode is zero and flush is not set. + CMPI2R(SCRATCH2, 3); + + FixupBranch skip2 = B(CC_EQ); + MOVI2R(SCRATCH2, 1); + MOVP2R(SCRATCH1_64, &js.hasSetRounding); + STRB(INDEX_UNSIGNED, SCRATCH2, SCRATCH1_64, 0); + SetJumpTarget(skip2); + } + + enterDispatcher = AlignCode16(); BitSet32 regs_to_save(Arm64Gen::ALL_CALLEE_SAVED); BitSet32 regs_to_save_fp(Arm64Gen::ALL_CALLEE_SAVED_FP); diff --git a/Core/MIPS/ARM64/Arm64Jit.cpp b/Core/MIPS/ARM64/Arm64Jit.cpp index 96b4b51807..b4677c2bae 100644 --- a/Core/MIPS/ARM64/Arm64Jit.cpp +++ b/Core/MIPS/ARM64/Arm64Jit.cpp @@ -220,7 +220,7 @@ void Arm64Jit::Compile(u32 em_address) { void Arm64Jit::RunLoopUntil(u64 globalticks) { PROFILE_THIS_SCOPE("jit"); - ((void (*)())enterCode)(); + ((void (*)())enterDispatcher)(); } u32 Arm64Jit::GetCompilerPC() { @@ -528,13 +528,7 @@ void Arm64Jit::WriteDownCountR(ARM64Reg reg, bool updateFlags) { void Arm64Jit::RestoreRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - MRS(SCRATCH2_64, FIELD_FPCR); - // We are not in flush-to-zero mode outside the JIT, so let's turn it off. - uint32_t mask = ~(4 << 22); - // Assume we're always in round-to-nearest mode beforehand. - mask &= ~(3 << 22); - ANDI2R(SCRATCH2, SCRATCH2, mask); - _MSR(FIELD_FPCR, SCRATCH2_64); + QuickCallFunction(SCRATCH2_64, restoreRoundingMode); } } @@ -542,70 +536,13 @@ void Arm64Jit::RestoreRoundingMode(bool force) { void Arm64Jit::ApplyRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31)); - TSTI2R(SCRATCH2, 1 << 24); - ANDI2R(SCRATCH2, SCRATCH2, 3); - FixupBranch skip1 = B(CC_EQ); - ADDI2R(SCRATCH2, SCRATCH2, 4); - SetJumpTarget(skip1); - // We can only skip if the rounding mode is zero and flush is set. - CMPI2R(SCRATCH2, 4); - // At this point, if it was zero, we can skip the rest. - FixupBranch skip = B(CC_EQ); - - // MIPS Rounding Mode: ARM Rounding Mode - // 0: Round nearest 0 - // 1: Round to zero 3 - // 2: Round up (ceil) 1 - // 3: Round down (floor) 2 - ANDI2R(SCRATCH1, SCRATCH2, 3); - CMPI2R(SCRATCH1, 1); - - FixupBranch skipadd = B(CC_NEQ); - ADDI2R(SCRATCH2, SCRATCH2, 2); - SetJumpTarget(skipadd); - FixupBranch skipsub = B(CC_LE); - SUBI2R(SCRATCH2, SCRATCH2, 1); - SetJumpTarget(skipsub); - - MRS(SCRATCH1_64, FIELD_FPCR); - - // Clear both flush-to-zero and rounding before re-setting them. - ANDI2R(SCRATCH1, SCRATCH1, ~((4 | 3) << 22)); - - ORR(SCRATCH1, SCRATCH1, SCRATCH2, ArithOption(SCRATCH2, ST_LSL, 22)); - _MSR(FIELD_FPCR, SCRATCH1_64); - - // Let's update js.currentRoundingFunc with the right convertS0ToSCRATCH1 func. - MOVP2R(SCRATCH1_64, convertS0ToSCRATCH1); - // We already index this array including the FZ bit. Easy. - LSL(SCRATCH2, SCRATCH2, 3); - LDR(SCRATCH2_64, SCRATCH1_64, SCRATCH2); - MOVP2R(SCRATCH1_64, &js.currentRoundingFunc); - STR(INDEX_UNSIGNED, SCRATCH2_64, SCRATCH1_64, 0); - - SetJumpTarget(skip); + QuickCallFunction(SCRATCH2_64, applyRoundingMode); } } // Destroys SCRATCH1 and SCRATCH2 void Arm64Jit::UpdateRoundingMode() { - LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31)); - - TSTI2R(SCRATCH2, 1 << 24); - ANDI2R(SCRATCH2, SCRATCH2, 3); - FixupBranch skip = B(CC_EQ); - ADDI2R(SCRATCH2, SCRATCH2, 4); - SetJumpTarget(skip); - - // We can only skip if the rounding mode is zero and flush is not set. - CMPI2R(SCRATCH2, 3); - - FixupBranch skip2 = B(CC_EQ); - MOVI2R(SCRATCH2, 1); - MOVP2R(SCRATCH1_64, &js.hasSetRounding); - STRB(INDEX_UNSIGNED, SCRATCH2, SCRATCH1_64, 0); - SetJumpTarget(skip2); + QuickCallFunction(SCRATCH2_64, updateRoundingMode); } // IDEA - could have a WriteDualExit that takes two destinations and two condition flags, diff --git a/Core/MIPS/ARM64/Arm64Jit.h b/Core/MIPS/ARM64/Arm64Jit.h index 0cbecc743c..2877024338 100644 --- a/Core/MIPS/ARM64/Arm64Jit.h +++ b/Core/MIPS/ARM64/Arm64Jit.h @@ -251,7 +251,7 @@ private: public: // Code pointers - const u8 *enterCode; + const u8 *enterDispatcher; const u8 *outerLoop; const u8 *outerLoopPCInSCRATCH1; @@ -265,6 +265,10 @@ public: const u8 *saveStaticRegisters; const u8 *loadStaticRegisters; + const u8 *restoreRoundingMode; + const u8 *applyRoundingMode; + const u8 *updateRoundingMode; + // Indexed by FPCR FZ:RN bits for convenience. Uses SCRATCH2. const u8 *convertS0ToSCRATCH1[8]; }; diff --git a/Core/MIPS/x86/Asm.cpp b/Core/MIPS/x86/Asm.cpp index 8bdc2915a3..2fb8301397 100644 --- a/Core/MIPS/x86/Asm.cpp +++ b/Core/MIPS/x86/Asm.cpp @@ -37,6 +37,7 @@ using namespace X64JitConstants; //TODO - make an option //#if _DEBUG static bool enableDebug = false; + //#else // bool enableDebug = false; //#endif @@ -55,14 +56,70 @@ static bool enableDebug = false; extern volatile CoreState coreState; -void ImHere() -{ +void ImHere() { DEBUG_LOG(CPU, "JIT Here: %08x", currentMIPS->pc); } -void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo) -{ - enterCode = AlignCode16(); +void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo) { + const u8 *start = AlignCode16(); + + restoreRoundingMode = AlignCode16(); { + STMXCSR(M(&mips->temp)); + // Clear the rounding mode and flush-to-zero bits back to 0. + AND(32, M(&mips->temp), Imm32(~(7 << 13))); + LDMXCSR(M(&mips->temp)); + RET(); + } + + applyRoundingMode = AlignCode16(); { + MOV(32, R(EAX), M(&mips->fcr31)); + AND(32, R(EAX), Imm32(0x1000003)); + + // If it's 0, we don't actually bother setting. This is the most common. + // We always use nearest as the default rounding mode with + // flush-to-zero disabled. + FixupBranch skip = J_CC(CC_Z); + + STMXCSR(M(&mips->temp)); + + // The MIPS bits don't correspond exactly, so we have to adjust. + // 0 -> 0 (skip2), 1 -> 3, 2 -> 2 (skip2), 3 -> 1 + TEST(8, R(AL), Imm8(1)); + FixupBranch skip2 = J_CC(CC_Z); + XOR(32, R(EAX), Imm8(2)); + SetJumpTarget(skip2); + + SHL(32, R(EAX), Imm8(13)); + OR(32, M(&mips->temp), R(EAX)); + + TEST(32, M(&mips->fcr31), Imm32(1 << 24)); + FixupBranch skip3 = J_CC(CC_Z); + OR(32, M(&mips->temp), Imm32(1 << 15)); + SetJumpTarget(skip3); + + LDMXCSR(M(&mips->temp)); + SetJumpTarget(skip); + RET(); + } + + updateRoundingMode = AlignCode16(); { + // If it's only ever 0, we don't actually bother applying or restoring it. + // This is the most common situation. + TEST(32, M(&mips->fcr31), Imm32(0x01000003)); + FixupBranch skip = J_CC(CC_Z); +#ifdef _M_X64 + // TODO: Move the hasSetRounding flag somewhere we can reach it through the context pointer, or something. + MOV(64, R(RAX), Imm64((uintptr_t)&jit->js.hasSetRounding)); + MOV(8, MatR(RAX), Imm8(1)); +#else + MOV(8, M(&jit->js.hasSetRounding), Imm8(1)); +#endif + SetJumpTarget(skip); + + RET(); + } + + enterDispatcher = AlignCode16(); ABI_PushAllCalleeSavedRegsAndAdjustStack(); #ifdef _M_X64 // Two statically allocated registers. diff --git a/Core/MIPS/x86/Asm.h b/Core/MIPS/x86/Asm.h index 4b9bb77354..af841b8256 100644 --- a/Core/MIPS/x86/Asm.h +++ b/Core/MIPS/x86/Asm.h @@ -38,7 +38,7 @@ public: WriteProtect(); } - const u8 *enterCode; + const u8 *enterDispatcher; const u8 *outerLoop; const u8 *dispatcher; @@ -47,4 +47,8 @@ public: const u8 *dispatcherInEAXNoCheck; const u8 *breakpointBailout; + + const u8 *restoreRoundingMode; + const u8 *applyRoundingMode; + const u8 *updateRoundingMode; }; diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index c1a0a4ef01..abb7c2a883 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -220,74 +220,28 @@ void Jit::WriteDowncount(int offset) SUB(32, M(&mips_->downcount), downcount > 127 ? Imm32(downcount) : Imm8(downcount)); } -void Jit::RestoreRoundingMode(bool force, XEmitter *emitter) -{ +void Jit::RestoreRoundingMode(bool force, XEmitter *emitter) { // If the game has never set an interesting rounding mode, we can safely skip this. - if (force || js.hasSetRounding) - { + if (force || js.hasSetRounding) { if (emitter == NULL) emitter = this; - emitter->STMXCSR(M(&mips_->temp)); - // Clear the rounding mode and flush-to-zero bits back to 0. - emitter->AND(32, M(&mips_->temp), Imm32(~(7 << 13))); - emitter->LDMXCSR(M(&mips_->temp)); + emitter->CALL(asm_.restoreRoundingMode); } } -void Jit::ApplyRoundingMode(bool force, XEmitter *emitter) -{ +void Jit::ApplyRoundingMode(bool force, XEmitter *emitter) { // If the game has never set an interesting rounding mode, we can safely skip this. - if (force || js.hasSetRounding) - { + if (force || js.hasSetRounding) { if (emitter == NULL) emitter = this; - emitter->MOV(32, R(EAX), M(&mips_->fcr31)); - emitter->AND(32, R(EAX), Imm32(0x1000003)); - - // If it's 0, we don't actually bother setting. This is the most common. - // We always use nearest as the default rounding mode with - // flush-to-zero disabled. - FixupBranch skip = emitter->J_CC(CC_Z); - - emitter->STMXCSR(M(&mips_->temp)); - - // The MIPS bits don't correspond exactly, so we have to adjust. - // 0 -> 0 (skip2), 1 -> 3, 2 -> 2 (skip2), 3 -> 1 - emitter->TEST(8, R(AL), Imm8(1)); - FixupBranch skip2 = emitter->J_CC(CC_Z); - emitter->XOR(32, R(EAX), Imm8(2)); - emitter->SetJumpTarget(skip2); - - emitter->SHL(32, R(EAX), Imm8(13)); - emitter->OR(32, M(&mips_->temp), R(EAX)); - - emitter->TEST(32, M(&mips_->fcr31), Imm32(1 << 24)); - FixupBranch skip3 = emitter->J_CC(CC_Z); - emitter->OR(32, M(&mips_->temp), Imm32(1 << 15)); - emitter->SetJumpTarget(skip3); - - emitter->LDMXCSR(M(&mips_->temp)); - emitter->SetJumpTarget(skip); + emitter->CALL(asm_.applyRoundingMode); } } -void Jit::UpdateRoundingMode(XEmitter *emitter) -{ +void Jit::UpdateRoundingMode(XEmitter *emitter) { if (emitter == NULL) emitter = this; - - // If it's only ever 0, we don't actually bother applying or restoring it. - // This is the most common situation. - emitter->TEST(32, M(&mips_->fcr31), Imm32(0x01000003)); - FixupBranch skip = emitter->J_CC(CC_Z); -#ifdef _M_X64 - // TODO: Move the hasSetRounding flag somewhere we can reach it through the context pointer, or something. - emitter->MOV(64, R(RAX), Imm64((uintptr_t)&js.hasSetRounding)); - emitter->MOV(8, MatR(RAX), Imm8(1)); -#else - emitter->MOV(8, M(&js.hasSetRounding), Imm8(1)); -#endif - emitter->SetJumpTarget(skip); + emitter->CALL(asm_.updateRoundingMode); } void Jit::ClearCache() @@ -383,7 +337,7 @@ void Jit::Compile(u32 em_address) void Jit::RunLoopUntil(u64 globalticks) { PROFILE_THIS_SCOPE("jit"); - ((void (*)())asm_.enterCode)(); + ((void (*)())asm_.enterDispatcher)(); } u32 Jit::GetCompilerPC() { diff --git a/Core/MIPS/x86/Jit.h b/Core/MIPS/x86/Jit.h index 9f0fc27148..703be6e341 100644 --- a/Core/MIPS/x86/Jit.h +++ b/Core/MIPS/x86/Jit.h @@ -140,7 +140,6 @@ public: void Comp_DoNothing(MIPSOpcode op); int Replace_fabsf(); - int Replace_dl_write_matrix(); void ApplyPrefixST(u8 *vregs, u32 prefix, VectorSize sz); void ApplyPrefixD(const u8 *vregs, VectorSize sz); @@ -304,6 +303,7 @@ private: friend class JitSafeMem; friend class JitSafeMemFuncs; + friend class AsmRoutineManager; }; } // namespace MIPSComp From 7fee5abf9fae3d070a729e06ca2874c258e14b3c Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Thu, 8 Oct 2015 22:15:28 +0200 Subject: [PATCH 2/4] x86/x64: Don't use a separate code block for pregenerated functions, just like on ARM --- CMakeLists.txt | 1 - Core/Core.vcxproj | 1 - Core/Core.vcxproj.filters | 3 -- Core/MIPS/JitCommon/JitBlockCache.cpp | 3 +- Core/MIPS/JitCommon/JitCommon.cpp | 5 +- Core/MIPS/x86/Asm.cpp | 67 ++++++++++++++------------- Core/MIPS/x86/Asm.h | 54 --------------------- Core/MIPS/x86/Jit.cpp | 55 ++++++++++------------ Core/MIPS/x86/Jit.h | 30 +++++++++--- Core/MIPS/x86/RegCache.cpp | 1 - 10 files changed, 84 insertions(+), 136 deletions(-) delete mode 100644 Core/MIPS/x86/Asm.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2b7c3a2d73..cb370df423 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1091,7 +1091,6 @@ elseif(ARM64) elseif(X86) set(CoreExtra ${CoreExtra} Core/MIPS/x86/Asm.cpp - Core/MIPS/x86/Asm.h Core/MIPS/x86/CompALU.cpp Core/MIPS/x86/CompBranch.cpp Core/MIPS/x86/CompFPU.cpp diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj index d84ff688e7..6358eb313a 100644 --- a/Core/Core.vcxproj +++ b/Core/Core.vcxproj @@ -679,7 +679,6 @@ true true - diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters index c004922624..0752ffdb08 100644 --- a/Core/Core.vcxproj.filters +++ b/Core/Core.vcxproj.filters @@ -666,9 +666,6 @@ MIPS\x86 - - MIPS\x86 - MIPS\x86 diff --git a/Core/MIPS/JitCommon/JitBlockCache.cpp b/Core/MIPS/JitCommon/JitBlockCache.cpp index 2e49d4834b..9fa6ceb040 100644 --- a/Core/MIPS/JitCommon/JitBlockCache.cpp +++ b/Core/MIPS/JitCommon/JitBlockCache.cpp @@ -46,7 +46,6 @@ #if defined(_M_IX86) || defined(_M_X64) #include "Common/x64Analyzer.h" -#include "Core/MIPS/x86/Asm.h" #endif // #include "JitBase.h" @@ -593,7 +592,7 @@ void JitBlockCache::DestroyBlock(int block_num, bool invalidate) { // Spurious entrances from previously linked blocks can only come through checkedEntry XEmitter emit((u8 *)b->checkedEntry); emit.MOV(32, M(&mips_->pc), Imm32(b->originalAddress)); - emit.JMP(MIPSComp::jit->Asm().dispatcher, true); + emit.JMP(MIPSComp::jit->GetDispatcher(), true); #elif defined(ARM64) diff --git a/Core/MIPS/JitCommon/JitCommon.cpp b/Core/MIPS/JitCommon/JitCommon.cpp index d96a69ce65..0591f5b286 100644 --- a/Core/MIPS/JitCommon/JitCommon.cpp +++ b/Core/MIPS/JitCommon/JitCommon.cpp @@ -154,15 +154,12 @@ const char *ppsspp_resolver(struct ud*, *offset = addr - (uint64_t)(¤tMIPS->v[0]); return "mips.v"; } + // But these do. if (MIPSComp::jit->IsInSpace((u8 *)(intptr_t)addr)) { *offset = addr - (uint64_t)MIPSComp::jit->GetBasePtr(); return "jitcode"; } - if (MIPSComp::jit->Asm().IsInSpace((u8 *)(intptr_t)addr)) { - *offset = addr - (uint64_t)MIPSComp::jit->Asm().GetBasePtr(); - return "dispatcher"; - } return NULL; } diff --git a/Core/MIPS/x86/Asm.cpp b/Core/MIPS/x86/Asm.cpp index 2fb8301397..253a3c2a3d 100644 --- a/Core/MIPS/x86/Asm.cpp +++ b/Core/MIPS/x86/Asm.cpp @@ -28,12 +28,16 @@ #include "Common/MemoryUtil.h" #include "Core/MIPS/JitCommon/JitCommon.h" -#include "Core/MIPS/x86/Asm.h" #include "Core/MIPS/x86/Jit.h" using namespace Gen; using namespace X64JitConstants; +extern volatile CoreState coreState; + +namespace MIPSComp +{ + //TODO - make an option //#if _DEBUG static bool enableDebug = false; @@ -54,25 +58,23 @@ static bool enableDebug = false; //R14 - Pointer to fpr/gpr regs //R15 - Pointer to array of block pointers -extern volatile CoreState coreState; - void ImHere() { DEBUG_LOG(CPU, "JIT Here: %08x", currentMIPS->pc); } -void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo) { +void Jit::GenerateFixedCode(JitOptions &jo) { const u8 *start = AlignCode16(); restoreRoundingMode = AlignCode16(); { - STMXCSR(M(&mips->temp)); + STMXCSR(M(&mips_->temp)); // Clear the rounding mode and flush-to-zero bits back to 0. - AND(32, M(&mips->temp), Imm32(~(7 << 13))); - LDMXCSR(M(&mips->temp)); + AND(32, M(&mips_->temp), Imm32(~(7 << 13))); + LDMXCSR(M(&mips_->temp)); RET(); } applyRoundingMode = AlignCode16(); { - MOV(32, R(EAX), M(&mips->fcr31)); + MOV(32, R(EAX), M(&mips_->fcr31)); AND(32, R(EAX), Imm32(0x1000003)); // If it's 0, we don't actually bother setting. This is the most common. @@ -80,7 +82,7 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: // flush-to-zero disabled. FixupBranch skip = J_CC(CC_Z); - STMXCSR(M(&mips->temp)); + STMXCSR(M(&mips_->temp)); // The MIPS bits don't correspond exactly, so we have to adjust. // 0 -> 0 (skip2), 1 -> 3, 2 -> 2 (skip2), 3 -> 1 @@ -90,14 +92,14 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: SetJumpTarget(skip2); SHL(32, R(EAX), Imm8(13)); - OR(32, M(&mips->temp), R(EAX)); + OR(32, M(&mips_->temp), R(EAX)); - TEST(32, M(&mips->fcr31), Imm32(1 << 24)); + TEST(32, M(&mips_->fcr31), Imm32(1 << 24)); FixupBranch skip3 = J_CC(CC_Z); - OR(32, M(&mips->temp), Imm32(1 << 15)); + OR(32, M(&mips_->temp), Imm32(1 << 15)); SetJumpTarget(skip3); - LDMXCSR(M(&mips->temp)); + LDMXCSR(M(&mips_->temp)); SetJumpTarget(skip); RET(); } @@ -105,14 +107,14 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: updateRoundingMode = AlignCode16(); { // If it's only ever 0, we don't actually bother applying or restoring it. // This is the most common situation. - TEST(32, M(&mips->fcr31), Imm32(0x01000003)); + TEST(32, M(&mips_->fcr31), Imm32(0x01000003)); FixupBranch skip = J_CC(CC_Z); #ifdef _M_X64 // TODO: Move the hasSetRounding flag somewhere we can reach it through the context pointer, or something. - MOV(64, R(RAX), Imm64((uintptr_t)&jit->js.hasSetRounding)); + MOV(64, R(RAX), Imm64((uintptr_t)&js.hasSetRounding)); MOV(8, MatR(RAX), Imm8(1)); #else - MOV(8, M(&jit->js.hasSetRounding), Imm8(1)); + MOV(8, M(&js.hasSetRounding), Imm8(1)); #endif SetJumpTarget(skip); @@ -124,20 +126,19 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: #ifdef _M_X64 // Two statically allocated registers. MOV(64, R(MEMBASEREG), ImmPtr(Memory::base)); - uintptr_t jitbase = (uintptr_t)jit->GetBasePtr(); - if (jitbase > 0x7FFFFFFFULL) - { - MOV(64, R(JITBASEREG), ImmPtr(jit->GetBasePtr())); - jo->reserveR15ForAsm = true; + uintptr_t jitbase = (uintptr_t)GetBasePtr(); + if (jitbase > 0x7FFFFFFFULL) { + MOV(64, R(JITBASEREG), ImmPtr(GetBasePtr())); + jo.reserveR15ForAsm = true; } #endif // From the start of the FP reg, a single byte offset can reach all GPR + all FPR (but no VFPUR) - MOV(PTRBITS, R(CTXREG), ImmPtr(&mips->f[0])); + MOV(PTRBITS, R(CTXREG), ImmPtr(&mips_->f[0])); outerLoop = GetCodePtr(); - jit->RestoreRoundingMode(true, this); + RestoreRoundingMode(true); ABI_CallFunction(reinterpret_cast(&CoreTiming::Advance)); - jit->ApplyRoundingMode(true, this); + ApplyRoundingMode(true); FixupBranch skipToRealDispatch = J(); //skip the sync and compare first time dispatcherCheckCoreState = GetCodePtr(); @@ -161,7 +162,7 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: dispatcherNoCheck = GetCodePtr(); - MOV(32, R(EAX), M(&mips->pc)); + MOV(32, R(EAX), M(&mips_->pc)); dispatcherInEAXNoCheck = GetCodePtr(); #ifdef _M_IX86 @@ -178,14 +179,14 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: FixupBranch notfound = J_CC(CC_NE); if (enableDebug) { - ADD(32, M(&mips->debugCount), Imm8(1)); + ADD(32, M(&mips_->debugCount), Imm8(1)); } //grab from list and jump to it AND(32, R(EAX), Imm32(MIPS_EMUHACK_VALUE_MASK)); #ifdef _M_IX86 - ADD(32, R(EAX), ImmPtr(jit->GetBasePtr())); + ADD(32, R(EAX), ImmPtr(GetBasePtr())); #elif _M_X64 - if (jo->reserveR15ForAsm) + if (jo.reserveR15ForAsm) ADD(64, R(RAX), R(JITBASEREG)); else ADD(64, R(EAX), Imm32(jitbase)); @@ -194,9 +195,9 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: SetJumpTarget(notfound); //Ok, no block, let's jit - jit->RestoreRoundingMode(true, this); + RestoreRoundingMode(true); ABI_CallFunction(&MIPSComp::JitAt); - jit->ApplyRoundingMode(true, this); + ApplyRoundingMode(true); JMP(dispatcherNoCheck, true); // Let's just dispatch again, we'll enter the block since we know it's there. SetJumpTarget(bail); @@ -206,12 +207,14 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp:: J_CC(CC_Z, outerLoop, true); SetJumpTarget(badCoreState); - jit->RestoreRoundingMode(true, this); + RestoreRoundingMode(true); ABI_PopAllCalleeSavedRegsAndAdjustStack(); RET(); breakpointBailout = GetCodePtr(); - jit->RestoreRoundingMode(true, this); + RestoreRoundingMode(true); ABI_PopAllCalleeSavedRegsAndAdjustStack(); RET(); } + +} // namespace \ No newline at end of file diff --git a/Core/MIPS/x86/Asm.h b/Core/MIPS/x86/Asm.h deleted file mode 100644 index af841b8256..0000000000 --- a/Core/MIPS/x86/Asm.h +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (C) 2003 Dolphin Project. - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, version 2.0 or later versions. - -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License 2.0 for more details. - -// A copy of the GPL 2.0 should have been included with the program. -// If not, see http://www.gnu.org/licenses/ - -// Official SVN repository and contact information can be found at -// http://code.google.com/p/dolphin-emu/ - -#pragma once - -#include "Common/x64Emitter.h" -#include "Core/MIPS/MIPS.h" - -// Runtime generated assembly routines, like the Dispatcher. - -namespace MIPSComp { - class Jit; - struct JitOptions; -} - -class AsmRoutineManager : public Gen::XCodeBlock { -private: - void Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo); - -public: - void Init(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo) { - AllocCodeSpace(8192); - Generate(mips, jit, jo); - WriteProtect(); - } - - const u8 *enterDispatcher; - - const u8 *outerLoop; - const u8 *dispatcher; - const u8 *dispatcherCheckCoreState; - const u8 *dispatcherNoCheck; - const u8 *dispatcherInEAXNoCheck; - - const u8 *breakpointBailout; - - const u8 *restoreRoundingMode; - const u8 *applyRoundingMode; - const u8 *updateRoundingMode; -}; diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index abb7c2a883..7f14c537af 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -119,13 +119,13 @@ static void JitLogMiss(MIPSOpcode op) // JitBlockCache doesn't use this, just stores it. #pragma warning(disable:4355) #endif -Jit::Jit(MIPSState *mips) : blocks(mips, this), mips_(mips) -{ +Jit::Jit(MIPSState *mips) + : blocks(mips, this), mips_(mips) { blocks.Init(); gpr.SetEmitter(this); fpr.SetEmitter(this); AllocCodeSpace(1024 * 1024 * 16); - asm_.Init(mips, this, &jo); + GenerateFixedCode(jo); safeMemFuncs.Init(&thunks); js.startDefaultPrefix = mips_->HasDefaultPrefix(); @@ -220,34 +220,29 @@ void Jit::WriteDowncount(int offset) SUB(32, M(&mips_->downcount), downcount > 127 ? Imm32(downcount) : Imm8(downcount)); } -void Jit::RestoreRoundingMode(bool force, XEmitter *emitter) { +void Jit::RestoreRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - if (emitter == NULL) - emitter = this; - emitter->CALL(asm_.restoreRoundingMode); + CALL(restoreRoundingMode); } } -void Jit::ApplyRoundingMode(bool force, XEmitter *emitter) { +void Jit::ApplyRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { - if (emitter == NULL) - emitter = this; - emitter->CALL(asm_.applyRoundingMode); + CALL(applyRoundingMode); } } -void Jit::UpdateRoundingMode(XEmitter *emitter) { - if (emitter == NULL) - emitter = this; - emitter->CALL(asm_.updateRoundingMode); +void Jit::UpdateRoundingMode() { + CALL(updateRoundingMode); } void Jit::ClearCache() { blocks.Clear(); ClearCodeSpace(); + GenerateFixedCode(jo); } void Jit::InvalidateCache() @@ -337,7 +332,7 @@ void Jit::Compile(u32 em_address) void Jit::RunLoopUntil(u64 globalticks) { PROFILE_THIS_SCOPE("jit"); - ((void (*)())asm_.enterDispatcher)(); + ((void (*)())enterDispatcher)(); } u32 Jit::GetCompilerPC() { @@ -367,7 +362,7 @@ const u8 *Jit::DoJit(u32 em_address, JitBlock *b) // Downcount flag check. The last block decremented downcounter, and the flag should still be available. FixupBranch skip = J_CC(CC_NS); MOV(32, M(&mips_->pc), Imm32(js.blockStart)); - JMP(asm_.outerLoop, true); // downcount hit zero - go advance. + JMP(outerLoop, true); // downcount hit zero - go advance. SetJumpTarget(skip); b->normalEntry = GetCodePtr(); @@ -445,15 +440,13 @@ void Jit::AddContinuedBlock(u32 dest) js.lastContinuedPC = dest; } -bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) -{ +bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) { u32 jitAddr = blocks.GetAddressFromBlockPtr(ptr); // Returns 0 when it's valid, but unknown. if (jitAddr == 0) name = "UnknownOrDeletedBlock"; - else if (jitAddr != (u32)-1) - { + else if (jitAddr != (u32)-1) { char temp[1024]; const std::string label = symbolMap.GetDescription(jitAddr); if (!label.empty()) @@ -462,7 +455,7 @@ bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) snprintf(temp, sizeof(temp), "%08x", jitAddr); name = temp; } - else if (asm_.IsInSpace(ptr)) + else if (IsInSpace(ptr)) name = "RunLoopUntil"; else if (thunks.IsInSpace(ptr)) name = "Thunk"; @@ -660,7 +653,7 @@ void Jit::WriteExit(u32 destination, int exit_num) } else { // No blocklinking. MOV(32, M(&mips_->pc), Imm32(destination)); - JMP(asm_.dispatcher, true); + JMP(dispatcher, true); // Normally, exits are 15 bytes (MOV + &pc + dest + JMP + dest) on 64 or 32 bit. // But just in case we somehow optimized, pad. @@ -699,8 +692,8 @@ void Jit::WriteExitDestInReg(X64Reg reg) // Need to set neg flag again. SUB(32, M(&mips_->downcount), Imm8(0)); if (reg == EAX) - J_CC(CC_NS, asm_.dispatcherInEAXNoCheck, true); - JMP(asm_.dispatcher, true); + J_CC(CC_NS, dispatcherInEAXNoCheck, true); + JMP(dispatcher, true); SetJumpTarget(tooLow); SetJumpTarget(tooHigh); @@ -717,15 +710,15 @@ void Jit::WriteExitDestInReg(X64Reg reg) } SUB(32, M(&mips_->downcount), Imm8(0)); - JMP(asm_.dispatcherCheckCoreState, true); + JMP(dispatcherCheckCoreState, true); } else if (reg == EAX) { - J_CC(CC_NS, asm_.dispatcherInEAXNoCheck, true); - JMP(asm_.dispatcher, true); + J_CC(CC_NS, dispatcherInEAXNoCheck, true); + JMP(dispatcher, true); } else - JMP(asm_.dispatcher, true); + JMP(dispatcher, true); } void Jit::WriteSyscallExit() @@ -736,7 +729,7 @@ void Jit::WriteSyscallExit() ABI_CallFunction(&JitMemCheckCleanup); ApplyRoundingMode(); } - JMP(asm_.dispatcherCheckCoreState, true); + JMP(dispatcherCheckCoreState, true); } bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset) @@ -756,7 +749,7 @@ bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset) ApplyRoundingMode(); // Just to fix the stack. LOAD_FLAGS; - JMP(asm_.dispatcherCheckCoreState, true); + JMP(dispatcherCheckCoreState, true); SetJumpTarget(skip); ApplyRoundingMode(); diff --git a/Core/MIPS/x86/Jit.h b/Core/MIPS/x86/Jit.h index 703be6e341..d5650d19b9 100644 --- a/Core/MIPS/x86/Jit.h +++ b/Core/MIPS/x86/Jit.h @@ -20,7 +20,6 @@ #include "Common/CommonTypes.h" #include "Common/Thunk.h" #include "Common/x64Emitter.h" -#include "Core/MIPS/x86/Asm.h" #if defined(ARM) #error DO NOT BUILD X86 JIT ON ARM @@ -156,12 +155,11 @@ public: void GetVectorRegsPrefixD(u8 *regs, VectorSize sz, int vectorReg); void EatPrefix() { js.EatPrefix(); } - void RestoreRoundingMode(bool force = false, XEmitter *emitter = NULL); - void ApplyRoundingMode(bool force = false, XEmitter *emitter = NULL); - void UpdateRoundingMode(XEmitter *emitter = NULL); + void RestoreRoundingMode(bool force = false); + void ApplyRoundingMode(bool force = false); + void UpdateRoundingMode(); JitBlockCache *GetBlockCache() { return &blocks; } - AsmRoutineManager &Asm() { return asm_; } void ClearCache(); void InvalidateCache(); @@ -171,7 +169,12 @@ public: } } + const u8 *GetDispatcher() const { + return dispatcher; + } + private: + void GenerateFixedCode(JitOptions &jo); void GetStateAndFlushAll(RegCacheState &state); void RestoreState(const RegCacheState& state); void FlushAll(); @@ -295,15 +298,28 @@ private: GPRRegCache gpr; FPURegCache fpr; - AsmRoutineManager asm_; ThunkManager thunks; JitSafeMemFuncs safeMemFuncs; MIPSState *mips_; + + const u8 *enterDispatcher; + + const u8 *outerLoop; + const u8 *dispatcher; + const u8 *dispatcherCheckCoreState; + const u8 *dispatcherNoCheck; + const u8 *dispatcherInEAXNoCheck; + + const u8 *breakpointBailout; + + const u8 *restoreRoundingMode; + const u8 *applyRoundingMode; + const u8 *updateRoundingMode; + friend class JitSafeMem; friend class JitSafeMemFuncs; - friend class AsmRoutineManager; }; } // namespace MIPSComp diff --git a/Core/MIPS/x86/RegCache.cpp b/Core/MIPS/x86/RegCache.cpp index d93df0b8fd..5a48b290f2 100644 --- a/Core/MIPS/x86/RegCache.cpp +++ b/Core/MIPS/x86/RegCache.cpp @@ -23,7 +23,6 @@ #include "Core/MIPS/MIPSTables.h" #include "Core/MIPS/MIPSAnalyst.h" #include "Core/MIPS/x86/Jit.h" -#include "Core/MIPS/x86/Asm.h" #include "Core/MIPS/x86/RegCache.h" using namespace Gen; From b2b5f3424feb952c8f61fbf6cb29b8258526fdb0 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Thu, 8 Oct 2015 23:11:57 +0200 Subject: [PATCH 3/4] Fix for 32-bit ARM --- Core/MIPS/ARM/ArmAsm.cpp | 22 ++++++++++++++-------- Core/MIPS/ARM/ArmJit.cpp | 4 ++-- Core/MIPS/ARM64/Arm64Asm.cpp | 2 +- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/Core/MIPS/ARM/ArmAsm.cpp b/Core/MIPS/ARM/ArmAsm.cpp index 73704340e2..43340ebe98 100644 --- a/Core/MIPS/ARM/ArmAsm.cpp +++ b/Core/MIPS/ARM/ArmAsm.cpp @@ -74,15 +74,21 @@ using namespace ArmJitConstants; void ArmJit::GenerateFixedCode() { const u8 *start = GetCodePtr(); + // LR == SCRATCHREG2.... Maybe we could find some other register to use to avoid having to + // push LR? + restoreRoundingMode = AlignCode16(); { + PUSH(1, R_LR); VMRS(SCRATCHREG2); // Assume we're always in round-to-nearest mode beforehand. Flush-to-zero is off. BIC(SCRATCHREG2, SCRATCHREG2, AssumeMakeOperand2((3 | 4) << 22)); VMSR(SCRATCHREG2); - B(R_LR); + POP(1, R_PC); } + // Must preserve SCRATCHREG1 (R0) applyRoundingMode = AlignCode16(); { + PUSH(2, SCRATCHREG1, R_LR); LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); @@ -93,9 +99,8 @@ void ArmJit::GenerateFixedCode() { // We can only skip if the rounding mode is zero and flush is not set. CMP(SCRATCHREG2, Operand2(3)); - // At this point, if it was zero, we can skip the rest. + // At this point, if it was zero, we can skip the rest. (could even return) FixupBranch skip = B_CC(CC_EQ); - PUSH(1, SCRATCHREG1); // MIPS Rounding Mode: ARM Rounding Mode // 0: Round nearest 0 @@ -116,12 +121,13 @@ void ArmJit::GenerateFixedCode() { ORR(SCRATCHREG1, SCRATCHREG1, Operand2(SCRATCHREG2, ST_LSL, 22)); VMSR(SCRATCHREG1); - POP(1, SCRATCHREG1); SetJumpTarget(skip); - B(R_LR); + POP(2, SCRATCHREG1, R_PC); } + // Must preserve SCRATCHREG1 (R0) updateRoundingMode = AlignCode16(); { + PUSH(2, SCRATCHREG1, R_LR); LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24)); @@ -133,15 +139,15 @@ void ArmJit::GenerateFixedCode() { CMP(SCRATCHREG2, Operand2(3)); FixupBranch skip = B_CC(CC_EQ); - PUSH(1, SCRATCHREG1); MOVI2R(SCRATCHREG2, 1); MOVP2R(SCRATCHREG1, &js.hasSetRounding); STRB(SCRATCHREG2, SCRATCHREG1, 0); - POP(1, SCRATCHREG1); SetJumpTarget(skip); - B(R_LR); + POP(2, SCRATCHREG1, R_PC); } + FlushLitPool(); + enterDispatcher = AlignCode16(); DEBUG_LOG(JIT, "Base: %08x", (u32)Memory::base); diff --git a/Core/MIPS/ARM/ArmJit.cpp b/Core/MIPS/ARM/ArmJit.cpp index 7acd017a47..19eae73884 100644 --- a/Core/MIPS/ARM/ArmJit.cpp +++ b/Core/MIPS/ARM/ArmJit.cpp @@ -593,7 +593,7 @@ void ArmJit::RestoreRoundingMode(bool force) { } } -// Does not destroy R0 (SCRATCHREG1). Destroys R1 (SCRATCHREG2). +// Does not destroy R0 (SCRATCHREG1). Destroys R14 (SCRATCHREG2). void ArmJit::ApplyRoundingMode(bool force) { // If the game has never set an interesting rounding mode, we can safely skip this. if (force || js.hasSetRounding) { @@ -601,7 +601,7 @@ void ArmJit::ApplyRoundingMode(bool force) { } } -// Does (must!) not destroy R0 (SCRATCHREG1). Destroys R1 (SCRATCHREG2). +// Does (must!) not destroy R0 (SCRATCHREG1). Destroys R14 (SCRATCHREG2). void ArmJit::UpdateRoundingMode() { QuickCallFunction(R1, updateRoundingMode); } diff --git a/Core/MIPS/ARM64/Arm64Asm.cpp b/Core/MIPS/ARM64/Arm64Asm.cpp index 5b8e7aba2c..8eb5d8e50a 100644 --- a/Core/MIPS/ARM64/Arm64Asm.cpp +++ b/Core/MIPS/ARM64/Arm64Asm.cpp @@ -251,7 +251,7 @@ void Arm64Jit::GenerateFixedCode(const JitOptions &jo) { LDR(INDEX_UNSIGNED, SCRATCH1, CTXREG, offsetof(MIPSState, pc)); LDR(SCRATCH1, MEMBASEREG, SCRATCH1_64); - LSR(SCRATCH2, SCRATCH1, 24); + LSR(SCRATCH2, SCRATCH1, 24); // or UBFX(SCRATCH2, SCRATCH1, 24, 8) ANDI2R(SCRATCH1, SCRATCH1, 0x00FFFFFF); CMP(SCRATCH2, MIPS_EMUHACK_OPCODE >> 24); FixupBranch skipJump = B(CC_NEQ); From d628b9b57baec29b22fc693481eef728033b57eb Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Sat, 10 Oct 2015 10:03:34 +0200 Subject: [PATCH 4/4] Minor fixes, mostly comments --- Core/MIPS/ARM/ArmAsm.cpp | 8 +++----- Core/MIPS/ARM/ArmJit.cpp | 2 +- Core/MIPS/ARM64/Arm64Jit.cpp | 2 +- Core/MIPS/x86/Asm.cpp | 2 ++ Core/MIPS/x86/Jit.cpp | 24 +++++++++++++----------- Core/MIPS/x86/Jit.h | 2 ++ 6 files changed, 22 insertions(+), 18 deletions(-) diff --git a/Core/MIPS/ARM/ArmAsm.cpp b/Core/MIPS/ARM/ArmAsm.cpp index 43340ebe98..5d29ca771b 100644 --- a/Core/MIPS/ARM/ArmAsm.cpp +++ b/Core/MIPS/ARM/ArmAsm.cpp @@ -74,9 +74,7 @@ using namespace ArmJitConstants; void ArmJit::GenerateFixedCode() { const u8 *start = GetCodePtr(); - // LR == SCRATCHREG2.... Maybe we could find some other register to use to avoid having to - // push LR? - + // LR == SCRATCHREG2 on ARM32 so it needs to be pushed. restoreRoundingMode = AlignCode16(); { PUSH(1, R_LR); VMRS(SCRATCHREG2); @@ -86,7 +84,7 @@ void ArmJit::GenerateFixedCode() { POP(1, R_PC); } - // Must preserve SCRATCHREG1 (R0) + // Must preserve SCRATCHREG1 (R0), destroys SCRATCHREG2 (LR) applyRoundingMode = AlignCode16(); { PUSH(2, SCRATCHREG1, R_LR); LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); @@ -125,7 +123,7 @@ void ArmJit::GenerateFixedCode() { POP(2, SCRATCHREG1, R_PC); } - // Must preserve SCRATCHREG1 (R0) + // Must preserve SCRATCHREG1 (R0), destroys SCRATCHREG2 (LR) updateRoundingMode = AlignCode16(); { PUSH(2, SCRATCHREG1, R_LR); LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31)); diff --git a/Core/MIPS/ARM/ArmJit.cpp b/Core/MIPS/ARM/ArmJit.cpp index 19eae73884..4401172402 100644 --- a/Core/MIPS/ARM/ArmJit.cpp +++ b/Core/MIPS/ARM/ArmJit.cpp @@ -387,7 +387,7 @@ void ArmJit::AddContinuedBlock(u32 dest) bool ArmJit::DescribeCodePtr(const u8 *ptr, std::string &name) { - // TODO: Not used by anything yet. + // TODO: Not used by anything yet (except the modified VerySleepy on Windows) return false; } diff --git a/Core/MIPS/ARM64/Arm64Jit.cpp b/Core/MIPS/ARM64/Arm64Jit.cpp index b4677c2bae..a8770bba29 100644 --- a/Core/MIPS/ARM64/Arm64Jit.cpp +++ b/Core/MIPS/ARM64/Arm64Jit.cpp @@ -350,7 +350,7 @@ void Arm64Jit::AddContinuedBlock(u32 dest) { } bool Arm64Jit::DescribeCodePtr(const u8 *ptr, std::string &name) { - // TODO: Not used by anything yet. + // TODO: Not used by anything yet (except the modified VerySleepy on Windows) return false; } diff --git a/Core/MIPS/x86/Asm.cpp b/Core/MIPS/x86/Asm.cpp index 253a3c2a3d..a261e2be5c 100644 --- a/Core/MIPS/x86/Asm.cpp +++ b/Core/MIPS/x86/Asm.cpp @@ -215,6 +215,8 @@ void Jit::GenerateFixedCode(JitOptions &jo) { RestoreRoundingMode(true); ABI_PopAllCalleeSavedRegsAndAdjustStack(); RET(); + + endOfPregeneratedCode = GetCodePtr(); } } // namespace \ No newline at end of file diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index 7f14c537af..88bcfff1a2 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -444,9 +444,9 @@ bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) { u32 jitAddr = blocks.GetAddressFromBlockPtr(ptr); // Returns 0 when it's valid, but unknown. - if (jitAddr == 0) + if (jitAddr == 0) { name = "UnknownOrDeletedBlock"; - else if (jitAddr != (u32)-1) { + } else if (jitAddr != (u32)-1) { char temp[1024]; const std::string label = symbolMap.GetDescription(jitAddr); if (!label.empty()) @@ -454,18 +454,20 @@ bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) { else snprintf(temp, sizeof(temp), "%08x", jitAddr); name = temp; - } - else if (IsInSpace(ptr)) - name = "RunLoopUntil"; - else if (thunks.IsInSpace(ptr)) + } else if (IsInSpace(ptr)) { + if (ptr < endOfPregeneratedCode) { + name = "PreGenCode"; + } else { + name = "Unknown"; + } + } else if (thunks.IsInSpace(ptr)) { name = "Thunk"; - else if (safeMemFuncs.IsInSpace(ptr)) + } else if (safeMemFuncs.IsInSpace(ptr)) { name = "JitSafeMem"; - else if (IsInSpace(ptr)) - name = "Unknown"; - // Not anywhere in jit, then. - else + } else { + // Not anywhere in jit, then. return false; + } // If we got here, one of the above cases matched. return true; diff --git a/Core/MIPS/x86/Jit.h b/Core/MIPS/x86/Jit.h index d5650d19b9..1e4d631b2c 100644 --- a/Core/MIPS/x86/Jit.h +++ b/Core/MIPS/x86/Jit.h @@ -318,6 +318,8 @@ private: const u8 *applyRoundingMode; const u8 *updateRoundingMode; + const u8 *endOfPregeneratedCode; + friend class JitSafeMem; friend class JitSafeMemFuncs; };