The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-10 08:09:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

Switch between JIT and Interpreter at runtime using the debug window (pause first!)

Browse Source 
Plus assorted cleanup & fixes.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@312 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard 2008-08-25 20:34:11 +00:00
parent 35fdbdc360
commit fd188ec09e
32 changed files with 1039 additions and 1150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/Core/Core.vcproj
View File

@ -800,10 +800,6 @@
RelativePath=".\Src\PowerPC\Gekko.h"
>
</File>
<File
RelativePath=".\Src\PowerPC\ICPUCore.h"
>
</File>
<File
RelativePath=".\Src\PowerPC\PowerPC.cpp"
>

3
Source/Core/Core/Src/Boot/Boot.cpp
View File

@ -446,7 +446,8 @@ bool CBoot::Load_BIOS(const std::string& _rBiosFilename)
bool CBoot::BootUp(const SCoreStartupParameter& _StartupPara)
{
const bool bDebugIsoBootup = false;
g_symbolDB.Clear();
VideoInterface::PreInit(_StartupPara.bNTSC);
switch(_StartupPara.m_BootType)
{

10
Source/Core/Core/Src/Core.cpp
View File

@ -296,17 +296,17 @@ THREAD_RETURN EmuThread(void *pArg)
g_bHwInit = true;
// Load GCM/DOL/ELF whatever ... we boot with the interpreter core
PowerPC::SetCore(PowerPC::CORE_INTERPRETER);
PowerPC::SetMode(PowerPC::MODE_INTERPRETER);
CBoot::BootUp(_CoreParameter);
if( g_pUpdateFPSDisplay != NULL )
g_pUpdateFPSDisplay("Loading...");
// setup our core, but can't use dynarec if we are compare server
if (_CoreParameter.bUseDynarec && !_CoreParameter.bRunCompareServer || _CoreParameter.bRunCompareClient)
PowerPC::SetCore(PowerPC::CORE_DYNAREC);
if (_CoreParameter.bUseJIT && !_CoreParameter.bRunCompareServer || _CoreParameter.bRunCompareClient)
PowerPC::SetMode(PowerPC::MODE_JIT);
else
PowerPC::SetCore(PowerPC::CORE_INTERPRETER);
PowerPC::SetMode(PowerPC::MODE_INTERPRETER);
// update the window again because all stuff is initialized
Host_UpdateDisasmDialog();
@ -472,7 +472,7 @@ void Callback_VideoCopiedToXFB()
char temp[256];
sprintf(temp, "FPS: %8.2f - %s - %i MHz (%i real, %i idle skipped) out of %i MHz",
(float)frames / t,
g_CoreStartupParameter.bUseDynarec ? "JIT" : "Interpreter",
g_CoreStartupParameter.bUseJIT ? "JIT" : "Interpreter",
(int)(diff),
(int)(diff-idleDiff),
(int)(idleDiff),

2
Source/Core/Core/Src/CoreParameter.cpp
View File

@ -30,7 +30,7 @@ SCoreStartupParameter::SCoreStartupParameter()
void SCoreStartupParameter::LoadDefaults()
{
bEnableDebugging = false;
bUseDynarec = false;
bUseJIT = false;
bUseDualCore = false;
bRunCompareServer = false;
bLockThreads = true;

2
Source/Core/Core/Src/CoreParameter.h
View File

@ -35,7 +35,7 @@ struct SCoreStartupParameter
// flags
bool bEnableDebugging;
bool bUseDynarec;
bool bUseJIT;
bool bUseDualCore;
bool bNTSC;
bool bHLEBios;

4
Source/Core/Core/Src/HW/CPU.cpp
View File

@ -81,7 +81,7 @@ void CCPU::Run()
break;
}
/* if (!Core::g_CoreStartupParameter.bUseDynarec && CBreakPoints::GetBreakCount() == PowerPC::ppcState.DebugCount)
/* if (!Core::g_CoreStartupParameter.bUseJIT && CBreakPoints::GetBreakCount() == PowerPC::ppcState.DebugCount)
{
LOG(GEKKO, "Hit DebugCount breakpoint - %i", PowerPC::ppcState.DebugCount);
EnableStepping(true);
@ -192,7 +192,7 @@ void CCPU::SingleStep()
break;
}
if (!Core::g_CoreStartupParameter.bUseDynarec && CBreakPoints::GetBreakCount() == PowerPC::ppcState.DebugCount)
if (!Core::g_CoreStartupParameter.bUseJIT && CBreakPoints::GetBreakCount() == PowerPC::ppcState.DebugCount)
{
LOG(GEKKO, "Hit DebugCount breakpoint - %i", PowerPC::ppcState.DebugCount);
EnableStepping(true);

4
Source/Core/Core/Src/HW/CPUCompare.cpp
View File

@ -120,7 +120,7 @@ int Sync()
if (!m_bEnabled)
return 0;
if (m_bIsServer) //This should be interpreter
if (m_bIsServer) // This should be interpreter
{
//write cpu state to m_hPipe
HRESULT result;
@ -135,7 +135,7 @@ int Sync()
}
// LogManager::Redraw();
}
else //This should be dynarec
else // This should be JIT
{
u32 read;
memset(&state,0xcc,stateSize);

2
Source/Core/Core/Src/HW/Memmap.h
View File

@ -89,7 +89,7 @@ namespace Memory
inline u32 ReadFast32(const u32 _Address)
{
#ifdef _M_IX86
return ReadUnchecked_U32(_Address);
return Common::swap32(*(u32 *)(base + (_Address & MEMVIEW32_MASK))); //ReadUnchecked_U32(_Address);
#elif defined(_M_X64)
return Common::swap32(*(u32 *)(base + _Address));
#endif

34
Source/Core/Core/Src/PowerPC/ICPUCore.h
View File

@ -1,34 +0,0 @@
// Copyright (C) 2003-2008 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/
// Interface to connect a core like interpreter or dynarec
//
#ifndef _ICPUCORE_H
#define _ICPUCORE_H
class ICPUCore
{
public:
virtual ~ICPUCore() {}
virtual void Init() = 0;
virtual void Shutdown() = 0;
virtual void Reset() = 0;
virtual void SingleStep() = 0;
virtual void Run() = 0;
};
#endif

138
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter.cpp
View File

@ -27,111 +27,46 @@
#include "PowerPCDisasm.h"
#include "../../IPC_HLE/WII_IPC_HLE.h"
static const unsigned short FPU_PREC_24 = 0 << 8;
static const unsigned short FPU_PREC_53 = 2 << 8;
static const unsigned short FPU_PREC_64 = 3 << 8;
static const unsigned short FPU_PREC_MASK = 3 << 8;
enum {
FPU_PREC_24 = 0 << 8,
FPU_PREC_53 = 2 << 8,
FPU_PREC_64 = 3 << 8,
FPU_PREC_MASK = 3 << 8,
};
// cpu register to keep the code readable
u32* CInterpreter::m_GPR = PowerPC::ppcState.gpr;
bool CInterpreter::m_EndBlock = false;
namespace {
u32 last_pc;
}
// function tables
CInterpreter::_interpreterInstruction CInterpreter::m_opTable[64];
CInterpreter::_interpreterInstruction CInterpreter::m_opTable4[1024];
CInterpreter::_interpreterInstruction CInterpreter::m_opTable19[1024];
CInterpreter::_interpreterInstruction CInterpreter::m_opTable31[1024];
CInterpreter::_interpreterInstruction CInterpreter::m_opTable59[32];
CInterpreter::_interpreterInstruction CInterpreter::m_opTable63[1024];
void CInterpreter::RunTable4(UGeckoInstruction _inst) {m_opTable4 [_inst.SUBOP10](_inst);}
void CInterpreter::RunTable19(UGeckoInstruction _inst) {m_opTable19[_inst.SUBOP10](_inst);}
void CInterpreter::RunTable31(UGeckoInstruction _inst) {m_opTable31[_inst.SUBOP10](_inst);}
void CInterpreter::RunTable59(UGeckoInstruction _inst) {m_opTable59[_inst.SUBOP5 ](_inst);}
void CInterpreter::RunTable63(UGeckoInstruction _inst) {m_opTable63[_inst.SUBOP10](_inst);}
void CInterpreter::sInit()
namespace Interpreter
{
// Crash();
#ifdef _M_IX86
// sets the floating-point lib to 53-bit
// PowerPC has a 53bit floating pipeline only
// eg: sscanf is very sensitive
#ifdef _WIN32
_control87(_PC_53, MCW_PC);
#else
unsigned short mode;
asm ("fstcw %0" : : "m" (mode));
mode = (mode & ~FPU_PREC_MASK) | FPU_PREC_53;
asm ("fldcw %0" : : "m" (mode));
#endif
#else
//x64 doesn't need this - fpu is done with SSE
//but still - set any useful sse options here
#endif
}
// cpu register to keep the code readable
u32 *m_GPR = PowerPC::ppcState.gpr;
bool m_EndBlock = false;
void CInterpreter::sShutdown()
_interpreterInstruction m_opTable[64];
_interpreterInstruction m_opTable4[1024];
_interpreterInstruction m_opTable19[1024];
_interpreterInstruction m_opTable31[1024];
_interpreterInstruction m_opTable59[32];
_interpreterInstruction m_opTable63[1024];
void RunTable4(UGeckoInstruction _inst) {m_opTable4 [_inst.SUBOP10](_inst);}
void RunTable19(UGeckoInstruction _inst) {m_opTable19[_inst.SUBOP10](_inst);}
void RunTable31(UGeckoInstruction _inst) {m_opTable31[_inst.SUBOP10](_inst);}
void RunTable59(UGeckoInstruction _inst) {m_opTable59[_inst.SUBOP5 ](_inst);}
void RunTable63(UGeckoInstruction _inst) {m_opTable63[_inst.SUBOP10](_inst);}
void Init()
{
}
void CInterpreter::sReset()
void Shutdown()
{
}
void CInterpreter::Log()
{
static u32 startPC = 0x80003154;
const char *kLogFile = "D:\\dolphin.txt";
static bool bStart = false;
if ((PC == startPC) && (bStart == false))
{
FILE* pOut = fopen(kLogFile, "wt");
if (pOut)
fclose(pOut);
bStart = true;
// just for sync
/* m_FPR[8].u64 = 0x0000000080000000;
m_FPR[10].u64 = 0x00000000a0000000;
m_FPR[4].u64 = 0x0000000000000000;
m_FPR[5].u64 = 0x0000000000000000;
m_FPR[6].u64 = 0x0000000000000000;
m_FPR[12].u64 = 0x0000000040000000; */
}
if (bStart)
{
static int steps = 0;
steps ++;
// if (steps > 150000)
{
FILE* pOut = fopen(kLogFile, "at");
if (pOut != NULL)
{
fprintf(pOut, "0x%08x: PC: 0x%08x (carry: %i)\n", steps, PC, GetCarry() ? 1:0);
for (int i=0; i<32;i++)
{
//fprintf(pOut, "GPR[%02i] 0x%08x\n", i, m_GPR[i]);
}
for (int i=0; i<32;i++)
{
// fprintf(pOut, "FPR[%02i] 0x%016x (%.4f)\n", i, m_FPR[i].u64, m_FPR[i].d);
// fprintf(pOut, "FPR[%02i] 0x%016x\n", i, m_FPR[i].u64);
// fprintf(pOut, "PS[%02i] %.4f %.4f\n", i, m_PS0[i], m_PS0[i]);
}
fclose(pOut);
}
//if (steps >= 10000)
//exit(1);
}
}
}
//#include "../../Plugins/Plugin_DSP.h"
void patches()
@ -152,10 +87,8 @@ void patches()
// WII_IPC_HLE_Interface::Update();
}
void CInterpreter::sStepInner(void)
void SingleStepInner(void)
{
// Log();
/* static int count = 0;
count++;
if ((count % 50) == 0)
@ -163,8 +96,8 @@ void CInterpreter::sStepInner(void)
static UGeckoInstruction instCode;
NPC = PC + sizeof(UGeckoInstruction);
instCode.hex = Memory::ReadFast32(PC); // Memory::ReadUnchecked_U32(PC);
instCode.hex = Memory::ReadUnchecked_U32(PC);
//Memory::Read_Instruction(PC); // use the memory functions to read from the memory !!!!!!
//if (PowerPC::ppcState.DebugCount > 0x10f233a) { // 50721ef253a
// printf("> %08x - %08x - %s\n", PC, instCode.hex, DisassembleGekko(instCode.hex, PC));
@ -199,9 +132,9 @@ void CInterpreter::sStepInner(void)
patches();
}
void CInterpreter::sStep()
void SingleStep()
{
sStepInner();
SingleStepInner();
CoreTiming::slicelength = 1;
CoreTiming::downcount = 0;
@ -215,7 +148,7 @@ void CInterpreter::sStep()
}
// sFastRun - inspired by GCemu
void CInterpreter::sFastRun()
void Run()
{
while (!PowerPC::state)
{
@ -226,11 +159,8 @@ void CInterpreter::sFastRun()
int i;
for (i = 0; !m_EndBlock; i++)
{
sStepInner();
SingleStepInner();
}
#if defined(DEBUGFAST) || defined(_DEBUG)
// Core::SyncTrace();
#endif
CoreTiming::downcount -= i;
}
@ -244,10 +174,12 @@ void CInterpreter::sFastRun()
}
}
void CInterpreter::unknown_instruction(UGeckoInstruction _inst)
void unknown_instruction(UGeckoInstruction _inst)
{
CCPU::Break();
printf("Last PC = %08x : %s\n", last_pc, DisassembleGekko(Memory::ReadUnchecked_U32(last_pc), last_pc));
Debugger::PrintCallstack();
_dbg_assert_msg_(GEKKO, 0, "\nIntCPU: Unknown instr %08x at PC = %08x last_PC = %08x LR = %08x\n", _inst.hex, PC, last_pc, LR);
}
} // namespace

554
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter.h
View File

@ -21,326 +21,304 @@
#include "../Gekko.h"
#include "../PowerPC.h"
class CInterpreter : public ICPUCore
namespace Interpreter
{
public:
// ICPUCore Interface
void Init() { sInit(); }
void Shutdown() { sShutdown(); }
void Reset() { sReset(); }
void SingleStep() { sStep(); }
void Run() { sFastRun(); }
static void sInit();
static void sShutdown();
static void sReset();
static void sStep();
static void sStepInner();
static void sFastRun();
void Init();
void Shutdown();
void Reset();
void SingleStep();
void SingleStepInner();
void Run();
typedef void (*_interpreterInstruction)(UGeckoInstruction instCode);
static _interpreterInstruction GetInstruction(UGeckoInstruction instCode);
_interpreterInstruction GetInstruction(UGeckoInstruction instCode);
private:
static void Log();
void Log();
// pointer to the CPU-Regs to keep the code cleaner
static u32* m_GPR;
static bool m_EndBlock;
extern u32* m_GPR;
extern bool m_EndBlock;
public:
static void unknown_instruction(UGeckoInstruction _inst);
void unknown_instruction(UGeckoInstruction _inst);
// Branch Instructions
static void bx(UGeckoInstruction _inst);
static void bcx(UGeckoInstruction _inst);
static void bcctrx(UGeckoInstruction _inst);
static void bclrx(UGeckoInstruction _inst);
static void HLEFunction(UGeckoInstruction _inst);
static void CompiledBlock(UGeckoInstruction _inst);
void bx(UGeckoInstruction _inst);
void bcx(UGeckoInstruction _inst);
void bcctrx(UGeckoInstruction _inst);
void bclrx(UGeckoInstruction _inst);
void HLEFunction(UGeckoInstruction _inst);
void CompiledBlock(UGeckoInstruction _inst);
// Syscall Instruction
static void sc(UGeckoInstruction _inst);
void sc(UGeckoInstruction _inst);
// Floating Point Instructions
static void faddsx(UGeckoInstruction _inst);
static void fdivsx(UGeckoInstruction _inst);
static void fmaddsx(UGeckoInstruction _inst);
static void fmsubsx(UGeckoInstruction _inst);
static void fmulsx(UGeckoInstruction _inst);
static void fnmaddsx(UGeckoInstruction _inst);
static void fnmsubsx(UGeckoInstruction _inst);
static void fresx(UGeckoInstruction _inst);
// static void fsqrtsx(UGeckoInstruction _inst);
static void fsubsx(UGeckoInstruction _inst);
static void fabsx(UGeckoInstruction _inst);
static void fcmpo(UGeckoInstruction _inst);
static void fcmpu(UGeckoInstruction _inst);
static void fctiwx(UGeckoInstruction _inst);
static void fctiwzx(UGeckoInstruction _inst);
static void fmrx(UGeckoInstruction _inst);
static void fnabsx(UGeckoInstruction _inst);
static void fnegx(UGeckoInstruction _inst);
static void frspx(UGeckoInstruction _inst);
static void faddx(UGeckoInstruction _inst);
static void fdivx(UGeckoInstruction _inst);
static void fmaddx(UGeckoInstruction _inst);
static void fmsubx(UGeckoInstruction _inst);
static void fmulx(UGeckoInstruction _inst);
static void fnmaddx(UGeckoInstruction _inst);
static void fnmsubx(UGeckoInstruction _inst);
static void frsqrtex(UGeckoInstruction _inst);
static void fselx(UGeckoInstruction _inst);
static void fsqrtx(UGeckoInstruction _inst);
static void fsubx(UGeckoInstruction _inst);
void faddsx(UGeckoInstruction _inst);
void fdivsx(UGeckoInstruction _inst);
void fmaddsx(UGeckoInstruction _inst);
void fmsubsx(UGeckoInstruction _inst);
void fmulsx(UGeckoInstruction _inst);
void fnmaddsx(UGeckoInstruction _inst);
void fnmsubsx(UGeckoInstruction _inst);
void fresx(UGeckoInstruction _inst);
// void fsqrtsx(UGeckoInstruction _inst);
void fsubsx(UGeckoInstruction _inst);
void fabsx(UGeckoInstruction _inst);
void fcmpo(UGeckoInstruction _inst);
void fcmpu(UGeckoInstruction _inst);
void fctiwx(UGeckoInstruction _inst);
void fctiwzx(UGeckoInstruction _inst);
void fmrx(UGeckoInstruction _inst);
void fnabsx(UGeckoInstruction _inst);
void fnegx(UGeckoInstruction _inst);
void frspx(UGeckoInstruction _inst);
void faddx(UGeckoInstruction _inst);
void fdivx(UGeckoInstruction _inst);
void fmaddx(UGeckoInstruction _inst);
void fmsubx(UGeckoInstruction _inst);
void fmulx(UGeckoInstruction _inst);
void fnmaddx(UGeckoInstruction _inst);
void fnmsubx(UGeckoInstruction _inst);
void frsqrtex(UGeckoInstruction _inst);
void fselx(UGeckoInstruction _inst);
void fsqrtx(UGeckoInstruction _inst);
void fsubx(UGeckoInstruction _inst);
// Integer Instructions
static void addi(UGeckoInstruction _inst);
static void addic(UGeckoInstruction _inst);
static void addic_rc(UGeckoInstruction _inst);
static void addis(UGeckoInstruction _inst);
static void andi_rc(UGeckoInstruction _inst);
static void andis_rc(UGeckoInstruction _inst);
static void cmpi(UGeckoInstruction _inst);
static void cmpli(UGeckoInstruction _inst);
static void mulli(UGeckoInstruction _inst);
static void ori(UGeckoInstruction _inst);
static void oris(UGeckoInstruction _inst);
static void subfic(UGeckoInstruction _inst);
static void twi(UGeckoInstruction _inst);
static void xori(UGeckoInstruction _inst);
static void xoris(UGeckoInstruction _inst);
static void rlwimix(UGeckoInstruction _inst);
static void rlwinmx(UGeckoInstruction _inst);
static void rlwnmx(UGeckoInstruction _inst);
static void andx(UGeckoInstruction _inst);
static void andcx(UGeckoInstruction _inst);
static void cmp(UGeckoInstruction _inst);
static void cmpl(UGeckoInstruction _inst);
static void cntlzwx(UGeckoInstruction _inst);
static void eqvx(UGeckoInstruction _inst);
static void extsbx(UGeckoInstruction _inst);
static void extshx(UGeckoInstruction _inst);
static void nandx(UGeckoInstruction _inst);
static void norx(UGeckoInstruction _inst);
static void orx(UGeckoInstruction _inst);
static void orcx(UGeckoInstruction _inst);
static void slwx(UGeckoInstruction _inst);
static void srawx(UGeckoInstruction _inst);
static void srawix(UGeckoInstruction _inst);
static void srwx(UGeckoInstruction _inst);
static void tw(UGeckoInstruction _inst);
static void xorx(UGeckoInstruction _inst);
static void addx(UGeckoInstruction _inst);
static void addcx(UGeckoInstruction _inst);
static void addex(UGeckoInstruction _inst);
static void addmex(UGeckoInstruction _inst);
static void addzex(UGeckoInstruction _inst);
static void divwx(UGeckoInstruction _inst);
static void divwux(UGeckoInstruction _inst);
static void mulhwx(UGeckoInstruction _inst);
static void mulhwux(UGeckoInstruction _inst);
static void mullwx(UGeckoInstruction _inst);
static void negx(UGeckoInstruction _inst);
static void subfx(UGeckoInstruction _inst);
static void subfcx(UGeckoInstruction _inst);
static void subfex(UGeckoInstruction _inst);
static void subfmex(UGeckoInstruction _inst);
static void subfzex(UGeckoInstruction _inst);
void addi(UGeckoInstruction _inst);
void addic(UGeckoInstruction _inst);
void addic_rc(UGeckoInstruction _inst);
void addis(UGeckoInstruction _inst);
void andi_rc(UGeckoInstruction _inst);
void andis_rc(UGeckoInstruction _inst);
void cmpi(UGeckoInstruction _inst);
void cmpli(UGeckoInstruction _inst);
void mulli(UGeckoInstruction _inst);
void ori(UGeckoInstruction _inst);
void oris(UGeckoInstruction _inst);
void subfic(UGeckoInstruction _inst);
void twi(UGeckoInstruction _inst);
void xori(UGeckoInstruction _inst);
void xoris(UGeckoInstruction _inst);
void rlwimix(UGeckoInstruction _inst);
void rlwinmx(UGeckoInstruction _inst);
void rlwnmx(UGeckoInstruction _inst);
void andx(UGeckoInstruction _inst);
void andcx(UGeckoInstruction _inst);
void cmp(UGeckoInstruction _inst);
void cmpl(UGeckoInstruction _inst);
void cntlzwx(UGeckoInstruction _inst);
void eqvx(UGeckoInstruction _inst);
void extsbx(UGeckoInstruction _inst);
void extshx(UGeckoInstruction _inst);
void nandx(UGeckoInstruction _inst);
void norx(UGeckoInstruction _inst);
void orx(UGeckoInstruction _inst);
void orcx(UGeckoInstruction _inst);
void slwx(UGeckoInstruction _inst);
void srawx(UGeckoInstruction _inst);
void srawix(UGeckoInstruction _inst);
void srwx(UGeckoInstruction _inst);
void tw(UGeckoInstruction _inst);
void xorx(UGeckoInstruction _inst);
void addx(UGeckoInstruction _inst);
void addcx(UGeckoInstruction _inst);
void addex(UGeckoInstruction _inst);
void addmex(UGeckoInstruction _inst);
void addzex(UGeckoInstruction _inst);
void divwx(UGeckoInstruction _inst);
void divwux(UGeckoInstruction _inst);
void mulhwx(UGeckoInstruction _inst);
void mulhwux(UGeckoInstruction _inst);
void mullwx(UGeckoInstruction _inst);
void negx(UGeckoInstruction _inst);
void subfx(UGeckoInstruction _inst);
void subfcx(UGeckoInstruction _inst);
void subfex(UGeckoInstruction _inst);
void subfmex(UGeckoInstruction _inst);
void subfzex(UGeckoInstruction _inst);
// Load/Store Instructions
static void lbz(UGeckoInstruction _inst);
static void lbzu(UGeckoInstruction _inst);
static void lfd(UGeckoInstruction _inst);
static void lfdu(UGeckoInstruction _inst);
static void lfs(UGeckoInstruction _inst);
static void lfsu(UGeckoInstruction _inst);
static void lha(UGeckoInstruction _inst);
static void lhau(UGeckoInstruction _inst);
static void lhz(UGeckoInstruction _inst);
static void lhzu(UGeckoInstruction _inst);
static void lmw(UGeckoInstruction _inst);
static void lwz(UGeckoInstruction _inst);
static void lwzu(UGeckoInstruction _inst);
static void stb(UGeckoInstruction _inst);
static void stbu(UGeckoInstruction _inst);
static void stfd(UGeckoInstruction _inst);
static void stfdu(UGeckoInstruction _inst);
static void stfs(UGeckoInstruction _inst);
static void stfsu(UGeckoInstruction _inst);
static void sth(UGeckoInstruction _inst);
static void sthu(UGeckoInstruction _inst);
static void stmw(UGeckoInstruction _inst);
static void stw(UGeckoInstruction _inst);
static void stwu(UGeckoInstruction _inst);
static void dcba(UGeckoInstruction _inst);
static void dcbf(UGeckoInstruction _inst);
static void dcbi(UGeckoInstruction _inst);
static void dcbst(UGeckoInstruction _inst);
static void dcbt(UGeckoInstruction _inst);
static void dcbtst(UGeckoInstruction _inst);
static void dcbz(UGeckoInstruction _inst);
static void eciwx(UGeckoInstruction _inst);
static void ecowx(UGeckoInstruction _inst);
static void eieio(UGeckoInstruction _inst);
static void icbi(UGeckoInstruction _inst);
static void lbzux(UGeckoInstruction _inst);
static void lbzx(UGeckoInstruction _inst);
static void lfdux(UGeckoInstruction _inst);
static void lfdx(UGeckoInstruction _inst);
static void lfsux(UGeckoInstruction _inst);
static void lfsx(UGeckoInstruction _inst);
static void lhaux(UGeckoInstruction _inst);
static void lhax(UGeckoInstruction _inst);
static void lhbrx(UGeckoInstruction _inst);
static void lhzux(UGeckoInstruction _inst);
static void lhzx(UGeckoInstruction _inst);
static void lswi(UGeckoInstruction _inst);
static void lswx(UGeckoInstruction _inst);
static void lwarx(UGeckoInstruction _inst);
static void lwbrx(UGeckoInstruction _inst);
static void lwzux(UGeckoInstruction _inst);
static void lwzx(UGeckoInstruction _inst);
static void stbux(UGeckoInstruction _inst);
static void stbx(UGeckoInstruction _inst);
static void stfdux(UGeckoInstruction _inst);
static void stfdx(UGeckoInstruction _inst);
static void stfiwx(UGeckoInstruction _inst);
static void stfsux(UGeckoInstruction _inst);
static void stfsx(UGeckoInstruction _inst);
static void sthbrx(UGeckoInstruction _inst);
static void sthux(UGeckoInstruction _inst);
static void sthx(UGeckoInstruction _inst);
static void stswi(UGeckoInstruction _inst);
static void stswx(UGeckoInstruction _inst);
static void stwbrx(UGeckoInstruction _inst);
static void stwcxd(UGeckoInstruction _inst);
static void stwux(UGeckoInstruction _inst);
static void stwx(UGeckoInstruction _inst);
static void sync(UGeckoInstruction _inst);
static void tlbia(UGeckoInstruction _inst);
static void tlbie(UGeckoInstruction _inst);
static void tlbsync(UGeckoInstruction _inst);
void lbz(UGeckoInstruction _inst);
void lbzu(UGeckoInstruction _inst);
void lfd(UGeckoInstruction _inst);
void lfdu(UGeckoInstruction _inst);
void lfs(UGeckoInstruction _inst);
void lfsu(UGeckoInstruction _inst);
void lha(UGeckoInstruction _inst);
void lhau(UGeckoInstruction _inst);
void lhz(UGeckoInstruction _inst);
void lhzu(UGeckoInstruction _inst);
void lmw(UGeckoInstruction _inst);
void lwz(UGeckoInstruction _inst);
void lwzu(UGeckoInstruction _inst);
void stb(UGeckoInstruction _inst);
void stbu(UGeckoInstruction _inst);
void stfd(UGeckoInstruction _inst);
void stfdu(UGeckoInstruction _inst);
void stfs(UGeckoInstruction _inst);
void stfsu(UGeckoInstruction _inst);
void sth(UGeckoInstruction _inst);
void sthu(UGeckoInstruction _inst);
void stmw(UGeckoInstruction _inst);
void stw(UGeckoInstruction _inst);
void stwu(UGeckoInstruction _inst);
void dcba(UGeckoInstruction _inst);
void dcbf(UGeckoInstruction _inst);
void dcbi(UGeckoInstruction _inst);
void dcbst(UGeckoInstruction _inst);
void dcbt(UGeckoInstruction _inst);
void dcbtst(UGeckoInstruction _inst);
void dcbz(UGeckoInstruction _inst);
void eciwx(UGeckoInstruction _inst);
void ecowx(UGeckoInstruction _inst);
void eieio(UGeckoInstruction _inst);
void icbi(UGeckoInstruction _inst);
void lbzux(UGeckoInstruction _inst);
void lbzx(UGeckoInstruction _inst);
void lfdux(UGeckoInstruction _inst);
void lfdx(UGeckoInstruction _inst);
void lfsux(UGeckoInstruction _inst);
void lfsx(UGeckoInstruction _inst);
void lhaux(UGeckoInstruction _inst);
void lhax(UGeckoInstruction _inst);
void lhbrx(UGeckoInstruction _inst);
void lhzux(UGeckoInstruction _inst);
void lhzx(UGeckoInstruction _inst);
void lswi(UGeckoInstruction _inst);
void lswx(UGeckoInstruction _inst);
void lwarx(UGeckoInstruction _inst);
void lwbrx(UGeckoInstruction _inst);
void lwzux(UGeckoInstruction _inst);
void lwzx(UGeckoInstruction _inst);
void stbux(UGeckoInstruction _inst);
void stbx(UGeckoInstruction _inst);
void stfdux(UGeckoInstruction _inst);
void stfdx(UGeckoInstruction _inst);
void stfiwx(UGeckoInstruction _inst);
void stfsux(UGeckoInstruction _inst);
void stfsx(UGeckoInstruction _inst);
void sthbrx(UGeckoInstruction _inst);
void sthux(UGeckoInstruction _inst);
void sthx(UGeckoInstruction _inst);
void stswi(UGeckoInstruction _inst);
void stswx(UGeckoInstruction _inst);
void stwbrx(UGeckoInstruction _inst);
void stwcxd(UGeckoInstruction _inst);
void stwux(UGeckoInstruction _inst);
void stwx(UGeckoInstruction _inst);
void sync(UGeckoInstruction _inst);
void tlbia(UGeckoInstruction _inst);
void tlbie(UGeckoInstruction _inst);
void tlbsync(UGeckoInstruction _inst);
// Paired Instructions
static void psq_l(UGeckoInstruction _inst);
static void psq_lu(UGeckoInstruction _inst);
static void psq_st(UGeckoInstruction _inst);
static void psq_stu(UGeckoInstruction _inst);
static void psq_lx(UGeckoInstruction _inst);
static void psq_stx(UGeckoInstruction _inst);
static void psq_lux(UGeckoInstruction _inst);
static void psq_stux(UGeckoInstruction _inst);
static void ps_div(UGeckoInstruction _inst);
static void ps_sub(UGeckoInstruction _inst);
static void ps_add(UGeckoInstruction _inst);
static void ps_sel(UGeckoInstruction _inst);
static void ps_res(UGeckoInstruction _inst);
static void ps_mul(UGeckoInstruction _inst);
static void ps_rsqrte(UGeckoInstruction _inst);
static void ps_msub(UGeckoInstruction _inst);
static void ps_madd(UGeckoInstruction _inst);
static void ps_nmsub(UGeckoInstruction _inst);
static void ps_nmadd(UGeckoInstruction _inst);
static void ps_neg(UGeckoInstruction _inst);
static void ps_mr(UGeckoInstruction _inst);
static void ps_nabs(UGeckoInstruction _inst);
static void ps_abs(UGeckoInstruction _inst);
static void ps_sum0(UGeckoInstruction _inst);
static void ps_sum1(UGeckoInstruction _inst);
static void ps_muls0(UGeckoInstruction _inst);
static void ps_muls1(UGeckoInstruction _inst);
static void ps_madds0(UGeckoInstruction _inst);
static void ps_madds1(UGeckoInstruction _inst);
static void ps_cmpu0(UGeckoInstruction _inst);
static void ps_cmpo0(UGeckoInstruction _inst);
static void ps_cmpu1(UGeckoInstruction _inst);
static void ps_cmpo1(UGeckoInstruction _inst);
static void ps_merge00(UGeckoInstruction _inst);
static void ps_merge01(UGeckoInstruction _inst);
static void ps_merge10(UGeckoInstruction _inst);
static void ps_merge11(UGeckoInstruction _inst);
static void dcbz_l(UGeckoInstruction _inst);
void psq_l(UGeckoInstruction _inst);
void psq_lu(UGeckoInstruction _inst);
void psq_st(UGeckoInstruction _inst);
void psq_stu(UGeckoInstruction _inst);
void psq_lx(UGeckoInstruction _inst);
void psq_stx(UGeckoInstruction _inst);
void psq_lux(UGeckoInstruction _inst);
void psq_stux(UGeckoInstruction _inst);
void ps_div(UGeckoInstruction _inst);
void ps_sub(UGeckoInstruction _inst);
void ps_add(UGeckoInstruction _inst);
void ps_sel(UGeckoInstruction _inst);
void ps_res(UGeckoInstruction _inst);
void ps_mul(UGeckoInstruction _inst);
void ps_rsqrte(UGeckoInstruction _inst);
void ps_msub(UGeckoInstruction _inst);
void ps_madd(UGeckoInstruction _inst);
void ps_nmsub(UGeckoInstruction _inst);
void ps_nmadd(UGeckoInstruction _inst);
void ps_neg(UGeckoInstruction _inst);
void ps_mr(UGeckoInstruction _inst);
void ps_nabs(UGeckoInstruction _inst);
void ps_abs(UGeckoInstruction _inst);
void ps_sum0(UGeckoInstruction _inst);
void ps_sum1(UGeckoInstruction _inst);
void ps_muls0(UGeckoInstruction _inst);
void ps_muls1(UGeckoInstruction _inst);
void ps_madds0(UGeckoInstruction _inst);
void ps_madds1(UGeckoInstruction _inst);
void ps_cmpu0(UGeckoInstruction _inst);
void ps_cmpo0(UGeckoInstruction _inst);
void ps_cmpu1(UGeckoInstruction _inst);
void ps_cmpo1(UGeckoInstruction _inst);
void ps_merge00(UGeckoInstruction _inst);
void ps_merge01(UGeckoInstruction _inst);
void ps_merge10(UGeckoInstruction _inst);
void ps_merge11(UGeckoInstruction _inst);
void dcbz_l(UGeckoInstruction _inst);
// System Registers Instructions
static void mcrfs(UGeckoInstruction _inst);
static void mffsx(UGeckoInstruction _inst);
static void mtfsb0x(UGeckoInstruction _inst);
static void mtfsb1x(UGeckoInstruction _inst);
static void mtfsfix(UGeckoInstruction _inst);
static void mtfsfx(UGeckoInstruction _inst);
static void mcrxr(UGeckoInstruction _inst);
static void mfcr(UGeckoInstruction _inst);
static void mfmsr(UGeckoInstruction _inst);
static void mfsr(UGeckoInstruction _inst);
static void mfsrin(UGeckoInstruction _inst);
static void mtmsr(UGeckoInstruction _inst);
static void mtsr(UGeckoInstruction _inst);
static void mtsrin(UGeckoInstruction _inst);
static void mfspr(UGeckoInstruction _inst);
static void mftb(UGeckoInstruction _inst);
static void mtcrf(UGeckoInstruction _inst);
static void mtspr(UGeckoInstruction _inst);
static void crand(UGeckoInstruction _inst);
static void crandc(UGeckoInstruction _inst);
static void creqv(UGeckoInstruction _inst);
static void crnand(UGeckoInstruction _inst);
static void crnor(UGeckoInstruction _inst);
static void cror(UGeckoInstruction _inst);
static void crorc(UGeckoInstruction _inst);
static void crxor(UGeckoInstruction _inst);
static void mcrf(UGeckoInstruction _inst);
static void rfi(UGeckoInstruction _inst);
static void rfid(UGeckoInstruction _inst);
// static void sync(UGeckoInstruction _inst);
static void isync(UGeckoInstruction _inst);
void mcrfs(UGeckoInstruction _inst);
void mffsx(UGeckoInstruction _inst);
void mtfsb0x(UGeckoInstruction _inst);
void mtfsb1x(UGeckoInstruction _inst);
void mtfsfix(UGeckoInstruction _inst);
void mtfsfx(UGeckoInstruction _inst);
void mcrxr(UGeckoInstruction _inst);
void mfcr(UGeckoInstruction _inst);
void mfmsr(UGeckoInstruction _inst);
void mfsr(UGeckoInstruction _inst);
void mfsrin(UGeckoInstruction _inst);
void mtmsr(UGeckoInstruction _inst);
void mtsr(UGeckoInstruction _inst);
void mtsrin(UGeckoInstruction _inst);
void mfspr(UGeckoInstruction _inst);
void mftb(UGeckoInstruction _inst);
void mtcrf(UGeckoInstruction _inst);
void mtspr(UGeckoInstruction _inst);
void crand(UGeckoInstruction _inst);
void crandc(UGeckoInstruction _inst);
void creqv(UGeckoInstruction _inst);
void crnand(UGeckoInstruction _inst);
void crnor(UGeckoInstruction _inst);
void cror(UGeckoInstruction _inst);
void crorc(UGeckoInstruction _inst);
void crxor(UGeckoInstruction _inst);
void mcrf(UGeckoInstruction _inst);
void rfi(UGeckoInstruction _inst);
void rfid(UGeckoInstruction _inst);
// void sync(UGeckoInstruction _inst);
void isync(UGeckoInstruction _inst);
static void RunTable4(UGeckoInstruction _instCode);
static void RunTable19(UGeckoInstruction _instCode);
static void RunTable31(UGeckoInstruction _instCode);
static void RunTable59(UGeckoInstruction _instCode);
static void RunTable63(UGeckoInstruction _instCode);
private:
void RunTable4(UGeckoInstruction _instCode);
void RunTable19(UGeckoInstruction _instCode);
void RunTable31(UGeckoInstruction _instCode);
void RunTable59(UGeckoInstruction _instCode);
void RunTable63(UGeckoInstruction _instCode);
// flag helper
static inline void Helper_UpdateCR0(u32 _uValue);
static inline void Helper_UpdateCR1(double _fValue);
static inline void Helper_UpdateCR1(float _fValue);
static inline void Helper_UpdateCRx(int _x, u32 _uValue);
static inline u32 Helper_Carry(u32 _uValue1, u32 _uValue2);
inline void Helper_UpdateCR0(u32 _uValue);
inline void Helper_UpdateCR1(double _fValue);
inline void Helper_UpdateCR1(float _fValue);
inline void Helper_UpdateCRx(int _x, u32 _uValue);
inline u32 Helper_Carry(u32 _uValue1, u32 _uValue2);
// address helper
static inline u32 Helper_Get_EA (const UGeckoInstruction _inst);
static inline u32 Helper_Get_EA_U (const UGeckoInstruction _inst);
static inline u32 Helper_Get_EA_X (const UGeckoInstruction _inst);
static inline u32 Helper_Get_EA_UX(const UGeckoInstruction _inst);
inline u32 Helper_Get_EA (const UGeckoInstruction _inst);
inline u32 Helper_Get_EA_U (const UGeckoInstruction _inst);
inline u32 Helper_Get_EA_X (const UGeckoInstruction _inst);
inline u32 Helper_Get_EA_UX(const UGeckoInstruction _inst);
// paired helper
static float inline Helper_Dequantize(const u32 _Addr, const EQuantizeType _quantizeType, const unsigned int _uScale);
static void inline Helper_Quantize (const u32 _Addr, const float _fValue, const EQuantizeType _quantizeType, const unsigned _uScale);
float inline Helper_Dequantize(const u32 _Addr, const EQuantizeType _quantizeType, const unsigned int _uScale);
void inline Helper_Quantize (const u32 _Addr, const float _fValue, const EQuantizeType _quantizeType, const unsigned _uScale);
// other helper
static u32 Helper_Mask(int mb, int me);
static inline bool IsNAN(double _dValue);
u32 Helper_Mask(int mb, int me);
inline bool IsNAN(double _dValue);
//
// --- Variables ---
//
// Helper tables
//static const float m_quantizeTable[];
//static const float m_dequantizeTable[];
// Instruction Tables
public: //made these public until i figure out a better way
static _interpreterInstruction m_opTable[64];
static _interpreterInstruction m_opTable4[1024];
static _interpreterInstruction m_opTable19[1024];
static _interpreterInstruction m_opTable31[1024];
static _interpreterInstruction m_opTable59[32];
static _interpreterInstruction m_opTable63[1024];
extern _interpreterInstruction m_opTable[64];
extern _interpreterInstruction m_opTable4[1024];
extern _interpreterInstruction m_opTable19[1024];
extern _interpreterInstruction m_opTable31[1024];
extern _interpreterInstruction m_opTable59[32];
extern _interpreterInstruction m_opTable63[1024];
};
#endif

23
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_Branch.cpp
View File

@ -20,8 +20,10 @@
#include "../../HLE/HLE.h"
#include "../PPCAnalyst.h"
namespace Interpreter
{
void CInterpreter::bx(UGeckoInstruction _inst)
void bx(UGeckoInstruction _inst)
{
if (_inst.LK)
LR = PC + 4;
@ -41,7 +43,7 @@ void CInterpreter::bx(UGeckoInstruction _inst)
}
// bcx - ugly, straight from PPC manual equations :)
void CInterpreter::bcx(UGeckoInstruction _inst)
void bcx(UGeckoInstruction _inst)
{
if ((_inst.BO & BO_DONT_DECREMENT_FLAG) == 0)
CTR--;
@ -65,7 +67,7 @@ void CInterpreter::bcx(UGeckoInstruction _inst)
m_EndBlock = true;
}
void CInterpreter::bcctrx(UGeckoInstruction _inst)
void bcctrx(UGeckoInstruction _inst)
{
if ((_inst.BO & BO_DONT_DECREMENT_FLAG) == 0)
CTR--;
@ -81,7 +83,7 @@ void CInterpreter::bcctrx(UGeckoInstruction _inst)
m_EndBlock = true;
}
void CInterpreter::bclrx(UGeckoInstruction _inst)
void bclrx(UGeckoInstruction _inst)
{
if ((_inst.BO & BO_DONT_DECREMENT_FLAG) == 0)
CTR--;
@ -98,18 +100,18 @@ void CInterpreter::bclrx(UGeckoInstruction _inst)
m_EndBlock = true;
}
void CInterpreter::HLEFunction(UGeckoInstruction _inst)
void HLEFunction(UGeckoInstruction _inst)
{
m_EndBlock = true;
HLE::Execute(PC, _inst.hex);
}
void CInterpreter::CompiledBlock(UGeckoInstruction _inst)
void CompiledBlock(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO, 0, "CInterpreter::CompiledBlock - shouldn't be here!");
_assert_msg_(GEKKO, 0, "CompiledBlock - shouldn't be here!");
}
void CInterpreter::rfi(UGeckoInstruction _inst)
void rfi(UGeckoInstruction _inst)
{
//Bits SRR1[0,5-9,16<31>23, 25<32>27, 30<33>31] are placed into the corresponding bits of the MSR.
//MSR[13] is set to 0.
@ -123,7 +125,7 @@ void CInterpreter::rfi(UGeckoInstruction _inst)
// PowerPC::CheckExceptions();
}
void CInterpreter::rfid(UGeckoInstruction _inst)
void rfid(UGeckoInstruction _inst)
{
_dbg_assert_msg_(GEKKO,0,"Instruction unimplemented (does this instruction even exist?)","rfid");
m_EndBlock = true;
@ -131,10 +133,11 @@ void CInterpreter::rfid(UGeckoInstruction _inst)
// sc isn't really used for anything important in gc games (just for a write barrier) so we really don't have to emulate it.
// We do it anyway, though :P
void CInterpreter::sc(UGeckoInstruction _inst)
void sc(UGeckoInstruction _inst)
{
PowerPC::ppcState.Exceptions |= EXCEPTION_SYSCALL;
PowerPC::CheckExceptions();
m_EndBlock = true;
}
} // namespace

67
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_FloatingPoint.cpp
View File

@ -57,6 +57,9 @@
// Super Monkey Ball reads FPRF & friends after fmadds, fmuls, frspx
// WHY do the FR & FI flags affect it so much?
namespace Interpreter
{
void UpdateFPSCR(UReg_FPSCR fp);
void UpdateSSEState();
@ -110,7 +113,7 @@ void UpdateFPRF(double value)
// extremely rare
void CInterpreter::Helper_UpdateCR1(double _fValue)
void Helper_UpdateCR1(double _fValue)
{
FPSCR.FPRF = 0;
if (_fValue == 0.0 || _fValue == -0.0)
@ -124,12 +127,12 @@ void CInterpreter::Helper_UpdateCR1(double _fValue)
PanicAlert("CR1");
}
bool CInterpreter::IsNAN(double _dValue)
bool IsNAN(double _dValue)
{
return _dValue != _dValue;
}
void CInterpreter::fcmpo(UGeckoInstruction _inst)
void fcmpo(UGeckoInstruction _inst)
{
double fa = rPS0(_inst.FA);
double fb = rPS0(_inst.FB);
@ -151,7 +154,7 @@ void CInterpreter::fcmpo(UGeckoInstruction _inst)
then VXVC ¬ 1 */
}
void CInterpreter::fcmpu(UGeckoInstruction _inst)
void fcmpu(UGeckoInstruction _inst)
{
double fa = rPS0(_inst.FA);
double fb = rPS0(_inst.FB);
@ -171,7 +174,7 @@ void CInterpreter::fcmpu(UGeckoInstruction _inst)
}
// Apply current rounding mode
void CInterpreter::fctiwx(UGeckoInstruction _inst)
void fctiwx(UGeckoInstruction _inst)
{
UpdateSSEState();
const double b = rPS0(_inst.FB);
@ -210,7 +213,7 @@ representable int result in 0x80000000 (a very negative number) rather than the
largest representable int on PowerPC. */
// Always round toward zero
void CInterpreter::fctiwzx(UGeckoInstruction _inst)
void fctiwzx(UGeckoInstruction _inst)
{
//UpdateFPSCR(FPSCR);
const double b = rPS0(_inst.FB);
@ -241,35 +244,35 @@ void CInterpreter::fctiwzx(UGeckoInstruction _inst)
Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fmrx(UGeckoInstruction _inst)
void fmrx(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB);
// This is a binary instruction. Does not alter FPSCR
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fabsx(UGeckoInstruction _inst)
void fabsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = fabs(rPS0(_inst.FB));
// This is a binary instruction. Does not alter FPSCR
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fnabsx(UGeckoInstruction _inst)
void fnabsx(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB) | (1ULL << 63);
// This is a binary instruction. Does not alter FPSCR
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fnegx(UGeckoInstruction _inst)
void fnegx(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB) ^ (1ULL << 63);
// This is a binary instruction. Does not alter FPSCR
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fselx(UGeckoInstruction _inst)
void fselx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = (rPS0(_inst.FA) >= -0.0) ? rPS0(_inst.FC) : rPS0(_inst.FB);
// This is a binary instruction. Does not alter FPSCR
@ -281,7 +284,7 @@ void CInterpreter::fselx(UGeckoInstruction _inst)
// PS1 must be set to the value of PS0 or DragonballZ will be f**ked up
// PS1 is said to be undefined
// Super Monkey Ball is using this to do wacky tricks so we need 100% correct emulation.
void CInterpreter::frspx(UGeckoInstruction _inst) // round to single
void frspx(UGeckoInstruction _inst) // round to single
{
if (true || FPSCR.RN != 0)
{
@ -352,14 +355,14 @@ void CInterpreter::frspx(UGeckoInstruction _inst) // round to single
}
void CInterpreter::fmulx(UGeckoInstruction _inst)
void fmulx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS0(_inst.FA) * rPS0(_inst.FC);
FPSCR.FI = 0;
FPSCR.FR = 1;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fmulsx(UGeckoInstruction _inst)
void fmulsx(UGeckoInstruction _inst)
{
double d_value = rPS0(_inst.FA) * rPS0(_inst.FC);
rPS0(_inst.FD) = rPS1(_inst.FD) = static_cast<float>(d_value);
@ -370,14 +373,14 @@ void CInterpreter::fmulsx(UGeckoInstruction _inst)
}
void CInterpreter::fmaddx(UGeckoInstruction _inst)
void fmaddx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = (rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB);
FPSCR.FI = 0;
FPSCR.FR = 0;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fmaddsx(UGeckoInstruction _inst)
void fmaddsx(UGeckoInstruction _inst)
{
double d_value = (rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB);
rPS0(_inst.FD) = rPS1(_inst.FD) =
@ -389,14 +392,14 @@ void CInterpreter::fmaddsx(UGeckoInstruction _inst)
}
void CInterpreter::faddx(UGeckoInstruction _inst)
void faddx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS0(_inst.FA) + rPS0(_inst.FB);
// FPSCR.FI = 0;
// FPSCR.FR = 1;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::faddsx(UGeckoInstruction _inst)
void faddsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) = static_cast<float>(rPS0(_inst.FA) + rPS0(_inst.FB));
// FPSCR.FI = 0;
@ -406,7 +409,7 @@ void CInterpreter::faddsx(UGeckoInstruction _inst)
}
void CInterpreter::fdivx(UGeckoInstruction _inst)
void fdivx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS0(_inst.FA) / rPS0(_inst.FB);
// FPSCR.FI = 0;
@ -416,7 +419,7 @@ void CInterpreter::fdivx(UGeckoInstruction _inst)
}
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fdivsx(UGeckoInstruction _inst)
void fdivsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) = static_cast<float>(rPS0(_inst.FA) / rPS0(_inst.FB));
// FPSCR.FI = 0;
@ -426,7 +429,7 @@ void CInterpreter::fdivsx(UGeckoInstruction _inst)
}
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fresx(UGeckoInstruction _inst)
void fresx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) = static_cast<float>(1.0f / rPS0(_inst.FB));
// FPSCR.FI = 0;
@ -438,7 +441,7 @@ void CInterpreter::fresx(UGeckoInstruction _inst)
}
void CInterpreter::fmsubx(UGeckoInstruction _inst)
void fmsubx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = (rPS0(_inst.FA) * rPS0(_inst.FC)) - rPS0(_inst.FB);
// FPSCR.FI = 0;
@ -446,7 +449,7 @@ void CInterpreter::fmsubx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fmsubsx(UGeckoInstruction _inst)
void fmsubsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) =
static_cast<float>((rPS0(_inst.FA) * rPS0(_inst.FC)) - rPS0(_inst.FB));
@ -456,14 +459,14 @@ void CInterpreter::fmsubsx(UGeckoInstruction _inst)
}
void CInterpreter::fnmaddx(UGeckoInstruction _inst)
void fnmaddx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = -((rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB));
// FPSCR.FI = 0;
// FPSCR.FR = 0;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fnmaddsx(UGeckoInstruction _inst)
void fnmaddsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) =
static_cast<float>(-((rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB)));
@ -473,14 +476,14 @@ void CInterpreter::fnmaddsx(UGeckoInstruction _inst)
}
void CInterpreter::fnmsubx(UGeckoInstruction _inst)
void fnmsubx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = -((rPS0(_inst.FA) * rPS0(_inst.FC)) - rPS0(_inst.FB));
// FPSCR.FI = 0;
// FPSCR.FR = 0;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fnmsubsx(UGeckoInstruction _inst)
void fnmsubsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) =
static_cast<float>(-((rPS0(_inst.FA) * rPS0(_inst.FC)) - rPS0(_inst.FB)));
@ -490,14 +493,14 @@ void CInterpreter::fnmsubsx(UGeckoInstruction _inst)
}
void CInterpreter::fsubx(UGeckoInstruction _inst)
void fsubx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS0(_inst.FA) - rPS0(_inst.FB);
// FPSCR.FI = 0;
// FPSCR.FR = 0;
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fsubsx(UGeckoInstruction _inst)
void fsubsx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS1(_inst.FD) = static_cast<float>(rPS0(_inst.FA) - rPS0(_inst.FB));
// FPSCR.FI = 0;
@ -506,7 +509,7 @@ void CInterpreter::fsubsx(UGeckoInstruction _inst)
}
void CInterpreter::frsqrtex(UGeckoInstruction _inst)
void frsqrtex(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = 1.0f / (sqrt(rPS0(_inst.FB)));
// FPSCR.FI = 0;
@ -514,7 +517,7 @@ void CInterpreter::frsqrtex(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
void CInterpreter::fsqrtx(UGeckoInstruction _inst)
void fsqrtx(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = sqrt(rPS0(_inst.FB));
// FPSCR.FI = 0;
@ -522,3 +525,5 @@ void CInterpreter::fsqrtx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR1(rPS0(_inst.FD));
}
} // namespace

116
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_Integer.cpp
View File

@ -18,6 +18,8 @@
#include "Interpreter.h"
#include "../../Core.h"
namespace Interpreter
{
#ifndef _WIN32
inline u32 _rotl(u32 x, int shift) {
@ -27,7 +29,7 @@ inline u32 _rotl(u32 x, int shift) {
#endif
void CInterpreter::Helper_UpdateCR0(u32 _uValue)
void Helper_UpdateCR0(u32 _uValue)
{
u32 Flags = 0;
int sValue = (int)_uValue;
@ -41,7 +43,7 @@ void CInterpreter::Helper_UpdateCR0(u32 _uValue)
PowerPC::ppcState.cr = (PowerPC::ppcState.cr & 0xFFFFFFF) | Flags;
}
void CInterpreter::Helper_UpdateCRx(int _x, u32 _uValue)
void Helper_UpdateCRx(int _x, u32 _uValue)
{
int shiftamount = _x*4;
int crmask = 0xFFFFFFFF ^ (0xF0000000 >> shiftamount);
@ -58,12 +60,12 @@ void CInterpreter::Helper_UpdateCRx(int _x, u32 _uValue)
PowerPC::ppcState.cr = (PowerPC::ppcState.cr & crmask) | (Flags >> shiftamount);
}
u32 CInterpreter::Helper_Carry(u32 _uValue1, u32 _uValue2)
u32 Helper_Carry(u32 _uValue1, u32 _uValue2)
{
return _uValue2 > (~_uValue1);
}
u32 CInterpreter::Helper_Mask(int mb, int me)
u32 Helper_Mask(int mb, int me)
{
//first make 001111111111111 part
u32 begin = 0xFFFFFFFF >> mb;
@ -78,7 +80,7 @@ u32 CInterpreter::Helper_Mask(int mb, int me)
return mask;
}
void CInterpreter::addi(UGeckoInstruction _inst)
void addi(UGeckoInstruction _inst)
{
if (_inst.RA)
m_GPR[_inst.RD] = m_GPR[_inst.RA] + _inst.SIMM_16;
@ -86,7 +88,7 @@ void CInterpreter::addi(UGeckoInstruction _inst)
m_GPR[_inst.RD] = _inst.SIMM_16;
}
void CInterpreter::addic(UGeckoInstruction _inst)
void addic(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 imm = (u32)(s32)_inst.SIMM_16;
@ -95,13 +97,13 @@ void CInterpreter::addic(UGeckoInstruction _inst)
SetCarry(Helper_Carry(a, imm));
}
void CInterpreter::addic_rc(UGeckoInstruction _inst)
void addic_rc(UGeckoInstruction _inst)
{
addic(_inst);
Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::addis(UGeckoInstruction _inst)
void addis(UGeckoInstruction _inst)
{
if (_inst.RA)
m_GPR[_inst.RD] = m_GPR[_inst.RA] + (_inst.SIMM_16 << 16);
@ -109,24 +111,24 @@ void CInterpreter::addis(UGeckoInstruction _inst)
m_GPR[_inst.RD] = (_inst.SIMM_16 << 16);
}
void CInterpreter::andi_rc(UGeckoInstruction _inst)
void andi_rc(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] & _inst.UIMM;
Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::andis_rc(UGeckoInstruction _inst)
void andis_rc(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] & ((u32)_inst.UIMM<<16);
Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::cmpi(UGeckoInstruction _inst)
void cmpi(UGeckoInstruction _inst)
{
Helper_UpdateCRx(_inst.CRFD, m_GPR[_inst.RA]-_inst.SIMM_16);
}
void CInterpreter::cmpli(UGeckoInstruction _inst)
void cmpli(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = _inst.UIMM;
@ -138,22 +140,22 @@ void CInterpreter::cmpli(UGeckoInstruction _inst)
SetCRField(_inst.CRFD, f);
}
void CInterpreter::mulli(UGeckoInstruction _inst)
void mulli(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (s32)m_GPR[_inst.RA] * _inst.SIMM_16;
}
void CInterpreter::ori(UGeckoInstruction _inst)
void ori(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] | _inst.UIMM;
}
void CInterpreter::oris(UGeckoInstruction _inst)
void oris(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] | (_inst.UIMM << 16);
}
void CInterpreter::subfic(UGeckoInstruction _inst)
void subfic(UGeckoInstruction _inst)
{
/* u32 rra = ~m_GPR[_inst.RA];
s32 immediate = (s16)_inst.SIMM_16 + 1;
@ -173,7 +175,7 @@ void CInterpreter::subfic(UGeckoInstruction _inst)
SetCarry((m_GPR[_inst.RA] == 0) || (Helper_Carry(0-m_GPR[_inst.RA], immediate)));
}
void CInterpreter::twi(UGeckoInstruction _inst)
void twi(UGeckoInstruction _inst)
{
bool bFirst = true;
if (bFirst)
@ -182,31 +184,31 @@ void CInterpreter::twi(UGeckoInstruction _inst)
bFirst = false;
}
void CInterpreter::xori(UGeckoInstruction _inst)
void xori(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] ^ _inst.UIMM;
}
void CInterpreter::xoris(UGeckoInstruction _inst)
void xoris(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] ^ (_inst.UIMM << 16);
}
void CInterpreter::rlwimix(UGeckoInstruction _inst)
void rlwimix(UGeckoInstruction _inst)
{
u32 mask = Helper_Mask(_inst.MB,_inst.ME);
m_GPR[_inst.RA] = (m_GPR[_inst.RA] & ~mask) | (_rotl(m_GPR[_inst.RS],_inst.SH) & mask);
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::rlwinmx(UGeckoInstruction _inst)
void rlwinmx(UGeckoInstruction _inst)
{
u32 mask = Helper_Mask(_inst.MB,_inst.ME);
m_GPR[_inst.RA] = _rotl(m_GPR[_inst.RS],_inst.SH) & mask;
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::rlwnmx(UGeckoInstruction _inst)
void rlwnmx(UGeckoInstruction _inst)
{
u32 mask = Helper_Mask(_inst.MB,_inst.ME);
m_GPR[_inst.RA] = _rotl(m_GPR[_inst.RS], m_GPR[_inst.RB] & 0x1F) & mask;
@ -214,21 +216,21 @@ void CInterpreter::rlwnmx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::andx(UGeckoInstruction _inst)
void andx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] & m_GPR[_inst.RB];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::andcx(UGeckoInstruction _inst)
void andcx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] & ~m_GPR[_inst.RB];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::cmp(UGeckoInstruction _inst)
void cmp(UGeckoInstruction _inst)
{
s32 a = (s32)m_GPR[_inst.RA];
s32 b = (s32)m_GPR[_inst.RB];
@ -240,7 +242,7 @@ void CInterpreter::cmp(UGeckoInstruction _inst)
SetCRField(_inst.CRFD, fTemp);
}
void CInterpreter::cmpl(UGeckoInstruction _inst)
void cmpl(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -252,7 +254,7 @@ void CInterpreter::cmpl(UGeckoInstruction _inst)
SetCRField(_inst.CRFD, fTemp);
}
void CInterpreter::cntlzwx(UGeckoInstruction _inst)
void cntlzwx(UGeckoInstruction _inst)
{
u32 val = m_GPR[_inst.RS];
u32 mask = 0x80000000;
@ -264,56 +266,56 @@ void CInterpreter::cntlzwx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::eqvx(UGeckoInstruction _inst)
void eqvx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = ~(m_GPR[_inst.RS] ^ m_GPR[_inst.RB]);
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::extsbx(UGeckoInstruction _inst)
void extsbx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = (u32)(s32)(s8)m_GPR[_inst.RS];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::extshx(UGeckoInstruction _inst)
void extshx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = (u32)(s32)(s16)m_GPR[_inst.RS];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::nandx(UGeckoInstruction _inst)
void nandx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = ~(m_GPR[_inst.RS] & m_GPR[_inst.RB]);
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::norx(UGeckoInstruction _inst)
void norx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = ~(m_GPR[_inst.RS] | m_GPR[_inst.RB]);
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::orx(UGeckoInstruction _inst)
void orx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] | m_GPR[_inst.RB];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::orcx(UGeckoInstruction _inst)
void orcx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] | (~m_GPR[_inst.RB]);
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::slwx(UGeckoInstruction _inst)
void slwx(UGeckoInstruction _inst)
{
// TODO(ector): wtf is this code?
/* u32 amount = m_GPR[_inst.RB];
@ -328,7 +330,7 @@ void CInterpreter::slwx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::srawx(UGeckoInstruction _inst)
void srawx(UGeckoInstruction _inst)
{
int rb = m_GPR[_inst.RB];
if (rb & 0x20)
@ -365,7 +367,7 @@ void CInterpreter::srawx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::srawix(UGeckoInstruction _inst)
void srawix(UGeckoInstruction _inst)
{
int amount = _inst.SH;
@ -388,7 +390,7 @@ void CInterpreter::srawix(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::srwx(UGeckoInstruction _inst)
void srwx(UGeckoInstruction _inst)
{
u32 amount = m_GPR[_inst.RB];
m_GPR[_inst.RA] = (amount & 0x20) ? 0 : (m_GPR[_inst.RS] >> amount);
@ -396,7 +398,7 @@ void CInterpreter::srwx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::tw(UGeckoInstruction _inst)
void tw(UGeckoInstruction _inst)
{
static bool bFirst = true;
if (bFirst)
@ -404,14 +406,14 @@ void CInterpreter::tw(UGeckoInstruction _inst)
bFirst = false;
}
void CInterpreter::xorx(UGeckoInstruction _inst)
void xorx(UGeckoInstruction _inst)
{
m_GPR[_inst.RA] = m_GPR[_inst.RS] ^ m_GPR[_inst.RB];
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RA]);
}
void CInterpreter::addx(UGeckoInstruction _inst)
void addx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = m_GPR[_inst.RA] + m_GPR[_inst.RB];
@ -419,7 +421,7 @@ void CInterpreter::addx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::addcx(UGeckoInstruction _inst)
void addcx(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -430,7 +432,7 @@ void CInterpreter::addcx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::addex(UGeckoInstruction _inst)
void addex(UGeckoInstruction _inst)
{
int carry = GetCarry();
int a = m_GPR[_inst.RA];
@ -442,7 +444,7 @@ void CInterpreter::addex(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::addmex(UGeckoInstruction _inst)
void addmex(UGeckoInstruction _inst)
{
int carry = GetCarry();
int a = m_GPR[_inst.RA];
@ -453,7 +455,7 @@ void CInterpreter::addmex(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::addzex(UGeckoInstruction _inst)
void addzex(UGeckoInstruction _inst)
{
int carry = GetCarry();
int a = m_GPR[_inst.RA];
@ -464,7 +466,7 @@ void CInterpreter::addzex(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::divwx(UGeckoInstruction _inst)
void divwx(UGeckoInstruction _inst)
{
s32 a = m_GPR[_inst.RA];
s32 b = m_GPR[_inst.RB];
@ -481,7 +483,7 @@ void CInterpreter::divwx(UGeckoInstruction _inst)
}
void CInterpreter::divwux(UGeckoInstruction _inst)
void divwux(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -499,7 +501,7 @@ void CInterpreter::divwux(UGeckoInstruction _inst)
}
}
void CInterpreter::mulhwx(UGeckoInstruction _inst)
void mulhwx(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -508,7 +510,7 @@ void CInterpreter::mulhwx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::mulhwux(UGeckoInstruction _inst)
void mulhwux(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -517,7 +519,7 @@ void CInterpreter::mulhwux(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::mullwx(UGeckoInstruction _inst)
void mullwx(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -528,7 +530,7 @@ void CInterpreter::mullwx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::negx(UGeckoInstruction _inst)
void negx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (~m_GPR[_inst.RA]) + 1;
if (m_GPR[_inst.RD] == 0x80000000)
@ -538,7 +540,7 @@ void CInterpreter::negx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::subfx(UGeckoInstruction _inst)
void subfx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = m_GPR[_inst.RB] - m_GPR[_inst.RA];
@ -546,7 +548,7 @@ void CInterpreter::subfx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::subfcx(UGeckoInstruction _inst)
void subfcx(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -557,7 +559,7 @@ void CInterpreter::subfcx(UGeckoInstruction _inst)
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
void CInterpreter::subfex(UGeckoInstruction _inst)
void subfex(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
u32 b = m_GPR[_inst.RB];
@ -570,7 +572,7 @@ void CInterpreter::subfex(UGeckoInstruction _inst)
}
// sub from minus one
void CInterpreter::subfmex(UGeckoInstruction _inst)
void subfmex(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
int carry = GetCarry();
@ -582,7 +584,7 @@ void CInterpreter::subfmex(UGeckoInstruction _inst)
}
// sub from zero
void CInterpreter::subfzex(UGeckoInstruction _inst)
void subfzex(UGeckoInstruction _inst)
{
u32 a = m_GPR[_inst.RA];
int carry = GetCarry();
@ -592,3 +594,5 @@ void CInterpreter::subfzex(UGeckoInstruction _inst)
if (_inst.OE) PanicAlert("OE: subfzex");
if (_inst.Rc) Helper_UpdateCR0(m_GPR[_inst.RD]);
}
} // namespace

181
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_LoadStore.cpp
View File

@ -25,70 +25,73 @@
#include "../Jit64/Jit.h"
#include "../Jit64/JitCache.h"
u32 CInterpreter::Helper_Get_EA(const UGeckoInstruction _inst)
namespace Interpreter
{
u32 Helper_Get_EA(const UGeckoInstruction _inst)
{
return _inst.RA ? (m_GPR[_inst.RA] + _inst.SIMM_16) : _inst.SIMM_16;
}
u32 CInterpreter::Helper_Get_EA_U(const UGeckoInstruction _inst)
u32 Helper_Get_EA_U(const UGeckoInstruction _inst)
{
return (m_GPR[_inst.RA] + _inst.SIMM_16);
}
u32 CInterpreter::Helper_Get_EA_X(const UGeckoInstruction _inst)
u32 Helper_Get_EA_X(const UGeckoInstruction _inst)
{
return _inst.RA ? (m_GPR[_inst.RA] + m_GPR[_inst.RB]) : m_GPR[_inst.RB];
}
u32 CInterpreter::Helper_Get_EA_UX(const UGeckoInstruction _inst)
u32 Helper_Get_EA_UX(const UGeckoInstruction _inst)
{
return (m_GPR[_inst.RA] + m_GPR[_inst.RB]);
}
void CInterpreter::lbz(UGeckoInstruction _inst)
void lbz(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)Memory::Read_U8(Helper_Get_EA(_inst));
}
void CInterpreter::lbzu(UGeckoInstruction _inst)
void lbzu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
m_GPR[_inst.RD] = (u32)Memory::Read_U8(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lfd(UGeckoInstruction _inst)
void lfd(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = Memory::Read_U64(Helper_Get_EA(_inst));
}
void CInterpreter::lfdu(UGeckoInstruction _inst)
void lfdu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
riPS0(_inst.FD) = Memory::Read_U64(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lfdux(UGeckoInstruction _inst)
void lfdux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
riPS0(_inst.FD) = Memory::Read_U64(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lfdx(UGeckoInstruction _inst)
void lfdx(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = Memory::Read_U64(Helper_Get_EA_X(_inst));
}
void CInterpreter::lfs(UGeckoInstruction _inst)
void lfs(UGeckoInstruction _inst)
{
u32 uTemp = Memory::Read_U32(Helper_Get_EA(_inst));
rPS0(_inst.FD) = *(float*)&uTemp;
rPS1(_inst.FD) = rPS0(_inst.FD);
}
void CInterpreter::lfsu(UGeckoInstruction _inst)
void lfsu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
u32 uTemp = Memory::Read_U32(uAddress);
@ -97,7 +100,7 @@ void CInterpreter::lfsu(UGeckoInstruction _inst)
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lfsux(UGeckoInstruction _inst)
void lfsux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
u32 uTemp = Memory::Read_U32(uAddress);
@ -106,38 +109,38 @@ void CInterpreter::lfsux(UGeckoInstruction _inst)
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lfsx(UGeckoInstruction _inst)
void lfsx(UGeckoInstruction _inst)
{
u32 uTemp = Memory::Read_U32(Helper_Get_EA_X(_inst));
rPS0(_inst.FD) = *(float*)&uTemp;
rPS1(_inst.FD) = rPS0(_inst.FD);
}
void CInterpreter::lha(UGeckoInstruction _inst)
void lha(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)(s32)(s16)Memory::Read_U16(Helper_Get_EA(_inst));
}
void CInterpreter::lhau(UGeckoInstruction _inst)
void lhau(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
m_GPR[_inst.RD] = (u32)(s32)(s16)Memory::Read_U16(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lhz(UGeckoInstruction _inst)
void lhz(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)(u16)Memory::Read_U16(Helper_Get_EA(_inst));
}
void CInterpreter::lhzu(UGeckoInstruction _inst)
void lhzu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
m_GPR[_inst.RD] = (u32)(u16)Memory::Read_U16(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lmw(UGeckoInstruction _inst)
void lmw(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA(_inst);
for (int iReg = _inst.RD; iReg <= 31; iReg++, uAddress += 4)
@ -153,7 +156,7 @@ void CInterpreter::lmw(UGeckoInstruction _inst)
}
}
void CInterpreter::stmw(UGeckoInstruction _inst)
void stmw(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA(_inst);
for (int iReg = _inst.RS; iReg <= 31; iReg++, uAddress+=4)
@ -164,7 +167,7 @@ void CInterpreter::stmw(UGeckoInstruction _inst)
}
}
void CInterpreter::lwz(UGeckoInstruction _inst)
void lwz(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA(_inst);
m_GPR[_inst.RD] = Memory::Read_U32(uAddress);
@ -186,55 +189,44 @@ void CInterpreter::lwz(UGeckoInstruction _inst)
}*/
}
void CInterpreter::lwzu(UGeckoInstruction _inst)
void lwzu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
m_GPR[_inst.RD] = Memory::Read_U32(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stb(UGeckoInstruction _inst)
void stb(UGeckoInstruction _inst)
{
Memory::Write_U8((u8)m_GPR[_inst.RS], Helper_Get_EA(_inst));
}
void CInterpreter::stbu(UGeckoInstruction _inst)
void stbu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
Memory::Write_U8((u8)m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stfd(UGeckoInstruction _inst)
void stfd(UGeckoInstruction _inst)
{
Memory::Write_U64(riPS0(_inst.FS), Helper_Get_EA(_inst));
}
void CInterpreter::stfdu(UGeckoInstruction _inst)
void stfdu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
Memory::Write_U64(riPS0(_inst.FS), uAddress);
m_GPR[_inst.RA] = uAddress;
}
// __________________________________________________________________________________________________
// stfs
//
// no paired ??
//
void
CInterpreter::stfs(UGeckoInstruction _inst)
void stfs(UGeckoInstruction _inst)
{
float fTemp = (float)rPS0(_inst.FS);
Memory::Write_U32(*(u32*)&fTemp, Helper_Get_EA(_inst));
}
// __________________________________________________________________________________________________
// stfsu
//
// no paired ??
//
void CInterpreter::stfsu(UGeckoInstruction _inst)
void stfsu(UGeckoInstruction _inst)
{
float fTemp = (float)rPS0(_inst.FS);
u32 uAddress = Helper_Get_EA_U(_inst);
@ -242,36 +234,36 @@ void CInterpreter::stfsu(UGeckoInstruction _inst)
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::sth(UGeckoInstruction _inst)
void sth(UGeckoInstruction _inst)
{
Memory::Write_U16((u16)m_GPR[_inst.RS], Helper_Get_EA(_inst));
}
void CInterpreter::sthu(UGeckoInstruction _inst)
void sthu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
Memory::Write_U16((u16)m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stw(UGeckoInstruction _inst)
void stw(UGeckoInstruction _inst)
{
Memory::Write_U32(m_GPR[_inst.RS], Helper_Get_EA(_inst));
}
void CInterpreter::stwu(UGeckoInstruction _inst)
void stwu(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_U(_inst);
Memory::Write_U32(m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::dcba(UGeckoInstruction _inst)
void dcba(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO,0,"dcba - Not implemented - not a Gekko instruction");
}
void CInterpreter::dcbf(UGeckoInstruction _inst)
void dcbf(UGeckoInstruction _inst)
{
//This should tell GFX plugin to throw out any cached data here
// !!! SPEEDUP HACK for OSProtectRange !!!
@ -285,25 +277,25 @@ void CInterpreter::dcbf(UGeckoInstruction _inst)
}*/
}
void CInterpreter::dcbi(UGeckoInstruction _inst)
void dcbi(UGeckoInstruction _inst)
{
//Used during initialization
//_assert_msg_(GEKKO,0,"dcbi - Not implemented");
}
void CInterpreter::dcbst(UGeckoInstruction _inst)
void dcbst(UGeckoInstruction _inst)
{
//_assert_msg_(GEKKO,0,"dcbst - Not implemented");
}
void CInterpreter::dcbt(UGeckoInstruction _inst)
void dcbt(UGeckoInstruction _inst)
{
//This should tell GFX plugin to throw out any cached data here
//Used by Ikaruga
//_assert_msg_(GEKKO,0,"dcbt - Not implemented");
}
void CInterpreter::dcbtst(UGeckoInstruction _inst)
void dcbtst(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO,0,"dcbtst - Not implemented");
}
@ -311,82 +303,83 @@ void CInterpreter::dcbtst(UGeckoInstruction _inst)
// __________________________________________________________________________________________________
// dcbz
// TODO(ector) check docs
void CInterpreter::dcbz(UGeckoInstruction _inst)
void dcbz(UGeckoInstruction _inst)
{
// HACK but works... we think
Memory::Memset(Helper_Get_EA_X(_inst) & (~31), 0, 32);
}
void CInterpreter::eciwx(UGeckoInstruction _inst)
void eciwx(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO,0,"eciwx - Not implemented");
}
void CInterpreter::ecowx(UGeckoInstruction _inst)
void ecowx(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO,0,"ecowx - Not implemented");
}
void CInterpreter::eieio(UGeckoInstruction _inst)
void eieio(UGeckoInstruction _inst)
{
_assert_msg_(GEKKO,0,"eieio - Not implemented");
}
void CInterpreter::icbi(UGeckoInstruction _inst)
void icbi(UGeckoInstruction _inst)
{
u32 address = CInterpreter::Helper_Get_EA_X(_inst);
//block size seems to be 0x20
u32 address = Helper_Get_EA_X(_inst);
// block size seems to be 0x20
address &= ~0x1f;
//Inform the dynarec to kill off this area of code NOW
//VERY IMPORTANT when we start linking blocks
//There are a TON of these so hopefully we can make this mechanism
//fast in the dynarec
// this comment is slightly outdated but still relevant:
// Inform the JIT to kill off this area of code NOW
// VERY IMPORTANT when we start linking blocks
// There are a TON of these so hopefully we can make this mechanism
// fast in the JIT
Jit64::InvalidateCodeRange(address, 0x20);
}
void CInterpreter::lbzux(UGeckoInstruction _inst)
void lbzux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
m_GPR[_inst.RD] = (u32)Memory::Read_U8(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lbzx(UGeckoInstruction _inst)
void lbzx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)Memory::Read_U8(Helper_Get_EA_X(_inst));
}
void CInterpreter::lhaux(UGeckoInstruction _inst)
void lhaux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
m_GPR[_inst.RD] = (s32)(s16)Memory::Read_U16(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lhax(UGeckoInstruction _inst)
void lhax(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (s32)(s16)Memory::Read_U16(Helper_Get_EA_X(_inst));
}
void CInterpreter::lhbrx(UGeckoInstruction _inst)
void lhbrx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)Common::swap16(Memory::Read_U16(Helper_Get_EA_X(_inst)));
}
void CInterpreter::lhzux(UGeckoInstruction _inst)
void lhzux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
m_GPR[_inst.RD] = (u32)Memory::Read_U16(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lhzx(UGeckoInstruction _inst)
void lhzx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = (u32)Memory::Read_U16(Helper_Get_EA_X(_inst));
}
void CInterpreter::lswx(UGeckoInstruction _inst)
void lswx(UGeckoInstruction _inst)
{
static bool bFirst = true;
if (bFirst)
@ -394,44 +387,44 @@ void CInterpreter::lswx(UGeckoInstruction _inst)
bFirst = false;
}
void CInterpreter::lwbrx(UGeckoInstruction _inst)
void lwbrx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = Common::swap32(Memory::Read_U32(Helper_Get_EA_X(_inst)));
}
void CInterpreter::lwzux(UGeckoInstruction _inst)
void lwzux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
m_GPR[_inst.RD] = Memory::Read_U32(uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::lwzx(UGeckoInstruction _inst)
void lwzx(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_X(_inst);
m_GPR[_inst.RD] = Memory::Read_U32(uAddress);
}
void CInterpreter::stbux(UGeckoInstruction _inst)
void stbux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
Memory::Write_U8((u8)m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stbx(UGeckoInstruction _inst)
void stbx(UGeckoInstruction _inst)
{
Memory::Write_U8((u8)m_GPR[_inst.RS], Helper_Get_EA_X(_inst));
}
void CInterpreter::stfdux(UGeckoInstruction _inst)
void stfdux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
Memory::Write_U64(riPS0(_inst.FS), uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stfdx(UGeckoInstruction _inst)
void stfdx(UGeckoInstruction _inst)
{
Memory::Write_U64(riPS0(_inst.FS), Helper_Get_EA_X(_inst));
}
@ -439,7 +432,7 @@ void CInterpreter::stfdx(UGeckoInstruction _inst)
// __________________________________________________________________________________________________
// stfiwx
// TODO - examine what this really does
void CInterpreter::stfiwx(UGeckoInstruction _inst)
void stfiwx(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_X(_inst);
@ -451,7 +444,7 @@ void CInterpreter::stfiwx(UGeckoInstruction _inst)
//
// no paired ??
//
void CInterpreter::stfsux(UGeckoInstruction _inst)
void stfsux(UGeckoInstruction _inst)
{
float fTemp = (float)rPS0(_inst.FS);
u32 uAddress = Helper_Get_EA_UX(_inst);
@ -464,25 +457,25 @@ void CInterpreter::stfsux(UGeckoInstruction _inst)
//
// no paired ??
//
void CInterpreter::stfsx(UGeckoInstruction _inst)
void stfsx(UGeckoInstruction _inst)
{
float fTemp = (float)rPS0(_inst.FS);
Memory::Write_U32(*(u32 *)&fTemp, Helper_Get_EA_X(_inst));
}
void CInterpreter::sthbrx(UGeckoInstruction _inst)
void sthbrx(UGeckoInstruction _inst)
{
Memory::Write_U16(Common::swap16((u16)m_GPR[_inst.RS]), Helper_Get_EA_X(_inst));
}
void CInterpreter::sthux(UGeckoInstruction _inst)
void sthux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
Memory::Write_U16((u16)m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::sthx(UGeckoInstruction _inst)
void sthx(UGeckoInstruction _inst)
{
Memory::Write_U16((u16)m_GPR[_inst.RS], Helper_Get_EA_X(_inst));
}
@ -490,7 +483,7 @@ void CInterpreter::sthx(UGeckoInstruction _inst)
// __________________________________________________________________________________________________
// lswi - bizarro string instruction
//
void CInterpreter::lswi(UGeckoInstruction _inst)
void lswi(UGeckoInstruction _inst)
{
u32 EA;
if (_inst.RA == 0)
@ -536,7 +529,7 @@ void CInterpreter::lswi(UGeckoInstruction _inst)
// __________________________________________________________________________________________________
// stswi - bizarro string instruction
//
void CInterpreter::stswi(UGeckoInstruction _inst)
void stswi(UGeckoInstruction _inst)
{
u32 EA;
if (_inst.RA == 0)
@ -571,7 +564,7 @@ void CInterpreter::stswi(UGeckoInstruction _inst)
}
}
void CInterpreter::stswx(UGeckoInstruction _inst)
void stswx(UGeckoInstruction _inst)
{
static bool bFirst = true;
if (bFirst)
@ -579,7 +572,7 @@ void CInterpreter::stswx(UGeckoInstruction _inst)
bFirst = false;
}
void CInterpreter::stwbrx(UGeckoInstruction _inst)
void stwbrx(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_X(_inst);
Memory::Write_U32(Common::swap32(m_GPR[_inst.RS]), uAddress);
@ -589,7 +582,7 @@ void CInterpreter::stwbrx(UGeckoInstruction _inst)
// The following two instructions are for inter-cpu communications. On a single CPU, they cannot
// fail unless an interrupt happens in between, which usually won't happen with the JIT, so we just pretend
// they are regular loads and stores for now. If this proves to be a problem, we could add a reservation flag.
void CInterpreter::lwarx(UGeckoInstruction _inst)
void lwarx(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = Memory::Read_U32(Helper_Get_EA_X(_inst));
//static bool bFirst = true;
@ -598,7 +591,7 @@ void CInterpreter::lwarx(UGeckoInstruction _inst)
//bFirst = false;
}
void CInterpreter::stwcxd(UGeckoInstruction _inst)
void stwcxd(UGeckoInstruction _inst)
{
// This instruction, to
static bool bFirst = true;
@ -609,25 +602,25 @@ void CInterpreter::stwcxd(UGeckoInstruction _inst)
Memory::Write_U32(m_GPR[_inst.RS], uAddress);
}
void CInterpreter::stwux(UGeckoInstruction _inst)
void stwux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
Memory::Write_U32(m_GPR[_inst.RS], uAddress);
m_GPR[_inst.RA] = uAddress;
}
void CInterpreter::stwx(UGeckoInstruction _inst)
void stwx(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_X(_inst);
Memory::Write_U32(m_GPR[_inst.RS], uAddress);
}
void CInterpreter::sync(UGeckoInstruction _inst)
void sync(UGeckoInstruction _inst)
{
//ignored
}
void CInterpreter::tlbia(UGeckoInstruction _inst)
void tlbia(UGeckoInstruction _inst)
{
// Gekko does not support this instructions.
PanicAlert("The GC CPU does not support tlbia");
@ -635,7 +628,7 @@ void CInterpreter::tlbia(UGeckoInstruction _inst)
//MessageBox(0,"TLBIA","TLBIA",0);
}
void CInterpreter::tlbie(UGeckoInstruction _inst)
void tlbie(UGeckoInstruction _inst)
{
// invalid entry
int entry = _inst.RB;
@ -643,7 +636,9 @@ void CInterpreter::tlbie(UGeckoInstruction _inst)
//MessageBox(0,"TLBIE","TLBIE",0);
}
void CInterpreter::tlbsync(UGeckoInstruction _inst)
void tlbsync(UGeckoInstruction _inst)
{
//MessageBox(0,"TLBsync","TLBsyncE",0);
}
} // namespace

25
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_LoadStorePaired.cpp
View File

@ -19,6 +19,9 @@
#include "Interpreter.h"
#include "../../HW/Memmap.h"
namespace Interpreter
{
// dequantize table
const float m_dequantizeTable[] =
{
@ -68,7 +71,7 @@ inline T CLAMP(T a, T bottom, T top) {
return a;
}
void CInterpreter::Helper_Quantize(const u32 _Addr, const float _fValue,
void Helper_Quantize(const u32 _Addr, const float _fValue,
const EQuantizeType _quantizeType, const unsigned int _uScale)
{
switch(_quantizeType)
@ -112,7 +115,7 @@ void CInterpreter::Helper_Quantize(const u32 _Addr, const float _fValue,
}
}
float CInterpreter::Helper_Dequantize(const u32 _Addr, const EQuantizeType _quantizeType,
float Helper_Dequantize(const u32 _Addr, const EQuantizeType _quantizeType,
const unsigned int _uScale)
{
// dequantize the value
@ -152,7 +155,7 @@ float CInterpreter::Helper_Dequantize(const u32 _Addr, const EQuantizeType _quan
return fResult;
}
void CInterpreter::psq_l(UGeckoInstruction _inst)
void psq_l(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.I));
const EQuantizeType ldType = static_cast<EQuantizeType>(gqr.LD_TYPE);
@ -175,7 +178,7 @@ void CInterpreter::psq_l(UGeckoInstruction _inst)
}
}
void CInterpreter::psq_lu(UGeckoInstruction _inst)
void psq_lu(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.I));
const EQuantizeType ldType = static_cast<EQuantizeType>(gqr.LD_TYPE);
@ -199,7 +202,7 @@ void CInterpreter::psq_lu(UGeckoInstruction _inst)
m_GPR[_inst.RA] = EA;
}
void CInterpreter::psq_st(UGeckoInstruction _inst)
void psq_st(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.I));
const EQuantizeType stType = static_cast<EQuantizeType>(gqr.ST_TYPE);
@ -221,7 +224,7 @@ void CInterpreter::psq_st(UGeckoInstruction _inst)
}
}
void CInterpreter::psq_stu(UGeckoInstruction _inst)
void psq_stu(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.I));
const EQuantizeType stType = static_cast<EQuantizeType>(gqr.ST_TYPE);
@ -244,7 +247,7 @@ void CInterpreter::psq_stu(UGeckoInstruction _inst)
m_GPR[_inst.RA] = EA;
}
void CInterpreter::psq_lx(UGeckoInstruction _inst)
void psq_lx(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.Ix));
const EQuantizeType ldType = static_cast<EQuantizeType>(gqr.LD_TYPE);
@ -267,7 +270,7 @@ void CInterpreter::psq_lx(UGeckoInstruction _inst)
}
}
void CInterpreter::psq_stx(UGeckoInstruction _inst)
void psq_stx(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.Ix));
const EQuantizeType stType = static_cast<EQuantizeType>(gqr.ST_TYPE);
@ -289,7 +292,7 @@ void CInterpreter::psq_stx(UGeckoInstruction _inst)
}
}
void CInterpreter::psq_lux(UGeckoInstruction _inst)
void psq_lux(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.Ix));
const EQuantizeType ldType = static_cast<EQuantizeType>(gqr.LD_TYPE);
@ -313,7 +316,7 @@ void CInterpreter::psq_lux(UGeckoInstruction _inst)
m_GPR[_inst.RA] = EA;
}
void CInterpreter::psq_stux(UGeckoInstruction _inst)
void psq_stux(UGeckoInstruction _inst)
{
const UGQR gqr(rSPR(SPR_GQR0 + _inst.Ix));
const EQuantizeType stType = static_cast<EQuantizeType>(gqr.ST_TYPE);
@ -334,4 +337,6 @@ void CInterpreter::psq_stux(UGeckoInstruction _inst)
Helper_Quantize(EA, (float)rPS0(_inst.RS), stType, stScale);
}
m_GPR[_inst.RA] = EA;
} // namespace=======
}

