mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-16 19:13:40 +01:00
Merge pull request #506 from unknownbrackets/jit-minor
Jit memory access cleanup + VFPU
This commit is contained in:
commit
88d484f028
8 files changed
+364
-356
No files matched your search
@@ -184,10 +184,12 @@ namespace MIPSComp
|
||||
// Optimize out + 0 and | 0.
|
||||
if ((doImm == &RType3_ImmAdd || doImm == &RType3_ImmOr) && (rs == 0 || rt == 0))
|
||||
{
|
||||
gpr.BindToRegister(rd, rd == rs || rd == rt, true);
|
||||
int rsource = rt == 0 ? rs : rt;
|
||||
if (rsource != rd)
|
||||
{
|
||||
gpr.BindToRegister(rd, false, true);
|
||||
MOV(32, gpr.R(rd), gpr.R(rsource));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
+26
-154
@@ -96,174 +96,46 @@ void Jit::Comp_FPULS(u32 op)
|
||||
switch(op >> 26)
|
||||
{
|
||||
case 49: //FI(ft) = Memory::Read_U32(addr); break; //lwc1
|
||||
gpr.Lock(rs);
|
||||
fpr.SpillLock(ft);
|
||||
fpr.BindToRegister(ft, false, true);
|
||||
|
||||
if (gpr.R(rs).IsImm())
|
||||
{
|
||||
void *data = Memory::GetPointer(gpr.R(rs).GetImmValue() + offset);
|
||||
if (data)
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
MOVSS(fpr.RX(ft), M(data));
|
||||
#else
|
||||
MOVSS(fpr.RX(ft), MDisp(RBX, gpr.R(rs).GetImmValue() + offset));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
MOV(32, M((void *)ssLoadStoreTemp), Imm32(0));
|
||||
MOVSS(fpr.RX(ft), M((void *)ssLoadStoreTemp));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// We may not even need to move into EAX as a temporary.
|
||||
X64Reg addr;
|
||||
if (gpr.R(rs).IsSimpleReg())
|
||||
{
|
||||
// TODO: Maybe just add a check if it's away, don't mind copying to EAX instead...
|
||||
gpr.BindToRegister(rs, true, false);
|
||||
addr = gpr.RX(rs);
|
||||
}
|
||||
else
|
||||
{
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
addr = EAX;
|
||||
}
|
||||
gpr.Lock(rs);
|
||||
fpr.SpillLock(ft);
|
||||
fpr.BindToRegister(ft, false, true);
|
||||
|
||||
if (!g_Config.bFastMemory)
|
||||
JitSafeMem safe(this, rs, offset);
|
||||
OpArg src;
|
||||
if (safe.PrepareRead(src))
|
||||
MOVSS(fpr.RX(ft), src);
|
||||
if (safe.PrepareSlowRead((void *) &Memory::Read_U32))
|
||||
{
|
||||
// Is it in physical ram?
|
||||
CMP(32, R(addr), Imm32(0x08000000));
|
||||
FixupBranch tooLow = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x0A000000));
|
||||
FixupBranch tooHigh = J_CC(CC_GE);
|
||||
|
||||
const u8* safe = GetCodePtr();
|
||||
#ifdef _M_IX86
|
||||
MOVSS(fpr.RX(ft), MDisp(addr, (u32)Memory::base + offset));
|
||||
#else
|
||||
MOVSS(fpr.RX(ft), MComplex(RBX, addr, SCALE_1, offset));
|
||||
#endif
|
||||
|
||||
FixupBranch skip = J();
|
||||
SetJumpTarget(tooLow);
|
||||
SetJumpTarget(tooHigh);
|
||||
|
||||
// Might also be the scratchpad.
|
||||
CMP(32, R(addr), Imm32(0x00010000));
|
||||
FixupBranch tooLow2 = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x00014000));
|
||||
J_CC(CC_L, safe);
|
||||
SetJumpTarget(tooLow2);
|
||||
|
||||
LEA(32, EAX, MDisp(addr, offset));
|
||||
ABI_CallFunctionA(thunks.ProtectFunction((void *) &Memory::Read_U32, 1), R(EAX));
|
||||
MOV(32, M((void *)&ssLoadStoreTemp), R(EAX));
|
||||
MOVSS(fpr.RX(ft), M((void *)&ssLoadStoreTemp));
|
||||
}
|
||||
safe.Finish();
|
||||
|
||||
SetJumpTarget(skip);
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
// Need to modify it, too bad.
|
||||
if (addr != EAX)
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
AND(32, R(EAX), Imm32(Memory::MEMVIEW32_MASK));
|
||||
MOVSS(fpr.RX(ft), MDisp(EAX, (u32)Memory::base + offset));
|
||||
#else
|
||||
MOVSS(fpr.RX(ft), MComplex(RBX, addr, SCALE_1, offset));
|
||||
#endif
|
||||
}
|
||||
gpr.UnlockAll();
|
||||
fpr.ReleaseSpillLocks();
|
||||
}
|
||||
|
||||
gpr.UnlockAll();
|
||||
fpr.ReleaseSpillLocks();
|
||||
break;
|
||||
case 57: //Memory::Write_U32(FI(ft), addr); break; //swc1
|
||||
gpr.Lock(rs);
|
||||
fpr.SpillLock(ft);
|
||||
fpr.BindToRegister(ft, true, false);
|
||||
|
||||
if (gpr.R(rs).IsImm())
|
||||
{
|
||||
void *data = Memory::GetPointer(gpr.R(rs).GetImmValue() + offset);
|
||||
if (data)
|
||||
gpr.Lock(rs);
|
||||
fpr.SpillLock(ft);
|
||||
fpr.BindToRegister(ft, true, false);
|
||||
|
||||
JitSafeMem safe(this, rs, offset);
|
||||
OpArg dest;
|
||||
if (safe.PrepareWrite(dest))
|
||||
MOVSS(dest, fpr.RX(ft));
|
||||
if (safe.PrepareSlowWrite())
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
MOVSS(M(data), fpr.RX(ft));
|
||||
#else
|
||||
MOVSS(MDisp(RBX, gpr.R(rs).GetImmValue() + offset), fpr.RX(ft));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// We may not even need to move into EAX as a temporary.
|
||||
X64Reg addr;
|
||||
if (gpr.R(rs).IsSimpleReg())
|
||||
{
|
||||
// TODO: Maybe just add a check if it's away, don't mind copying to EAX instead...
|
||||
gpr.BindToRegister(rs, true, false);
|
||||
addr = gpr.RX(rs);
|
||||
}
|
||||
else
|
||||
{
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
addr = EAX;
|
||||
}
|
||||
|
||||
if (!g_Config.bFastMemory)
|
||||
{
|
||||
// Is it in physical ram?
|
||||
CMP(32, R(addr), Imm32(0x08000000));
|
||||
FixupBranch tooLow = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x0A000000));
|
||||
FixupBranch tooHigh = J_CC(CC_GE);
|
||||
|
||||
const u8* safe = GetCodePtr();
|
||||
#ifdef _M_IX86
|
||||
MOVSS(MDisp(addr, (u32)Memory::base + offset), fpr.RX(ft));
|
||||
#else
|
||||
MOVSS(MComplex(RBX, addr, SCALE_1, offset), fpr.RX(ft));
|
||||
#endif
|
||||
|
||||
FixupBranch skip = J();
|
||||
SetJumpTarget(tooLow);
|
||||
SetJumpTarget(tooHigh);
|
||||
|
||||
// Might also be the scratchpad.
|
||||
CMP(32, R(addr), Imm32(0x00010000));
|
||||
FixupBranch tooLow2 = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x00014000));
|
||||
J_CC(CC_L, safe);
|
||||
SetJumpTarget(tooLow2);
|
||||
|
||||
LEA(32, EAX, MDisp(addr, offset));
|
||||
MOVSS(M((void *)&ssLoadStoreTemp), fpr.RX(ft));
|
||||
ABI_CallFunctionAA(thunks.ProtectFunction((void *) &Memory::Write_U32, 2), M((void *)&ssLoadStoreTemp), R(EAX));
|
||||
safe.DoSlowWrite((void *) &Memory::Write_U32, M((void *)&ssLoadStoreTemp));
|
||||
}
|
||||
safe.Finish();
|
||||
|
||||
SetJumpTarget(skip);
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
// Need to modify it, too bad.
|
||||
if (addr != EAX)
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
AND(32, R(EAX), Imm32(Memory::MEMVIEW32_MASK));
|
||||
MOVSS(MDisp(EAX, (u32)Memory::base + offset), fpr.RX(ft));
|
||||
#else
|
||||
MOVSS(MComplex(RBX, addr, SCALE_1, offset), fpr.RX(ft));
|
||||
#endif
|
||||
}
|
||||
gpr.UnlockAll();
|
||||
fpr.ReleaseSpillLocks();
|
||||
}
|
||||
|
||||
gpr.UnlockAll();
|
||||
fpr.ReleaseSpillLocks();
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
+19
-164
@@ -51,82 +51,13 @@ namespace MIPSComp
|
||||
gpr.Lock(rt, rs);
|
||||
gpr.BindToRegister(rt, rt == rs, true);
|
||||
|
||||
if (gpr.R(rs).IsImm())
|
||||
{
|
||||
void *data = Memory::GetPointer(gpr.R(rs).GetImmValue() + offset);
|
||||
if (data)
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
(this->*mov)(32, bits, gpr.RX(rt), M(data));
|
||||
#else
|
||||
(this->*mov)(32, bits, gpr.RX(rt), MDisp(RBX, gpr.R(rs).GetImmValue() + offset));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
gpr.SetImmediate32(rt, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// We may not even need to move into EAX as a temporary.
|
||||
X64Reg addr;
|
||||
if (gpr.R(rs).IsSimpleReg())
|
||||
{
|
||||
// TODO: Maybe just add a check if it's away, don't mind copying to EAX instead...
|
||||
if (rs != rt)
|
||||
gpr.BindToRegister(rs, true, false);
|
||||
addr = gpr.RX(rs);
|
||||
}
|
||||
else
|
||||
{
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
addr = EAX;
|
||||
}
|
||||
|
||||
if (!g_Config.bFastMemory)
|
||||
{
|
||||
// Is it in physical ram?
|
||||
CMP(32, R(addr), Imm32(0x08000000));
|
||||
FixupBranch tooLow = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x0A000000));
|
||||
FixupBranch tooHigh = J_CC(CC_GE);
|
||||
|
||||
const u8* safe = GetCodePtr();
|
||||
#ifdef _M_IX86
|
||||
(this->*mov)(32, bits, gpr.RX(rt), MDisp(addr, (u32)Memory::base + offset));
|
||||
#else
|
||||
(this->*mov)(32, bits, gpr.RX(rt), MComplex(RBX, addr, SCALE_1, offset));
|
||||
#endif
|
||||
|
||||
FixupBranch skip = J();
|
||||
SetJumpTarget(tooLow);
|
||||
SetJumpTarget(tooHigh);
|
||||
|
||||
// Might also be the scratchpad.
|
||||
CMP(32, R(addr), Imm32(0x00010000));
|
||||
FixupBranch tooLow2 = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x00014000));
|
||||
J_CC(CC_L, safe);
|
||||
SetJumpTarget(tooLow2);
|
||||
|
||||
LEA(32, EAX, MDisp(addr, offset));
|
||||
ABI_CallFunctionA(thunks.ProtectFunction(safeFunc, 1), R(EAX));
|
||||
(this->*mov)(32, bits, gpr.RX(rt), R(EAX));
|
||||
|
||||
SetJumpTarget(skip);
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
// Need to modify it, too bad.
|
||||
if (addr != EAX)
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
AND(32, R(EAX), Imm32(Memory::MEMVIEW32_MASK));
|
||||
(this->*mov)(32, bits, gpr.RX(rt), MDisp(EAX, (u32)Memory::base + offset));
|
||||
#else
|
||||
(this->*mov)(32, bits, gpr.RX(rt), MComplex(RBX, addr, SCALE_1, offset));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
JitSafeMem safe(this, rs, offset);
|
||||
OpArg src;
|
||||
if (safe.PrepareRead(src))
|
||||
(this->*mov)(32, bits, gpr.RX(rt), src);
|
||||
if (safe.PrepareSlowRead(safeFunc))
|
||||
(this->*mov)(32, bits, gpr.RX(rt), R(EAX));
|
||||
safe.Finish();
|
||||
|
||||
gpr.UnlockAll();
|
||||
}
|
||||
@@ -146,104 +77,28 @@ namespace MIPSComp
|
||||
const bool needSwap = bits == 8 && !gpr.R(rt).IsSimpleReg(EDX) && !gpr.R(rt).IsSimpleReg(ECX);
|
||||
if (needSwap)
|
||||
gpr.FlushLockX(EDX);
|
||||
#else
|
||||
const bool needSwap = false;
|
||||
#endif
|
||||
|
||||
if (gpr.R(rs).IsImm())
|
||||
JitSafeMem safe(this, rs, offset);
|
||||
OpArg dest;
|
||||
if (safe.PrepareWrite(dest))
|
||||
{
|
||||
void *data = Memory::GetPointer(gpr.R(rs).GetImmValue() + offset);
|
||||
if (data)
|
||||
if (needSwap)
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
if (needSwap)
|
||||
{
|
||||
MOV(32, R(EDX), gpr.R(rt));
|
||||
MOV(bits, M(data), R(EDX));
|
||||
}
|
||||
else
|
||||
MOV(bits, M(data), gpr.R(rt));
|
||||
#else
|
||||
MOV(bits, MDisp(RBX, gpr.R(rs).GetImmValue() + offset), gpr.R(rt));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// We may not even need to move into EAX as a temporary.
|
||||
X64Reg addr;
|
||||
if (gpr.R(rs).IsSimpleReg())
|
||||
{
|
||||
// TODO: Maybe just add a check if it's away, don't mind copying to EAX instead...
|
||||
if (rs != rt)
|
||||
gpr.BindToRegister(rs, true, false);
|
||||
addr = gpr.RX(rs);
|
||||
MOV(32, R(EDX), gpr.R(rt));
|
||||
MOV(bits, dest, R(EDX));
|
||||
}
|
||||
else
|
||||
{
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
addr = EAX;
|
||||
}
|
||||
|
||||
if (!g_Config.bFastMemory)
|
||||
{
|
||||
// Is it in physical ram?
|
||||
CMP(32, R(addr), Imm32(0x08000000));
|
||||
FixupBranch tooLow = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x0A000000));
|
||||
FixupBranch tooHigh = J_CC(CC_GE);
|
||||
|
||||
const u8* safe = GetCodePtr();
|
||||
#ifdef _M_IX86
|
||||
if (needSwap)
|
||||
{
|
||||
MOV(32, R(EDX), gpr.R(rt));
|
||||
MOV(bits, MDisp(addr, (u32)Memory::base + offset), R(EDX));
|
||||
}
|
||||
else
|
||||
MOV(bits, MDisp(addr, (u32)Memory::base + offset), gpr.R(rt));
|
||||
#else
|
||||
MOV(bits, MComplex(RBX, addr, SCALE_1, offset), gpr.R(rt));
|
||||
#endif
|
||||
|
||||
FixupBranch skip = J();
|
||||
SetJumpTarget(tooLow);
|
||||
SetJumpTarget(tooHigh);
|
||||
|
||||
// Might also be the scratchpad.
|
||||
CMP(32, R(addr), Imm32(0x00010000));
|
||||
FixupBranch tooLow2 = J_CC(CC_L);
|
||||
CMP(32, R(addr), Imm32(0x00014000));
|
||||
J_CC(CC_L, safe);
|
||||
SetJumpTarget(tooLow2);
|
||||
|
||||
LEA(32, EAX, MDisp(addr, offset));
|
||||
ABI_CallFunctionAA(thunks.ProtectFunction(safeFunc, 2), gpr.R(rt), R(EAX));
|
||||
|
||||
SetJumpTarget(skip);
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
// Need to modify it, too bad.
|
||||
if (addr != EAX)
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
AND(32, R(EAX), Imm32(Memory::MEMVIEW32_MASK));
|
||||
if (needSwap)
|
||||
{
|
||||
MOV(32, R(EDX), gpr.R(rt));
|
||||
MOV(bits, MDisp(EAX, (u32)Memory::base + offset), R(EDX));
|
||||
}
|
||||
else
|
||||
MOV(bits, MDisp(EAX, (u32)Memory::base + offset), gpr.R(rt));
|
||||
#else
|
||||
MOV(bits, MComplex(RBX, addr, SCALE_1, offset), gpr.R(rt));
|
||||
#endif
|
||||
}
|
||||
MOV(bits, dest, gpr.R(rt));
|
||||
}
|
||||
if (safe.PrepareSlowWrite())
|
||||
safe.DoSlowWrite(safeFunc, gpr.R(rt));
|
||||
safe.Finish();
|
||||
|
||||
#ifdef _M_IX86
|
||||
if (needSwap)
|
||||
gpr.UnlockAllX();
|
||||
#endif
|
||||
gpr.UnlockAll();
|
||||
}
|
||||
|
||||
|
||||
+33
-35
@@ -139,6 +139,7 @@ void Jit::ApplyPrefixD(const u8 *vregs, u32 prefix, VectorSize sz, bool onlyWrit
|
||||
}
|
||||
}
|
||||
|
||||
static u32 GC_ALIGNED16(ssLoadStoreTemp[1]);
|
||||
|
||||
void Jit::Comp_SVQ(u32 op)
|
||||
{
|
||||
@@ -150,28 +151,30 @@ void Jit::Comp_SVQ(u32 op)
|
||||
{
|
||||
case 54: //lv.q
|
||||
{
|
||||
if (!g_Config.bFastMemory) {
|
||||
DISABLE;
|
||||
}
|
||||
gpr.BindToRegister(rs, true, true);
|
||||
|
||||
u8 vregs[4];
|
||||
GetVectorRegs(vregs, V_Quad, vt);
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
// Just copy 4 words the easiest way while not wasting registers.
|
||||
#ifndef _M_X64
|
||||
AND(32, R(EAX), Imm32(0x3FFFFFFF));
|
||||
#endif
|
||||
fpr.MapRegsV(vregs, V_Quad, MAP_DIRTY | MAP_NOINIT);
|
||||
|
||||
// MOVSS to prime any crazy cache mechanism that might assume that there's a float somewhere...
|
||||
for (int i = 0; i < 4; i++) {
|
||||
#ifdef _M_X64
|
||||
MOVSS(fpr.VX(vregs[i]), MComplex(RBX, EAX, 1, i * 4 + imm));
|
||||
#else
|
||||
MOVSS(fpr.VX(vregs[i]), MDisp(EAX, (u32)(Memory::base + i * 4 + imm)));
|
||||
#endif
|
||||
JitSafeMem safe(this, rs, imm);
|
||||
OpArg src;
|
||||
if (safe.PrepareRead(src))
|
||||
{
|
||||
// Just copy 4 words the easiest way while not wasting registers.
|
||||
for (int i = 0; i < 4; i++)
|
||||
MOVSS(fpr.VX(vregs[i]), safe.NextFastAddress(i * 4));
|
||||
}
|
||||
if (safe.PrepareSlowRead((void *) &Memory::Read_U32))
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
safe.NextSlowRead((void *) &Memory::Read_U32, i * 4);
|
||||
MOV(32, M((void *)&ssLoadStoreTemp), R(EAX));
|
||||
MOVSS(fpr.VX(vregs[i]), M((void *)&ssLoadStoreTemp));
|
||||
}
|
||||
}
|
||||
safe.Finish();
|
||||
|
||||
gpr.UnlockAll();
|
||||
fpr.ReleaseSpillLocks();
|
||||
@@ -180,34 +183,29 @@ void Jit::Comp_SVQ(u32 op)
|
||||
|
||||
case 62: //sv.q
|
||||
{
|
||||
if (!g_Config.bFastMemory) {
|
||||
DISABLE;
|
||||
}
|
||||
fpr.Flush();
|
||||
gpr.BindToRegister(rs, true, true);
|
||||
|
||||
u8 vregs[4];
|
||||
GetVectorRegs(vregs, V_Quad, vt);
|
||||
|
||||
MOV(32, R(EAX), gpr.R(rs));
|
||||
// Just copy 4 words the easiest way while not wasting registers.
|
||||
#ifndef _M_X64
|
||||
AND(32, R(EAX), Imm32(0x3FFFFFFF));
|
||||
#endif
|
||||
// MOVSS to prime any crazy cache mechanism that might assume that there's a float somewhere...
|
||||
|
||||
// It would be pretty nice to have these in registers for the next instruction...
|
||||
// Even if we don't use real SIMD there's still 8 or 16 scalar float registers.
|
||||
|
||||
fpr.MapRegsV(vregs, V_Quad, 0);
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
#ifdef _M_X64
|
||||
MOVSS(MComplex(RBX, EAX, 1, i * 4 + imm), fpr.VX(vregs[i]));
|
||||
#else
|
||||
MOVSS(MDisp(EAX, (u32)(Memory::base + i * 4 + imm)), fpr.VX(vregs[i]));
|
||||
#endif
|
||||
JitSafeMem safe(this, rs, imm);
|
||||
OpArg dest;
|
||||
if (safe.PrepareWrite(dest))
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
MOVSS(safe.NextFastAddress(i * 4), fpr.VX(vregs[i]));
|
||||
}
|
||||
if (safe.PrepareSlowWrite())
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
MOVSS(M((void *)&ssLoadStoreTemp), fpr.VX(vregs[i]));
|
||||
safe.DoSlowWrite((void *) &Memory::Write_U32, M((void *)&ssLoadStoreTemp), i * 4);
|
||||
}
|
||||
}
|
||||
safe.Finish();
|
||||
|
||||
fpr.ReleaseSpillLocks();
|
||||
gpr.UnlockAll();
|
||||
|
||||
@@ -19,6 +19,7 @@
|
||||
#include <iterator>
|
||||
#include "../../Core.h"
|
||||
#include "../../CoreTiming.h"
|
||||
#include "../../Config.h"
|
||||
#include "../MIPS.h"
|
||||
#include "../MIPSCodeUtils.h"
|
||||
#include "../MIPSInt.h"
|
||||
@@ -301,4 +302,234 @@ bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset)
|
||||
return false;
|
||||
}
|
||||
|
||||
Jit::JitSafeMem::JitSafeMem(Jit *jit, int raddr, s32 offset)
|
||||
: jit_(jit), raddr_(raddr), offset_(offset), needsCheck_(false), needsSkip_(false)
|
||||
{
|
||||
}
|
||||
|
||||
bool Jit::JitSafeMem::PrepareWrite(OpArg &dest)
|
||||
{
|
||||
// If it's an immediate, we can do the write if valid.
|
||||
if (jit_->gpr.IsImmediate(raddr_))
|
||||
{
|
||||
u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_;
|
||||
if (Memory::IsValidAddress(addr))
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
dest = M(Memory::base + addr);
|
||||
#else
|
||||
dest = MDisp(RBX, addr);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
// Otherwise, we always can do the write (conditionally.)
|
||||
else
|
||||
dest = PrepareMemoryOpArg();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Jit::JitSafeMem::PrepareRead(OpArg &src)
|
||||
{
|
||||
if (jit_->gpr.IsImmediate(raddr_))
|
||||
{
|
||||
u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_;
|
||||
if (Memory::IsValidAddress(addr))
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
src = M(Memory::base + addr);
|
||||
#else
|
||||
src = MDisp(RBX, addr);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
else
|
||||
src = PrepareMemoryOpArg();
|
||||
return true;
|
||||
}
|
||||
|
||||
OpArg Jit::JitSafeMem::NextFastAddress(int suboffset)
|
||||
{
|
||||
if (jit_->gpr.IsImmediate(raddr_))
|
||||
{
|
||||
u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_ + suboffset;
|
||||
|
||||
#ifdef _M_IX86
|
||||
return M(Memory::base + addr);
|
||||
#else
|
||||
return MDisp(RBX, addr);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _M_IX86
|
||||
return MDisp(xaddr_, (u32) Memory::base + offset_ + suboffset);
|
||||
#else
|
||||
return MComplex(RBX, xaddr_, SCALE_1, offset_ + suboffset);
|
||||
#endif
|
||||
}
|
||||
|
||||
OpArg Jit::JitSafeMem::PrepareMemoryOpArg()
|
||||
{
|
||||
// We may not even need to move into EAX as a temporary.
|
||||
// TODO: Except on x86 in fastmem mode.
|
||||
if (jit_->gpr.R(raddr_).IsSimpleReg())
|
||||
{
|
||||
jit_->gpr.BindToRegister(raddr_, true, false);
|
||||
xaddr_ = jit_->gpr.RX(raddr_);
|
||||
}
|
||||
else
|
||||
{
|
||||
jit_->MOV(32, R(EAX), jit_->gpr.R(raddr_));
|
||||
xaddr_ = EAX;
|
||||
}
|
||||
|
||||
if (!g_Config.bFastMemory)
|
||||
{
|
||||
// Is it in physical ram?
|
||||
jit_->CMP(32, R(xaddr_), Imm32(PSP_GetKernelMemoryBase()));
|
||||
tooLow_ = jit_->J_CC(CC_L);
|
||||
jit_->CMP(32, R(xaddr_), Imm32(PSP_GetUserMemoryEnd()));
|
||||
tooHigh_ = jit_->J_CC(CC_GE);
|
||||
|
||||
// We may need to jump back up here.
|
||||
safe_ = jit_->GetCodePtr();
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef _M_IX86
|
||||
// Need to modify it, too bad.
|
||||
if (xaddr_ != EAX)
|
||||
jit_->MOV(32, R(EAX), R(xaddr_));
|
||||
jit_->AND(32, R(EAX), Imm32(Memory::MEMVIEW32_MASK));
|
||||
xaddr_ = EAX;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _M_IX86
|
||||
return MDisp(xaddr_, (u32) Memory::base + offset_);
|
||||
#else
|
||||
return MComplex(RBX, xaddr_, SCALE_1, offset_);
|
||||
#endif
|
||||
}
|
||||
|
||||
void Jit::JitSafeMem::PrepareSlowAccess()
|
||||
{
|
||||
// Skip the fast path (which the caller wrote just now.)
|
||||
skip_ = jit_->J();
|
||||
needsSkip_ = true;
|
||||
jit_->SetJumpTarget(tooLow_);
|
||||
jit_->SetJumpTarget(tooHigh_);
|
||||
|
||||
// Might also be the scratchpad.
|
||||
jit_->CMP(32, R(xaddr_), Imm32(PSP_GetScratchpadMemoryBase()));
|
||||
FixupBranch tooLow = jit_->J_CC(CC_L);
|
||||
jit_->CMP(32, R(xaddr_), Imm32(PSP_GetScratchpadMemoryEnd()));
|
||||
jit_->J_CC(CC_L, safe_);
|
||||
jit_->SetJumpTarget(tooLow);
|
||||
}
|
||||
|
||||
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 (!g_Config.bFastMemory)
|
||||
{
|
||||
PrepareSlowAccess();
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
else
|
||||
jit_->LEA(32, EAX, MDisp(xaddr_, offset_ + suboffset));
|
||||
|
||||
jit_->ABI_CallFunctionAA(jit_->thunks.ProtectFunction(safeFunc, 2), src, R(EAX));
|
||||
needsCheck_ = true;
|
||||
}
|
||||
|
||||
bool Jit::JitSafeMem::PrepareSlowRead(void *safeFunc)
|
||||
{
|
||||
if (!g_Config.bFastMemory)
|
||||
{
|
||||
if (jit_->gpr.IsImmediate(raddr_))
|
||||
{
|
||||
u32 addr = jit_->gpr.GetImmediate32(raddr_) + offset_;
|
||||
|
||||
// No slow read necessary.
|
||||
if (Memory::IsValidAddress(addr))
|
||||
return false;
|
||||
jit_->MOV(32, R(EAX), Imm32(addr));
|
||||
}
|
||||
else
|
||||
{
|
||||
PrepareSlowAccess();
|
||||
jit_->LEA(32, EAX, MDisp(xaddr_, offset_));
|
||||
}
|
||||
|
||||
jit_->ABI_CallFunctionA(jit_->thunks.ProtectFunction(safeFunc, 1), R(EAX));
|
||||
needsCheck_ = true;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
void Jit::JitSafeMem::NextSlowRead(void *safeFunc, int suboffset)
|
||||
{
|
||||
_dbg_assert_msg_(JIT, !g_Config.bFastMemory, "NextSlowRead() called in fast memory mode?");
|
||||
|
||||
// For simplicity, do nothing for 0. We already read in PrepareSlowRead().
|
||||
if (suboffset == 0)
|
||||
return;
|
||||
|
||||
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?");
|
||||
|
||||
jit_->MOV(32, R(EAX), Imm32(addr + suboffset));
|
||||
}
|
||||
// For GPR, if xaddr_ was the dest register, this will be wrong. Don't use in GPR.
|
||||
else
|
||||
jit_->LEA(32, EAX, MDisp(xaddr_, offset_ + suboffset));
|
||||
|
||||
jit_->ABI_CallFunctionA(jit_->thunks.ProtectFunction(safeFunc, 1), R(EAX));
|
||||
}
|
||||
|
||||
void Jit::JitSafeMem::Finish()
|
||||
{
|
||||
if (needsCheck_)
|
||||
{
|
||||
// Memory::Read_U32/etc. may have tripped coreState.
|
||||
if (!g_Config.bIgnoreBadMemAccess)
|
||||
{
|
||||
jit_->CMP(32, M((void*)&coreState), Imm32(0));
|
||||
FixupBranch skipCheck = jit_->J_CC(CC_E);
|
||||
jit_->MOV(32, M(¤tMIPS->pc), Imm32(jit_->js.compilerPC + 4));
|
||||
jit_->WriteSyscallExit();
|
||||
jit_->SetJumpTarget(skipCheck);
|
||||
}
|
||||
}
|
||||
if (needsSkip_)
|
||||
jit_->SetJumpTarget(skip_);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
@@ -183,6 +183,46 @@ private:
|
||||
ThunkManager thunks;
|
||||
|
||||
MIPSState *mips_;
|
||||
|
||||
class JitSafeMem
|
||||
{
|
||||
public:
|
||||
JitSafeMem(Jit *jit, int raddr, s32 offset);
|
||||
|
||||
// Emit code necessary for a memory write, returns true if MOV to dest is needed.
|
||||
bool PrepareWrite(OpArg &dest);
|
||||
// Emit code proceeding a slow write call, returns true if slow write is needed.
|
||||
bool PrepareSlowWrite();
|
||||
// Emit a slow write from src.
|
||||
void DoSlowWrite(void *safeFunc, const OpArg src, int suboffset = 0);
|
||||
|
||||
// Emit code necessary for a memory read, returns true if MOV from src is needed.
|
||||
bool PrepareRead(OpArg &src);
|
||||
// Emit code for a slow read call, and returns true if result is in EAX.
|
||||
bool PrepareSlowRead(void *safeFunc);
|
||||
|
||||
// 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();
|
||||
|
||||
Jit *jit_;
|
||||
int raddr_;
|
||||
s32 offset_;
|
||||
bool needsCheck_;
|
||||
bool needsSkip_;
|
||||
X64Reg xaddr_;
|
||||
FixupBranch tooLow_, tooHigh_, skip_;
|
||||
const u8 *safe_;
|
||||
};
|
||||
friend class JitSafeMem;
|
||||
};
|
||||
|
||||
typedef void (Jit::*MIPSCompileFunc)(u32 opcode);
|
||||
|
||||
@@ -55,6 +55,8 @@ typedef void (*readFn16)(u16&, const u32);
|
||||
typedef void (*readFn32)(u32&, const u32);
|
||||
typedef void (*readFn64)(u64&, const u32);
|
||||
|
||||
inline u32 PSP_GetScratchpadMemoryBase() { return 0x00010000;}
|
||||
inline u32 PSP_GetScratchpadMemoryEnd() { return 0x00014000;}
|
||||
|
||||
inline u32 PSP_GetKernelMemoryBase() { return 0x08000000;}
|
||||
inline u32 PSP_GetKernelMemoryEnd() { return 0x08400000;}
|
||||
|
||||
@@ -83,7 +83,11 @@ inline void ReadFromHardware(T &var, const u32 address)
|
||||
}
|
||||
else
|
||||
{
|
||||
WARN_LOG(MEMMAP, "ReadFromHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
|
||||
if (g_Config.iCpuCore == CPU_JIT) {
|
||||
WARN_LOG(MEMMAP, "ReadFromHardware: Invalid address %08x", address);
|
||||
} else {
|
||||
WARN_LOG(MEMMAP, "ReadFromHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
|
||||
}
|
||||
if (!g_Config.bIgnoreBadMemAccess) {
|
||||
Core_EnableStepping(true);
|
||||
host->SetDebugMode(true);
|
||||
@@ -111,7 +115,11 @@ inline void WriteToHardware(u32 address, const T data)
|
||||
}
|
||||
else
|
||||
{
|
||||
WARN_LOG(MEMMAP, "WriteToHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
|
||||
if (g_Config.iCpuCore == CPU_JIT) {
|
||||
WARN_LOG(MEMMAP, "WriteToHardware: Invalid address %08x", address);
|
||||
} else {
|
||||
WARN_LOG(MEMMAP, "WriteToHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
|
||||
}
|
||||
if (!g_Config.bIgnoreBadMemAccess) {
|
||||
Core_EnableStepping(true);
|
||||
host->SetDebugMode(true);
|
||||
|
||||
Reference in new issue
Block a user