From 188fa9b2cb9ba5f5d37faab40a906112905e7aa9 Mon Sep 17 00:00:00 2001 From: magumagu9 Date: Mon, 29 Jun 2009 01:21:55 +0000 Subject: [PATCH] JitIL doesn't use JitRegCache; get rid of it. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@3590 8ced0084-cf51-0410-be5f-012b33b47a6e --- .../Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp | 3 + Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp | 8 - Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h | 7 - .../Core/Src/PowerPC/Jit64IL/JitRegCache.cpp | 394 ------------------ .../Core/Src/PowerPC/Jit64IL/JitRegCache.h | 150 ------- .../Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp | 1 - .../Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp | 1 - .../Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp | 1 - .../Src/PowerPC/Jit64IL/Jit_LoadStore.cpp | 1 - .../PowerPC/Jit64IL/Jit_LoadStoreFloating.cpp | 1 - .../PowerPC/Jit64IL/Jit_LoadStorePaired.cpp | 1 - .../Core/Src/PowerPC/Jit64IL/Jit_Paired.cpp | 1 - .../PowerPC/Jit64IL/Jit_SystemRegisters.cpp | 1 - .../Core/Src/PowerPC/JitCommon/Jit_Util.cpp | 3 +- Source/Core/Core/Src/SConscript | 1 - 15 files changed, 5 insertions(+), 569 deletions(-) delete mode 100644 Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.cpp delete mode 100644 Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.h diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp index 9ed15dc172..af2fceb2e2 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp @@ -46,7 +46,10 @@ The register allocation is just a simple forward greedy allocator. #include "Jit.h" #include "../../HW/GPFifo.h" #include "../../Core.h" +#include "x64Emitter.h" + using namespace IREmitter; +using namespace Gen; struct RegInfo { Jit64* Jit; diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp index 52a519c708..eb3b89a6dc 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp @@ -34,7 +34,6 @@ #include "Jit.h" #include "JitAsm.h" #include "../JitCommon/JitCache.h" -#include "JitRegCache.h" #if !defined JITTEST || ! JITTEST #error JitIL needs JITTEST define @@ -197,9 +196,6 @@ void Jit64::Init() jo.fastInterrupts = false; jo.accurateSinglePrecision = false; - gpr.SetEmitter(this); - fpr.SetEmitter(this); - trampolines.Init(); AllocCodeSpace(CODE_SIZE); @@ -226,8 +222,6 @@ void Jit64::Shutdown() void Jit64::WriteCallInterpreter(UGeckoInstruction inst) { - gpr.Flush(FLUSH_ALL); - fpr.Flush(FLUSH_ALL); if (js.isLastInstruction) { MOV(32, M(&PC), Imm32(js.compilerPC)); @@ -257,8 +251,6 @@ void Jit64::Default(UGeckoInstruction _inst) void Jit64::HLEFunction(UGeckoInstruction _inst) { - gpr.Flush(FLUSH_ALL); - fpr.Flush(FLUSH_ALL); ABI_CallFunctionCC((void*)&HLE::Execute, js.compilerPC, _inst.hex); MOV(32, R(EAX), M(&NPC)); WriteExitDestInEAX(0); diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h index 02a8c5bc6b..fa0ba37508 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h @@ -32,11 +32,6 @@ #include "../PPCAnalyst.h" #include "../JitCommon/JitCache.h" -#if JITTEST -#include "../Jit64IL/JitRegCache.h" -#else -#include "../Jit64/JitRegCache.h" -#endif #include "x64Emitter.h" #include "x64Analyzer.h" #include "IR.h" @@ -134,8 +129,6 @@ private: JitBlockCache blocks; TrampolineCache trampolines; - GPRRegCache gpr; - FPURegCache fpr; // The default code buffer. We keep it around to not have to alloc/dealloc a // large chunk of memory for each recompiled block. diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.cpp deleted file mode 100644 index 0b470d9daa..0000000000 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.cpp +++ /dev/null @@ -1,394 +0,0 @@ -// Copyright (C) 2003-2009 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. - -// 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/ - -#include "../PowerPC.h" -#include "../PPCTables.h" -#include "../PPCAnalyst.h" -#include "Jit.h" -#include "JitAsm.h" -#include "JitRegCache.h" - -using namespace Gen; -using namespace PowerPC; - -void RegCache::Start(PPCAnalyst::BlockRegStats &stats) -{ - for (int i = 0; i < NUMXREGS; i++) - { - xregs[i].free = true; - xregs[i].dirty = false; - xlocks[i] = false; - } - for (int i = 0; i < 32; i++) - { - regs[i].location = GetDefaultLocation(i); - regs[i].away = false; - } - - // todo: sort to find the most popular regs - /* - int maxPreload = 2; - for (int i = 0; i < 32; i++) - { - if (stats.numReads[i] > 2 || stats.numWrites[i] >= 2) - { - LoadToX64(i, true, false); //stats.firstRead[i] <= stats.firstWrite[i], false); - maxPreload--; - if (!maxPreload) - break; - } - }*/ - //Find top regs - preload them (load bursts ain't bad) - //But only preload IF written OR reads >= 3 -} - -// these are powerpc reg indices -void RegCache::Lock(int p1, int p2, int p3, int p4) -{ - locks[p1] = true; - if (p2 != 0xFF) locks[p2] = true; - if (p3 != 0xFF) locks[p3] = true; - if (p4 != 0xFF) locks[p4] = true; -} - -// these are x64 reg indices -void RegCache::LockX(int x1, int x2, int x3, int x4) -{ - if (xlocks[x1]) { - PanicAlert("RegCache: x %i already locked!"); - } - xlocks[x1] = true; - if (x2 != 0xFF) xlocks[x2] = true; - if (x3 != 0xFF) xlocks[x3] = true; - if (x4 != 0xFF) xlocks[x4] = true; -} - -bool RegCache::IsFreeX(int xreg) const -{ - return xregs[xreg].free && !xlocks[xreg]; -} - -void RegCache::UnlockAll() -{ - for (int i = 0; i < 32; i++) - locks[i] = false; -} - -void RegCache::UnlockAllX() -{ - for (int i = 0; i < NUMXREGS; i++) - xlocks[i] = false; -} - -X64Reg RegCache::GetFreeXReg() -{ - int aCount; - const int *aOrder = GetAllocationOrder(aCount); - for (int i = 0; i < aCount; i++) - { - X64Reg xr = (X64Reg)aOrder[i]; - if (!xlocks[xr] && xregs[xr].free) - { - return (X64Reg)xr; - } - } - //Okay, not found :( Force grab one - - //TODO - add a pass to grab xregs whose ppcreg is not used in the next 3 instructions - for (int i = 0; i < aCount; i++) - { - X64Reg xr = (X64Reg)aOrder[i]; - if (xlocks[xr]) - continue; - int preg = xregs[xr].ppcReg; - if (!locks[preg]) - { - StoreFromX64(preg); - return xr; - } - } - //Still no dice? Die! - _assert_msg_(DYNA_REC, 0, "Regcache ran out of regs"); - return (X64Reg) -1; -} - -void RegCache::SaveState() -{ - memcpy(saved_locks, locks, sizeof(locks)); - memcpy(saved_xlocks, xlocks, sizeof(xlocks)); - memcpy(saved_regs, regs, sizeof(regs)); - memcpy(saved_xregs, xregs, sizeof(xregs)); -} - -void RegCache::LoadState() -{ - memcpy(xlocks, saved_xlocks, sizeof(xlocks)); - memcpy(locks, saved_locks, sizeof(locks)); - memcpy(regs, saved_regs, sizeof(regs)); - memcpy(xregs, saved_xregs, sizeof(xregs)); -} - -void RegCache::FlushR(X64Reg reg) -{ - if (reg >= NUMXREGS) - PanicAlert("Flushing non existent reg"); - if (!xregs[reg].free) - { - StoreFromX64(xregs[reg].ppcReg); - } -} - -void RegCache::SanityCheck() const -{ - for (int i = 0; i < 32; i++) { - if (regs[i].away) { - if (regs[i].location.IsSimpleReg()) { - Gen::X64Reg simple = regs[i].location.GetSimpleReg(); - if (xlocks[simple]) { - PanicAlert("%08x : PPC Reg %i is in locked x64 register %i", /*js.compilerPC*/ 0, i, regs[i].location.GetSimpleReg()); - } - if (xregs[simple].ppcReg != i) { - PanicAlert("%08x : Xreg/ppcreg mismatch"); - } - } - } - } -} - -void RegCache::DiscardRegContentsIfCached(int preg) -{ - if (regs[preg].away && regs[preg].location.IsSimpleReg()) - { - xregs[regs[preg].location.GetSimpleReg()].free = true; - xregs[regs[preg].location.GetSimpleReg()].dirty = false; - regs[preg].away = false; - } -} - - -void GPRRegCache::SetImmediate32(int preg, u32 immValue) -{ - DiscardRegContentsIfCached(preg); - regs[preg].away = true; - regs[preg].location = Imm32(immValue); -} - -void GPRRegCache::Start(PPCAnalyst::BlockRegStats &stats) -{ - RegCache::Start(stats); -} - -void FPURegCache::Start(PPCAnalyst::BlockRegStats &stats) -{ - RegCache::Start(stats); -} - -const int *GPRRegCache::GetAllocationOrder(int &count) -{ - static const int allocationOrder[] = - { -#ifdef _M_X64 -#ifdef _WIN32 - RSI, RDI, R13, R14, R8, R9, R10, R11 //, RCX -#else - RBP, R13, R14, R8, R9, R10, R11, //, RCX -#endif -#elif _M_IX86 - ESI, EDI, EBX, EBP, EDX, ECX, -#endif - }; - count = sizeof(allocationOrder) / sizeof(const int); - return allocationOrder; -} - -const int *FPURegCache::GetAllocationOrder(int &count) -{ - static const int allocationOrder[] = - { -#ifdef _M_X64 - XMM6, XMM7, XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, XMM2, XMM3, XMM4, XMM5 -#elif _M_IX86 - XMM2, XMM3, XMM4, XMM5, XMM6, XMM7, -#endif - }; - count = sizeof(allocationOrder) / sizeof(int); - return allocationOrder; -} - -OpArg GPRRegCache::GetDefaultLocation(int reg) const -{ - return M(&ppcState.gpr[reg]); -} - -OpArg FPURegCache::GetDefaultLocation(int reg) const -{ - return M(&ppcState.ps[reg][0]); -} - -void RegCache::KillImmediate(int preg) -{ - if (regs[preg].away && regs[preg].location.IsImm()) - { - LoadToX64(preg, true, true); - } -} - -void GPRRegCache::LoadToX64(int i, bool doLoad, bool makeDirty) -{ - PanicAlert("BADNESS!"); - - if (!regs[i].away && regs[i].location.IsImm()) - PanicAlert("Bad immedaite"); - - if (!regs[i].away || (regs[i].away && regs[i].location.IsImm())) - { - X64Reg xr = GetFreeXReg(); - if (xregs[xr].dirty) PanicAlert("Xreg already dirty"); - if (xlocks[xr]) PanicAlert("GetFreeXReg returned locked register"); - xregs[xr].free = false; - xregs[xr].ppcReg = i; - xregs[xr].dirty = makeDirty || regs[i].location.IsImm(); - OpArg newloc = ::Gen::R(xr); - if (doLoad) - emit->MOV(32, newloc, regs[i].location); - for (int j = 0; j < 32; j++) - { - if (i != j && regs[j].location.IsSimpleReg() && regs[j].location.GetSimpleReg() == xr) - { - Crash(); - } - } - regs[i].away = true; - regs[i].location = newloc; - } - else - { - // reg location must be simplereg; memory locations - // and immediates are taken care of above. - xregs[RX(i)].dirty |= makeDirty; - } - if (xlocks[RX(i)]) { - PanicAlert("Seriously WTF, this reg should have been flushed"); - } -} - -void GPRRegCache::StoreFromX64(int i) -{ - if (regs[i].away) - { - bool doStore; - if (regs[i].location.IsSimpleReg()) - { - X64Reg xr = RX(i); - xregs[xr].free = true; - xregs[xr].ppcReg = -1; - doStore = xregs[xr].dirty; - xregs[xr].dirty = false; - } - else - { - //must be immediate - do nothing - doStore = true; - } - OpArg newLoc = GetDefaultLocation(i); - // if (doStore) //<-- Breaks JIT compilation - emit->MOV(32, newLoc, regs[i].location); - regs[i].location = newLoc; - regs[i].away = false; - } -} - -void FPURegCache::LoadToX64(int i, bool doLoad, bool makeDirty) -{ - _assert_msg_(DYNA_REC, !regs[i].location.IsImm(), "WTF - load - imm"); - if (!regs[i].away) - { - // Reg is at home in the memory register file. Let's pull it out. - X64Reg xr = GetFreeXReg(); - _assert_msg_(DYNA_REC, xr >= 0 && xr < NUMXREGS, "WTF - load - invalid reg"); - xregs[xr].ppcReg = i; - xregs[xr].free = false; - xregs[xr].dirty = makeDirty; - OpArg newloc = ::Gen::R(xr); - if (doLoad) - { - if (!regs[i].location.IsImm() && (regs[i].location.offset & 0xF)) - { - PanicAlert("WARNING - misaligned fp register location %i", i); - } - emit->MOVAPD(xr, regs[i].location); - } - regs[i].location = newloc; - regs[i].away = true; - } else { - // There are no immediates in the FPR reg file, so we already had this in a register. Make dirty as necessary. - xregs[RX(i)].dirty |= makeDirty; - } -} - -void FPURegCache::StoreFromX64(int i) -{ - _assert_msg_(DYNA_REC, !regs[i].location.IsImm(), "WTF - store - imm"); - if (regs[i].away) - { - X64Reg xr = regs[i].location.GetSimpleReg(); - _assert_msg_(DYNA_REC, xr >= 0 && xr < NUMXREGS, "WTF - store - invalid reg"); - xregs[xr].free = true; - xregs[xr].dirty = false; - xregs[xr].ppcReg = -1; - OpArg newLoc = GetDefaultLocation(i); - emit->MOVAPD(newLoc, xr); - regs[i].location = newLoc; - regs[i].away = false; - } - else - { - // _assert_msg_(DYNA_REC,0,"already stored"); - } -} - -void RegCache::Flush(FlushMode mode) -{ - for (int i = 0; i < NUMXREGS; i++) { - if (xlocks[i]) - PanicAlert("Somone forgot to unlock X64 reg %i.", i); - } - for (int i = 0; i < 32; i++) - { - if (locks[i]) - { - PanicAlert("Somebody forgot to unlock PPC reg %i.", i); - } - if (regs[i].away) - { - if (regs[i].location.IsSimpleReg()) - { - X64Reg xr = RX(i); - StoreFromX64(i); - xregs[xr].dirty = false; - } - else if (regs[i].location.IsImm()) - { - StoreFromX64(i); - } - else - { - _assert_msg_(DYNA_REC,0,"Jit64 - Flush unhandled case, reg %i", i); - } - } - } -} diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.h b/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.h deleted file mode 100644 index f1404fc1be..0000000000 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/JitRegCache.h +++ /dev/null @@ -1,150 +0,0 @@ -// Copyright (C) 2003-2009 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. - -// 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/ - -#ifndef _JITREGCACHE_H -#define _JITREGCACHE_H - -#include "x64Emitter.h" - -using namespace Gen; -enum FlushMode -{ - FLUSH_ALL -}; - -enum GrabMode -{ - M_READ = 1, - M_WRITE = 2, - M_READWRITE = 3, -}; - -struct PPCCachedReg -{ - OpArg location; - bool away; // value not in source register -}; - -struct X64CachedReg -{ - int ppcReg; - bool dirty; - bool free; -}; - -typedef int XReg; -typedef int PReg; - -#ifdef _M_X64 -#define NUMXREGS 16 -#elif _M_IX86 -#define NUMXREGS 8 -#endif - -class RegCache -{ -private: - bool locks[32]; - bool saved_locks[32]; - bool saved_xlocks[NUMXREGS]; - -protected: - bool xlocks[NUMXREGS]; - PPCCachedReg regs[32]; - X64CachedReg xregs[NUMXREGS]; - - PPCCachedReg saved_regs[32]; - X64CachedReg saved_xregs[NUMXREGS]; - - void DiscardRegContentsIfCached(int preg); - virtual const int *GetAllocationOrder(int &count) = 0; - - XEmitter *emit; - -public: - virtual ~RegCache() {} - virtual void Start(PPCAnalyst::BlockRegStats &stats) = 0; - - void SetEmitter(XEmitter *emitter) {emit = emitter;} - - void FlushR(X64Reg reg); - void FlushR(X64Reg reg, X64Reg reg2) {FlushR(reg); FlushR(reg2);} - void FlushLockX(X64Reg reg) { - FlushR(reg); - LockX(reg); - } - void FlushLockX(X64Reg reg1, X64Reg reg2) { - FlushR(reg1); FlushR(reg2); - LockX(reg1); LockX(reg2); - } - virtual void Flush(FlushMode mode); - virtual void Flush(PPCAnalyst::CodeOp *op) {Flush(FLUSH_ALL);} - void SanityCheck() const; - void KillImmediate(int preg); - - //TODO - instead of doload, use "read", "write" - //read only will not set dirty flag - virtual void LoadToX64(int preg, bool doLoad = true, bool makeDirty = true) = 0; - virtual void StoreFromX64(int preg) = 0; - - const OpArg &R(int preg) const {return regs[preg].location;} - X64Reg RX(int preg) const - { - if (regs[preg].away && regs[preg].location.IsSimpleReg()) - return regs[preg].location.GetSimpleReg(); - PanicAlert("Not so simple - %i", preg); - return (X64Reg)-1; - } - virtual OpArg GetDefaultLocation(int reg) const = 0; - - // Register locking. - void Lock(int p1, int p2=0xff, int p3=0xff, int p4=0xff); - void LockX(int x1, int x2=0xff, int x3=0xff, int x4=0xff); - void UnlockAll(); - void UnlockAllX(); - - bool IsFreeX(int xreg) const; - - X64Reg GetFreeXReg(); - - void SaveState(); - void LoadState(); -}; - -class GPRRegCache : public RegCache -{ -public: - void Start(PPCAnalyst::BlockRegStats &stats); - void LoadToX64(int preg, bool doLoad = true, bool makeDirty = true); - void StoreFromX64(int preg); - OpArg GetDefaultLocation(int reg) const; - const int *GetAllocationOrder(int &count); - void SetImmediate32(int preg, u32 immValue); -}; - - -class FPURegCache : public RegCache -{ -public: - void Start(PPCAnalyst::BlockRegStats &stats); - void LoadToX64(int preg, bool doLoad = true, bool makeDirty = true); - void StoreFromX64(int preg); - const int *GetAllocationOrder(int &count); - OpArg GetDefaultLocation(int reg) const; -}; - -#endif diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp index bfd7035acc..e98368324c 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp @@ -24,7 +24,6 @@ #include "x64Emitter.h" #include "Jit.h" -#include "JitRegCache.h" #include "JitAsm.h" #include "../../HW/Memmap.h" diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp index 61aedcc90a..38ae196cde 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp @@ -23,7 +23,6 @@ #include "x64Emitter.h" #include "Jit.h" -#include "JitRegCache.h" //#define INSTRUCTION_START Default(inst); return; #define INSTRUCTION_START diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp index ec2e201387..2f87c15c26 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp @@ -25,7 +25,6 @@ #include "x64Emitter.h" #include "Jit.h" -#include "JitRegCache.h" #include "JitAsm.h" //#define INSTRUCTION_START Default(inst); return; diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStore.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStore.cpp index 52515a633e..8749a49467 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStore.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStore.cpp @@ -33,7 +33,6 @@ #include "Jit.h" #include "JitAsm.h" -#include "JitRegCache.h" //#define INSTRUCTION_START Default(inst); return; #define INSTRUCTION_START diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStoreFloating.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStoreFloating.cpp index c1b1afa4fa..7d79e5eaae 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStoreFloating.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStoreFloating.cpp @@ -33,7 +33,6 @@ #include "Jit.h" #include "JitAsm.h" -#include "JitRegCache.h" //#define INSTRUCTION_START Default(inst); return; #define INSTRUCTION_START diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStorePaired.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStorePaired.cpp index 74c4745ed9..20896175d2 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStorePaired.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_LoadStorePaired.cpp @@ -34,7 +34,6 @@ #include "Jit.h" #include "JitAsm.h" -#include "JitRegCache.h" //#define INSTRUCTION_START Default(inst); return; #define INSTRUCTION_START diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Paired.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Paired.cpp index 4db88a0972..19583b2e6a 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Paired.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Paired.cpp @@ -24,7 +24,6 @@ #include "../../HW/GPFifo.h" #include "Jit.h" -#include "JitRegCache.h" void Jit64::ps_mr(UGeckoInstruction inst) { diff --git a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_SystemRegisters.cpp b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_SystemRegisters.cpp index e4d2c5aa7c..acfb86149d 100644 --- a/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_SystemRegisters.cpp +++ b/Source/Core/Core/Src/PowerPC/Jit64IL/Jit_SystemRegisters.cpp @@ -27,7 +27,6 @@ #include "Thunk.h" #include "Jit.h" -#include "JitRegCache.h" //#define INSTRUCTION_START Default(inst); return; #define INSTRUCTION_START diff --git a/Source/Core/Core/Src/PowerPC/JitCommon/Jit_Util.cpp b/Source/Core/Core/Src/PowerPC/JitCommon/Jit_Util.cpp index 4eabbed4e5..e75b10a8cc 100644 --- a/Source/Core/Core/Src/PowerPC/JitCommon/Jit_Util.cpp +++ b/Source/Core/Core/Src/PowerPC/JitCommon/Jit_Util.cpp @@ -32,7 +32,6 @@ #include "../Jit64IL/Jit.h" #include "JitCache.h" #include "../Jit64IL/JitAsm.h" -#include "../Jit64IL/JitRegCache.h" #else #include "../Jit64/Jit.h" #include "JitCache.h" @@ -40,6 +39,8 @@ #include "../Jit64/JitRegCache.h" #endif +using namespace Gen; + void Jit64::JitClearCA() { AND(32, M(&PowerPC::ppcState.spr[SPR_XER]), Imm32(~XER_CA_MASK)); //XER.CA = 0 diff --git a/Source/Core/Core/Src/SConscript b/Source/Core/Core/Src/SConscript index feda2e734e..5dbfb6f952 100644 --- a/Source/Core/Core/Src/SConscript +++ b/Source/Core/Core/Src/SConscript @@ -92,7 +92,6 @@ files = ["ActionReplay.cpp", if env['JITTEST']: files += ["PowerPC/Jit64IL/Jit.cpp", - "PowerPC/Jit64IL/JitRegCache.cpp", "PowerPC/Jit64IL/JitAsm.cpp", "PowerPC/Jit64IL/Jit_Branch.cpp", "PowerPC/Jit64IL/Jit_Integer.cpp",