66
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_Paired.cpp
View File

@ -19,39 +19,42 @@
#include "Interpreter.h"
#include "../../HW/Memmap.h"
namespace Interpreter
{
// These "binary instructions" do not alter FPSCR.
void CInterpreter::ps_sel(UGeckoInstruction _inst)
void ps_sel(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>((rPS0(_inst.FA) >= -0.0) ? rPS0(_inst.FC) : rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>((rPS1(_inst.FA) >= -0.0) ? rPS1(_inst.FC) : rPS1(_inst.FB));
}
void CInterpreter::ps_neg(UGeckoInstruction _inst)
void ps_neg(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB) ^ (1ULL << 63);
riPS1(_inst.FD) = riPS1(_inst.FB) ^ (1ULL << 63);
}
void CInterpreter::ps_mr(UGeckoInstruction _inst)
void ps_mr(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = rPS0(_inst.FB);
rPS1(_inst.FD) = rPS1(_inst.FB);
}
void CInterpreter::ps_nabs(UGeckoInstruction _inst)
void ps_nabs(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB) | (1ULL << 63);
riPS1(_inst.FD) = riPS1(_inst.FB) | (1ULL << 63);
}
void CInterpreter::ps_abs(UGeckoInstruction _inst)
void ps_abs(UGeckoInstruction _inst)
{
riPS0(_inst.FD) = riPS0(_inst.FB) &~ (1ULL << 63);
riPS1(_inst.FD) = riPS1(_inst.FB) &~ (1ULL << 63);
}
// These are just moves, double is OK.
void CInterpreter::ps_merge00(UGeckoInstruction _inst)
void ps_merge00(UGeckoInstruction _inst)
{
double p0 = rPS0(_inst.FA);
double p1 = rPS0(_inst.FB);
@ -59,7 +62,7 @@ void CInterpreter::ps_merge00(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_merge01(UGeckoInstruction _inst)
void ps_merge01(UGeckoInstruction _inst)
{
double p0 = rPS0(_inst.FA);
double p1 = rPS1(_inst.FB);
@ -67,7 +70,7 @@ void CInterpreter::ps_merge01(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_merge10(UGeckoInstruction _inst)
void ps_merge10(UGeckoInstruction _inst)
{
double p0 = rPS1(_inst.FA);
double p1 = rPS0(_inst.FB);
@ -75,7 +78,7 @@ void CInterpreter::ps_merge10(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_merge11(UGeckoInstruction _inst)
void ps_merge11(UGeckoInstruction _inst)
{
double p0 = rPS1(_inst.FA);
double p1 = rPS1(_inst.FB);
@ -86,7 +89,7 @@ void CInterpreter::ps_merge11(UGeckoInstruction _inst)
// From here on, the real deal.
void CInterpreter::ps_div(UGeckoInstruction _inst)
void ps_div(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(rPS0(_inst.FA) / rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>(rPS1(_inst.FA) / rPS1(_inst.FB));
@ -96,31 +99,31 @@ void CInterpreter::ps_div(UGeckoInstruction _inst)
}
}
void CInterpreter::ps_sub(UGeckoInstruction _inst)
void ps_sub(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(rPS0(_inst.FA) - rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>(rPS1(_inst.FA) - rPS1(_inst.FB));
}
void CInterpreter::ps_add(UGeckoInstruction _inst)
void ps_add(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(rPS0(_inst.FA) + rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>(rPS1(_inst.FA) + rPS1(_inst.FB));
}
void CInterpreter::ps_res(UGeckoInstruction _inst)
void ps_res(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = 1.0f / static_cast<float>(rPS0(_inst.FB));
rPS1(_inst.FD) = 1.0f / static_cast<float>(rPS1(_inst.FB));
}
void CInterpreter::ps_mul(UGeckoInstruction _inst)
void ps_mul(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(rPS0(_inst.FA) * rPS0(_inst.FC));
rPS1(_inst.FD) = static_cast<float>(rPS1(_inst.FA) * rPS1(_inst.FC));
}
void CInterpreter::ps_rsqrte(UGeckoInstruction _inst)
void ps_rsqrte(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<double>(1.0f / sqrtf((float)rPS0(_inst.FB)));
rPS1(_inst.FD) = static_cast<double>(1.0f / sqrtf((float)rPS1(_inst.FB)));
@ -129,31 +132,31 @@ void CInterpreter::ps_rsqrte(UGeckoInstruction _inst)
}
}
void CInterpreter::ps_msub(UGeckoInstruction _inst)
void ps_msub(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>((rPS0(_inst.FA) * rPS0(_inst.FC)) - rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>((rPS1(_inst.FA) * rPS1(_inst.FC)) - rPS1(_inst.FB));
}
void CInterpreter::ps_madd(UGeckoInstruction _inst)
void ps_madd(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>((rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB));
rPS1(_inst.FD) = static_cast<float>((rPS1(_inst.FA) * rPS1(_inst.FC)) + rPS1(_inst.FB));
}
void CInterpreter::ps_nmsub(UGeckoInstruction _inst)
void ps_nmsub(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(-(rPS0(_inst.FA) * rPS0(_inst.FC) - rPS0(_inst.FB)));
rPS1(_inst.FD) = static_cast<float>(-(rPS1(_inst.FA) * rPS1(_inst.FC) - rPS1(_inst.FB)));
}
void CInterpreter::ps_nmadd(UGeckoInstruction _inst)
void ps_nmadd(UGeckoInstruction _inst)
{
rPS0(_inst.FD) = static_cast<float>(-(rPS0(_inst.FA) * rPS0(_inst.FC) + rPS0(_inst.FB)));
rPS1(_inst.FD) = static_cast<float>(-(rPS1(_inst.FA) * rPS1(_inst.FC) + rPS1(_inst.FB)));
}
void CInterpreter::ps_sum0(UGeckoInstruction _inst)
void ps_sum0(UGeckoInstruction _inst)
{
double p0 = (float)(rPS0(_inst.FA) + rPS1(_inst.FB));
double p1 = (float)(rPS1(_inst.FC));
@ -161,7 +164,7 @@ void CInterpreter::ps_sum0(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_sum1(UGeckoInstruction _inst)
void ps_sum1(UGeckoInstruction _inst)
{
double p0 = rPS0(_inst.FC);
double p1 = rPS0(_inst.FA) + rPS1(_inst.FB);
@ -169,7 +172,7 @@ void CInterpreter::ps_sum1(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_muls0(UGeckoInstruction _inst)
void ps_muls0(UGeckoInstruction _inst)
{
double p0 = rPS0(_inst.FA) * rPS0(_inst.FC);
double p1 = rPS1(_inst.FA) * rPS0(_inst.FC);
@ -177,7 +180,7 @@ void CInterpreter::ps_muls0(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_muls1(UGeckoInstruction _inst)
void ps_muls1(UGeckoInstruction _inst)
{
double p0 = rPS0(_inst.FA) * rPS1(_inst.FC);
double p1 = rPS1(_inst.FA) * rPS1(_inst.FC);
@ -185,7 +188,7 @@ void CInterpreter::ps_muls1(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_madds0(UGeckoInstruction _inst)
void ps_madds0(UGeckoInstruction _inst)
{
double p0 = (rPS0(_inst.FA) * rPS0(_inst.FC)) + rPS0(_inst.FB);
double p1 = (rPS1(_inst.FA) * rPS0(_inst.FC)) + rPS1(_inst.FB);
@ -193,7 +196,7 @@ void CInterpreter::ps_madds0(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_madds1(UGeckoInstruction _inst)
void ps_madds1(UGeckoInstruction _inst)
{
double p0 = (rPS0(_inst.FA) * rPS1(_inst.FC)) + rPS0(_inst.FB);
double p1 = (rPS1(_inst.FA) * rPS1(_inst.FC)) + rPS1(_inst.FB);
@ -201,7 +204,7 @@ void CInterpreter::ps_madds1(UGeckoInstruction _inst)
rPS1(_inst.FD) = p1;
}
void CInterpreter::ps_cmpu0(UGeckoInstruction _inst)
void ps_cmpu0(UGeckoInstruction _inst)
{
double fa = rPS0(_inst.FA);
double fb = rPS0(_inst.FB);
@ -212,13 +215,13 @@ void CInterpreter::ps_cmpu0(UGeckoInstruction _inst)
SetCRField(_inst.CRFD, compareResult);
}
void CInterpreter::ps_cmpo0(UGeckoInstruction _inst)
void ps_cmpo0(UGeckoInstruction _inst)
{
// for now HACK
ps_cmpu0(_inst);
}
void CInterpreter::ps_cmpu1(UGeckoInstruction _inst)
void ps_cmpu1(UGeckoInstruction _inst)
{
double fa = rPS1(_inst.FA);
double fb = rPS1(_inst.FB);
@ -230,7 +233,7 @@ void CInterpreter::ps_cmpu1(UGeckoInstruction _inst)
SetCRField(_inst.CRFD, compareResult);
}
void CInterpreter::ps_cmpo1(UGeckoInstruction _inst)
void ps_cmpo1(UGeckoInstruction _inst)
{
// for now HACK
ps_cmpu1(_inst);
@ -239,8 +242,7 @@ void CInterpreter::ps_cmpo1(UGeckoInstruction _inst)
// __________________________________________________________________________________________________
// dcbz_l
// TODO(ector) check docs
void
CInterpreter::dcbz_l(UGeckoInstruction _inst)
void dcbz_l(UGeckoInstruction _inst)
{
// This is supposed to allocate a cache line in the locked cache. Not entirely sure how
// this is visible to the rest of the world. For now, we ignore it.
@ -255,3 +257,5 @@ CInterpreter::dcbz_l(UGeckoInstruction _inst)
Memory::Write_U32(0,i);
*/
}
} // namespace

61
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_SystemRegisters.cpp
View File

@ -49,6 +49,9 @@ mffsx: 80036650 (huh?)
// That is, set rounding mode etc when entering jit code or the interpreter loop
// Restore rounding mode when calling anything external
namespace Interpreter
{
void UpdateSSEState()
{
u32 csr = _mm_getcsr();
@ -116,7 +119,7 @@ void UpdateFPSCR(UReg_FPSCR fp)
UpdateSSEState();
}
void CInterpreter::mcrfs(UGeckoInstruction _inst)
void mcrfs(UGeckoInstruction _inst)
{
u32 fpflags = ((FPSCR.Hex >> (4*(_inst.CRFS))) & 0xF);
switch (_inst.CRFS) {
@ -165,7 +168,7 @@ void CInterpreter::mcrfs(UGeckoInstruction _inst)
#define MXCSR_ROUND (16384|8192)
#define MXCSR_FLUSH 32768
void CInterpreter::mffsx(UGeckoInstruction _inst)
void mffsx(UGeckoInstruction _inst)
{
// load from FPSCR
// This may or may not be accurate - but better than nothing, I guess
@ -175,21 +178,21 @@ void CInterpreter::mffsx(UGeckoInstruction _inst)
if (_inst.Rc) PanicAlert("mffsx: inst_.Rc");
}
void CInterpreter::mtfsb0x(UGeckoInstruction _inst)
void mtfsb0x(UGeckoInstruction _inst)
{
FPSCR.Hex &= (~(0x80000000 >> _inst.CRBD));
UpdateFPSCR(FPSCR);
if (_inst.Rc) PanicAlert("mtfsb0x: inst_.Rc");
}
void CInterpreter::mtfsb1x(UGeckoInstruction _inst)
void mtfsb1x(UGeckoInstruction _inst)
{
FPSCR.Hex |= 0x80000000 >> _inst.CRBD;
UpdateFPSCR(FPSCR);
if (_inst.Rc) PanicAlert("mtfsb1x: inst_.Rc");
}
void CInterpreter::mtfsfix(UGeckoInstruction _inst)
void mtfsfix(UGeckoInstruction _inst)
{
u32 mask = (0xF0000000 >> (4 * _inst.CRFD));
u32 imm = (_inst.hex << 16) & 0xF0000000;
@ -198,7 +201,7 @@ void CInterpreter::mtfsfix(UGeckoInstruction _inst)
if (_inst.Rc) PanicAlert("mtfsfix: inst_.Rc");
}
void CInterpreter::mtfsfx(UGeckoInstruction _inst)
void mtfsfx(UGeckoInstruction _inst)
{
u32 fm = _inst.FM;
u32 m = 0;
@ -212,18 +215,18 @@ void CInterpreter::mtfsfx(UGeckoInstruction _inst)
if (_inst.Rc) PanicAlert("mtfsfx: inst_.Rc");
}
void CInterpreter::mcrxr(UGeckoInstruction _inst)
void mcrxr(UGeckoInstruction _inst)
{
SetCRField(_inst.CRFD, XER.Hex >> 28);
XER.Hex &= ~0xF0000000; // clear 0-3
}
void CInterpreter::mfcr(UGeckoInstruction _inst)
void mfcr(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = GetCR();
}
void CInterpreter::mtcrf(UGeckoInstruction _inst)
void mtcrf(UGeckoInstruction _inst)
{
u32 mask = 0;
u32 crm = _inst.CRM;
@ -240,7 +243,7 @@ void CInterpreter::mtcrf(UGeckoInstruction _inst)
}
void CInterpreter::mfmsr(UGeckoInstruction _inst)
void mfmsr(UGeckoInstruction _inst)
{
//Privileged?
m_GPR[_inst.RD] = MSR;
@ -248,38 +251,38 @@ void CInterpreter::mfmsr(UGeckoInstruction _inst)
// segment register
// We can probably ignore all this junk
void CInterpreter::mfsr(UGeckoInstruction _inst)
void mfsr(UGeckoInstruction _inst)
{
m_GPR[_inst.RD] = PowerPC::ppcState.sr[_inst.SR];
}
// segment register
void CInterpreter::mfsrin(UGeckoInstruction _inst)
void mfsrin(UGeckoInstruction _inst)
{
int index = m_GPR[_inst.RB] & 0xF;
m_GPR[_inst.RD] = PowerPC::ppcState.sr[index];
}
void CInterpreter::mtmsr(UGeckoInstruction _inst)
void mtmsr(UGeckoInstruction _inst)
{
//Privileged?
MSR = m_GPR[_inst.RS];
}
// segment register
void CInterpreter::mtsr(UGeckoInstruction _inst)
void mtsr(UGeckoInstruction _inst)
{
PowerPC::ppcState.sr[_inst.SR] = m_GPR[_inst.RS];
}
// segment register
void CInterpreter::mtsrin(UGeckoInstruction _inst)
void mtsrin(UGeckoInstruction _inst)
{
int index = m_GPR[_inst.RB] & 0xF;
PowerPC::ppcState.sr[index] = m_GPR[_inst.RS];
}
void CInterpreter::mftb(UGeckoInstruction _inst)
void mftb(UGeckoInstruction _inst)
{
int iIndex = (_inst.TBR >> 5) | ((_inst.TBR & 0x1F) << 5);
if (iIndex == 268) m_GPR[_inst.RD] = TL;
@ -288,7 +291,7 @@ void CInterpreter::mftb(UGeckoInstruction _inst)
}
void CInterpreter::mfspr(UGeckoInstruction _inst)
void mfspr(UGeckoInstruction _inst)
{
u32 iIndex = ((_inst.SPR & 0x1F) << 5) + ((_inst.SPR >> 5) & 0x1F);
@ -315,7 +318,7 @@ void CInterpreter::mfspr(UGeckoInstruction _inst)
m_GPR[_inst.RD] = rSPR(iIndex);
}
void CInterpreter::mtspr(UGeckoInstruction _inst)
void mtspr(UGeckoInstruction _inst)
{
u32 iIndex = (_inst.SPRU << 5) | (_inst.SPRL & 0x1F);
u32 oldValue = rSPR(iIndex);
@ -405,7 +408,7 @@ void CInterpreter::mtspr(UGeckoInstruction _inst)
}
}
void CInterpreter::crand(UGeckoInstruction _inst)
void crand(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -414,7 +417,7 @@ void CInterpreter::crand(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::crandc(UGeckoInstruction _inst)
void crandc(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -424,7 +427,7 @@ void CInterpreter::crandc(UGeckoInstruction _inst)
}
void CInterpreter::creqv(UGeckoInstruction _inst)
void creqv(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -433,7 +436,7 @@ void CInterpreter::creqv(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::crnand(UGeckoInstruction _inst)
void crnand(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -442,7 +445,7 @@ void CInterpreter::crnand(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::crnor(UGeckoInstruction _inst)
void crnor(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -451,7 +454,7 @@ void CInterpreter::crnor(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::cror(UGeckoInstruction _inst)
void cror(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -460,7 +463,7 @@ void CInterpreter::cror(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::crorc(UGeckoInstruction _inst)
void crorc(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -469,7 +472,7 @@ void CInterpreter::crorc(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::crxor(UGeckoInstruction _inst)
void crxor(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 a = cr << _inst.CRBA;
@ -478,7 +481,7 @@ void CInterpreter::crxor(UGeckoInstruction _inst)
SetCR(d | (cr & ~(0x80000000 >> _inst.CRBD)));
}
void CInterpreter::mcrf(UGeckoInstruction _inst)
void mcrf(UGeckoInstruction _inst)
{
u32 cr = GetCR();
u32 crmask = ~(0xF0000000 >> (4*_inst.CRFD));
@ -486,7 +489,9 @@ void CInterpreter::mcrf(UGeckoInstruction _inst)
SetCR((cr & crmask) | flags);
}
void CInterpreter::isync(UGeckoInstruction _inst)
void isync(UGeckoInstruction _inst)
{
//shouldnt do anything
}
} // namespace

23
Source/Core/Core/Src/PowerPC/Jit64/Jit.cpp
View File

@ -80,8 +80,8 @@ extern int blocksExecuted;
//be allocated, it should just be a temporary to do non-destructive trinary ops.
//However, for the above to work and be a win, we need to store away the non volatiles before
//entering "dynarec space". However, once we're there, it will be a win.
//Also, dynarec space will need to be surrounded with stack adjusting, since functions will be called.
//entering "JIT space". However, once we're there, it will be a win.
//Also, JIT space will need to be surrounded with stack adjusting, since functions will be called.
//Many instructions have shorter forms for EAX. However, I believe their performance boost
//will be as small to be negligble, so I haven't dirtied up the code with that. AMD recommends it in their
@ -118,36 +118,36 @@ extern int blocksExecuted;
// Plan: 1. Byteswap Dolphin DONE!
// 2. Fix timing WORKING
// 3. Lay groundwork for x64 dynarec WORKING
// 3. Lay groundwork for x64 JIT WORKING
// 4. Get OneTri up to 60fps, and check compatibility from time to time (yea right) ????
// 5. Add block linking to dynarec << NOT SO IMPORTANT
// 5. Add block linking to JIT << NOT SO IMPORTANT
// 6. Optimize GFX plugin to hell << IMPORTANT
// 7. Watch Zelda do 20 fps.
// 8. Watch Zelda TP do 30 fps.
// 8. Watch Zelda TP do 30 fps. DONE :D
//Optimizations -
/*
* Assume SP is in main RAM (in Wii mode too?)
* Assume all floating point loads and double precision stores are to/from main ram (single precision can be used in write gather)
* Assume all floating point loads and double precision loads+stores are to/from main ram
(single precision can be used in write gather)
(this is valid on Wii too when using the VM emulator)
* AMD only - use movaps instead of movapd when loading ps from memory?
* HLE functions like floorf, sin, memcpy, etc - they can be much faster
* Optimal sequence to store floats
* TODO: find optimal sequence to store doubles as floats
cvtpd2ps xmm0, xmm0
movss xmm0, f
movss tempspace, xmm0
mov eax, tempspace
bswap eax
mov [edi], eax
I think pshufb does it faster.
BLOCK EXIT DESIGN
TEST whatever
JZ skip
MOV NPC, exit1
@ -162,9 +162,6 @@ JMP exit1
The problem is, we still need to fit the downcount somewhere...
Low hanging fruit:
stfd -- guaranteed in memory
cmpl
@ -256,7 +253,7 @@ namespace Jit64
MOV(32, M(&PC), Imm32(js.compilerPC));
MOV(32, M(&NPC), Imm32(js.compilerPC + 4));
}
CInterpreter::_interpreterInstruction instr = GetInterpreterOp(_inst);
Interpreter::_interpreterInstruction instr = GetInterpreterOp(_inst);
ABI_CallFunctionC((void*)instr, _inst.hex);
}

2
Source/Core/Core/Src/PowerPC/Jit64/Jit.h
View File

@ -39,7 +39,7 @@ namespace Jit64
struct JitBlock;
const u8* DoJit(u32 emaddress, JitBlock &b);
bool IsInJitCode(u8 *codePtr);
bool IsInJitCode(const u8 *codePtr);
struct JitState
{

89
Source/Core/Core/Src/PowerPC/Jit64/JitCache.cpp
View File

@ -62,13 +62,12 @@ namespace Jit64
static JitBlock *blocks;
static int numBlocks;
//stats
static int numFlushes;
void DestroyBlock(int blocknum, bool invalidate);
void PrintStats()
{
LOG(DYNA_REC, "JIT Statistics =======================");
LOG(DYNA_REC, "Number of full cache flushes: %i", numFlushes);
LOG(DYNA_REC, "Number of blocks currently: %i", numBlocks);
LOG(DYNA_REC, "Code cache size: %i b", GetCodePtr() - codeCache);
LOG(DYNA_REC, "======================================");
@ -80,7 +79,6 @@ namespace Jit64
genFunctions = (u8*)AllocateExecutableMemory(GEN_SIZE);
trampolineCache = (u8*)AllocateExecutableMemory(TRAMPOLINE_SIZE);
trampolineCodePtr = trampolineCache;
numFlushes = 0;
blocks = new JitBlock[MAX_NUM_BLOCKS];
blockCodePointers = new u8*[MAX_NUM_BLOCKS];
@ -88,10 +86,44 @@ namespace Jit64
SetCodePtr(genFunctions);
Asm::Generate();
// Protect the generated functions
WriteProtectMemory(genFunctions, 4096, true);
WriteProtectMemory(genFunctions, GEN_SIZE, true);
SetCodePtr(codeCache);
}
void ShutdownCache()
{
UnWriteProtectMemory(genFunctions, GEN_SIZE, true);
FreeMemoryPages(codeCache, CODE_SIZE);
FreeMemoryPages(genFunctions, GEN_SIZE);
FreeMemoryPages(trampolineCache, TRAMPOLINE_SIZE);
delete [] blocks;
delete [] blockCodePointers;
blocks = 0;
blockCodePointers = 0;
numBlocks = 0;
}
void ClearCache()
{
Core::DisplayMessage("Cleared code cache.", 3000);
// Is destroying the blocks really necessary?
for (int i = 0; i < numBlocks; i++) {
DestroyBlock(i, false);
}
links_to.clear();
trampolineCodePtr = trampolineCache;
numBlocks = 0;
memset(blockCodePointers, 0, sizeof(u8*)*MAX_NUM_BLOCKS);
memset(codeCache, 0xCC, CODE_SIZE);
SetCodePtr(codeCache);
}
void ResetCache()
{
ShutdownCache();
InitCache();
}
JitBlock *CurBlock()
{
return &blocks[numBlocks];
@ -123,10 +155,10 @@ namespace Jit64
{
if (GetCodePtr() >= codeCache + CODE_SIZE - 0x10000 || numBlocks >= MAX_NUM_BLOCKS - 1)
{
// PanicAlert("Cleared cache");
LOG(DYNA_REC, "JIT code cache full - clearing cache and restoring memory")
LOG(DYNA_REC, "JIT cache full - clearing.")
ClearCache();
}
JitBlock &b = blocks[numBlocks];
b.invalid = false;
b.originalAddress = emAddress;
@ -169,12 +201,10 @@ namespace Jit64
return blockCodePointers;
}
bool IsInJitCode(u8 *codePtr) {
bool IsInJitCode(const u8 *codePtr) {
return codePtr >= codeCache && codePtr <= GetCodePtr();
}
void EnterFastRun()
{
CompiledCode pExecAddr = (CompiledCode)Asm::enterCode;
@ -182,25 +212,6 @@ namespace Jit64
//Will return when PowerPC::state changes
}
void ShutdownCache()
{
UnWriteProtectMemory(genFunctions, 4096, true);
FreeMemoryPages(codeCache, CODE_SIZE);
FreeMemoryPages(genFunctions, GEN_SIZE);
FreeMemoryPages(trampolineCache, TRAMPOLINE_SIZE);
delete [] blocks;
delete [] blockCodePointers;
blocks = 0;
blockCodePointers = 0;
numBlocks = 0;
}
void ResetCache()
{
ShutdownCache();
InitCache();
}
int GetBlockNumberFromAddress(u32 addr)
{
if (!blocks)
@ -226,6 +237,7 @@ namespace Jit64
return -1;
}
}
u32 GetOriginalCode(u32 address)
{
int num = GetBlockNumberFromAddress(address);
@ -357,21 +369,4 @@ namespace Jit64
}
}
void ClearCache()
{
Core::DisplayMessage("Cleared code cache.", 3000);
// Is destroying the blocks really necessary?
for (int i = 0; i < numBlocks; i++) {
DestroyBlock(i, false);
}
links_to.clear();
trampolineCodePtr = trampolineCache;
numBlocks = 0;
numFlushes++;
memset(blockCodePointers, 0, sizeof(u8*)*MAX_NUM_BLOCKS);
memset(codeCache, 0xCC, CODE_SIZE);
SetCodePtr(codeCache);
}
}
} // namespace

58
Source/Core/Core/Src/PowerPC/Jit64/JitCore.cpp
View File

@ -30,38 +30,30 @@
namespace Jit64
{
void Jit64Core::Init()
{
::Jit64::Init();
InitCache();
Asm::compareEnabled = Core::g_CoreStartupParameter.bRunCompareClient;
}
namespace Core
{
void Jit64Core::Shutdown()
{
ShutdownCache();
}
void Jit64Core::Reset()
{
ResetCache();
}
void Jit64Core::SingleStep()
{
Run();
/*
CompiledCode pExecAddr = (CompiledCode)GetCompiledCode(PC);
if (pExecAddr == NULL)
{
pExecAddr = (CompiledCode)Jit(PC);
}
pExecAddr();
*/
}
void Jit64Core::Run()
{
EnterFastRun();
}
void Init()
{
::Jit64::Init();
InitCache();
Asm::compareEnabled = ::Core::g_CoreStartupParameter.bRunCompareClient;
}
void Shutdown()
{
ShutdownCache();
}
void SingleStep()
{
Run();
}
void Run()
{
EnterFastRun();
}
} // namespace
} // namespace

5
Source/Core/Core/Src/PowerPC/Jit64/JitCore.h
View File

@ -17,13 +17,10 @@
#ifndef _JITCORE_H
#define _JITCORE_H
#include "../ICPUCore.h"
namespace Jit64
{
class Jit64Core : public ICPUCore
namespace Core
{
public:
void Init();
void Shutdown();
void Reset();

528
Source/Core/Core/Src/PowerPC/PPCTables.cpp
View File

@ -95,7 +95,7 @@ GekkoOPInfo *GetOpInfo(UGeckoInstruction _inst)
}
}
CInterpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst)
Interpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst)
{
const GekkoOPInfo *info = m_infoTable[_inst.OPCD];
if ((info->type & 0xFFFFFF) == OPTYPE_SUBTABLE)
@ -103,11 +103,11 @@ CInterpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst)
int table = info->type>>24;
switch(table)
{
case 4: return CInterpreter::m_opTable4[_inst.SUBOP10];
case 19: return CInterpreter::m_opTable19[_inst.SUBOP10];
case 31: return CInterpreter::m_opTable31[_inst.SUBOP10];
case 59: return CInterpreter::m_opTable59[_inst.SUBOP5];
case 63: return CInterpreter::m_opTable63[_inst.SUBOP10];
case 4: return Interpreter::m_opTable4[_inst.SUBOP10];
case 19: return Interpreter::m_opTable19[_inst.SUBOP10];
case 31: return Interpreter::m_opTable31[_inst.SUBOP10];
case 59: return Interpreter::m_opTable59[_inst.SUBOP5];
case 63: return Interpreter::m_opTable63[_inst.SUBOP10];
default:
_assert_msg_(GEKKO,0,"GetInterpreterOp - invalid subtable op %08x @ %08x", _inst, PC);
return 0;
@ -120,338 +120,338 @@ CInterpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst)
_assert_msg_(GEKKO,0,"GetInterpreterOp - invalid op %08x @ %08x", _inst, PC);
return 0;
}
return CInterpreter::m_opTable[_inst.OPCD];
return Interpreter::m_opTable[_inst.OPCD];
}
}
GekkoOPTemplate primarytable[] =
{
{4, CInterpreter::RunTable4, DynaRunTable4, {"RunTable4", OPTYPE_SUBTABLE | (4<<24), 0}},
{19, CInterpreter::RunTable19, DynaRunTable19, {"RunTable19", OPTYPE_SUBTABLE | (19<<24), 0}},
{31, CInterpreter::RunTable31, DynaRunTable31, {"RunTable31", OPTYPE_SUBTABLE | (31<<24), 0}},
{59, CInterpreter::RunTable59, DynaRunTable59, {"RunTable59", OPTYPE_SUBTABLE | (59<<24), 0}},
{63, CInterpreter::RunTable63, DynaRunTable63, {"RunTable63", OPTYPE_SUBTABLE | (63<<24), 0}},
{4, Interpreter::RunTable4, DynaRunTable4, {"RunTable4", OPTYPE_SUBTABLE | (4<<24), 0}},
{19, Interpreter::RunTable19, DynaRunTable19, {"RunTable19", OPTYPE_SUBTABLE | (19<<24), 0}},
{31, Interpreter::RunTable31, DynaRunTable31, {"RunTable31", OPTYPE_SUBTABLE | (31<<24), 0}},
{59, Interpreter::RunTable59, DynaRunTable59, {"RunTable59", OPTYPE_SUBTABLE | (59<<24), 0}},
{63, Interpreter::RunTable63, DynaRunTable63, {"RunTable63", OPTYPE_SUBTABLE | (63<<24), 0}},
{16, CInterpreter::bcx, Jit64::bcx, {"bcx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{18, CInterpreter::bx, Jit64::bx, {"bx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{16, Interpreter::bcx, Jit64::bcx, {"bcx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{18, Interpreter::bx, Jit64::bx, {"bx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{1, CInterpreter::HLEFunction, Jit64::HLEFunction, {"HLEFunction", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{2, CInterpreter::CompiledBlock, Jit64::Default, {"DynaBlock", OPTYPE_SYSTEM, 0}},
{3, CInterpreter::twi, Jit64::Default, {"twi", OPTYPE_SYSTEM, 0}},
{17, CInterpreter::sc, Jit64::sc, {"sc", OPTYPE_SYSTEM, FL_ENDBLOCK, 1}},
{1, Interpreter::HLEFunction, Jit64::HLEFunction, {"HLEFunction", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{2, Interpreter::CompiledBlock, Jit64::Default, {"DynaBlock", OPTYPE_SYSTEM, 0}},
{3, Interpreter::twi, Jit64::Default, {"twi", OPTYPE_SYSTEM, 0}},
{17, Interpreter::sc, Jit64::sc, {"sc", OPTYPE_SYSTEM, FL_ENDBLOCK, 1}},
{7, CInterpreter::mulli, Jit64::mulli, {"mulli", OPTYPE_INTEGER, FL_RC_BIT, 2}},
{8, CInterpreter::subfic, Jit64::subfic, {"subfic", OPTYPE_INTEGER, FL_SET_CA}},
{10, CInterpreter::cmpli, Jit64::cmpli, {"cmpli", OPTYPE_INTEGER, FL_SET_CRn}},
{11, CInterpreter::cmpi, Jit64::cmpi, {"cmpi", OPTYPE_INTEGER, FL_SET_CRn}},
{12, CInterpreter::addic, Jit64::reg_imm, {"addic", OPTYPE_INTEGER, FL_SET_CA}},
{13, CInterpreter::addic_rc, Jit64::reg_imm, {"addic_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{14, CInterpreter::addi, Jit64::reg_imm, {"addi", OPTYPE_INTEGER, 0}},
{15, CInterpreter::addis, Jit64::reg_imm, {"addis", OPTYPE_INTEGER, 0}},
{7, Interpreter::mulli, Jit64::mulli, {"mulli", OPTYPE_INTEGER, FL_RC_BIT, 2}},
{8, Interpreter::subfic, Jit64::subfic, {"subfic", OPTYPE_INTEGER, FL_SET_CA}},
{10, Interpreter::cmpli, Jit64::cmpli, {"cmpli", OPTYPE_INTEGER, FL_SET_CRn}},
{11, Interpreter::cmpi, Jit64::cmpi, {"cmpi", OPTYPE_INTEGER, FL_SET_CRn}},
{12, Interpreter::addic, Jit64::reg_imm, {"addic", OPTYPE_INTEGER, FL_SET_CA}},
{13, Interpreter::addic_rc, Jit64::reg_imm, {"addic_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{14, Interpreter::addi, Jit64::reg_imm, {"addi", OPTYPE_INTEGER, 0}},
{15, Interpreter::addis, Jit64::reg_imm, {"addis", OPTYPE_INTEGER, 0}},
{20, CInterpreter::rlwimix, Jit64::rlwimix, {"rlwimix", OPTYPE_INTEGER, FL_RC_BIT}},
{21, CInterpreter::rlwinmx, Jit64::rlwinmx, {"rlwinmx", OPTYPE_INTEGER, FL_RC_BIT}},
{23, CInterpreter::rlwnmx, Jit64::rlwnmx, {"rlwnmx", OPTYPE_INTEGER, FL_RC_BIT}},
{20, Interpreter::rlwimix, Jit64::rlwimix, {"rlwimix", OPTYPE_INTEGER, FL_RC_BIT}},
{21, Interpreter::rlwinmx, Jit64::rlwinmx, {"rlwinmx", OPTYPE_INTEGER, FL_RC_BIT}},
{23, Interpreter::rlwnmx, Jit64::rlwnmx, {"rlwnmx", OPTYPE_INTEGER, FL_RC_BIT}},
{24, CInterpreter::ori, Jit64::reg_imm, {"ori", OPTYPE_INTEGER, 0}},
{25, CInterpreter::oris, Jit64::reg_imm, {"oris", OPTYPE_INTEGER, 0}},
{26, CInterpreter::xori, Jit64::reg_imm, {"xori", OPTYPE_INTEGER, 0}},
{27, CInterpreter::xoris, Jit64::reg_imm, {"xoris", OPTYPE_INTEGER, 0}},
{28, CInterpreter::andi_rc, Jit64::reg_imm, {"andi_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{29, CInterpreter::andis_rc, Jit64::reg_imm, {"andis_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{24, Interpreter::ori, Jit64::reg_imm, {"ori", OPTYPE_INTEGER, 0}},
{25, Interpreter::oris, Jit64::reg_imm, {"oris", OPTYPE_INTEGER, 0}},
{26, Interpreter::xori, Jit64::reg_imm, {"xori", OPTYPE_INTEGER, 0}},
{27, Interpreter::xoris, Jit64::reg_imm, {"xoris", OPTYPE_INTEGER, 0}},
{28, Interpreter::andi_rc, Jit64::reg_imm, {"andi_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{29, Interpreter::andis_rc, Jit64::reg_imm, {"andis_rc", OPTYPE_INTEGER, FL_SET_CR0}},
{32, CInterpreter::lwz, Jit64::lXz, {"lwz", OPTYPE_LOAD, 0}},
{33, CInterpreter::lwzu, Jit64::Default, {"lwzu", OPTYPE_LOAD, 0}},
{34, CInterpreter::lbz, Jit64::lXz, {"lbz", OPTYPE_LOAD, 0}},
{35, CInterpreter::lbzu, Jit64::Default, {"lbzu", OPTYPE_LOAD, 0}},
{40, CInterpreter::lhz, Jit64::lXz, {"lhz", OPTYPE_LOAD, 0}},
{41, CInterpreter::lhzu, Jit64::Default, {"lhzu", OPTYPE_LOAD, 0}},
{42, CInterpreter::lha, Jit64::lha, {"lha", OPTYPE_LOAD, 0}},
{43, CInterpreter::lhau, Jit64::Default, {"lhau", OPTYPE_LOAD, 0}},
{32, Interpreter::lwz, Jit64::lXz, {"lwz", OPTYPE_LOAD, 0}},
{33, Interpreter::lwzu, Jit64::Default, {"lwzu", OPTYPE_LOAD, 0}},
{34, Interpreter::lbz, Jit64::lXz, {"lbz", OPTYPE_LOAD, 0}},
{35, Interpreter::lbzu, Jit64::Default, {"lbzu", OPTYPE_LOAD, 0}},
{40, Interpreter::lhz, Jit64::lXz, {"lhz", OPTYPE_LOAD, 0}},
{41, Interpreter::lhzu, Jit64::Default, {"lhzu", OPTYPE_LOAD, 0}},
{42, Interpreter::lha, Jit64::lha, {"lha", OPTYPE_LOAD, 0}},
{43, Interpreter::lhau, Jit64::Default, {"lhau", OPTYPE_LOAD, 0}},
{48, CInterpreter::lfs, Jit64::lfs, {"lfs", OPTYPE_LOADFP, 0}},
{49, CInterpreter::lfsu, Jit64::Default, {"lfsu", OPTYPE_LOADFP, 0}},
{50, CInterpreter::lfd, Jit64::lfd, {"lfd", OPTYPE_LOADFP, 0}},
{51, CInterpreter::lfdu, Jit64::Default, {"lfdu", OPTYPE_LOADFP, 0}},
{48, Interpreter::lfs, Jit64::lfs, {"lfs", OPTYPE_LOADFP, 0}},
{49, Interpreter::lfsu, Jit64::Default, {"lfsu", OPTYPE_LOADFP, 0}},
{50, Interpreter::lfd, Jit64::lfd, {"lfd", OPTYPE_LOADFP, 0}},
{51, Interpreter::lfdu, Jit64::Default, {"lfdu", OPTYPE_LOADFP, 0}},
{44, CInterpreter::sth, Jit64::stX, {"sth", OPTYPE_STORE, 0}},
{45, CInterpreter::sthu, Jit64::stX, {"sthu", OPTYPE_STORE, 0}},
{36, CInterpreter::stw, Jit64::stX, {"stw", OPTYPE_STORE, 0}},
{37, CInterpreter::stwu, Jit64::stX, {"stwu", OPTYPE_STORE, 0}},
{38, CInterpreter::stb, Jit64::stX, {"stb", OPTYPE_STORE, 0}},
{39, CInterpreter::stbu, Jit64::stX, {"stbu", OPTYPE_STORE, 0}},
{44, Interpreter::sth, Jit64::stX, {"sth", OPTYPE_STORE, 0}},
{45, Interpreter::sthu, Jit64::stX, {"sthu", OPTYPE_STORE, 0}},
{36, Interpreter::stw, Jit64::stX, {"stw", OPTYPE_STORE, 0}},
{37, Interpreter::stwu, Jit64::stX, {"stwu", OPTYPE_STORE, 0}},
{38, Interpreter::stb, Jit64::stX, {"stb", OPTYPE_STORE, 0}},
{39, Interpreter::stbu, Jit64::stX, {"stbu", OPTYPE_STORE, 0}},
{52, CInterpreter::stfs, Jit64::stfs, {"stfs", OPTYPE_STOREFP, 0}},
{53, CInterpreter::stfsu, Jit64::stfs, {"stfsu", OPTYPE_STOREFP, 0}},
{54, CInterpreter::stfd, Jit64::stfd, {"stfd", OPTYPE_STOREFP, 0}},
{55, CInterpreter::stfdu, Jit64::Default, {"stfdu", OPTYPE_STOREFP, 0}},
{52, Interpreter::stfs, Jit64::stfs, {"stfs", OPTYPE_STOREFP, 0}},
{53, Interpreter::stfsu, Jit64::stfs, {"stfsu", OPTYPE_STOREFP, 0}},
{54, Interpreter::stfd, Jit64::stfd, {"stfd", OPTYPE_STOREFP, 0}},
{55, Interpreter::stfdu, Jit64::Default, {"stfdu", OPTYPE_STOREFP, 0}},
{46, CInterpreter::lmw, Jit64::lmw, {"lmw", OPTYPE_SYSTEM, 0, 10}},
{47, CInterpreter::stmw, Jit64::stmw, {"stmw", OPTYPE_SYSTEM, 0, 10}},
{46, Interpreter::lmw, Jit64::lmw, {"lmw", OPTYPE_SYSTEM, 0, 10}},
{47, Interpreter::stmw, Jit64::stmw, {"stmw", OPTYPE_SYSTEM, 0, 10}},
{56, CInterpreter::psq_l, Jit64::psq_l, {"psq_l", OPTYPE_PS, 0}},
{57, CInterpreter::psq_lu, Jit64::psq_l, {"psq_lu", OPTYPE_PS, 0}},
{60, CInterpreter::psq_st, Jit64::psq_st, {"psq_st", OPTYPE_PS, 0}},
{61, CInterpreter::psq_stu, Jit64::psq_st, {"psq_stu", OPTYPE_PS, 0}},
{56, Interpreter::psq_l, Jit64::psq_l, {"psq_l", OPTYPE_PS, 0}},
{57, Interpreter::psq_lu, Jit64::psq_l, {"psq_lu", OPTYPE_PS, 0}},
{60, Interpreter::psq_st, Jit64::psq_st, {"psq_st", OPTYPE_PS, 0}},
{61, Interpreter::psq_stu, Jit64::psq_st, {"psq_stu", OPTYPE_PS, 0}},
//missing: 0, 5, 6, 9, 22, 30, 62, 58
{0, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{5, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{6, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{9, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{22, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{30, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{62, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{58, CInterpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{0, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{5, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{6, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{9, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{22, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{30, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{62, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{58, Interpreter::unknown_instruction, Jit64::Default, {"unknown_instruction", OPTYPE_UNKNOWN, 0}},
};
GekkoOPTemplate table4[] =
{
{0, CInterpreter::ps_cmpu0, Jit64::Default, {"ps_cmpu0", OPTYPE_PS, FL_SET_CRn}},
{32, CInterpreter::ps_cmpo0, Jit64::Default, {"ps_cmpo0", OPTYPE_PS, FL_SET_CRn}},
{40, CInterpreter::ps_neg, Jit64::ps_sign, {"ps_neg", OPTYPE_PS, FL_RC_BIT}},
{136, CInterpreter::ps_nabs, Jit64::ps_sign, {"ps_nabs", OPTYPE_PS, FL_RC_BIT}},
{264, CInterpreter::ps_abs, Jit64::ps_sign, {"ps_abs", OPTYPE_PS, FL_RC_BIT}},
{64, CInterpreter::ps_cmpu1, Jit64::Default, {"ps_cmpu1", OPTYPE_PS, FL_RC_BIT}},
{72, CInterpreter::ps_mr, Jit64::ps_mr, {"ps_mr", OPTYPE_PS, FL_RC_BIT}},
{96, CInterpreter::ps_cmpo1, Jit64::Default, {"ps_cmpo1", OPTYPE_PS, FL_RC_BIT}},
{528, CInterpreter::ps_merge00, Jit64::ps_mergeXX, {"ps_merge00", OPTYPE_PS, FL_RC_BIT}},
{560, CInterpreter::ps_merge01, Jit64::ps_mergeXX, {"ps_merge01", OPTYPE_PS, FL_RC_BIT}},
{592, CInterpreter::ps_merge10, Jit64::ps_mergeXX, {"ps_merge10", OPTYPE_PS, FL_RC_BIT}},
{624, CInterpreter::ps_merge11, Jit64::ps_mergeXX, {"ps_merge11", OPTYPE_PS, FL_RC_BIT}},
{0, Interpreter::ps_cmpu0, Jit64::Default, {"ps_cmpu0", OPTYPE_PS, FL_SET_CRn}},
{32, Interpreter::ps_cmpo0, Jit64::Default, {"ps_cmpo0", OPTYPE_PS, FL_SET_CRn}},
{40, Interpreter::ps_neg, Jit64::ps_sign, {"ps_neg", OPTYPE_PS, FL_RC_BIT}},
{136, Interpreter::ps_nabs, Jit64::ps_sign, {"ps_nabs", OPTYPE_PS, FL_RC_BIT}},
{264, Interpreter::ps_abs, Jit64::ps_sign, {"ps_abs", OPTYPE_PS, FL_RC_BIT}},
{64, Interpreter::ps_cmpu1, Jit64::Default, {"ps_cmpu1", OPTYPE_PS, FL_RC_BIT}},
{72, Interpreter::ps_mr, Jit64::ps_mr, {"ps_mr", OPTYPE_PS, FL_RC_BIT}},
{96, Interpreter::ps_cmpo1, Jit64::Default, {"ps_cmpo1", OPTYPE_PS, FL_RC_BIT}},
{528, Interpreter::ps_merge00, Jit64::ps_mergeXX, {"ps_merge00", OPTYPE_PS, FL_RC_BIT}},
{560, Interpreter::ps_merge01, Jit64::ps_mergeXX, {"ps_merge01", OPTYPE_PS, FL_RC_BIT}},
{592, Interpreter::ps_merge10, Jit64::ps_mergeXX, {"ps_merge10", OPTYPE_PS, FL_RC_BIT}},
{624, Interpreter::ps_merge11, Jit64::ps_mergeXX, {"ps_merge11", OPTYPE_PS, FL_RC_BIT}},
{1014, CInterpreter::dcbz_l, Jit64::Default, {"dcbz_l", OPTYPE_SYSTEM, 0}},
{1014, Interpreter::dcbz_l, Jit64::Default, {"dcbz_l", OPTYPE_SYSTEM, 0}},
};
GekkoOPTemplate table4_2[] =
{
{10, CInterpreter::ps_sum0, Jit64::Default, {"ps_sum0", OPTYPE_PS, 0}},
{11, CInterpreter::ps_sum1, Jit64::Default, {"ps_sum1", OPTYPE_PS, 0}},
{12, CInterpreter::ps_muls0, Jit64::Default, {"ps_muls0", OPTYPE_PS, 0}},
{13, CInterpreter::ps_muls1, Jit64::Default, {"ps_muls1", OPTYPE_PS, 0}},
{14, CInterpreter::ps_madds0, Jit64::Default, {"ps_madds0", OPTYPE_PS, 0}},
{15, CInterpreter::ps_madds1, Jit64::Default, {"ps_madds1", OPTYPE_PS, 0}},
{18, CInterpreter::ps_div, Jit64::ps_arith, {"ps_div", OPTYPE_PS, 0, 16}},
{20, CInterpreter::ps_sub, Jit64::ps_arith, {"ps_sub", OPTYPE_PS, 0}},
{21, CInterpreter::ps_add, Jit64::ps_arith, {"ps_add", OPTYPE_PS, 0}},
{23, CInterpreter::ps_sel, Jit64::ps_sel, {"ps_sel", OPTYPE_PS, 0}},
{24, CInterpreter::ps_res, Jit64::Default, {"ps_res", OPTYPE_PS, 0}},
{25, CInterpreter::ps_mul, Jit64::ps_arith, {"ps_mul", OPTYPE_PS, 0}},
{26, CInterpreter::ps_rsqrte, Jit64::ps_rsqrte, {"ps_rsqrte", OPTYPE_PS, 0}},
{28, CInterpreter::ps_msub, Jit64::ps_maddXX, {"ps_msub", OPTYPE_PS, 0}},
{29, CInterpreter::ps_madd, Jit64::ps_maddXX, {"ps_madd", OPTYPE_PS, 0}},
{30, CInterpreter::ps_nmsub, Jit64::ps_maddXX, {"ps_nmsub", OPTYPE_PS, 0}},
{31, CInterpreter::ps_nmadd, Jit64::ps_maddXX, {"ps_nmadd", OPTYPE_PS, 0}},
{10, Interpreter::ps_sum0, Jit64::Default, {"ps_sum0", OPTYPE_PS, 0}},
{11, Interpreter::ps_sum1, Jit64::Default, {"ps_sum1", OPTYPE_PS, 0}},
{12, Interpreter::ps_muls0, Jit64::Default, {"ps_muls0", OPTYPE_PS, 0}},
{13, Interpreter::ps_muls1, Jit64::Default, {"ps_muls1", OPTYPE_PS, 0}},
{14, Interpreter::ps_madds0, Jit64::Default, {"ps_madds0", OPTYPE_PS, 0}},
{15, Interpreter::ps_madds1, Jit64::Default, {"ps_madds1", OPTYPE_PS, 0}},
{18, Interpreter::ps_div, Jit64::ps_arith, {"ps_div", OPTYPE_PS, 0, 16}},
{20, Interpreter::ps_sub, Jit64::ps_arith, {"ps_sub", OPTYPE_PS, 0}},
{21, Interpreter::ps_add, Jit64::ps_arith, {"ps_add", OPTYPE_PS, 0}},
{23, Interpreter::ps_sel, Jit64::ps_sel, {"ps_sel", OPTYPE_PS, 0}},
{24, Interpreter::ps_res, Jit64::Default, {"ps_res", OPTYPE_PS, 0}},
{25, Interpreter::ps_mul, Jit64::ps_arith, {"ps_mul", OPTYPE_PS, 0}},
{26, Interpreter::ps_rsqrte, Jit64::ps_rsqrte, {"ps_rsqrte", OPTYPE_PS, 0}},
{28, Interpreter::ps_msub, Jit64::ps_maddXX, {"ps_msub", OPTYPE_PS, 0}},
{29, Interpreter::ps_madd, Jit64::ps_maddXX, {"ps_madd", OPTYPE_PS, 0}},
{30, Interpreter::ps_nmsub, Jit64::ps_maddXX, {"ps_nmsub", OPTYPE_PS, 0}},
{31, Interpreter::ps_nmadd, Jit64::ps_maddXX, {"ps_nmadd", OPTYPE_PS, 0}},
};
GekkoOPTemplate table4_3[] =
{
{6, CInterpreter::psq_lx, Jit64::Default, {"psq_lx", OPTYPE_PS, 0}},
{7, CInterpreter::psq_stx, Jit64::Default, {"psq_stx", OPTYPE_PS, 0}},
{38, CInterpreter::psq_lux, Jit64::Default, {"psq_lux", OPTYPE_PS, 0}},
{39, CInterpreter::psq_stux, Jit64::Default, {"psq_stux", OPTYPE_PS, 0}},
{6, Interpreter::psq_lx, Jit64::Default, {"psq_lx", OPTYPE_PS, 0}},
{7, Interpreter::psq_stx, Jit64::Default, {"psq_stx", OPTYPE_PS, 0}},
{38, Interpreter::psq_lux, Jit64::Default, {"psq_lux", OPTYPE_PS, 0}},
{39, Interpreter::psq_stux, Jit64::Default, {"psq_stux", OPTYPE_PS, 0}},
};
GekkoOPTemplate table19[] =
{
{528, CInterpreter::bcctrx, Jit64::bcctrx, {"bcctrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{16, CInterpreter::bclrx, Jit64::bclrx, {"bclrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{257, CInterpreter::crand, Jit64::Default, {"crand", OPTYPE_CR, 0}},
{129, CInterpreter::crandc, Jit64::Default, {"crandc", OPTYPE_CR, 0}},
{289, CInterpreter::creqv, Jit64::Default, {"creqv", OPTYPE_CR, 0}},
{225, CInterpreter::crnand, Jit64::Default, {"crnand", OPTYPE_CR, 0}},
{33, CInterpreter::crnor, Jit64::Default, {"crnor", OPTYPE_CR, 0}},
{449, CInterpreter::cror, Jit64::Default, {"cror", OPTYPE_CR, 0}},
{417, CInterpreter::crorc, Jit64::Default, {"crorc", OPTYPE_CR, 0}},
{193, CInterpreter::crxor, Jit64::Default, {"crxor", OPTYPE_CR, 0}},
{528, Interpreter::bcctrx, Jit64::bcctrx, {"bcctrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{16, Interpreter::bclrx, Jit64::bclrx, {"bclrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{257, Interpreter::crand, Jit64::Default, {"crand", OPTYPE_CR, 0}},
{129, Interpreter::crandc, Jit64::Default, {"crandc", OPTYPE_CR, 0}},
{289, Interpreter::creqv, Jit64::Default, {"creqv", OPTYPE_CR, 0}},
{225, Interpreter::crnand, Jit64::Default, {"crnand", OPTYPE_CR, 0}},
{33, Interpreter::crnor, Jit64::Default, {"crnor", OPTYPE_CR, 0}},
{449, Interpreter::cror, Jit64::Default, {"cror", OPTYPE_CR, 0}},
{417, Interpreter::crorc, Jit64::Default, {"crorc", OPTYPE_CR, 0}},
{193, Interpreter::crxor, Jit64::Default, {"crxor", OPTYPE_CR, 0}},
{150, CInterpreter::isync, Jit64::DoNothing, {"isync", OPTYPE_ICACHE, 0 }},
{0, CInterpreter::mcrf, Jit64::Default, {"mcrf", OPTYPE_SYSTEM, 0}},
{150, Interpreter::isync, Jit64::DoNothing, {"isync", OPTYPE_ICACHE, 0 }},
{0, Interpreter::mcrf, Jit64::Default, {"mcrf", OPTYPE_SYSTEM, 0}},
{50, CInterpreter::rfi, Jit64::rfi, {"rfi", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS, 1}},
{18, CInterpreter::rfid, Jit64::Default, {"rfid", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS}}
{50, Interpreter::rfi, Jit64::rfi, {"rfi", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS, 1}},
{18, Interpreter::rfid, Jit64::Default, {"rfid", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS}}
};
GekkoOPTemplate table31[] =
{
{28, CInterpreter::andx, Jit64::andx, {"andx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{60, CInterpreter::andcx, Jit64::Default, {"andcx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{444, CInterpreter::orx, Jit64::orx, {"orx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{124, CInterpreter::norx, Jit64::Default, {"norx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{316, CInterpreter::xorx, Jit64::Default, {"xorx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{412, CInterpreter::orcx, Jit64::Default, {"orcx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{476, CInterpreter::nandx, Jit64::Default, {"nandx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{284, CInterpreter::eqvx, Jit64::Default, {"eqvx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{0, CInterpreter::cmp, Jit64::cmp, {"cmp", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{32, CInterpreter::cmpl, Jit64::cmpl, {"cmpl", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{26, CInterpreter::cntlzwx, Jit64::cntlzwx, {"cntlzwx",OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{922, CInterpreter::extshx, Jit64::extshx, {"extshx", OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{954, CInterpreter::extsbx, Jit64::extsbx, {"extsbx", OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{536, CInterpreter::srwx, Jit64::srwx, {"srwx", OPTYPE_INTEGER, FL_RC_BIT}},
{792, CInterpreter::srawx, Jit64::Default, {"srawx", OPTYPE_INTEGER, FL_RC_BIT}},
{824, CInterpreter::srawix, Jit64::srawix, {"srawix", OPTYPE_INTEGER, FL_RC_BIT}},
{24, CInterpreter::slwx, Jit64::slwx, {"slwx", OPTYPE_INTEGER, FL_RC_BIT}},
{28, Interpreter::andx, Jit64::andx, {"andx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{60, Interpreter::andcx, Jit64::Default, {"andcx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{444, Interpreter::orx, Jit64::orx, {"orx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{124, Interpreter::norx, Jit64::Default, {"norx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{316, Interpreter::xorx, Jit64::Default, {"xorx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{412, Interpreter::orcx, Jit64::Default, {"orcx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{476, Interpreter::nandx, Jit64::Default, {"nandx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{284, Interpreter::eqvx, Jit64::Default, {"eqvx", OPTYPE_INTEGER, FL_IN_AB | FL_OUT_S | FL_RC_BIT}},
{0, Interpreter::cmp, Jit64::cmp, {"cmp", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{32, Interpreter::cmpl, Jit64::cmpl, {"cmpl", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{26, Interpreter::cntlzwx, Jit64::cntlzwx, {"cntlzwx",OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{922, Interpreter::extshx, Jit64::extshx, {"extshx", OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{954, Interpreter::extsbx, Jit64::extsbx, {"extsbx", OPTYPE_INTEGER, FL_IN_A | FL_OUT_S | FL_RC_BIT}},
{536, Interpreter::srwx, Jit64::srwx, {"srwx", OPTYPE_INTEGER, FL_RC_BIT}},
{792, Interpreter::srawx, Jit64::Default, {"srawx", OPTYPE_INTEGER, FL_RC_BIT}},
{824, Interpreter::srawix, Jit64::srawix, {"srawix", OPTYPE_INTEGER, FL_RC_BIT}},
{24, Interpreter::slwx, Jit64::slwx, {"slwx", OPTYPE_INTEGER, FL_RC_BIT}},
{54, CInterpreter::dcbst, Jit64::Default, {"dcbst", OPTYPE_DCACHE, 0, 4}},
{86, CInterpreter::dcbf, Jit64::Default, {"dcbf", OPTYPE_DCACHE, 0, 4}},
{246, CInterpreter::dcbtst, Jit64::Default, {"dcbtst", OPTYPE_DCACHE, 0, 1}},
{278, CInterpreter::dcbt, Jit64::Default, {"dcbt", OPTYPE_DCACHE, 0, 1}},
{470, CInterpreter::dcbi, Jit64::Default, {"dcbi", OPTYPE_DCACHE, 0, 4}},
{758, CInterpreter::dcba, Jit64::Default, {"dcba", OPTYPE_DCACHE, 0, 4}},
{1014, CInterpreter::dcbz, Jit64::dcbz, {"dcbz", OPTYPE_DCACHE, 0, 4}},
{54, Interpreter::dcbst, Jit64::Default, {"dcbst", OPTYPE_DCACHE, 0, 4}},
{86, Interpreter::dcbf, Jit64::Default, {"dcbf", OPTYPE_DCACHE, 0, 4}},
{246, Interpreter::dcbtst, Jit64::Default, {"dcbtst", OPTYPE_DCACHE, 0, 1}},
{278, Interpreter::dcbt, Jit64::Default, {"dcbt", OPTYPE_DCACHE, 0, 1}},
{470, Interpreter::dcbi, Jit64::Default, {"dcbi", OPTYPE_DCACHE, 0, 4}},
{758, Interpreter::dcba, Jit64::Default, {"dcba", OPTYPE_DCACHE, 0, 4}},
{1014, Interpreter::dcbz, Jit64::dcbz, {"dcbz", OPTYPE_DCACHE, 0, 4}},
//load word
{23, CInterpreter::lwzx, Jit64::Default, {"lwzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{55, CInterpreter::lwzux, Jit64::Default, {"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
{23, Interpreter::lwzx, Jit64::Default, {"lwzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{55, Interpreter::lwzux, Jit64::Default, {"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
//load halfword
{279, CInterpreter::lhzx, Jit64::Default, {"lhzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{311, CInterpreter::lhzux, Jit64::Default, {"lhzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
{279, Interpreter::lhzx, Jit64::Default, {"lhzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{311, Interpreter::lhzux, Jit64::Default, {"lhzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
//load halfword signextend
{343, CInterpreter::lhax, Jit64::Default, {"lhax", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{375, CInterpreter::lhaux, Jit64::Default, {"lhaux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
{343, Interpreter::lhax, Jit64::Default, {"lhax", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{375, Interpreter::lhaux, Jit64::Default, {"lhaux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
//load byte
{87, CInterpreter::lbzx, Jit64::lbzx, {"lbzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{119, CInterpreter::lbzux, Jit64::Default, {"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
{87, Interpreter::lbzx, Jit64::lbzx, {"lbzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{119, Interpreter::lbzux, Jit64::Default, {"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_IN_A | FL_IN_B}},
//load byte reverse
{534, CInterpreter::lwbrx, Jit64::Default, {"lwbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{790, CInterpreter::lhbrx, Jit64::Default, {"lhbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{534, Interpreter::lwbrx, Jit64::Default, {"lwbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{790, Interpreter::lhbrx, Jit64::Default, {"lhbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{20, CInterpreter::lwarx, Jit64::Default, {"lwarx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0B}},
{20, Interpreter::lwarx, Jit64::Default, {"lwarx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0B}},
//load string (interpret these)
{533, CInterpreter::lswx, Jit64::Default, {"lswx", OPTYPE_LOAD, FL_IN_A | FL_OUT_D}},
{597, CInterpreter::lswi, Jit64::Default, {"lswi", OPTYPE_LOAD, FL_IN_AB | FL_OUT_D}},
{533, Interpreter::lswx, Jit64::Default, {"lswx", OPTYPE_LOAD, FL_IN_A | FL_OUT_D}},
{597, Interpreter::lswi, Jit64::Default, {"lswi", OPTYPE_LOAD, FL_IN_AB | FL_OUT_D}},
{535, CInterpreter::lfsx, Jit64::lfsx, {"lfsx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{567, CInterpreter::lfsux, Jit64::Default, {"lfsux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
{599, CInterpreter::lfdx, Jit64::Default, {"lfdx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{631, CInterpreter::lfdux, Jit64::Default, {"lfdux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
{535, Interpreter::lfsx, Jit64::lfsx, {"lfsx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{567, Interpreter::lfsux, Jit64::Default, {"lfsux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
{599, Interpreter::lfdx, Jit64::Default, {"lfdx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{631, Interpreter::lfdux, Jit64::Default, {"lfdux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
//store word
{151, CInterpreter::stwx, Jit64::Default, {"stwx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{183, CInterpreter::stwux, Jit64::Default, {"stwux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{151, Interpreter::stwx, Jit64::Default, {"stwx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{183, Interpreter::stwux, Jit64::Default, {"stwux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
//store halfword
{407, CInterpreter::sthx, Jit64::Default, {"sthx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{439, CInterpreter::sthux, Jit64::Default, {"sthux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{407, Interpreter::sthx, Jit64::Default, {"sthx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{439, Interpreter::sthux, Jit64::Default, {"sthux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
//store byte
{215, CInterpreter::stbx, Jit64::Default, {"stbx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{247, CInterpreter::stbux, Jit64::Default, {"stbux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{215, Interpreter::stbx, Jit64::Default, {"stbx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{247, Interpreter::stbux, Jit64::Default, {"stbux", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
//store bytereverse
{662, CInterpreter::stwbrx, Jit64::Default, {"stwbrx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{918, CInterpreter::sthbrx, Jit64::Default, {"sthbrx", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{662, Interpreter::stwbrx, Jit64::Default, {"stwbrx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{918, Interpreter::sthbrx, Jit64::Default, {"sthbrx", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{661, CInterpreter::stswx, Jit64::Default, {"stswx", OPTYPE_STORE, 0}},
{725, CInterpreter::stswi, Jit64::Default, {"stswi", OPTYPE_STORE, 0}},
{661, Interpreter::stswx, Jit64::Default, {"stswx", OPTYPE_STORE, 0}},
{725, Interpreter::stswi, Jit64::Default, {"stswi", OPTYPE_STORE, 0}},
{663, CInterpreter::stfsx, Jit64::Default, {"stfsx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{695, CInterpreter::stfsux, Jit64::Default, {"stfsux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{727, CInterpreter::stfdx, Jit64::Default, {"stfdx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{759, CInterpreter::stfdux, Jit64::Default, {"stfdux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{983, CInterpreter::stfiwx, Jit64::Default, {"stfiwx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{663, Interpreter::stfsx, Jit64::Default, {"stfsx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{695, Interpreter::stfsux, Jit64::Default, {"stfsux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{727, Interpreter::stfdx, Jit64::Default, {"stfdx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{759, Interpreter::stfdux, Jit64::Default, {"stfdux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{983, Interpreter::stfiwx, Jit64::Default, {"stfiwx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{19, CInterpreter::mfcr, Jit64::Default, {"mfcr", OPTYPE_SYSTEM, 0}},
{83, CInterpreter::mfmsr, Jit64::mfmsr, {"mfmsr", OPTYPE_SYSTEM, 0}},
{144, CInterpreter::mtcrf, Jit64::Default, {"mtcrf", OPTYPE_SYSTEM, 0}},
{146, CInterpreter::mtmsr, Jit64::mtmsr, {"mtmsr", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{210, CInterpreter::mtsr, Jit64::Default, {"mtsr", OPTYPE_SYSTEM, 0}},
{242, CInterpreter::mtsrin, Jit64::Default, {"mtsrin", OPTYPE_SYSTEM, 0}},
{339, CInterpreter::mfspr, Jit64::mfspr, {"mfspr", OPTYPE_SYSTEM, 0}},
{467, CInterpreter::mtspr, Jit64::mtspr, {"mtspr", OPTYPE_SYSTEM, 0, 2}},
{371, CInterpreter::mftb, Jit64::mftb, {"mftb", OPTYPE_SYSTEM, FL_TIMER}},
{512, CInterpreter::mcrxr, Jit64::Default, {"mcrxr", OPTYPE_SYSTEM, 0}},
{595, CInterpreter::mfsr, Jit64::Default, {"mfsr", OPTYPE_SYSTEM, 0, 2}},
{659, CInterpreter::mfsrin, Jit64::Default, {"mfsrin", OPTYPE_SYSTEM, 0, 2}},
{19, Interpreter::mfcr, Jit64::Default, {"mfcr", OPTYPE_SYSTEM, 0}},
{83, Interpreter::mfmsr, Jit64::mfmsr, {"mfmsr", OPTYPE_SYSTEM, 0}},
{144, Interpreter::mtcrf, Jit64::Default, {"mtcrf", OPTYPE_SYSTEM, 0}},
{146, Interpreter::mtmsr, Jit64::mtmsr, {"mtmsr", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{210, Interpreter::mtsr, Jit64::Default, {"mtsr", OPTYPE_SYSTEM, 0}},
{242, Interpreter::mtsrin, Jit64::Default, {"mtsrin", OPTYPE_SYSTEM, 0}},
{339, Interpreter::mfspr, Jit64::mfspr, {"mfspr", OPTYPE_SYSTEM, 0}},
{467, Interpreter::mtspr, Jit64::mtspr, {"mtspr", OPTYPE_SYSTEM, 0, 2}},
{371, Interpreter::mftb, Jit64::mftb, {"mftb", OPTYPE_SYSTEM, FL_TIMER}},
{512, Interpreter::mcrxr, Jit64::Default, {"mcrxr", OPTYPE_SYSTEM, 0}},
{595, Interpreter::mfsr, Jit64::Default, {"mfsr", OPTYPE_SYSTEM, 0, 2}},
{659, Interpreter::mfsrin, Jit64::Default, {"mfsrin", OPTYPE_SYSTEM, 0, 2}},
{4, CInterpreter::tw, Jit64::Default, {"tw", OPTYPE_SYSTEM, 0, 1}},
{598, CInterpreter::sync, Jit64::Default, {"sync", OPTYPE_SYSTEM, 0, 2}},
{982, CInterpreter::icbi, Jit64::Default, {"icbi", OPTYPE_SYSTEM, 0, 3}},
{4, Interpreter::tw, Jit64::Default, {"tw", OPTYPE_SYSTEM, 0, 1}},
{598, Interpreter::sync, Jit64::Default, {"sync", OPTYPE_SYSTEM, 0, 2}},
{982, Interpreter::icbi, Jit64::Default, {"icbi", OPTYPE_SYSTEM, 0, 3}},
//Unused instructions on GC
{310, CInterpreter::eciwx, Jit64::Default, {"eciwx", OPTYPE_INTEGER, FL_RC_BIT}},
{438, CInterpreter::ecowx, Jit64::Default, {"ecowx", OPTYPE_INTEGER, FL_RC_BIT}},
{854, CInterpreter::eieio, Jit64::Default, {"eieio", OPTYPE_INTEGER, FL_RC_BIT}},
{306, CInterpreter::tlbie, Jit64::Default, {"tlbie", OPTYPE_SYSTEM, 0}},
{370, CInterpreter::tlbia, Jit64::Default, {"tlbia", OPTYPE_SYSTEM, 0}},
{566, CInterpreter::tlbsync, Jit64::Default, {"tlbsync", OPTYPE_SYSTEM, 0}},
{150, CInterpreter::stwcxd, Jit64::Default, {"stwcxd", OPTYPE_STORE, 0}},
{310, Interpreter::eciwx, Jit64::Default, {"eciwx", OPTYPE_INTEGER, FL_RC_BIT}},
{438, Interpreter::ecowx, Jit64::Default, {"ecowx", OPTYPE_INTEGER, FL_RC_BIT}},
{854, Interpreter::eieio, Jit64::Default, {"eieio", OPTYPE_INTEGER, FL_RC_BIT}},
{306, Interpreter::tlbie, Jit64::Default, {"tlbie", OPTYPE_SYSTEM, 0}},
{370, Interpreter::tlbia, Jit64::Default, {"tlbia", OPTYPE_SYSTEM, 0}},
{566, Interpreter::tlbsync, Jit64::Default, {"tlbsync", OPTYPE_SYSTEM, 0}},
{150, Interpreter::stwcxd, Jit64::Default, {"stwcxd", OPTYPE_STORE, 0}},
};
GekkoOPTemplate table31_2[] =
{
{266, CInterpreter::addx, Jit64::addx, {"addx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{10, CInterpreter::addcx, Jit64::Default, {"addcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_SET_CA | FL_RC_BIT}},
{138, CInterpreter::addex, Jit64::addex, {"addex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{234, CInterpreter::addmex, Jit64::Default, {"addmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{202, CInterpreter::addzex, Jit64::Default, {"addzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{491, CInterpreter::divwx, Jit64::Default, {"divwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 39}},
{459, CInterpreter::divwux, Jit64::divwux, {"divwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 39}},
{75, CInterpreter::mulhwx, Jit64::Default, {"mulhwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{11, CInterpreter::mulhwux, Jit64::mulhwux, {"mulhwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{235, CInterpreter::mullwx, Jit64::mullwx, {"mullwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{104, CInterpreter::negx, Jit64::negx, {"negx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{40, CInterpreter::subfx, Jit64::subfx, {"subfx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{8, CInterpreter::subfcx, Jit64::subfcx, {"subfcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_SET_CA | FL_RC_BIT}},
{136, CInterpreter::subfex, Jit64::Default, {"subfex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{232, CInterpreter::subfmex, Jit64::Default, {"subfmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{200, CInterpreter::subfzex, Jit64::Default, {"subfzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{266, Interpreter::addx, Jit64::addx, {"addx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{10, Interpreter::addcx, Jit64::Default, {"addcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_SET_CA | FL_RC_BIT}},
{138, Interpreter::addex, Jit64::addex, {"addex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{234, Interpreter::addmex, Jit64::Default, {"addmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{202, Interpreter::addzex, Jit64::Default, {"addzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{491, Interpreter::divwx, Jit64::Default, {"divwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 39}},
{459, Interpreter::divwux, Jit64::divwux, {"divwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 39}},
{75, Interpreter::mulhwx, Jit64::Default, {"mulhwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{11, Interpreter::mulhwux, Jit64::mulhwux, {"mulhwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{235, Interpreter::mullwx, Jit64::mullwx, {"mullwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT, 4}},
{104, Interpreter::negx, Jit64::negx, {"negx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{40, Interpreter::subfx, Jit64::subfx, {"subfx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_RC_BIT}},
{8, Interpreter::subfcx, Jit64::subfcx, {"subfcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_SET_CA | FL_RC_BIT}},
{136, Interpreter::subfex, Jit64::Default, {"subfex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{232, Interpreter::subfmex, Jit64::Default, {"subfmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{200, Interpreter::subfzex, Jit64::Default, {"subfzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_IN_B | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
};
GekkoOPTemplate table59[] =
{
{18, CInterpreter::fdivsx, Jit64::fp_arith_s, {"fdivsx", OPTYPE_FPU, FL_RC_BIT_F, 16}},
{20, CInterpreter::fsubsx, Jit64::fp_arith_s, {"fsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, CInterpreter::faddsx, Jit64::fp_arith_s, {"faddsx", OPTYPE_FPU, FL_RC_BIT_F}},
// {22, CInterpreter::fsqrtsx, Jit64::Default, {"fsqrtsx", OPTYPE_FPU, FL_RC_BIT_F}}, // Not implemented on gekko
{24, CInterpreter::fresx, Jit64::Default, {"fresx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, CInterpreter::fmulsx, Jit64::fp_arith_s, {"fmulsx", OPTYPE_FPU, FL_RC_BIT_F}},
{28, CInterpreter::fmsubsx, Jit64::fmaddXX, {"fmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, CInterpreter::fmaddsx, Jit64::fmaddXX, {"fmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, CInterpreter::fnmsubsx, Jit64::fmaddXX, {"fnmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, CInterpreter::fnmaddsx, Jit64::fmaddXX, {"fnmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
{18, Interpreter::fdivsx, Jit64::fp_arith_s, {"fdivsx", OPTYPE_FPU, FL_RC_BIT_F, 16}},
{20, Interpreter::fsubsx, Jit64::fp_arith_s, {"fsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, Interpreter::faddsx, Jit64::fp_arith_s, {"faddsx", OPTYPE_FPU, FL_RC_BIT_F}},
// {22, Interpreter::fsqrtsx, Jit64::Default, {"fsqrtsx", OPTYPE_FPU, FL_RC_BIT_F}}, // Not implemented on gekko
{24, Interpreter::fresx, Jit64::Default, {"fresx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, Interpreter::fmulsx, Jit64::fp_arith_s, {"fmulsx", OPTYPE_FPU, FL_RC_BIT_F}},
{28, Interpreter::fmsubsx, Jit64::fmaddXX, {"fmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, Interpreter::fmaddsx, Jit64::fmaddXX, {"fmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, Interpreter::fnmsubsx, Jit64::fmaddXX, {"fnmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, Interpreter::fnmaddsx, Jit64::fmaddXX, {"fnmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
};
GekkoOPTemplate table63[] =
{
{264, CInterpreter::fabsx, Jit64::Default, {"fabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{32, CInterpreter::fcmpo, Jit64::fcmpx, {"fcmpo", OPTYPE_FPU, FL_RC_BIT_F}},
{0, CInterpreter::fcmpu, Jit64::fcmpx, {"fcmpu", OPTYPE_FPU, FL_RC_BIT_F}},
{14, CInterpreter::fctiwx, Jit64::Default, {"fctiwx", OPTYPE_FPU, FL_RC_BIT_F}},
{15, CInterpreter::fctiwzx, Jit64::Default, {"fctiwzx", OPTYPE_FPU, FL_RC_BIT_F}},
{72, CInterpreter::fmrx, Jit64::fmrx, {"fmrx", OPTYPE_FPU, FL_RC_BIT_F}},
{136, CInterpreter::fnabsx, Jit64::Default, {"fnabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{40, CInterpreter::fnegx, Jit64::Default, {"fnegx", OPTYPE_FPU, FL_RC_BIT_F}},
{12, CInterpreter::frspx, Jit64::Default, {"frspx", OPTYPE_FPU, FL_RC_BIT_F}},
{264, Interpreter::fabsx, Jit64::Default, {"fabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{32, Interpreter::fcmpo, Jit64::fcmpx, {"fcmpo", OPTYPE_FPU, FL_RC_BIT_F}},
{0, Interpreter::fcmpu, Jit64::fcmpx, {"fcmpu", OPTYPE_FPU, FL_RC_BIT_F}},
{14, Interpreter::fctiwx, Jit64::Default, {"fctiwx", OPTYPE_FPU, FL_RC_BIT_F}},
{15, Interpreter::fctiwzx, Jit64::Default, {"fctiwzx", OPTYPE_FPU, FL_RC_BIT_F}},
{72, Interpreter::fmrx, Jit64::fmrx, {"fmrx", OPTYPE_FPU, FL_RC_BIT_F}},
{136, Interpreter::fnabsx, Jit64::Default, {"fnabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{40, Interpreter::fnegx, Jit64::Default, {"fnegx", OPTYPE_FPU, FL_RC_BIT_F}},
{12, Interpreter::frspx, Jit64::Default, {"frspx", OPTYPE_FPU, FL_RC_BIT_F}},
{64, CInterpreter::mcrfs, Jit64::Default, {"mcrfs", OPTYPE_SYSTEMFP, 0}},
{583, CInterpreter::mffsx, Jit64::Default, {"mffsx", OPTYPE_SYSTEMFP, 0}},
{70, CInterpreter::mtfsb0x, Jit64::Default, {"mtfsb0x", OPTYPE_SYSTEMFP, 0, 2}},
{38, CInterpreter::mtfsb1x, Jit64::Default, {"mtfsb1x", OPTYPE_SYSTEMFP, 0, 2}},
{134, CInterpreter::mtfsfix, Jit64::Default, {"mtfsfix", OPTYPE_SYSTEMFP, 0, 2}},
{711, CInterpreter::mtfsfx, Jit64::Default, {"mtfsfx", OPTYPE_SYSTEMFP, 0, 2}},
{64, Interpreter::mcrfs, Jit64::Default, {"mcrfs", OPTYPE_SYSTEMFP, 0}},
{583, Interpreter::mffsx, Jit64::Default, {"mffsx", OPTYPE_SYSTEMFP, 0}},
{70, Interpreter::mtfsb0x, Jit64::Default, {"mtfsb0x", OPTYPE_SYSTEMFP, 0, 2}},
{38, Interpreter::mtfsb1x, Jit64::Default, {"mtfsb1x", OPTYPE_SYSTEMFP, 0, 2}},
{134, Interpreter::mtfsfix, Jit64::Default, {"mtfsfix", OPTYPE_SYSTEMFP, 0, 2}},
{711, Interpreter::mtfsfx, Jit64::Default, {"mtfsfx", OPTYPE_SYSTEMFP, 0, 2}},
};
GekkoOPTemplate table63_2[] =
{
{18, CInterpreter::fdivx, Jit64::Default, {"fdivx", OPTYPE_FPU, FL_RC_BIT_F, 30}},
{20, CInterpreter::fsubx, Jit64::Default, {"fsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, CInterpreter::faddx, Jit64::Default, {"faddx", OPTYPE_FPU, FL_RC_BIT_F}},
{22, CInterpreter::fsqrtx, Jit64::Default, {"fsqrtx", OPTYPE_FPU, FL_RC_BIT_F}},
{23, CInterpreter::fselx, Jit64::Default, {"fselx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, CInterpreter::fmulx, Jit64::Default, {"fmulx", OPTYPE_FPU, FL_RC_BIT_F}},
{26, CInterpreter::frsqrtex,Jit64::Default, {"frsqrtex", OPTYPE_FPU, FL_RC_BIT_F}},
{28, CInterpreter::fmsubx, Jit64::Default, {"fmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, CInterpreter::fmaddx, Jit64::Default, {"fmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, CInterpreter::fnmsubx, Jit64::Default, {"fnmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, CInterpreter::fnmaddx, Jit64::Default, {"fnmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
{18, Interpreter::fdivx, Jit64::Default, {"fdivx", OPTYPE_FPU, FL_RC_BIT_F, 30}},
{20, Interpreter::fsubx, Jit64::Default, {"fsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, Interpreter::faddx, Jit64::Default, {"faddx", OPTYPE_FPU, FL_RC_BIT_F}},
{22, Interpreter::fsqrtx, Jit64::Default, {"fsqrtx", OPTYPE_FPU, FL_RC_BIT_F}},
{23, Interpreter::fselx, Jit64::Default, {"fselx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, Interpreter::fmulx, Jit64::Default, {"fmulx", OPTYPE_FPU, FL_RC_BIT_F}},
{26, Interpreter::frsqrtex,Jit64::Default, {"frsqrtex", OPTYPE_FPU, FL_RC_BIT_F}},
{28, Interpreter::fmsubx, Jit64::Default, {"fmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, Interpreter::fmaddx, Jit64::Default, {"fmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, Interpreter::fnmsubx, Jit64::Default, {"fnmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, Interpreter::fnmaddx, Jit64::Default, {"fnmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
};
bool PPCTables::UsesFPU(UGeckoInstruction _inst)
@ -502,17 +502,17 @@ void PPCTables::InitTables()
//clear
for (int i = 0; i < 32; i++)
{
CInterpreter::m_opTable59[i] = CInterpreter::unknown_instruction;
Interpreter::m_opTable59[i] = Interpreter::unknown_instruction;
dynaOpTable59[i] = Jit64::unknown_instruction;
m_infoTable59[i] = 0;
}
for (int i = 0; i < 1024; i++)
{
CInterpreter::m_opTable4 [i] = CInterpreter::unknown_instruction;
CInterpreter::m_opTable19[i] = CInterpreter::unknown_instruction;
CInterpreter::m_opTable31[i] = CInterpreter::unknown_instruction;
CInterpreter::m_opTable63[i] = CInterpreter::unknown_instruction;
Interpreter::m_opTable4 [i] = Interpreter::unknown_instruction;
Interpreter::m_opTable19[i] = Interpreter::unknown_instruction;
Interpreter::m_opTable31[i] = Interpreter::unknown_instruction;
Interpreter::m_opTable63[i] = Interpreter::unknown_instruction;
dynaOpTable4 [i] = Jit64::unknown_instruction;
dynaOpTable19[i] = Jit64::unknown_instruction;
dynaOpTable31[i] = Jit64::unknown_instruction;
@ -525,7 +525,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(primarytable) / sizeof(GekkoOPTemplate)); i++)
{
CInterpreter::m_opTable[primarytable[i].opcode] = primarytable[i].interpret;
Interpreter::m_opTable[primarytable[i].opcode] = primarytable[i].interpret;
dynaOpTable[primarytable[i].opcode] = primarytable[i].recompile;
m_infoTable[primarytable[i].opcode] = &primarytable[i].opinfo;
}
@ -536,7 +536,7 @@ void PPCTables::InitTables()
for (int j = 0; j < (int)(sizeof(table4_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill+table4_2[j].opcode;
CInterpreter::m_opTable4[op] = table4_2[j].interpret;
Interpreter::m_opTable4[op] = table4_2[j].interpret;
dynaOpTable4[op] = table4_2[j].recompile;
m_infoTable4[op] = &table4_2[j].opinfo;
}
@ -548,7 +548,7 @@ void PPCTables::InitTables()
for (int j = 0; j < (int)(sizeof(table4_3) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill+table4_3[j].opcode;
CInterpreter::m_opTable4[op] = table4_3[j].interpret;
Interpreter::m_opTable4[op] = table4_3[j].interpret;
dynaOpTable4[op] = table4_3[j].recompile;
m_infoTable4[op] = &table4_3[j].opinfo;
}
@ -557,7 +557,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(table4) / sizeof(GekkoOPTemplate)); i++)
{
int op = table4[i].opcode;
CInterpreter::m_opTable4[op] = table4[i].interpret;
Interpreter::m_opTable4[op] = table4[i].interpret;
dynaOpTable4[op] = table4[i].recompile;
m_infoTable4[op] = &table4[i].opinfo;
}
@ -565,7 +565,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(table31) / sizeof(GekkoOPTemplate)); i++)
{
int op = table31[i].opcode;
CInterpreter::m_opTable31[op] = table31[i].interpret;
Interpreter::m_opTable31[op] = table31[i].interpret;
dynaOpTable31[op] = table31[i].recompile;
m_infoTable31[op] = &table31[i].opinfo;
}
@ -576,7 +576,7 @@ void PPCTables::InitTables()
for (int j = 0; j < (int)(sizeof(table31_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill + table31_2[j].opcode;
CInterpreter::m_opTable31[op] = table31_2[j].interpret;
Interpreter::m_opTable31[op] = table31_2[j].interpret;
dynaOpTable31[op] = table31_2[j].recompile;
m_infoTable31[op] = &table31_2[j].opinfo;
}
@ -585,7 +585,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(table19) / sizeof(GekkoOPTemplate)); i++)
{
int op = table19[i].opcode;
CInterpreter::m_opTable19[op] = table19[i].interpret;
Interpreter::m_opTable19[op] = table19[i].interpret;
dynaOpTable19[op] = table19[i].recompile;
m_infoTable19[op] = &table19[i].opinfo;
}
@ -593,7 +593,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(table59) / sizeof(GekkoOPTemplate)); i++)
{
int op = table59[i].opcode;
CInterpreter::m_opTable59[op] = table59[i].interpret;
Interpreter::m_opTable59[op] = table59[i].interpret;
dynaOpTable59[op] = table59[i].recompile;
m_infoTable59[op] = &table59[i].opinfo;
}
@ -601,7 +601,7 @@ void PPCTables::InitTables()
for (int i = 0; i < (int)(sizeof(table63) / sizeof(GekkoOPTemplate)); i++)
{
int op = table63[i].opcode;
CInterpreter::m_opTable63[op] = table63[i].interpret;
Interpreter::m_opTable63[op] = table63[i].interpret;
dynaOpTable63[op] = table63[i].recompile;
m_infoTable63[op] = &table63[i].opinfo;
}
@ -612,7 +612,7 @@ void PPCTables::InitTables()
for (int j = 0; j < (int)(sizeof(table63_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill + table63_2[j].opcode;
CInterpreter::m_opTable63[op] = table63_2[j].interpret;
Interpreter::m_opTable63[op] = table63_2[j].interpret;
dynaOpTable63[op] = table63_2[j].recompile;
m_infoTable63[op] = &table63_2[j].opinfo;
}

4
Source/Core/Core/Src/PowerPC/PPCTables.h
View File

@ -78,10 +78,8 @@ struct GekkoOPInfo
u32 lastUse;
};
GekkoOPInfo *GetOpInfo(UGeckoInstruction _inst);
CInterpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst);
Interpreter::_interpreterInstruction GetInterpreterOp(UGeckoInstruction _inst);
class PPCTables
{

102
Source/Core/Core/Src/PowerPC/PowerPC.cpp
View File

@ -15,6 +15,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifdef _WIN32
#include <float.h>
#endif
#include "Common.h"
#include "ChunkFile.h"
@ -25,6 +29,7 @@
#include "Interpreter/Interpreter.h"
#include "Jit64/JitCore.h"
#include "Jit64/JitCache.h"
#include "PowerPC.h"
#include "PPCTables.h"
@ -36,7 +41,7 @@ namespace PowerPC
PowerPCState GC_ALIGNED16(ppcState);
volatile CPUState state = CPU_STEPPING;
ICPUCore* m_pCore = NULL;
static CoreMode mode;
void DoState(ChunkFile &f)
{
@ -48,10 +53,6 @@ namespace PowerPC
void ResetRegisters()
{
if (((u64)&ppcState & 0xf) != 0) {
PanicAlert("The compiler misaligned ppcState in memory. Likely to cause crashes.");
}
for (int i = 0; i < 32; i++)
{
ppcState.gpr[i] = 0;
@ -70,73 +71,90 @@ namespace PowerPC
TL = 0;
TU = 0;
ppcState.DoPreRetrace = true;
ppcState.msr = 0;
rDEC = 0xFFFFFFFF;
}
void Init()
{
#ifdef _M_IX86
// sets the floating-point lib to 53-bit
// PowerPC has a 53bit floating pipeline only
// eg: sscanf is very sensitive
#ifdef _WIN32
_control87(_PC_53, MCW_PC);
#else
unsigned short mode;
asm ("fstcw %0" : : "m" (mode));
mode = (mode & ~FPU_PREC_MASK) | FPU_PREC_53;
asm ("fldcw %0" : : "m" (mode));
#endif
#else
//x64 doesn't need this - fpu is done with SSE
//but still - set any useful sse options here
#endif
ResetRegisters();
PPCTables::InitTables();
// Initialize both execution engines ...
Interpreter::Init();
Jit64::Core::Init();
// ... but start as interpreter by default.
mode = MODE_INTERPRETER;
state = CPU_STEPPING;
SetCore(CORE_INTERPRETER);
}
void Shutdown()
{
if (m_pCore != NULL)
{
m_pCore->Shutdown();
delete m_pCore;
m_pCore = NULL;
}
// Shutdown both execution engines. Doesn't matter which one is active.
Jit64::Core::Shutdown();
Interpreter::Shutdown();
}
void Reset()
void SetMode(CoreMode new_mode)
{
ResetRegisters();
if (m_pCore!= NULL)
m_pCore->Reset();
}
if (new_mode == mode)
return; // We don't need to do anything.
void SetCore(ECoreType _coreType)
{
// shutdown the old core
if (m_pCore != NULL)
mode = new_mode;
switch (mode)
{
m_pCore->Shutdown();
delete m_pCore;
m_pCore = NULL;
}
// create the new one
switch(_coreType)
{
case CORE_INTERPRETER:
m_pCore = new CInterpreter();
m_pCore->Init();
case MODE_INTERPRETER: // Switching from JIT to interpreter
Jit64::ClearCache(); // Remove all those nasty JIT patches.
break;
case CORE_DYNAREC:
m_pCore = new Jit64::Jit64Core();
m_pCore->Init();
break;
default:
case MODE_JIT: // Switching from interpreter to JIT.
// Don't really need to do much. It'll work, the cache will refill itself.
break;
}
}
void SingleStep()
{
m_pCore->SingleStep();
switch (mode)
{
case MODE_INTERPRETER:
Interpreter::SingleStep();
break;
case MODE_JIT:
Jit64::Core::SingleStep();
break;
}
}
void RunLoop()
{
state = CPU_RUNNING;
m_pCore->Run();
switch (mode)
{
case MODE_INTERPRETER:
Interpreter::Run();
break;
case MODE_JIT:
Jit64::Core::Run();
break;
}
Host_UpdateDisasmDialog();
}
@ -240,7 +258,7 @@ namespace PowerPC
LOG(GEKKO, "EXCEPTION_EXTERNAL_INT");
SRR1 |= 0x02; //set it to recoverable
_dbg_assert_msg_(GEKKO,(SRR1 & 0x02) != 0,"GEKKO","EXTERNAL_INT unrecoverable???"); // unrecoverable exception !?!
_dbg_assert_msg_(GEKKO, (SRR1 & 0x02) != 0, "GEKKO", "EXTERNAL_INT unrecoverable???"); // unrecoverable exception !?!
}
else if (ppcState.Exceptions & EXCEPTION_DECREMENTER)
{

53
Source/Core/Core/Src/PowerPC/PowerPC.h
View File

@ -27,46 +27,43 @@
#include "Common.h"
#include "Gekko.h"
#include "ICPUCore.h"
class ChunkFile;
namespace PowerPC
{
enum ECoreType
enum CoreMode
{
CORE_INTERPRETER,
CORE_DYNAREC,
MODE_INTERPRETER,
MODE_JIT,
};
struct GC_ALIGNED64(PowerPCState)
{
u32 mojs[128];
// sets of registers
u32 gpr[32];
// the paired singles are strange : PS0 is stored in the full 64 bits of each FPR
// but ps calculations are probably only 32-bit
u32 mojs[128]; // Try to isolate the regs from other variables in the cache.
u32 gpr[32]; // General purpose registers. r1 = stack pointer.
// The paired singles are strange : PS0 is stored in the full 64 bits of each FPR
// but ps calculations are only done in 32-bit precision, and PS1 is only 32 bits.
// Since we want to use SIMD, SSE2 is the only viable alternative - 2x double.
u64 ps[32][2];
// program counter
u32 pc;
u32 pc; // program counter
u32 npc;
// flags
u32 cr;
u32 msr;
u32 fpscr;
u32 cr; // flags
u32 msr; // machine specific register
u32 fpscr; // floating point flags/status bits
//exception management
// Exception management.
u32 Exceptions;
u32 sr[16];
// interrupts hack
u32 DoPreRetrace;
u32 sr[16]; // Segment registers. Unused.
u32 DebugCount;
// additional special purpose registers
// special purpose registers - controlls quantizers, DMA, and lots of other misc extensions.
// also for power management, but we don't care about that.
u32 spr[1024];
};
@ -79,29 +76,21 @@ namespace PowerPC
};
extern PowerPCState ppcState;
extern volatile CPUState state; //cpu cores should poll this
void ResetRegisters();
void Reset();
extern volatile CPUState state; // Execution engines should poll this to know when to exit.
void Init();
void Shutdown();
void DoState(ChunkFile &f);
void SetCore(ECoreType _coreType);
void SetMode(CoreMode _coreType);
ICPUCore& GetCore();
void SingleStep();
void SingleStep();
void CheckExceptions();
void RunLoop();
void Start();
void Pause();
void Stop();
u32 ConvertMillisecondToTicks(u32 _Milliseconds);
void OnIdle(u32 _uThreadAddr);
}

5
Source/Core/DebuggerWX/src/CodeView.cpp
View File

@ -341,9 +341,8 @@ void CCodeView::OnPaint(wxPaintEvent& event)
dc.DrawRectangle(0, 0, 16, rc.height);
dc.DrawRectangle(0, 0, rc.width, 5);
// TODO - clean up this freaking mess!!!!!
int i;
for (i = -numRows; i <= numRows; i++)
for (int i = -numRows; i <= numRows; i++)
{
unsigned int address = curAddress + i * align;
@ -469,7 +468,7 @@ void CCodeView::OnPaint(wxPaintEvent& event)
dc.SetPen(currentPen);
for (i = 0; i < numBranches; i++)
for (int i = 0; i < numBranches; i++)
{
int x = 300 + (branches[i].srcAddr % 9) * 8;
_MoveTo(x-2, branches[i].src);

15
Source/Core/DebuggerWX/src/CodeWindow.cpp
View File

@ -75,6 +75,8 @@ BEGIN_EVENT_TABLE(CCodeWindow, wxFrame)
EVT_MENU(IDM_BREAKPOINTWINDOW, CCodeWindow::OnToggleBreakPointWindow)
EVT_MENU(IDM_MEMORYWINDOW, CCodeWindow::OnToggleMemoryWindow)
EVT_MENU(IDM_INTERPRETER, CCodeWindow::OnInterpreter)
EVT_MENU(IDM_CLEARSYMBOLS, CCodeWindow::OnSymbolsMenu)
EVT_MENU(IDM_LOADMAPFILE, CCodeWindow::OnSymbolsMenu)
EVT_MENU(IDM_SCANFUNCTIONS, CCodeWindow::OnSymbolsMenu)
@ -103,7 +105,6 @@ inline wxBitmap _wxGetBitmapFromMemory(const unsigned char* data, int length)
return(wxBitmap(wxImage(is, wxBITMAP_TYPE_ANY, -1), -1));
}
CCodeWindow::CCodeWindow(const SCoreStartupParameter& _LocalCoreStartupParameter, wxWindow* parent, wxWindowID id,
const wxString& title, const wxPoint& pos, const wxSize& size, long style)
: wxFrame(parent, id, title, pos, size, style)
@ -225,12 +226,12 @@ void CCodeWindow::CreateMenu(const SCoreStartupParameter& _LocalCoreStartupParam
{
wxMenu* pCoreMenu = new wxMenu;
wxMenuItem* interpreter = pCoreMenu->Append(IDM_INTERPRETER, _T("&Interpreter"), wxEmptyString, wxITEM_CHECK);
interpreter->Check(!_LocalCoreStartupParameter.bUseDynarec);
interpreter->Check(!_LocalCoreStartupParameter.bUseJIT);
// wxMenuItem* dualcore = pDebugMenu->Append(IDM_DUALCORE, _T("&DualCore"), wxEmptyString, wxITEM_CHECK);
// dualcore->Check(_LocalCoreStartupParameter.bUseDualCore);
pMenuBar->Append(pCoreMenu, _T("&Core Startup"));
pMenuBar->Append(pCoreMenu, _T("&CPU Mode"));
}
{
@ -289,6 +290,14 @@ bool CCodeWindow::UseDualCore()
return(GetMenuBar()->IsChecked(IDM_DUALCORE));
}
void CCodeWindow::OnInterpreter(wxCommandEvent& event)
{
if (Core::GetState() != Core::CORE_RUN) {
PowerPC::SetMode(UseInterpreter() ? PowerPC::MODE_INTERPRETER : PowerPC::MODE_JIT);
} else {
wxMessageBox(_T("Please pause the emulator before changing mode."));
}
}
void CCodeWindow::OnJitMenu(wxCommandEvent& event)
{

1
Source/Core/DebuggerWX/src/CodeWindow.h
View File

@ -144,6 +144,7 @@ class CCodeWindow
void OnHostMessage(wxCommandEvent& event);
void OnSymbolsMenu(wxCommandEvent& event);
void OnJitMenu(wxCommandEvent& event);
void OnInterpreter(wxCommandEvent& event);
void CreateMenu(const SCoreStartupParameter& _LocalCoreStartupParameter);

4
Source/Core/DolphinWX/src/BootManager.cpp
View File

@ -50,12 +50,12 @@ bool BootCore(const std::string& _rFilename)
if (g_pCodeWindow)
{
// StartUp.bUseDualCore = code_frame->UseDualCore();
StartUp.bUseDynarec = !g_pCodeWindow->UseInterpreter();
StartUp.bUseJIT = !g_pCodeWindow->UseInterpreter();
}
else
{
// StartUp.bUseDualCore = false;
StartUp.bUseDynarec = true;
StartUp.bUseJIT = true;
}
StartUp.m_BootType = SCoreStartupParameter::BOOT_ISO;
StartUp.m_strFilename = _rFilename;

4
Source/Core/DolphinWX/src/Config.cpp
View File

@ -64,7 +64,7 @@ void SConfig::SaveSettings()
ini.Set("Core", "PadPlugin", m_LocalCoreStartupParameter.m_strPadPlugin);
ini.Set("Core", "HLEBios", m_LocalCoreStartupParameter.bHLEBios);
ini.Set("Core", "UseDynarec", m_LocalCoreStartupParameter.bUseDynarec);
ini.Set("Core", "UseDynarec", m_LocalCoreStartupParameter.bUseJIT);
ini.Set("Core", "UseDualCore", m_LocalCoreStartupParameter.bUseDualCore);
ini.Set("Core", "LockThreads", m_LocalCoreStartupParameter.bLockThreads);
ini.Set("Core", "DefaultGCM", m_LocalCoreStartupParameter.m_strDefaultGCM);
@ -114,7 +114,7 @@ void SConfig::LoadSettings()
ini.Get("Core", "PadPlugin", &m_LocalCoreStartupParameter.m_strPadPlugin, m_DefaultPADPlugin.c_str());
ini.Get("Core", "HLEBios", &m_LocalCoreStartupParameter.bHLEBios, true);
ini.Get("Core", "UseDynarec", &m_LocalCoreStartupParameter.bUseDynarec, true);
ini.Get("Core", "UseDynarec", &m_LocalCoreStartupParameter.bUseJIT, true);
ini.Get("Core", "UseDualCore", &m_LocalCoreStartupParameter.bUseDualCore, false);
ini.Get("Core", "LockThreads", &m_LocalCoreStartupParameter.bLockThreads, true);
ini.Get("Core", "OptimizeQuantizers", &m_LocalCoreStartupParameter.bOptimizeQuantizers, true);