ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #71 from lioncash/jit-cleanup 

Remove unused code in the JIT recompiler.
This commit is contained in:
Ryan Houdek 2014-02-14 23:11:06 -06:00
parent 8e5067500b 867d0f01a2
commit b2c0d5d5e6
4 changed files with 14 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/Core/PowerPC/Jit64/JitRegCache.cpp
View File

@ -360,10 +360,6 @@ void FPURegCache::StoreFromRegister(int i)
regs[i].location = newLoc;
regs[i].away = false;
}
else
{
// _assert_msg_(DYNA_REC,0,"already stored");
}
}
void RegCache::Flush(FlushMode mode)

17
Source/Core/Core/PowerPC/Jit64/Jit_LoadStoreFloating.cpp
View File

@ -80,7 +80,9 @@ void Jit64::lfd(UGeckoInstruction inst)
fpr.Lock(d);
fpr.BindToRegister(d, true);
X64Reg xd = fpr.RX(d);
if (cpu_info.bSSSE3) {
if (cpu_info.bSSSE3)
{
#ifdef _M_X64
MOVQ_xmm(XMM0, MComplex(RBX, ABI_PARAM1, SCALE_1, offset));
#else
@ -116,20 +118,9 @@ void Jit64::lfd(UGeckoInstruction inst)
MOVSD(xd, R(XMM0));
MEMCHECK_END
#if 0
// Alternate implementation; possibly faster
AND(32, R(ABI_PARAM1), Imm32(Memory::MEMVIEW32_MASK));
MOVQ_xmm(XMM0, MDisp(ABI_PARAM1, (u32)Memory::base + offset));
PSHUFLW(XMM0, R(XMM0), 0x1B);
PSRLW(XMM0, 8);
MOVSD(xd, R(XMM0));
MOVQ_xmm(XMM0, MDisp(ABI_PARAM1, (u32)Memory::base + offset));
PSHUFLW(XMM0, R(XMM0), 0x1B);
PSLLW(XMM0, 8);
POR(xd, R(XMM0));
#endif
#endif
}
gpr.UnlockAll();
gpr.UnlockAllX();
fpr.UnlockAll();

41
Source/Core/Core/PowerPC/Jit64/Jit_LoadStorePaired.cpp
View File

@ -14,18 +14,6 @@
const u8 GC_ALIGNED16(pbswapShuffle2x4[16]) = {3, 2, 1, 0, 7, 6, 5, 4, 8, 9, 10, 11, 12, 13, 14, 15};
//static u64 GC_ALIGNED16(temp64); // unused?
// TODO(ector): Improve 64-bit version
#if 0
static void WriteDual32(u64 value, u32 address)
{
MOV(32, M(&PC), Imm32(jit->js.compilerPC)); // Helps external systems know which instruction triggered the write
Memory::Write_U32((u32)(value >> 32), address);
Memory::Write_U32((u32)value, address + 4);
}
#endif
// The big problem is likely instructions that set the quantizers in the same block.
// We will have to break block after quantizers are written to.
void Jit64::psq_st(UGeckoInstruction inst)
@ -48,33 +36,6 @@ void Jit64::psq_st(UGeckoInstruction inst)
int a = inst.RA;
int s = inst.RS; // Fp numbers
const UGQR gqr(rSPR(SPR_GQR0 + inst.I));
#if 0
u16 store_gqr = gqr.Hex & 0xFFFF;
const EQuantizeType stType = static_cast<EQuantizeType>(gqr.ST_TYPE);
int stScale = gqr.ST_SCALE;
// Is this specialization still worth it? Let's keep it for now. It's probably
// not very risky since a game most likely wouldn't use the same code to process
// floats as integers (but you never know....).
if (stType == QUANTIZE_FLOAT)
{
if (gpr.R(a).IsImm() && !update && cpu_info.bSSSE3)
{
u32 addr = (u32)(gpr.R(a).offset + offset);
if (addr == 0xCC008000) {
// Writing to FIFO. Let's do fast method.
CVTPD2PS(XMM0, fpr.R(s));
PSHUFB(XMM0, M((void*)&pbswapShuffle2x4));
CALL((void*)asm_routines.fifoDirectWriteXmm64);
js.fifoBytesThisBlock += 8;
return;
}
}
}
#endif
gpr.FlushLockX(EAX, EDX);
gpr.FlushLockX(ECX);
if (update)
@ -120,8 +81,6 @@ void Jit64::psq_l(UGeckoInstruction inst)
return;
}
const UGQR gqr(rSPR(SPR_GQR0 + inst.I));
bool update = inst.OPCD == 57;
int offset = inst.SIMM_12;

32
Source/Core/Core/PowerPC/Jit64/Jit_SystemRegisters.cpp
View File

@ -19,7 +19,6 @@ void Jit64::mtspr(UGeckoInstruction inst)
switch (iIndex)
{
case SPR_DMAU:
case SPR_SPRG0:
@ -46,20 +45,9 @@ void Jit64::mtspr(UGeckoInstruction inst)
case SPR_GQR0 + 5:
case SPR_GQR0 + 6:
case SPR_GQR0 + 7:
// Prevent recompiler from compiling in old quantizer values.
// If the value changed, destroy all blocks using this quantizer
// This will create a little bit of block churn, but hopefully not too bad.
{
/*
MOV(32, R(EAX), M(&PowerPC::ppcState.spr[iIndex])); // Load old value
CMP(32, R(EAX), gpr.R(inst.RD));
FixupBranch skip_destroy = J_CC(CC_E, false);
int gqr = iIndex - SPR_GQR0;
ABI_CallFunctionC(ProtectFunction(&Jit64::DestroyBlocksWithFlag, 1), (u32)BLOCK_USE_GQR0 << gqr);
SetJumpTarget(skip_destroy);*/
}
// These are safe to do the easy way, see the bottom of this function.
break;
// TODO - break block if quantizers are written to.
default:
Default(inst);
return;
@ -276,40 +264,40 @@ void Jit64::crXXX(UGeckoInstruction inst)
// Compute combined bit
switch(inst.SUBOP10)
{
case 33: // crnor
case 33: // crnor
OR(8, R(EAX), R(ECX));
NOT(8, R(EAX));
break;
case 129: // crandc
case 129: // crandc
NOT(8, R(ECX));
AND(8, R(EAX), R(ECX));
break;
case 193: // crxor
case 193: // crxor
XOR(8, R(EAX), R(ECX));
break;
case 225: // crnand
case 225: // crnand
AND(8, R(EAX), R(ECX));
NOT(8, R(EAX));
break;
case 257: // crand
case 257: // crand
AND(8, R(EAX), R(ECX));
break;
case 289: // creqv
case 289: // creqv
XOR(8, R(EAX), R(ECX));
NOT(8, R(EAX));
break;
case 417: // crorc
case 417: // crorc
NOT(8, R(ECX));
OR(8, R(EAX), R(ECX));
break;
case 449: // cror
case 449: // cror
OR(8, R(EAX), R(ECX));
break;
}