From a89d61463e294bafbd1f1411d357809708cc49a2 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 26 Jan 2013 23:08:19 -0800 Subject: [PATCH 1/3] Make the VFPU jit use far jumps for memory access. --- Core/MIPS/x86/CompVFPU.cpp | 2 ++ Core/MIPS/x86/Jit.cpp | 10 +++++++++- Core/MIPS/x86/Jit.h | 9 ++++++--- 3 files changed, 17 insertions(+), 4 deletions(-) diff --git a/Core/MIPS/x86/CompVFPU.cpp b/Core/MIPS/x86/CompVFPU.cpp index 383638fc67..32a859d19b 100644 --- a/Core/MIPS/x86/CompVFPU.cpp +++ b/Core/MIPS/x86/CompVFPU.cpp @@ -158,6 +158,7 @@ void Jit::Comp_SVQ(u32 op) fpr.MapRegsV(vregs, V_Quad, MAP_DIRTY | MAP_NOINIT); JitSafeMem safe(this, rs, imm); + safe.SetFar(); OpArg src; if (safe.PrepareRead(src)) { @@ -191,6 +192,7 @@ void Jit::Comp_SVQ(u32 op) fpr.MapRegsV(vregs, V_Quad, 0); JitSafeMem safe(this, rs, imm); + safe.SetFar(); OpArg dest; if (safe.PrepareWrite(dest)) { diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index f486a4a53d..d252420b94 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -305,6 +305,14 @@ bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset) Jit::JitSafeMem::JitSafeMem(Jit *jit, int raddr, s32 offset) : jit_(jit), raddr_(raddr), offset_(offset), needsCheck_(false), needsSkip_(false) { + // This makes it more instructions, so let's play it safe and say we need a far jump. + far_ = !g_Config.bIgnoreBadMemAccess; +} + +void Jit::JitSafeMem::SetFar() +{ + _dbg_assert_msg_(JIT, !needsSkip_, "Sorry, you need to call SetFar() earlier."); + far_ = true; } bool Jit::JitSafeMem::PrepareWrite(OpArg &dest) @@ -420,7 +428,7 @@ OpArg Jit::JitSafeMem::PrepareMemoryOpArg() void Jit::JitSafeMem::PrepareSlowAccess() { // Skip the fast path (which the caller wrote just now.) - skip_ = jit_->J(); + skip_ = jit_->J(far_); needsSkip_ = true; jit_->SetJumpTarget(tooLow_); jit_->SetJumpTarget(tooHigh_); diff --git a/Core/MIPS/x86/Jit.h b/Core/MIPS/x86/Jit.h index 25b3d24cac..84ad6974d6 100644 --- a/Core/MIPS/x86/Jit.h +++ b/Core/MIPS/x86/Jit.h @@ -201,14 +201,16 @@ private: // Emit code for a slow read call, and returns true if result is in EAX. bool PrepareSlowRead(void *safeFunc); + // Cleans up final code for the memory access. + void Finish(); + + // Use this before anything else if you're gonna use the below. + void SetFar(); // WARNING: Only works for non-GPR. Do not use for reads into GPR. OpArg NextFastAddress(int suboffset); // WARNING: Only works for non-GPR. Do not use for reads into GPR. void NextSlowRead(void *safeFunc, int suboffset); - // Cleans up final code for the memory access. - void Finish(); - private: OpArg PrepareMemoryOpArg(); void PrepareSlowAccess(); @@ -218,6 +220,7 @@ private: s32 offset_; bool needsCheck_; bool needsSkip_; + bool far_; X64Reg xaddr_; FixupBranch tooLow_, tooHigh_, skip_; const u8 *safe_; From a7b5433ba7c3f41b39998f94fdd2ddf8fb20b868 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 26 Jan 2013 23:18:50 -0800 Subject: [PATCH 2/3] Make sure fastmem isn't confused by rs changing. --- Core/MIPS/x86/Jit.cpp | 49 +++++++++++++++++++------------------------ Core/MIPS/x86/Jit.h | 1 + 2 files changed, 22 insertions(+), 28 deletions(-) diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index d252420b94..8ae02cceef 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -307,6 +307,10 @@ Jit::JitSafeMem::JitSafeMem(Jit *jit, int raddr, s32 offset) { // This makes it more instructions, so let's play it safe and say we need a far jump. far_ = !g_Config.bIgnoreBadMemAccess; + if (jit_->gpr.IsImmediate(raddr_)) + iaddr_ = jit_->gpr.GetImmediate32(raddr_) + offset_; + else + iaddr_ = (u32) -1; } void Jit::JitSafeMem::SetFar() @@ -318,15 +322,14 @@ void Jit::JitSafeMem::SetFar() bool Jit::JitSafeMem::PrepareWrite(OpArg &dest) { // If it's an immediate, we can do the write if valid. - if (jit_->gpr.IsImmediate(raddr_)) + if (iaddr_ != (u32) -1) { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - if (Memory::IsValidAddress(addr)) + if (Memory::IsValidAddress(iaddr_)) { #ifdef _M_IX86 - dest = M(Memory::base + addr); + dest = M(Memory::base + iaddr_); #else - dest = MDisp(RBX, addr); + dest = MDisp(RBX, iaddr_); #endif return true; } @@ -341,15 +344,14 @@ bool Jit::JitSafeMem::PrepareWrite(OpArg &dest) bool Jit::JitSafeMem::PrepareRead(OpArg &src) { - if (jit_->gpr.IsImmediate(raddr_)) + if (iaddr_ != (u32) -1) { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - if (Memory::IsValidAddress(addr)) + if (Memory::IsValidAddress(iaddr_)) { #ifdef _M_IX86 - src = M(Memory::base + addr); + src = M(Memory::base + iaddr_); #else - src = MDisp(RBX, addr); + src = MDisp(RBX, iaddr_); #endif return true; } @@ -444,11 +446,8 @@ void Jit::JitSafeMem::PrepareSlowAccess() bool Jit::JitSafeMem::PrepareSlowWrite() { // If it's immediate, we only need a slow write on invalid. - if (jit_->gpr.IsImmediate(raddr_)) - { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - return !g_Config.bFastMemory && !Memory::IsValidAddress(addr); - } + if (iaddr_ != (u32) -1) + return !g_Config.bFastMemory && !Memory::IsValidAddress(iaddr_); if (!g_Config.bFastMemory) { @@ -461,11 +460,8 @@ bool Jit::JitSafeMem::PrepareSlowWrite() void Jit::JitSafeMem::DoSlowWrite(void *safeFunc, const OpArg src, int suboffset) { - if (jit_->gpr.IsImmediate(raddr_)) - { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - jit_->MOV(32, R(EAX), Imm32(addr + suboffset)); - } + if (iaddr_ != (u32) -1) + jit_->MOV(32, R(EAX), Imm32(iaddr_ + suboffset)); else jit_->LEA(32, EAX, MDisp(xaddr_, offset_ + suboffset)); @@ -477,14 +473,12 @@ bool Jit::JitSafeMem::PrepareSlowRead(void *safeFunc) { if (!g_Config.bFastMemory) { - if (jit_->gpr.IsImmediate(raddr_)) + if (iaddr_ != (u32) -1) { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - // No slow read necessary. - if (Memory::IsValidAddress(addr)) + if (Memory::IsValidAddress(iaddr_)) return false; - jit_->MOV(32, R(EAX), Imm32(addr)); + jit_->MOV(32, R(EAX), Imm32(iaddr_)); } else { @@ -510,10 +504,9 @@ void Jit::JitSafeMem::NextSlowRead(void *safeFunc, int suboffset) if (jit_->gpr.IsImmediate(raddr_)) { - u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_; - _dbg_assert_msg_(JIT, !Memory::IsValidAddress(addr), "NextSlowRead() for a valid immediate address?"); + _dbg_assert_msg_(JIT, !Memory::IsValidAddress(iaddr_), "NextSlowRead() for a valid immediate address?"); - jit_->MOV(32, R(EAX), Imm32(addr + suboffset)); + jit_->MOV(32, R(EAX), Imm32(iaddr_ + suboffset)); } // For GPR, if xaddr_ was the dest register, this will be wrong. Don't use in GPR. else diff --git a/Core/MIPS/x86/Jit.h b/Core/MIPS/x86/Jit.h index 84ad6974d6..aa148cff62 100644 --- a/Core/MIPS/x86/Jit.h +++ b/Core/MIPS/x86/Jit.h @@ -221,6 +221,7 @@ private: bool needsCheck_; bool needsSkip_; bool far_; + u32 iaddr_; X64Reg xaddr_; FixupBranch tooLow_, tooHigh_, skip_; const u8 *safe_; From 6d7a8d9b1ae4e48e9cba80d43768d91813cb4921 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 26 Jan 2013 23:54:43 -0800 Subject: [PATCH 3/3] Apply the memview mask to jit immediates too. --- Core/MIPS/x86/Jit.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Core/MIPS/x86/Jit.cpp b/Core/MIPS/x86/Jit.cpp index 8ae02cceef..cf0c723e19 100644 --- a/Core/MIPS/x86/Jit.cpp +++ b/Core/MIPS/x86/Jit.cpp @@ -327,7 +327,7 @@ bool Jit::JitSafeMem::PrepareWrite(OpArg &dest) if (Memory::IsValidAddress(iaddr_)) { #ifdef _M_IX86 - dest = M(Memory::base + iaddr_); + dest = M(Memory::base + (iaddr_ & Memory::MEMVIEW32_MASK)); #else dest = MDisp(RBX, iaddr_); #endif @@ -349,7 +349,7 @@ bool Jit::JitSafeMem::PrepareRead(OpArg &src) if (Memory::IsValidAddress(iaddr_)) { #ifdef _M_IX86 - src = M(Memory::base + iaddr_); + src = M(Memory::base + (iaddr_ & Memory::MEMVIEW32_MASK)); #else src = MDisp(RBX, iaddr_); #endif @@ -370,7 +370,7 @@ OpArg Jit::JitSafeMem::NextFastAddress(int suboffset) u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_ + suboffset; #ifdef _M_IX86 - return M(Memory::base + addr); + return M(Memory::base + (addr & Memory::MEMVIEW32_MASK)); #else return MDisp(RBX, addr); #endif